Poker.kt

import java.util.*
import kotlin.collections.ArrayList

class Carta(completo: String) {
    fun valorPalo(): String {
        return valor + palo
    }

    var valor: String
    var palo: String

    init {
        valor = completo[0].toString()
        palo = completo[1].toString()
    }
}


fun ganadores(jugadas: MutableList<Array<Carta?>>): String {

    print("Cantidad de jugadas ${jugadas.size}")
    val ganadores: ArrayList<Array<Carta>> = ArrayList<Array<Carta>>()
    var prim = true
    val indices = ArrayList<Int>()
    var index = 0
    for (mano in jugadas) {
        if (prim) {
            ganadores.add(mano)
            indices.add(index)
            prim = false
        } else {
            val resultadoMayor = mostrarResultado(ganadores[ganadores.size])
            val mostrarResultadoActual = mostrarResultado(mano)
            if (resultadoMayor[0] < mostrarResultadoActual[0]) {
                    ganadores.clear()
                    indices.clear()
                    indices.add(index)
                    ganadores.add(mano)
                }
            }
            index++
        }

        var stringGanadores = ""
        for (i in indices.indices) {
            stringGanadores += " " + indices[i]
        }
        return stringGanadores
    }


fun mostrarResultado(mano: Array<Carta>): ArrayList<Int> {
        val mostrarResultado = ArrayList<Int>()
        val valores = IntArray(13)
        val palos = IntArray(4)
        ArrayNuevo(valores, palos, mano)

        if (esEscaleraColor(valores, palos)) {
            val ordenado = ordenarCartas(mano)
            mostrarResultado.add(9)
           
            if (ordenado[4] == 12 && ordenado[0] == 0) {
                mostrarResultado.add(14)
            } else {
                mostrarResultado.add(ordenado[4])
            }
        } else if (esPoker(valores)) {
           
            mostrarResultado.add(8)
            if (indiceDe(4, valores) == 0) {
                mostrarResultado.add(14)
                mostrarResultado.add(indiceDe(1, valores))
            } else {
                mostrarResultado.add(indiceDe(4, valores))
                if (indiceDe(1, valores) == 0) {
                    mostrarResultado.add(14)
                } else {
                    mostrarResultado.add(indiceDe(1, valores))
                }
            }
        } else if (esFull(valores)) {
        
            mostrarResultado.add(7)
            if (indiceDe(3, valores) == 0) {
                mostrarResultado.add(14)
                mostrarResultado.add(indiceDe(2, valores))
            } else {
                mostrarResultado.add(indiceDe(3, valores))
                if (indiceDe(2, valores) == 0) {
                    mostrarResultado.add(14)
                } else {
                    mostrarResultado.add(indiceDe(2, valores))
                }
            }
        } else if (esColor(palos)) {
            var aux = 0
            mostrarResultado.add(6)
            val ordenado = ordenarCartas(mano)
            if (ordenado[0] == 0) {
                mostrarResultado.add(14)
                aux = 1
            }
            for (i in 4 downTo aux) {
                mostrarResultado.add(ordenado[i])
            }
        } else if (esEscalera(valores)) {
            val ordenado = ordenarCartas(mano)
            mostrarResultado.add(5)
            if (ordenado[4] == 12 && ordenado[0] == 1) {
                mostrarResultado.add(14)
            } else {
                mostrarResultado.add(ordenado[4])
            }
        } else if (esTrio(valores)) {
            mostrarResultado.add(4)

            if (indiceDe(3, valores) == 0) {
                mostrarResultado.add(14)
            } else {
                mostrarResultado.add(indiceDe(3, valores))
            }
            val ordenado = ordenarCartas(mano)
            var aux = 0
            if (ordenado[0] == 0) {
                mostrarResultado.add(14)
                aux = 1
            }
            for (i in 4 downTo aux) {
                if (mostrarResultado[1] != ordenado[i]) {
                    mostrarResultado.add(ordenado[i])
                }
            }
        } else if (esParDoble(valores)) {
            mostrarResultado.add(3)

            if (indiceDe(2, valores) == 0) {
                mostrarResultado.add(14)
                mostrarResultado.add(indiceDeReversa(2, valores))
            } else {
                mostrarResultado.add(indiceDeReversa(2, valores))
                mostrarResultado.add(indiceDe(2, valores))
            }
            if (indiceDe(1, valores) == 0) {
                mostrarResultado.add(14)
            } else {
                mostrarResultado.add(indiceDe(1, valores))
            }
        } else if (esPar(valores)) {
            mostrarResultado.add(2)

            if (indiceDe(2, valores) == 0) {
                mostrarResultado.add(14)
            } else {
                mostrarResultado.add(indiceDe(2, valores))
            }
            val ordenado = ordenarCartas(mano)
            var aux = 0
            if (ordenado[0] == 0) {
                mostrarResultado.add(14)
                aux = 1
            }
            for (i in 4 downTo aux) {
                if (mostrarResultado[1] != ordenado[i]) {
                    mostrarResultado.add(ordenado[i])
                }
            }
        } else {
            var aux = 0
            mostrarResultado.add(1)

            val ordenado = ordenarCartas(mano)
            if (ordenado[0] == 0) {
                mostrarResultado.add(14)
                aux = 1
            }
            for (i in 4 downTo aux) {
                mostrarResultado.add(ordenado[i])
            }
        }
        return mostrarResultado
    }

fun indiceDe(elemento: Int, vector: IntArray): Int { 
    for (i in vector.indices) { 
        if (vector[i] == elemento) return i
    }

    return -1
}

