diff --git a/src/TestRon.kt b/src/TestRon.kt
index fbf88bd..49b44df 100644
--- a/src/TestRon.kt
+++ b/src/TestRon.kt
@@ -24,6 +24,25 @@ fun obtSeq(arrl: ArrayList<Int>): ArrayList<ArrayList<Int>> {
     return arrlR
 }
 
+fun obtSeqInv(arrl: ArrayList<Int>): ArrayList<ArrayList<Int>> {
+    val arrlR = arrayListOf<ArrayList<Int>>()
+    var i = arrl.size - 1
+    while (i >= 0) {
+        val primerElem = arrl[i]
+        if (arrl.contains(primerElem - 1) && arrl.contains(primerElem - 2)) {
+            arrl.remove(primerElem)
+            arrl.remove(primerElem - 1)
+            arrl.remove(primerElem - 2)
+            i -= 3
+            arrlR.add(arrayListOf(primerElem, primerElem - 1, primerElem - 2))
+        } else {
+            i--
+        }
+    }
+
+    return arrlR
+}
+
 fun obtTri(arrl: ArrayList<Int>): ArrayList<ArrayList<Int>> {
     val arrlR = arrayListOf<ArrayList<Int>>()
     var i = 0
@@ -57,26 +76,27 @@ fun obtPar(arrl: ArrayList<Int>): ArrayList<ArrayList<Int>> {
     return arrlR
 }
 
-// TODO: Para solucionar el problema verificar tambien al reves
 fun main() {
-    val cartas = arrayListOf(1, 2, 2, 2, 3, 3, 4, 5)
-    val cartas2 = arrayListOf(1, 2, 2, 2, 3, 3, 4, 5)
+    val cartas  = arrayListOf(2, 2, 2, 3, 3, 4, 4)
+    val cartas2 = arrayListOf(2, 2, 2, 3, 3, 4, 4)
 
     val arrlR = obtSeq(cartas)
     val arrlT = obtTri(cartas)
     val arrlP = obtPar(cartas)
 
+    println("-------------------")
     println(arrlR)
     println(arrlT)
     println(arrlP)
+    println(cartas)
+
+    val arrlR2 = obtSeqInv(cartas2)
+    val arrlT2 = obtTri(cartas2)
+    val arrlP2 = obtPar(cartas2)
 
     println("-------------------")
-
-    val arrlP2 = obtPar(cartas2)
-    val arrlT2 = obtTri(cartas2)
-    val arrlR2 = obtSeq(cartas2)
-
     println(arrlR2)
     println(arrlT2)
     println(arrlP2)
+    println(cartas2)
 }
diff --git a/src/juego/OportunidadWin.kt b/src/juego/OportunidadWin.kt
index 4c135df..3c2c2ea 100644
--- a/src/juego/OportunidadWin.kt
+++ b/src/juego/OportunidadWin.kt
@@ -6,11 +6,123 @@ class OportunidadWin(override val cartaDescartada: Int) : Oportunidad {
 
     companion object {
 
-        private fun obtSeq1(arrl: ArrayList<CartaNumero>): ArrayList<ArrayList<CartaNumero>> {
-            TODO()
+        private fun <T : Carta> ArrayList<out T>.cartaExisteEnArrl(valorCarta: Int): Boolean {
+            for (c in this) {
+                val valorCartaParActual = (c.valor ushr 1) shl 1
+                if (valorCartaParActual == valorCarta) return true
+            }
+            return false
+        }
+
+        private fun <T : Carta> ArrayList<out T>.eliminarCarta(valorCarta: Int): T {
+            for (c in this) {
+                val valorCartaParActual = (c.valor ushr 1) shl 1
+                if (valorCartaParActual == valorCarta) {
+                    this.remove(c)
+                    return c
+                }
+            }
+
+            throw Error("El valor de la carta no existe en el array.")
+        }
+
+        private fun obtTri(cartas: ArrayList<Carta>): ArrayList<ArrayList<Carta>> {
+            val arrlR = arrayListOf<ArrayList<Carta>>()
+            var i = 0
+            while (i + 2 < cartas.size) {
+                val primeraCarta = cartas[i]
+                val valorPrimeraCartaPar = (primeraCarta.valor ushr 1) shl 1
+                val primerElem = (primeraCarta.valor ushr 1) shl 1
+                val segundoElem = (cartas[i + 1].valor ushr 1) shl 1
+                val tercerElem = (cartas[i + 2].valor ushr 1) shl 1
+                if (primerElem == segundoElem && primerElem == tercerElem) {
+                    val c1 = cartas.eliminarCarta(valorPrimeraCartaPar)
+                    val c2 = cartas.eliminarCarta(valorPrimeraCartaPar)
+                    val c3 = cartas.eliminarCarta(valorPrimeraCartaPar)
+                    arrlR.add(arrayListOf(c1, c2, c3))
+                } else {
+                    i++
+                }
+            }
+            return arrlR
+        }
+
+        private fun obtPar(cartas: ArrayList<Carta>): ArrayList<ArrayList<Carta>> {
+            val arrlR = arrayListOf<ArrayList<Carta>>()
+            var i = 0
+            while (i + 2 < cartas.size) {
+                val primeraCarta = cartas[i]
+                val valorPrimeraCartaPar = (primeraCarta.valor ushr 1) shl 1
+                val primerElem = (primeraCarta.valor ushr 1) shl 1
+                val segundoElem = (cartas[i + 1].valor ushr 1) shl 1
+                if (primerElem == segundoElem) {
+                    val c1 = cartas.eliminarCarta(valorPrimeraCartaPar)
+                    val c2 = cartas.eliminarCarta(valorPrimeraCartaPar)
+                    arrlR.add(arrayListOf(c1, c2))
+                } else {
+                    i++
+                }
+            }
+            return arrlR
+        }
+
+        private fun obtSeq1(cartas: ArrayList<CartaNumero>): ArrayList<ArrayList<CartaNumero>> {
+            val arrlCartas = arrayListOf<ArrayList<CartaNumero>>()
+            var i = 0
+            while (i < cartas.size) {
+                val primeraCarta = cartas[i]
+                val valorCartaPar = (primeraCarta.valor ushr 1) shl 1
+
+                if (
+                    cartas.cartaExisteEnArrl(valorCartaPar + 1)
+                    && cartas.cartaExisteEnArrl(valorCartaPar + 2)
+                ) {
+                    val c1 = cartas.eliminarCarta(valorCartaPar)
+                    val c2 = cartas.eliminarCarta(valorCartaPar + 1)
+                    val c3 = cartas.eliminarCarta(valorCartaPar + 2)
+                    arrlCartas.add(arrayListOf(c1, c2, c3))
+                } else {
+                    i++
+                }
+            }
+
+            return arrlCartas
+        }
+
+        private fun obtSeq2(cartas: ArrayList<CartaNumero>): ArrayList<ArrayList<CartaNumero>> {
+            val arrlCartas = arrayListOf<ArrayList<CartaNumero>>()
+            var i = cartas.size - 1
+            while (i < cartas.size) {
+                val primeraCarta = cartas[i]
+                val valorCartaPar = (primeraCarta.valor ushr 1) shl 1
+
+                if (
+                    cartas.cartaExisteEnArrl(valorCartaPar - 1)
+                    && cartas.cartaExisteEnArrl(valorCartaPar - 2)
+                ) {
+                    val c1 = cartas.eliminarCarta(valorCartaPar)
+                    val c2 = cartas.eliminarCarta(valorCartaPar - 1)
+                    val c3 = cartas.eliminarCarta(valorCartaPar - 2)
+                    arrlCartas.add(arrayListOf(c1, c2, c3))
+                    i -= 3
+                } else {
+                    i--
+                }
+            }
+
+            return arrlCartas
+        }
+
+        private fun obtenerPosiblesSeq(cartas: ArrayList<CartaNumero>): Pair<ArrayList<ArrayList<CartaNumero>>, ArrayList<ArrayList<CartaNumero>>> {
+            val cartas2 = ArrayList<CartaNumero>(cartas.size)
+            cartas2.addAll(cartas)
+
+            val seqOrden1 = obtSeq1(cartas)
+            val seqOrden2 = obtSeq2(cartas)
+
+            return Pair(seqOrden1, seqOrden2)
         }
 
-        // TODO
         fun verificar(valorCarta: Int, cartasMano: ArrayList<Int>, numGruposAbiertos: Int = 0) {
             val narrl = arrayListOf<Int>()
             narrl.addAll(cartasMano)