diff --git a/exercises/exercise1.py b/exercises/exercise1.py
index c9c0e74..bbcf8be 100644
--- a/exercises/exercise1.py
+++ b/exercises/exercise1.py
@@ -1,6 +1,9 @@
 """Bloque IF, operadores lógicos, función max y operador ternario."""
 
 
+from re import A
+
+
 def maximo_basico(a: float, b: float) -> float:
     """Toma dos números y devuelve el mayor.
 
@@ -12,6 +15,11 @@ def maximo_basico(a: float, b: float) -> float:
 
 
 # NO MODIFICAR - INICIO
+
+    if a > b: 
+        return a
+    if b > a: 
+        return b
 assert maximo_basico(10, 5) == 10
 assert maximo_basico(9, 18) == 18
 # NO MODIFICAR - FIN
@@ -25,8 +33,13 @@ def maximo_libreria(a: float, b: float) -> float:
     Referencia: https://docs.python.org/3/library/functions.html#max
     """
 
-
 # NO MODIFICAR - INICIO
+
+    if a > b: 
+        return max(a,b)
+    if b > a: 
+        return max(a,b)
+
 assert maximo_libreria(10, 5) == 10
 assert maximo_libreria(9, 18) == 18
 # NO MODIFICAR - FIN
@@ -42,6 +55,8 @@ def maximo_ternario(a: float, b: float) -> float:
 
 
 # NO MODIFICAR - INICIO
+    return a if (a>b) else b
+
 assert maximo_ternario(10, 5) == 10
 assert maximo_ternario(9, 18) == 18
 # NO MODIFICAR - FIN
diff --git a/exercises/exercise2.py b/exercises/exercise2.py
index 1f4e7f6..1b9ec6b 100644
--- a/exercises/exercise2.py
+++ b/exercises/exercise2.py
@@ -2,6 +2,9 @@
 """
 
 
+from ast import Compare
+
+
 def maximo_encadenado(a: float, b: float, c: float) -> float:
     """Toma 3 números y devuelve el máximo.
 
@@ -14,8 +17,14 @@ def maximo_encadenado(a: float, b: float, c: float) -> float:
     Referencia: https://docs.python.org/3/reference/expressions.html#comparisons # noqa: E501
     """
 
-
+######### FALTA REVISAR
 # NO MODIFICAR - INICIO
+    Compare(a | b | c)
+    if a > b:
+        return max(a,b)
+    if b > c:
+        return max(b,c)
+
 assert maximo_encadenado(1, 10, 5) == 10
 assert maximo_encadenado(5, 10, 1) == 10
 assert maximo_encadenado(5, 10, 5) == 10
@@ -40,6 +49,9 @@ def maximo_cuadruple(a: float, b: float, c: float, d: float) -> float:
 
 
 # NO MODIFICAR - INICIO
+
+    return max(a, b, c, d)
+
 assert maximo_cuadruple(1, 10, 5, -5) == 10
 assert maximo_cuadruple(4, 9, 18, 6) == 18
 assert maximo_cuadruple(24, 9, 18, 20) == 24
@@ -57,6 +69,9 @@ def maximo_arbitrario(*args) -> float:
 
 
 # NO MODIFICAR - INICIO
+
+    return max(*args)
+
 assert maximo_arbitrario(1, 10, 5, -5) == 10
 assert maximo_arbitrario(4, 9, 18, 6) == 18
 assert maximo_arbitrario(24, 9, 18, 20) == 24
diff --git a/exercises/exercise3.py b/exercises/exercise3.py
index 68339cd..157aec1 100644
--- a/exercises/exercise3.py
+++ b/exercises/exercise3.py
@@ -1,6 +1,8 @@
 """Único return vs múltiples return."""
 
+from operator import truediv
 from typing import Union
+from xmlrpc.server import MultiPathXMLRPCServer
 
 
 def operacion_basica(a: float, b: float, multiplicar: bool) -> Union[float, str]:  # noqa: E501
@@ -14,9 +16,16 @@ def operacion_basica(a: float, b: float, multiplicar: bool) -> Union[float, str]
         - Utilizar IF con ELIF con ELSE.
         - No utilizar AND ni OR.
     """