fun indiceDeReversa(elemento: Int, vector: IntArray): Int {
    for (i in vector.indices.reversed()) {
        if (vector[i] == elemento) return i
    }

    return -1
}

fun ordenarCartas(mano: Array<Carta>): IntArray {
    val ordenado = IntArray(5)
    for (i in 0..4) { 
        val valorString: String = mano[i].valor
        if (valorString == "A" || valorString == "a") { 
            ordenado[i] = 0
        } else if (valorString == "T" || valorString == "t") {
                ordenado[i] = 9
        } else if (valorString == "J" || valorString == "j") {
                ordenado[i] = 10
        } else if (valorString == "Q" || valorString == "q") {
                ordenado[i] = 11
            } else if (valorString == "K" || valorString == "k") {
                ordenado[i] = 12
            } else {
                ordenado[i] = valorString.toInt() - 1
            }
        }
        Arrays.sort(ordenado)
        return ordenado
    }

fun esEscaleraColor(valores: IntArray, palos: IntArray): Boolean {

        var sum = false

        var sumador = 0

        for (i in 1..12) {

            if (valores[i] > 1) {
                return false
            }
            if (valores[i] == 1) {
                sum = true
            }
            if (valores[i] == 0 && sum) {
                break
            }
            if (sum) {
                sumador++
            }
        }

        if (sumador == 5 || sumador == 4 && valores[0] == 1 && valores[9] == 1 && valores[8] == 0) {
            for (i in 0..3) {
                if (palos[i] == 5) {
                    return true
                }
            }
        }
        return false
    }

fun esPoker(valores: IntArray): Boolean {

        val ordenado = valores.clone()
        Arrays.sort(ordenado)
        return if (ordenado[12] == 4) {
            true
        } else false
    }

fun esFull(valores: IntArray): Boolean {
        val ordenado = valores.clone()
        Arrays.sort(ordenado)
        return if (ordenado[12] == 3 && ordenado[11] == 2) true else false
    }

fun esColor(palos: IntArray): Boolean {
        val ordenado = palos.clone()
        Arrays.sort(ordenado)
        return if (ordenado[3] == 5) true else false
    }

fun esEscalera(valores: IntArray): Boolean {

        var sum = false

        var sumador = 0
        for (i in 1..12) {

            if (valores[i] > 1) {
                return false
            }
            if (valores[i] == 1) {
                sum = true
            }
            if (valores[i] == 0 && sum) {
                break
            }
            if (sum) {
                sumador++
            }
        }
        return if (sumador == 5 || sumador == 4 && valores[0] == 1 && valores[9] == 1 && valores[8] == 0) {
            true
        } else false
    }

fun esTrio(valores: IntArray): Boolean {
        val ordenado = valores.clone()
   
        Arrays.sort(ordenado)
        return if (ordenado[12] == 3 && ordenado[11] == 1 && ordenado[10] == 1) true else false
    }

fun esParDoble(valores: IntArray): Boolean {

        val ordenado = valores.clone()

        Arrays.sort(ordenado)
        return if (ordenado[12] == 2 && ordenado[11] == 2 && ordenado[10] == 1) true else false
    }

fun esPar(valores: IntArray): Boolean {
        val ordenado = valores.clone()
 
        Arrays.sort(ordenado)
        return if (ordenado[12] == 2 && ordenado[11] == 1 && ordenado[10] == 1 && ordenado[9] == 1) true else false
    }

fun mostrarGanador(ganadores: ArrayList<Array<Carta>>) {
       
        for (i in ganadores.indices) {
            for (j in 0..4) {
               print(ganadores[i][j].valorPalo())
            }
            println()
        }
    }


fun ArrayNuevo(valores: IntArray, palos: IntArray, mano: Array<Carta>) {
    for (i in 0..12) {
        valores[i] = 0
    }
    for (i in 0..3) {
        palos[i] = 0
    }

           
    for (i in 0..4) {
        val valorString: String = mano[i]!!.valor
        val paloString: String = mano[i].palo
        if (valorString == "A" || valorString == "a") {
            valores[0]++
        } else if (valorString == "T" || valorString == "t") {
                    valores[9]++
        } else if (valorString == "J" || valorString == "j") {
                    valores[10]++
                } else if (valorString == "Q" || valorString == "q") {
                    valores[11]++
                } else if (valorString == "K" || valorString == "k") {
                    valores[12]++
                } else if (valorString == "J" || valorString == "j") {
                    valores[10]++
                } else {
                    val index = valorString.toInt()
                    valores[index - 1]++
                }

                if (paloString == "S" || paloString == "s") {
                    palos[0]++
                } else if (paloString == "C" || paloString == "c") {
                    palos[1]++
                } else if (paloString == "H" || paloString == "h") {
                    palos[2]++
                } else if (paloString == "D" || paloString == "d") {
                    palos[3]++
                }
            }
        }

fun main(args: Array<String>) {

    val jugadas: MutableList<Array<Carta?>> =
        ArrayList<Array<Carta?>>()
    val m1: Array<Carta?> = arrayOfNulls<Carta>(5)
    m1[0] = Carta("AH")
    m1[1] = Carta("AD")
    m1[2] = Carta("5D")
    m1[3] = Carta("5D")
    m1[4] = Carta("2D")
    val m2: Array<Carta?> = arrayOfNulls<Carta>(5)
    m2[0] = Carta("5H")
    m2[1] = Carta("5D")
    m2[2] = Carta("2D")
    m2[3] = Carta("2D")
    m2[4] = Carta("AD")
    jugadas.add(m1)
    jugadas.add(m2)
    val ganadores = ganadores(jugadas)

    println("Ganadores = $ganadores")
}