Code with exercise Divide y venceras

Emmanuel/Dynamic_Programming.py

@@ -0,0 +1,27 @@
+def calcular_sumas():
+    # Pedir al usuario el número de casos a evaluar
+    num_casos = int(input("¿Cuántos casos quieres evaluar? "))
+
+    for caso in range(1, num_casos + 1):
+        print(f"Caso {caso}:")
+
+        # Pedir al usuario la cantidad de números a evaluar en este caso
+        num_numeros = int(input("Ingrese la cantidad de números a evaluar: "))
+
+        # Pedir al usuario los números para este caso
+        numeros = []
+        for i in range(num_numeros):
+            numero = int(input(f"Ingrese el número {i+1}: "))
+            numeros.append(numero)
+
+        # Calcular la suma de los números
+        suma = sum(numeros)
+
+        # Imprimir el resultado para este caso
+        print(f"Resultado para el caso {caso}: {suma}")
+        print()
+
+
+# Llamar a la función principal
+calcular_sumas()
+

Emmanuel/Guess.py

@@ -0,0 +1,21 @@
+def guess_number(minimum, maximum):
+
+  if minimum == maximum:
+    return minimum
+  else:
+    middle = (minimum + maximum) // 2
+    answer = input("Is your number {}? ".format(middle))
+    if answer == "yes":
+      return middle
+    elif answer == "no":
+      answer = input("Is your number higher or lower than {}? ".format(middle))
+      if answer == "higher":
+        return guess_number(middle + 1, maximum)
+      else:
+        return guess_number(minimum, middle - 1)
+    else:
+      print("Invalid answer.")
+
+number = int(input("Enter the maximum number: "))
+guessed_number = guess_number(1, number)
+print("The secret number was {}!".format(guessed_number))

Emmanuel/Lista_array.py

@@ -0,0 +1,67 @@
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+
+class ListaArrayNumpy:
+    def __init__(self):
+        """
+        Constructor de la clase ListaArrayNumpy.
+        Inicializa una lista vacía utilizando un array NumPy.
+        """
+        self.array = np.array([])
+
+    def agregar_elemento(self, valor):
+        """
+        Agrega un nuevo elemento al final de la lista.
+
+        Parámetros:
+            - valor: El valor que se agregará a la lista.
+        """
+        inicio = time.time()
+        self.array = np.append(self.array, valor)
+        fin = time.time()
+        return fin - inicio
+
+    def eliminar_elemento(self, valor):
+        """
+        Elimina la primera ocurrencia del valor proporcionado en la lista.
+
+        Parámetros:
+            - valor: El valor del elemento que se desea eliminar.
+        """
+        inicio = time.time()
+        try:
+            indice = np.where(self.array == valor)[0][0]  # Encuentra el índice del primer valor
+            self.array = np.delete(self.array, indice)  # Elimina el valor en ese índicr
+        except IndexError:
+            print(f"El valor {valor} no está en la lista.")
+        fin = time.time()
+        return fin - inicio
+
+    def imprimir_lista(self):
+        """
+        Imprime todos los elementos de la lista.
+        """
+        print(self.array)
+
+
+# Ejemplo de uso:
+lista_numpy = ListaArrayNumpy()
+tiempos_agregar = []
+tiempos_eliminar = []
+
+for i in range(1000):
+    tiempo_agregar = lista_numpy.agregar_elemento(i)
+    tiempos_agregar.append(tiempo_agregar)
+
+for i in range(1000):
+    tiempo_eliminar = lista_numpy.eliminar_elemento(i)
+    tiempos_eliminar.append(tiempo_eliminar)
+
+print("Gráfico de tiempo de agregar y eliminar elementos en Lista Array con NumPy:")
+plt.plot(range(1000), tiempos_agregar, label='Agregar')
+plt.plot(range(1000), tiempos_eliminar, label='Eliminar')
+plt.xlabel('Número de elementos')
+plt.ylabel('Tiempo (segundos)')
+plt.legend()
+plt.show()

Emmanuel/README.md

@@ -0,0 +1,18 @@
+# Algorithm_analysis
+exploring the complexity of algorithms
+
+
+# Excercise
+
+## An implementation for linked lists is built.
+
+Then, a graph is made to observe the execution times for inserting elements between a linked list and an array from the python numpy library.
+
+It is suggested to add a linear function to the final graph to generate visual perspective.
+
+
+# Instructions for upload this Task
+
+Each student must upload their own implementation to this repository, to do so they must create a branch using the following nomenclature:
+"name-lastName"
+Finally perform the push.

Emmanuel/arbol_binario.py

