diff --git a/README.md b/README.md
index 91ab44d..a06dfc9 100644
--- a/README.md
+++ b/README.md
@@ -1,107 +1,50 @@
# Adivina el Número - Guess the Number
-## Índice
-
-- [1. Resumen del Proyecto](#1-resumen-del-proyecto)
-- [2. Consideraciones Generales](#2-consideraciones-generales)
-- [3. Objetivos de Aprendizaje](#3-objetivos-de-aprendizaje)
-
----
-
-
-
## 1. Resumen del Proyecto
_Guess The Number_ es un juego interactivo que se desarrolla en el terminal,
donde la jugadora y el ordenador se turnan para intentar adivinar un número
aleatorio entre 1 y 100. Deben tener en cuenta la tentativa anterior, si fue
"muy alta" o "muy baja".
-
-## 2. Consideraciones Generales
-
-- Este proyecto debe desarrollarse de manera **individual**.
-- La estimación de tiempo para completar el proyecto es de 1 a 2 Sprints.
-- Concéntrate en adquirir conocimientos en lugar de simplemente "terminar" el
- proyecto.
-- Ten paciencia. No te preocupes demasiado por lo que aún no entiendes
- completamente.
-- Tu aprendizaje se desarrollará a medida que progreses.
-
-### **Criterios de Aceptación Mínimos del Proyecto**
-
-- La jugadora y el ordenador se turnarán en turnos para intentar adivinar el
- número.
-- Después de cada tentativa, se debe mostrar:
- * El nombre del jugador (persona o computadora).
- * La suposición realizada.
- * Un mensaje indicando si la suposición fue muy alta, muy baja o correcta.
-- El juego terminará tan pronto como la jugadora o el ordenador adivine el
- número secreto. Debe mostrarse un mensaje de fin de juego, así como una lista
- de todas las tentativas realizadas por la jugadora ganadora.
-
-**_¡Diviértete construyendo tu juego de adivinanza de números! 🎲🎮_**
-
-- [Versión en Python](./docs/README-python.md)
-- [Versión en Java](./docs/README-java.md)
-- [Versión en C#](./docs/README-csharp.md)
-
-## 3. Objetivos de Aprendizaje
-
-
-Reflexiona y luego marca los objetivos que has llegado a entender y aplicar en tu proyecto. Piensa en eso al decidir tu estrategia de trabajo.
-
-### Java
-
-- [ ] **Modificadores de acesso (public, private, protected)**
-
-- [ ] **Uso de condicionales**
-
-- [ ] **Uso de bucles (Loops)**
-
-#### Tipos de data
-
-- [ ] **Datos primitivos vs no primitivos**
-
-- [ ] **Cadenas**
-
-- [ ] **Arreglos**
-
-#### Colecciones
-
-- [ ] **ArrayList**
-
-#### Testing
-
-- [ ] **JUnit**
-
-- [ ] **Mockito**
-
-### Programación Orientada a Objetos (OOP)
-
-- [ ] **Clases**
-
-- [ ] **Objetos**
-
-- [ ] **Métodos**
-- [ ] **Atributos**
+**Elementos del juego**
-- [ ] **Constructores**
+- player 1
+- Computadora
+- Numero aleatorio con random
+- Random que virifca y guarda dos numeros para crear el limite de consulta segun el Rango que computadora indique
-- [ ] **Encapsulamiento**
+**En este proyecto trabaje todo desde una solo archivo Python ya que lo veo mas practico, la distribucion fue la siguiente:**
+- Main.py : en este archivo cree la importacion de dos librerias una llamada random y la otra llamada time (manejo y usos se los dejare abajo)
+- El objetivo principal era crear una variable Random que creara un numero aleatorio para que pueda ser adivinado.
+- Llegamos a la creacion de una funcion llamada **Comparation_result** con su argumento **consult**,
+este esta verifica si el numero que generamos en random es mayor o menor.
-- [ ] **Abstracción**
+**Ìngresamos al area del** **Ciclo o Bucle**
+ - En el bucle verificamos con un input el ingreso del valor de uno de los jugadores **player** una vez tengamos el numero de **player**
+ lo comparamos con :
+ - Numero correcto.
+ - Numero mernor.
+ - Numero mayor.
+ **Creamos una variable llamada **computadora_numero** donde con un random genera su numero para ser comparado y lograr la interaccion de player y "computadora"**
+ donde dicho numero es tambien verificado con:
+ - Numero correcto.
+ - Numero mernor.
+ - Numero mayor.
+ **En este while utilizamos la declaracion break para romper el ciclo y no crear ciclos infinitos o con errores que dificulten el proceso del while.**
-- [ ] **Composición**
+**Utilizo la funcion **time.sleep(1)** para pausar la ejecucion 1 segundo , esto lo hago para tener una mejor experiencia en el juego.**
-- [ ] **Interfaces**
+**Ingresando al modo Hacker**
+- en esta seccion transformamos la interaccion de **computadora_numero** con la creacion de un random.randint(MIN_NUM, MAX_NUM) que guarde el ultimo valor de dicha variable bien sea por arriba o por abajo del numero random principal, esto genera un nuevo rango con el cual aseguramos que **computadora_numero** tenga una "ventaja" y aseguremos menor rango de numeros repetidos.
-- [ ] **Herencia (super, extends, override)**
+ Links de Consulta
-- [ ] **Lenguaje de Modelado Unificado (UML, class diagrams)**
+ * [MSTest V2 - GitHub](https://github.com/microsoft/testfx?tab=readme-ov-file)
+ * [Prueba unitaria de C# con MSTest y .NET](https://learn.microsoft.com/es-es/dotnet/core/testing/unit-testing-with-mstest)
+
-2. Ejecuta `main.py`.
-
-#### Referencias
-
-- [Cómo escribir y ejecutar un script de
- Python](https://entrenamiento-python-basico.readthedocs.io/es/3.7/leccion1/holamundo.html#ejecucion)
-
-### 4.3 Implementar el juego
-
-Ahora que tienes un entorno de desarrollo de Python funcionando, puedes empezar
-a implementar el juego.
-
-1. Genera un número aleatorio entre 1 y 100. Puedes usar la función `randint`
-en el módulo `random` para hacer esto.
-
-2. Implementa un bucle que solicite a la jugadora que adivine el número. Usa la
-función `input` para obtener la entrada de la jugadora.
-
-3. Compara la entrada de la jugadora con el número secreto. Si la jugadora
-adivina correctamente, termina el juego. Si la jugadora adivina
-incorrectamente, proporciona una pista sobre si el número secreto es mayor o
-menor que la entrada de la jugadora.
-
-4. Implementa la lógica para el turno del ordenador. El ordenador puede hacer
-una suposición aleatoria, o puedes implementar alguna estrategia para que sus
-suposiciones sean más inteligentes.
-
-5. Continúa el juego hasta que la jugadora o el ordenador adivinen
-correctamente el número.
-
-6. Añade pruebas unitarias para tu código. Python tiene un módulo incorporado
-llamado `unittest` que puedes usar para esto.
-
-#### Referencias
-
-- [Generación de números aleatorios en
- Python](https://docs.python.org/3/library/random.html)
-- [Bucles en
- Python](https://docs.python.org/3/tutorial/controlflow.html#for-statements)
-- [La función input en
- Python](https://docs.python.org/3/library/functions.html#input)
-- [Comparaciones en
- Python](https://docs.python.org/3/library/stdtypes.html#comparisons)
-- [Pruebas unitarias en Python con
- unittest](https://docs.python.org/4/library/unittest.html)
-
-### 4.4 Mejorar el juego
-
-Una vez que tengas una versión básica del juego funcionando, puedes hacer
-mejoras.
-
-1. Lleva un registro de las suposiciones de la jugadora y del ordenador. Cuando
-el juego termine, muestra todas las suposiciones que hizo la jugadora ganadora.
-
-2. Añade una opción para jugar de nuevo. Cuando el juego termine, pregunta a la
-jugadora si quiere jugar de nuevo.
-
-3. Añade comentarios a tu código para explicar qué hace cada parte. Esto hará
-que tu código sea más fácil de entender y mantener.
-
-#### Referencias
-
-- [Manejo de listas en
- Python](https://docs.python.org/3/tutorial/introduction.html#lists)
-- [Cómo escribir comentarios en
- Python](https://www.w3schools.com/python/python_comments.asp)
-
-### 4.5 Crear una "inteligencia" para jugar contra la computadora (Edición Hacker)
-
-Una vez que hayas implementado el juego básico y hecho algunas mejoras, puedes
-llevar las cosas al siguiente nivel creando una "inteligencia" para jugar
-contra la computadora. Esta "inteligencia" podría ser simplemente otra
-implementación del juego que utiliza una estrategia diferente, o podría ser un
-algoritmo de aprendizaje automático que mejora con cada juego que juega.
-
-1. Implementa una nueva versión del juego que utiliza una estrategia diferente.
-Por ejemplo, en lugar de adivinar al azar, esta versión podría intentar
-adivinar el número más probable basándose en las suposiciones anteriores.
-
-2. Prueba tu nueva "inteligencia" jugando contra la computadora. ¿Puedes
-ganarle a la computadora con tu nueva estrategia?
-
-3. Si te sientes ambicioso, podrías intentar implementar un algoritmo de
-aprendizaje automático. Este algoritmo podría aprender de cada juego que juega,
-mejorando sus suposiciones con cada juego. Podrías usar una biblioteca de
-aprendizaje automático como scikit-learn para hacer esto.
-
-4. Asegúrate de añadir pruebas unitarias para tu nueva "inteligencia". También
-podrías querer añadir algunas métricas para rastrear cómo mejora tu algoritmo
-con cada juego que juega.
-
-#### Referencias
-
-- [Introducción a
- scikit-learn](https://scikit-learn.org/stable/getting_started.html)
-- [Cómo implementar un algoritmo de aprendizaje
- automático](https://machinelearningmastery.com/start-here/#algorithms)
-
-## 5. Extensión: Versión Orientada a Objetos (OOP)
-
-Una vez que hayas implementado y perfeccionado la versión base del juego,
-es posible que desees considerar la posibilidad de reescribirlo utilizando
-el paradigma de la Programación Orientada a Objetos (OOP). Esta sería una
-ampliación (no un requisito) que te permitiría familiarizarte con los
-objetivos de aprendizaje de la programación orientada a objetos. Quizás te
-resulte útil si tus futuros proyectos en Python involucran el uso de
-frameworks que se basan en este paradigma. Por ejemplo, algunas
-herramientas como los ORM (mapeadores objeto-relacional) que se
-encuentran en el mundo de Python
-están diseñadas para funcionar con la programación orientada a objetos.
-
-1. Crea una clase `Game` que represente una instancia del juego. Esta clase
-puede tener métodos como `start`, `play_turn`, `check_guess`, y `end_game`.
-
-2. Crea una clase `Player` que represente a una jugadora. Esta clase puede
-tener atributos como `name` y `guesses`, y métodos como `make_guess`.
-
-3. Crea una subclase `ComputerPlayer` que herede de la clase `Player`. Esta
-clase puede sobrescribir el método `make_guess` para implementar la lógica de
-adivinación del ordenador.
-
-4. En la clase `Game`, usa instancias de las clases `Player` y `ComputerPlayer`
-para representar a la jugadora y al ordenador.
-
-5. Añade pruebas unitarias para tus clases y métodos. Python tiene un módulo
-incorporado llamado `unittest` que puedes usar para esto.
-
-### Referencias
-
-- [Programación Orientada a Objetos en
- Python](https://docs.python.org/3/tutorial/classes.html)
diff --git a/src/__pycache__/main.cpython-312.pyc b/src/__pycache__/main.cpython-312.pyc
new file mode 100644
index 0000000..3924edf
Binary files /dev/null and b/src/__pycache__/main.cpython-312.pyc differ
diff --git a/src/__pycache__/test.cpython-312.pyc b/src/__pycache__/test.cpython-312.pyc
new file mode 100644
index 0000000..0b23973
Binary files /dev/null and b/src/__pycache__/test.cpython-312.pyc differ
diff --git a/src/__pycache__/utils.cpython-312.pyc b/src/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 0000000..5b42941
Binary files /dev/null and b/src/__pycache__/utils.cpython-312.pyc differ
diff --git a/src/main.py b/src/main.py
new file mode 100644
index 0000000..1da1f5b
--- /dev/null
+++ b/src/main.py
@@ -0,0 +1,34 @@
+"""setear numero aleatorio"""
+"""- funcion que dada una variable numero esta diga si esta por arriba, por abajo o si es el numero
+ *si es el numero romper el ciclo"""
+import random
+import time
+from utils import player_validation
+"""variable mayuscula para que sea una variable global (buenas practicas)"""
+RANDOM_NUM: int = random.randint(1,101)
+MIN_NUM = 1
+MAX_NUM = 101
+COUNTER = 0
+RECORDS = []
+
+print(f"Numero a adivinar {RANDOM_NUM}")
+
+
+"""ciclo refactorizar """
+while True:
+ COUNTER += 1
+ result, MIN_NUM, MAX_NUM, choosen = player_validation("me", RANDOM_NUM, MIN_NUM, MAX_NUM)
+ RECORDS.append({"player": "me", "turn": COUNTER, "choosen": choosen})
+ if result == "winner":
+ print("Felicidades, ganaste!")
+ break
+ time.sleep(1)
+
+ result, MIN_NUM, MAX_NUM, choosen = player_validation("computadora", RANDOM_NUM, MIN_NUM, MAX_NUM)
+ RECORDS.append({"player": "computer", "turn": COUNTER, "choosen": choosen})
+ if result == "winner":
+ print("Computadora ha ganado!")
+ break
+
+print(f"Juego finalizado en {COUNTER} rondas")
+print(*RECORDS, sep="\n")
\ No newline at end of file
diff --git a/src/test.py b/src/test.py
new file mode 100644
index 0000000..d7f4a15
--- /dev/null
+++ b/src/test.py
@@ -0,0 +1,47 @@
+import unittest
+from utils import comparation_result
+
+
+class TestComparationResultFunction(unittest.TestCase):
+
+ def test_ok(self):
+ self.assertEqual(comparation_result(3, 3), 'winner')
+ self.assertEqual(comparation_result(3, 4), 'menor')
+ self.assertEqual(comparation_result(4, 3), 'mayor')
+
+ def test_errors(self):
+ self.assertEqual(comparation_result("3", 3), 'error')
+ self.assertEqual(comparation_result(3, "3"), 'error')
+ self.assertEqual(comparation_result("l", 3), 'error')
+ self.assertEqual(comparation_result(3, "l"), 'error')
+ self.assertEqual(comparation_result(" ", "l"), 'error')
+
+ def test_missing_arguments(self):
+ with self.assertRaises(TypeError) as result:
+ self.assertEqual(comparation_result(3,), 'error')
+ self.assertEqual(
+ str(result.exception), "comparation_result() missing 1 required positional argument: 'num'"
+ )
+
+ with self.assertRaises(TypeError) as result:
+ self.assertEqual(comparation_result(), 'error')
+ self.assertEqual(
+ str(result.exception), "comparation_result() missing 2 required positional arguments: 'consult' and 'num'"
+ )
+
+ """def test_upper(self):
+ self.assertEqual('foo'.upper(), 'FOO')
+
+ def test_isupper(self):
+ self.assertTrue('FOO'.isupper())
+ self.assertFalse('Foo'.isupper())
+
+ def test_split(self):
+ s = 'hello world'
+ self.assertEqual(s.split(), ['hello', 'world'])
+ # check that s.split fails when the separator is not a string
+ with self.assertRaises(TypeError):
+ s.split(2)"""
+
+if __name__ == '__main__':
+ unittest.main()
\ No newline at end of file
diff --git a/src/utils.py b/src/utils.py
new file mode 100644
index 0000000..c415217
--- /dev/null
+++ b/src/utils.py
@@ -0,0 +1,44 @@
+import random
+
+RANDOM_NUM: int = random.randint(1,101)
+
+
+def comparation_result(consult, num):
+ # validamos que sean enteros
+ # isinstance entrega booleano
+ if not isinstance(consult, int) or not isinstance(num, int):
+ return "error"
+ if (consult > num):
+ return "mayor"
+ elif (consult < num):
+ return "menor"
+ else:
+ return "winner"
+
+
+def player_validation(player_type, num, min_n, max_n):
+ if player_type == "me":
+ turn = int(input("Te toca jugar, por favor ingresa un numero\n"))
+ player = ""
+
+ elif player_type == "computadora":
+ print("\nComputador jugando " + "-"*10)
+ turn = random.randint(min_n, max_n)
+ player = player_type.title()
+ print(f"Computadora ha elegido el numero {turn}")
+
+ comparar = comparation_result(turn, num)
+
+ if comparar == "winner":
+ print("Felicidades acertaste al numero correcto")
+ else:
+ if comparar == "menor":
+ if player_type == "computadora":
+ min_n = turn
+ print(f"{player} El numero que elegiste es menor" )
+ else:
+ if player_type == "computadora":
+ max_n = turn
+ print(f"{player} El numero que elegiste es mayor")
+ return comparar,min_n, max_n, turn
+
\ No newline at end of file