Creada clase ContenedorGrupos.kt que almacena los tris, seq, pares y huerfanos de una mano.

src/juego/ContenedorGrupos.kt

@@ -0,0 +1,52 @@
+package dev.araozu.juego
+
+import com.sun.org.apache.xpath.internal.operations.Bool
+
+class ContenedorGrupos(
+    private val tris: ArrayList<ArrayList<Carta>>,
+    private val seqs: ArrayList<ArrayList<Carta>>,
+    private val pares: ArrayList<ArrayList<Carta>>,
+    private val huerfanos: ArrayList<Carta>
+) {
+
+    constructor () : this(
+        arrayListOf<ArrayList<Carta>>(),
+        arrayListOf<ArrayList<Carta>>(),
+        arrayListOf<ArrayList<Carta>>(),
+        arrayListOf<Carta>()
+    ) {
+    }
+
+    fun agregarDesdeContenedor(c: ContenedorGrupos) {
+        tris.addAll(c.tris)
+        seqs.addAll(c.seqs)
+        pares.addAll(c.pares)
+        huerfanos.addAll(c.huerfanos)
+    }
+
+    fun agregarSeqs(s: ArrayList<ArrayList<Carta>>) {
+        seqs.addAll(s)
+    }
+
+    fun agregarTris(a: ArrayList<ArrayList<Carta>>) {
+        tris.addAll(a)
+    }
+
+    fun agregarPares(a: ArrayList<ArrayList<Carta>>) {
+        pares.addAll(a)
+    }
+
+    fun agregarHuerfanos(a: ArrayList<out Carta>) {
+        for (c in a) {
+            huerfanos.add(c)
+        }
+    }
+
+    fun heuristic(): Int =
+        tris.size + seqs.size + (if (pares.size <= 1) 1 else 0) - huerfanos.size
+
+    fun estaListo(): Boolean =
+        pares.size == 1 && huerfanos.size == 0
+
+
+}

src/juego/OportunidadWin.kt