-
-
 # NO MODIFICAR - INICIO
+    if multiplicar:
+        result = a*b
+    elif b!=0:
+        result = a/b
+    else:
+        result = "Operación no válida"
+    print(result)
+    return result
+
 assert operacion_basica(1, 1, True) == 1
 assert operacion_basica(1, 1, False) == 1
 assert operacion_basica(25, 5, True) == 125
@@ -43,6 +52,14 @@ def operacion_multiple(a: float, b: float, multiplicar: bool) -> Union[float, st
 
 
 # NO MODIFICAR - INICIO
+    
+    if (multiplicar):
+        return a * b
+    if b != 0:
+        return a/b
+    return "Operación no válida"
+
+
 assert operacion_multiple(1, 1, True) == 1
 assert operacion_multiple(1, 1, False) == 1
 assert operacion_multiple(25, 5, True) == 125
diff --git a/exercises/exercise4.py b/exercises/exercise4.py
index 4a33f8b..c90e27b 100644
--- a/exercises/exercise4.py
+++ b/exercises/exercise4.py
@@ -1,6 +1,5 @@
 """Expresiones Booleanas."""
 
-
 def es_vocal_if(letra: str) -> bool:
     """Toma un string y devuelve un booleano en base a si letra es una vocal o
     no.
@@ -16,6 +15,19 @@ def es_vocal_if(letra: str) -> bool:
 
 
 # NO MODIFICAR - INICIO
+    letra = letra.lower()
+    if(letra == 'a'):
+        return True
+    elif (letra == 'e'):
+        return True
+    elif (letra == 'i'):
+        return True
+    elif (letra == 'o'):
+        return True
+    elif (letra == 'u'):
+        return True
+    return False
+
 assert es_vocal_if("a")
 assert not es_vocal_if("b")
 assert es_vocal_if("A")
@@ -42,6 +54,13 @@ def es_vocal_if_in(letra: str) -> bool:
 
 
 # NO MODIFICAR - INICIO
+    letra = letra.lower()
+    vocales = 'aeiou'
+
+    if (letra in vocales):
+        return True
+    return False
+
 assert es_vocal_if_in("a")
 assert not es_vocal_if_in("b")
 assert es_vocal_if_in("A")
@@ -63,6 +82,14 @@ def es_vocal_in(letra: str) -> bool:
 
 
 # NO MODIFICAR - INICIO
+    es_vocal=False
+    letra == letra.lower()
+    vocales = 'aeiou'
+    while letra in vocales:
+        es_vocal=True
+        break;
+    return es_vocal
+
 assert es_vocal_in("a")
 assert not es_vocal_in("b")
 assert es_vocal_in("A")
diff --git a/exercises/exercise5.py b/exercises/exercise5.py
index 1207cbb..2e112ae 100644
--- a/exercises/exercise5.py
+++ b/exercises/exercise5.py
@@ -9,6 +9,12 @@ def sumatoria_basico(n: int) -> int:
 
 
 # NO MODIFICAR - INICIO
+
+    resultado=0
+    for i in range (n+1):
+         resultado=resultado+i
+    return resultado
+    
 assert sumatoria_basico(1) == 1
 assert sumatoria_basico(100) == 5050
 # NO MODIFICAR - FIN
@@ -21,9 +27,10 @@ def sumatoria_sum(n: int) -> int:
     """Re-Escribir utilizando la función sum.
 
     Restricción: No utilizar bucles (FOR, WHILE, etc)
-    Referencia: https://docs.python.org/3/library/functions.html#sum
+    Referencia: https://docs.python.org/3/library/functions.html#sum   sum(Iterable,start=0)
     """
-
+    
+    return sum(range(n+1))
 
 # NO MODIFICAR - INICIO
 assert sumatoria_sum(1) == 1
@@ -38,7 +45,7 @@ def sumatoria_sum(n: int) -> int:
 
 
 def multiplicar_basico(numeros: Iterable[float]) -> float:
-    """Toma un lista de números y devuelve el producto todos los númereos. Si
+    """Toma un lista de números y devuelve el producto todos los números. Si
     la lista está vacia debe devolver 0.
 
     Restricciones:
@@ -47,6 +54,12 @@ def multiplicar_basico(numeros: Iterable[float]) -> float:
         - Utilizar múltiples Return
         - No utilizar ELSE
     """
+    if (len(numeros)==0):
+        return 0
+    total = 1
+    for i in numeros:   
+        total = total * i
+    return total
 
 
 # NO MODIFICAR - INICIO
diff --git a/exercises/exercise6.py b/exercises/exercise6.py
index cc6c8e0..b6690f8 100644
--- a/exercises/exercise6.py
+++ b/exercises/exercise6.py
@@ -3,6 +3,7 @@
 from typing import List, Union
 
 
+lista=[3, "a", 1, "b", 10, "j"]
 def numeros_al_final_basico(lista: List[Union[float, str]]) -> List[Union[float, str]]:  # noqa: E501
     """Toma una lista de enteros y strings y devuelve una lista con todos los
     elementos numéricos al final.
@@ -12,16 +13,25 @@ def numeros_al_final_basico(lista: List[Union[float, str]]) -> List[Union[float,
         - Utilizar la función type.
         - No utilizar índices.
     """
-
+    lista1=[]
+    for i in lista:                            
+        if type(i) == int:
+            lista1.append(i)
+        elif type(i)== str:                 
+            lista1.insert(0,i)
+    print(lista1)
+    return lista1
 
 # NO MODIFICAR - INICIO
 assert numeros_al_final_basico([3, "a", 1, "b", 10, "j"]) == ["a", "b", "j", 3, 1, 10]  # noqa: E501
+
 # NO MODIFICAR - FIN
 
 
 ###############################################################################
 
-
+#DIAPO 12 funciones
+from typing import List, Union
 def numeros_al_final_comprension(lista: List[Union[float, str]]) -> List[Union[float, str]]:  # noqa: E501
     """Re-escribir utilizando comprensión de listas.
 
@@ -30,7 +40,12 @@ def numeros_al_final_comprension(lista: List[Union[float, str]]) -> List[Union[f
         - Utilizar dos comprensiones de listas.
     """
 
-
+    numeros=[]
+    letras=[]
+    lista = [i for i in lista if type(i) ==int]
+    lista = [i for i in lista if type(i) == str]
+    suma = letras + numeros
+    print(suma)
 # NO MODIFICAR - INICIO
 assert numeros_al_final_comprension([3, "a", 1, "b", 10, "j"]) == ["a", "b", "j", 3, 1, 10]  # noqa: E501
 # NO MODIFICAR - FIN
diff --git a/exercises/exercise7.py b/exercises/exercise7.py
index 00534bc..d958b41 100644
--- a/exercises/exercise7.py
+++ b/exercises/exercise7.py
@@ -2,17 +2,25 @@
 
 from typing import Any, Iterable
 
-
+test_list = [1, "hello", 35.20]
 def superposicion_basico(lista_1: Iterable[Any], lista_2: Iterable[Any]) -> bool:  # noqa: E501
     """Toma dos listas y devuelve un booleano en base a si tienen al menos 1
     elemento en común.
 
     Restricciones:
-        - Utilizar dos bucles FOR anidados.
+        - Utilizar dos bucles FOR anidados.            
         - Utilizar dos returns.
     """
-
-
+    bool = 0
+    for x in lista_1:
+        for y in lista_2:
+            if x == y:
+                bool = True
+    if (not bool):
+        return False
+    else:
+        return True
+   
 # NO MODIFICAR - INICIO
 test_list = [1, "hello", 35.20]
 assert superposicion_basico(test_list, (2, "world", 35.20))
@@ -21,8 +29,8 @@ def superposicion_basico(lista_1: Iterable[Any], lista_2: Iterable[Any]) -> bool
 
 
 ###############################################################################
-
-
+from typing import Any, Iterable
+test_list = [1, "hello", 35.20]
 def superposicion_in(lista_1: Iterable[Any], lista_2: Iterable[Any]) -> bool:
     """Re-Escribir utilizando un sólo bucle y el operador IN.
 
@@ -30,7 +38,10 @@ def superposicion_in(lista_1: Iterable[Any], lista_2: Iterable[Any]) -> bool:
         - Utilizar un único bucle FOR.
         - Utilizar dos returns.
     """
-
+    for i in lista_1:          
+        if i in lista_2:
+            return True
+    return False
 
 # NO MODIFICAR - INICIO
 test_list = [1, "hello", 35.20]
@@ -52,7 +63,7 @@ def superposicion_any(lista_1: Iterable[Any], lista_2: Iterable[Any]) -> bool:
 
     Referencia: https://docs.python.org/3/library/functions.html#any
     """
-
+    return any(i in lista_2 for i in lista_1)
 
 # NO MODIFICAR - INICIO
 test_list = [1, "hello", 35.20]
@@ -74,6 +85,7 @@ def superposicion_set(lista_1: Iterable[Any], lista_2: Iterable[Any]) -> bool:
     Referencia: https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset  # noqa: E501
     """
 
+    return bool (set(lista_1) & set(lista_2))
 
 # NO MODIFICAR - INICIO
 test_list = [1, "hello", 35.20]
diff --git a/exercises/exercise8.py b/exercises/exercise8.py
index ceea14b..c50ae3d 100644
--- a/exercises/exercise8.py
+++ b/exercises/exercise8.py
@@ -7,6 +7,7 @@
 """
 
 
+from operator import iadd, iand
 from typing import Any, List, Tuple
 
 nombre_articulos = ["ventana", "lámpara", "shampoo"]
@@ -25,12 +26,19 @@ def combinar_basico(nombres: List[str], precios: List[float]) -> Tuple[Any]:
 
 
 # NO MODIFICAR - INICIO
+    lista_de_listas = []
+    for i in range(3):
+        lista = [nombres[i], precios[i]]
+        lista_de_listas.append(tuple(lista))
+    tupla = tuple(lista_de_listas)
+    return tupla
 respuesta = (
-    ("ventana", 100.48),
-    ("lámpara", 16.42),
-    ("shampoo", 5.2),
+("ventana", 100.48),
+("lámpara", 16.42),
+("shampoo", 5.2),
 )
 
+
 assert combinar_basico(nombre_articulos, precio_articulos) == respuesta
 # NO MODIFICAR - FIN
 
@@ -54,6 +62,14 @@ def combinar_enumerate(nombres: List[str], precios: List[float], ids: List[int])
 
 
 # NO MODIFICAR - INICIO
+    lista_1=[]
+    for i, nombres in enumerate(nombres):
+        lista = [nombres, precios[i], ids[i]]
+        lista_1.append(tuple(lista))
+    tupla = tuple(lista_1)
+    return tupla
+
+
 respuesta = (
     ("ventana", 100.48, 6852),
     ("lámpara", 16.42, 1459),
@@ -83,6 +99,15 @@ def combinar_zip(nombres: List[str], precios: List[float], ids: List[int]) -> Tu
 
 
 # NO MODIFICAR - INICIO
+    variable = []
+    lista3=[]
+    for nombres, precios, ids in zip(nombres, precios, ids):
+        variable = [nombres, precios, ids]
+        lista3.append(tuple(variable))
+
+    lista3 = tuple(respuesta)
+    return lista3
+
 respuesta = (
     ("ventana", 100.48, 6852),
     ("lámpara", 16.42, 1459),
@@ -115,6 +140,13 @@ def combinar_zip_args(*args) -> Tuple[Any]:
 
 
 # NO MODIFICAR - INICIO
+    lista_ultima = []
+    for i in zip(*args):
+        lista_ultima.append(i)
+
+    respuesta = tuple(lista_ultima)
+    return respuesta  
+
 respuesta = (
     ("ventana", 100.48, 6852, "hogar", True),
     ("lámpara", 16.42, 1459, "libreria", False),
diff --git a/exercises/exercise9.py b/exercises/exercise9.py
index fcfaccb..d3fe791 100644
--- a/exercises/exercise9.py
+++ b/exercises/exercise9.py
@@ -15,9 +15,17 @@ def suma_cubo_pares_for(numeros: Iterable[int]) -> int:
         - https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions # noqa: E501
         - https://docs.python.org/3/library/functions.html#sum
     """
-
+    
 
 # NO MODIFICAR - INICIO
+    suma=0
+    numeros_cubo = []
+    for x in numeros:
+        numeros_cubo.append(x**3)
+    for x in numeros_cubo:
+        if (x%2)==0:                      
+            suma=suma+x
+    return(suma)
 assert suma_cubo_pares_for([1, 2, 3, 4, 5, 6]) == 288
 # NO MODIFICAR - FIN
 
@@ -36,6 +44,7 @@ def suma_cubo_pares_sum_list(numeros: Iterable[int]) -> int:
 
 
 # NO MODIFICAR - INICIO
+    return sum(pow(x, 3) for x in numeros if x % 2 == 0)
 assert suma_cubo_pares_sum_list([1, 2, 3, 4, 5, 6]) == 288
 # NO MODIFICAR - FIN
 
@@ -52,7 +61,7 @@ def suma_cubo_pares_sum_list(numeros: Iterable[int]) -> int:
 Restricción: Utilizar List, map y lambda y la variable numeros
 """
 
-numeros_al_cubo =  # Completar
+numeros_al_cubo = list(map(lambda x: x ** 3, numeros))
 
 """
 Escribir una función lambda que permita filtrar todos los elementos pares
@@ -60,7 +69,7 @@ def suma_cubo_pares_sum_list(numeros: Iterable[int]) -> int:
 Restricción: Utilizar List, filter, lambda y la variable numeros_al_cubo
 """
 
-numeros_al_cubo_pares =  # Completar
+numeros_al_cubo_pares = list(filter(lambda x: x%2 ==0, numeros_al_cubo))
 
 
 """
@@ -71,7 +80,7 @@ def suma_cubo_pares_sum_list(numeros: Iterable[int]) -> int:
 
 from functools import reduce  # noqa: E402
 
-suma_numeros_al_cubo_pares =  # Completar
+suma_numeros_al_cubo_pares = reduce(lambda x, y: x + y, numeros_al_cubo_pares)
 
 
 # NO MODIFICAR - INICIO
diff --git a/exercises/tempCodeRunnerFile.py b/exercises/tempCodeRunnerFile.py
new file mode 100644
index 0000000..a84d3f1
--- /dev/null
+++ b/exercises/tempCodeRunnerFile.py
@@ -0,0 +1,30 @@
+"""Sum, Compresión de Listas, Map, Filter, Reduce."""
+
+from typing import Iterable
+
+
+def suma_cubo_pares_for(numeros: Iterable[int]) -> int:
+    """Toma una lista de números, los eleva al cubo, y devuelve la suma de
+    los elementos pares.
+
+    Restricciones:
+        - Utilizar dos bucles FOR.
+        - No utilizar la función range.
+
+    Referencias:
+        - https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions # noqa: E501
+        - https://docs.python.org/3/library/functions.html#sum
+    """
+    
+
+# NO MODIFICAR - INICIO
+    suma=0
+    numeros_cubo = []
+    for x in numeros:
+        numeros_cubo.append(x**3)
+    for x in numeros_cubo:
+        if (x%2)==0:                      ####################################
+            suma=suma+x
+    return(suma)
+assert suma_cubo_pares_for([1, 2, 3, 4, 5, 6]) == 288
+# NO MODIFICAR - FIN
\ No newline at end of file