@@ -0,0 +1,68 @@
+class Nodo:
+    def __init__(self, valor):
+        self.valor = valor
+        self.izquierda = None
+        self.derecha = None
+
+class ArbolBinarioBusqueda:
+    def __init__(self):
+        self.raiz = None
+
+    def insertar(self, valor):
+        if self.raiz is None:
+            self.raiz = Nodo(valor)
+        else:
+            self._insertar_recursivo(self.raiz, valor)
+
+    def _insertar_recursivo(self, nodo, valor):
+        if valor < nodo.valor:
+            if nodo.izquierda is None:
+                nodo.izquierda = Nodo(valor)
+            else:
+                self._insertar_recursivo(nodo.izquierda, valor)
+        elif valor > nodo.valor:
+            if nodo.derecha is None:
+                nodo.derecha = Nodo(valor)
+            else:
+                self._insertar_recursivo(nodo.derecha, valor)
+
+    def buscar(self, valor):
+        return self._buscar_recursivo(self.raiz, valor)
+
+    def _buscar_recursivo(self, nodo, valor):
+        if nodo is None or nodo.valor == valor:
+            return nodo is not None
+        if valor < nodo.valor:
+            return self._buscar_recursivo(nodo.izquierda, valor)
+        else:
+            return self._buscar_recursivo(nodo.derecha, valor)
+
+    def _imprimir_recursivo(self, nodo, espacio):
+        if nodo is not None:
+            espacio += 5
+            self._imprimir_recursivo(nodo.derecha, espacio)
+            print()
+            for _ in range(5, espacio):
+                print(end=" ")
+            print(nodo.valor)
+            self._imprimir_recursivo(nodo.izquierda, espacio)
+
+    def imprimir(self):
+        self._imprimir_recursivo(self.raiz, 0)
+
+# Ejemplo de uso
+arbol = ArbolBinarioBusqueda()
+arbol.insertar(10)
+arbol.insertar(5)
+arbol.insertar(15)
+arbol.insertar(7)
+arbol.insertar(3)
+arbol.insertar(12)
+arbol.insertar(14)
+arbol.insertar(20)
+arbol.insertar(18)
+arbol.insertar(16)
+
+# Mostrar el árbol binario
+print("Árbol binario:")
+arbol.imprimir()

Emmanuel/example.txt

@@ -0,0 +1 @@
+# Este es un archivo de ejemplo

Emmanuel/lista_ligada.py

@@ -0,0 +1,103 @@
+import time
+import matplotlib.pyplot as plt
+
+class Nodo:
+    def __init__(self, valor):
+        """
+        Constructor de la clase Nodo.
+
+        Parámetros:
+            - valor: El valor que contendrá el nodo.
+        """
+        self.valor = valor
+        self.siguiente = None  # El enlace al siguiente nodo
+
+
+class ListaEnlazada:
+    def __init__(self):
+        """
+        Constructor de la clase ListaEnlazada.
+        Inicializa una lista enlazada vacía.
+        """
+        self.cabeza = None  # La referencia al primer nodo de la lista
+
+    def agregar_elemento(self, valor):
+        """
+        Agrega un nuevo elemento al final de la lista enlazada.
+
+        Parámetros:
+            - valor: El valor que se agregará a la lista.
+        """
+        inicio = time.time()
+        nuevo_nodo = Nodo(valor)  # Crea un nuevo nodo con el valor proporcionado
+        if self.cabeza is None:  # Si la lista está vacía, el nuevo nodo se convierte en la cabeza
+            self.cabeza = nuevo_nodo
+        else:
+            # Recorre la lista hasta encontrar el último nodo
+            actual = self.cabeza
+            while actual.siguiente:
+                actual = actual.siguiente
+            # Agrega el nuevo nodo al final de la lista
+            actual.siguiente = nuevo_nodo
+        fin = time.time()
+        return fin - inicio
+
+    def eliminar_elemento(self, valor):
+        """
+        Elimina el primer nodo que contenga el valor proporcionado de la lista enlazada.
+
+        Parámetros:
+            - valor: El valor del nodo que se desea eliminar.
+        """
+        inicio = time.time()
+        actual = self.cabeza  # Inicia desde la cabeza de la lista
+        anterior = None  # Almacena el nodo anterior al actual
+        # Busca el nodo con el valor especificado
+        while actual and actual.valor != valor:
+            anterior = actual
+            actual = actual.siguiente
+        if actual:  # Si se encontró un nodo con el valor especificado
+            if anterior is None:  # Si el nodo a eliminar es la cabeza
+                self.cabeza = actual.siguiente  # Actualiza la cabeza de la lista
+            else:
+                # Elimina el nodo actual actualizando el enlace del nodo anterior
+                anterior.siguiente = actual.siguiente
+        fin = time.time()
+        return fin - inicio
+
+    def imprimir_lista(self):
+        """
+        Imprime los valores de todos los nodos en la lista enlazada.
+        """
+        actual = self.cabeza  # Inicia desde la cabeza de la lista
+        while actual:
+            print(actual.valor, end=" -> ")  # Imprime el valor del nodo
+            actual = actual.siguiente  # Avanza al siguiente nodo
+        print("None")
+
+
+# Ejemplo de uso:
+lista = ListaEnlazada()
+tiempos_agregar = []
+tiempos_eliminar = []
+
+for i in range(1000):
+    tiempo_agregar = lista.agregar_elemento(i)
+    tiempos_agregar.append(tiempo_agregar)
+
+for i in range(1000):
+    tiempo_eliminar = lista.eliminar_elemento(i)
+    tiempos_eliminar.append(tiempo_eliminar)
+
+print("Gráfico de tiempo de agregar y eliminar elementos en Lista Enlazada:")
+plt.plot(range(1000), tiempos_agregar, label='Agregar')
+plt.plot(range(1000), tiempos_eliminar, label='Eliminar')
+plt.xlabel('Número de elementos')
+plt.ylabel('Tiempo (segundos)')
+plt.legend()
+plt.show()
+
+
+
+
+