Refactor find_first_sum function for efficiency; switch from nested loops to a dictionary for tracking seen numbers

midudev · midudev · commit 683b639c690f · 2025-02-05T19:32:08.000+01:00
diff --git a/04_logic/03_challenge_find_first_sum.py b/04_logic/03_challenge_find_first_sum.py
@@ -7,17 +7,26 @@
 find_first_sum(nums, goal)  # [2, 3]
 """
 
+# def find_first_sum(nums, goal):
+#   # early return, una validación rápida
+#   if len(nums) == 0: return None
+
+#   for i in range(len(nums)):
+#     for j in range(i + 1, len(nums)):
+#       if nums[i] + nums[j] == goal:
+#         return [i, j]
+
+#   return None # no se encontró ninguna combinación
+
 def find_first_sum(nums, goal):
-  # early return, una validación rápida
-  if len(nums) == 0: return None
+  seen = {} # diccionario para guardar el numero y su índice
 
-  for i in range(len(nums)):
-    for j in range(i + 1, len(nums)):
-      if nums[i] + nums[j] == goal:
-        return [i, j]
-      
-  return None # no se encontró ninguna combinación
+  for index, value in enumerate(nums):
+    missing = goal - value
+    if missing in seen: return [seen[missing], index]
+    seen[value] = index # guardar el número actual a los vistos, porque no hemos encontrado la combinación
 
+  return None
 
 nums = [4, 5, 6, 2]
 goal = 8
diff --git a/04_logic/04_dictionaries.py b/04_logic/04_dictionaries.py
@@ -0,0 +1,61 @@
+###
+# 04 - Dictionaries
+# Los diccionarios son colecciones de pares clave-valor.
+# Sirven para almacenar datos relacionados.
+###
+
+# ejemplo tipico de diccionario
+persona = {
+  "nombre": "midudev",
+  "edad": 25,
+  "es_estudiante": True,
+  "calificaciones": [7, 8, 9],
+  "socials": {
+    "twitter": "@midudev",
+    "instagram": "@midudev",
+    "facebook": "midudev"
+  }
+}
+
+# para acceder a los valores
+print(persona["nombre"])
+print(persona["calificaciones"][2])
+print(persona["socials"]["twitter"])
+
+# cambiar valores al acceder
+persona["nombre"] = "madeval"
+persona["calificaciones"][2] = 10
+
+# eliminar completamente una propiedad
+del persona["edad"]
+# print(persona)
+
+es_estudiante = persona.pop("es_estudiante") 
+print(f"es_estudiante: {es_estudiante}")
+print(persona)
+
+# sobreescribir un diccionario con otro diccionario
+a = { "name": "miduev", "age": 25 }
+b = { "name": "madeval", "es_estudiante": True }
+
+a.update(b)
+print(a)
+
+# comprobar si existe una propiedad
+print("name" in persona) # False
+print("nombre" in persona) # True
+
+# obtener todas las claves
+print("\nkeys:")
+print(persona.keys())
+
+# obtener todas los valores
+print("\nvalues:")
+print(persona.values())
+
+# obtener tanto clave como valor
+print("\nitems:")
+print(persona.items())
+
+for key, value in persona.items():
+  print(f"{key}: {value}")
diff --git a/04_logic/05_challenge_battle.py b/04_logic/05_challenge_battle.py
@@ -0,0 +1,40 @@
+"""
+Tienes dos listas de números, lista_a y lista_b, ambas de la misma longitud. 
+
+Cada número en lista_a se "enfrenta" al número en la misma posición en lista_b.
+
+- Si el número en lista_a es mayor, su valor se suma al siguiente número en lista_a.
+- Si el número en lista_b es mayor, su valor se suma al siguiente número en lista_b.
+- Si los dos números son iguales, ambos se eliminan y no afectan al siguiente par.
+
+Debes simular estos enfrentamientos y devolver el resultado final:
+- Si al final queda un número en lista_a, devuelve ese número seguido de la letra "a" (por ejemplo, "3a").
+- Si al final queda un número en lista_b, devuelve ese número seguido de la letra "b" (por ejemplo, "2b").
+- En caso de empate, devuelve la letra "x".
+
+lista_a = [2, 4, 2]
+lista_b = [3, 3, 4]
+
+resultado = battle(lista_a, lista_b)  # -> "2b"
+
+# Explicación:
+# - 2 vs 3: gana 3 (+1)
+# - 4 vs 3+1: empate
+# - 2 vs 4: gana 4 (+2)
+# Resultado: "2b"
+
+lista_a = [4, 4, 4]
+lista_b = [2, 8, 2]
+
+resultado = battle(lista_a, lista_b)  # -> "x"
+
+# Explicación:
+# - 4 vs 2: gana 4 (+2)
+# - 4+2 vs 8: gana 8 (+2)
+# - 4 vs 2+2: empate
+# Resultado: "x"
+"""
+
+# Fuerza bruta: buscar la solución A SACO.
+# Algoritmos ocultos o cálculos o fórmulas
+# Programación dinámica: buscar una solución mas eficiente