@@ -6,10 +6,9 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad {
 
     companion object {
 
-        private fun <T : Carta> ArrayList<out T>.cartaExisteEnArrl(valorCarta: Int): Boolean {
+        private fun ArrayList<out CartaNumero>.cartaExisteEnArrl(valorCarta: Int): Boolean {
             for (c in this) {
-                val valorCartaParActual = (c.valor ushr 1) shl 1
+                if (valorCarta == c.numero) return true
-                if (valorCartaParActual == valorCarta) return true
             }
             return false
         }
@@ -26,7 +25,18 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad {
             throw Error("El valor de la carta no existe en el array.")
         }
 
-        private fun obtTri(cartas: ArrayList<Carta>): ArrayList<ArrayList<Carta>> {
+        private fun ArrayList<out CartaNumero>.eliminarCartaNumero(valorCarta: Int): CartaNumero {
+            for (c in this) {
+                if (c.numero == valorCarta) {
+                    this.remove(c)
+                    return c
+                }
+            }
+
+            throw Error("El valor de la carta no existe en el array.")
+        }
+
+        private fun obtTri(cartas: ArrayList<out Carta>): ArrayList<ArrayList<Carta>> {
             val arrlR = arrayListOf<ArrayList<Carta>>()
             var i = 0
             while (i + 2 < cartas.size) {
@@ -47,7 +57,7 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad {
             return arrlR
         }
 
-        private fun obtPar(cartas: ArrayList<Carta>): ArrayList<ArrayList<Carta>> {
+        private fun obtPar(cartas: ArrayList<out Carta>): ArrayList<ArrayList<Carta>> {
             val arrlR = arrayListOf<ArrayList<Carta>>()
             var i = 0
             while (i + 2 < cartas.size) {
@@ -66,20 +76,20 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad {
             return arrlR
         }
 
-        private fun obtSeq1(cartas: ArrayList<CartaNumero>): ArrayList<ArrayList<CartaNumero>> {
+        private fun obtSeq1(cartas: ArrayList<out CartaNumero>): ArrayList<ArrayList<Carta>> {
-            val arrlCartas = arrayListOf<ArrayList<CartaNumero>>()
+            val arrlCartas = arrayListOf<ArrayList<Carta>>()
             var i = 0
             while (i < cartas.size) {
                 val primeraCarta = cartas[i]
-                val valorCartaPar = (primeraCarta.valor ushr 1) shl 1
+                val valorCartaPar = primeraCarta.numero
 
                 if (
                     cartas.cartaExisteEnArrl(valorCartaPar + 1)
                     && cartas.cartaExisteEnArrl(valorCartaPar + 2)
                 ) {
-                    val c1 = cartas.eliminarCarta(valorCartaPar)
+                    val c1 = cartas.eliminarCartaNumero(valorCartaPar)
-                    val c2 = cartas.eliminarCarta(valorCartaPar + 1)
+                    val c2 = cartas.eliminarCartaNumero(valorCartaPar + 1)
-                    val c3 = cartas.eliminarCarta(valorCartaPar + 2)
+                    val c3 = cartas.eliminarCartaNumero(valorCartaPar + 2)
                     arrlCartas.add(arrayListOf(c1, c2, c3))
                 } else {
                     i++
@@ -113,24 +123,47 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad {
             return arrlCartas
         }
 
-        private fun obtenerPosiblesSeq(cartas: ArrayList<CartaNumero>): Pair<ArrayList<ArrayList<CartaNumero>>, ArrayList<ArrayList<CartaNumero>>> {
+        private fun obtenerContenedorCartasNumero(cartas: ArrayList<out CartaNumero>): ContenedorGrupos {
             val cartas2 = ArrayList<CartaNumero>(cartas.size)
             cartas2.addAll(cartas)
 
-            val seqOrden1 = obtSeq1(cartas)
+            val contenedor1 = ContenedorGrupos()
-            val seqOrden2 = obtSeq2(cartas)
+            contenedor1.agregarSeqs(obtSeq1(cartas))
+            contenedor1.agregarTris(obtTri(cartas))
+            contenedor1.agregarPares(obtPar(cartas))
+            contenedor1.agregarHuerfanos(cartas)
 
-            return Pair(seqOrden1, seqOrden2)
+            val contenedor2 = ContenedorGrupos()
+            contenedor2.agregarSeqs(obtSeq1(cartas2))
+            contenedor2.agregarTris(obtTri(cartas2))
+            contenedor2.agregarPares(obtPar(cartas2))
+            contenedor2.agregarHuerfanos(cartas2)
+
+            val valorCont1 = contenedor1.heuristic()
+            val valorCont2 = contenedor2.heuristic()
+
+            return if (valorCont1 > valorCont2) contenedor1 else contenedor2
         }
 
-        fun verificar(valorCarta: Int, cartasMano: ArrayList<Int>, numGruposAbiertos: Int = 0) {
+        fun verificar(valorCarta: Int, cartasMano: ArrayList<Int>) {
-            val narrl = arrayListOf<Int>()
+            val narrl = ArrayList<Int>(cartasMano.size + 1)
             narrl.addAll(cartasMano)
             narrl.add(valorCarta)
 
             val (cartasRojo, cartasRestantes1) = CartaNumero.separarCartasRojo(narrl)
             val (cartasNegro, cartasRestantes2) = CartaNumero.separarCartasNegro(cartasRestantes1)
-            val restoCartas = cartasRestantes2.map { Carta.obtenerCartaEspecifica(it) }
+            val restoCartas = arrayListOf<Carta>()
+            restoCartas.addAll(cartasRestantes2.map { Carta.obtenerCartaEspecifica(it) })
+
+            val contenedorGrupos = ContenedorGrupos()
+
+            // Obtener tris y pares de las cartas que no son numeros
+            contenedorGrupos.agregarTris(obtTri(restoCartas))
+            contenedorGrupos.agregarPares(obtPar(restoCartas))
+
+            // Obtener tris, pares y seq de las cartas de numeros
+            contenedorGrupos.agregarDesdeContenedor(obtenerContenedorCartasNumero(cartasRojo))
+            contenedorGrupos.agregarDesdeContenedor(obtenerContenedorCartasNumero(cartasNegro))
 
 
         }