From f93b61ebb3862437d85e06494106f9243154bcb6 Mon Sep 17 00:00:00 2001
From: "Angel A." <165582966+alcaan16@users.noreply.github.com>
Date: Sat, 5 Apr 2025 09:53:30 +0200
Subject: [PATCH] Soluciones en python

Soluciones a los retos planteados en python
---
 retos_resueltos_alcaan16/ejer_0.py  |  24 +++++++
 retos_resueltos_alcaan16/ejer_01.py |  30 ++++++++
 retos_resueltos_alcaan16/ejer_02.py |  18 +++++
 retos_resueltos_alcaan16/ejer_03.py |  42 ++++++++++++
 retos_resueltos_alcaan16/ejer_04.py |  28 ++++++++
 retos_resueltos_alcaan16/ejer_05.py |  44 ++++++++++++
 retos_resueltos_alcaan16/ejer_06.py |  20 ++++++
 retos_resueltos_alcaan16/ejer_07.py |  50 ++++++++++++++
 retos_resueltos_alcaan16/ejer_08.py |  41 +++++++++++
 retos_resueltos_alcaan16/ejer_09.py |  88 ++++++++++++++++++++++++
 retos_resueltos_alcaan16/ejer_10.py |  67 ++++++++++++++++++
 retos_resueltos_alcaan16/ejer_11.py |  38 ++++++++++
 retos_resueltos_alcaan16/ejer_12.py | 103 ++++++++++++++++++++++++++++
 retos_resueltos_alcaan16/ejer_13.py |  18 +++++
 retos_resueltos_alcaan16/ejer_14.py |  30 ++++++++
 retos_resueltos_alcaan16/ejer_15.py |  43 ++++++++++++
 retos_resueltos_alcaan16/ejer_16.py |  38 ++++++++++
 retos_resueltos_alcaan16/ejer_17.py |  47 +++++++++++++
 18 files changed, 769 insertions(+)
 create mode 100644 retos_resueltos_alcaan16/ejer_0.py
 create mode 100644 retos_resueltos_alcaan16/ejer_01.py
 create mode 100644 retos_resueltos_alcaan16/ejer_02.py
 create mode 100644 retos_resueltos_alcaan16/ejer_03.py
 create mode 100644 retos_resueltos_alcaan16/ejer_04.py
 create mode 100644 retos_resueltos_alcaan16/ejer_05.py
 create mode 100644 retos_resueltos_alcaan16/ejer_06.py
 create mode 100644 retos_resueltos_alcaan16/ejer_07.py
 create mode 100644 retos_resueltos_alcaan16/ejer_08.py
 create mode 100644 retos_resueltos_alcaan16/ejer_09.py
 create mode 100644 retos_resueltos_alcaan16/ejer_10.py
 create mode 100644 retos_resueltos_alcaan16/ejer_11.py
 create mode 100644 retos_resueltos_alcaan16/ejer_12.py
 create mode 100644 retos_resueltos_alcaan16/ejer_13.py
 create mode 100644 retos_resueltos_alcaan16/ejer_14.py
 create mode 100644 retos_resueltos_alcaan16/ejer_15.py
 create mode 100644 retos_resueltos_alcaan16/ejer_16.py
 create mode 100644 retos_resueltos_alcaan16/ejer_17.py

diff --git a/retos_resueltos_alcaan16/ejer_0.py b/retos_resueltos_alcaan16/ejer_0.py
new file mode 100644
index 000000000..3b1c55207
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_0.py
@@ -0,0 +1,24 @@
+"""
+#0-EL FAMOSO "FIZZ BUZZ"
+/*
+ * Escribe un programa que muestre por consola (con un print) los
+ * números de 1 a 100 (ambos incluidos y con un salto de línea entre
+ * cada impresión), sustituyendo los siguientes:
+ * - Múltiplos de 3 por la palabra "fizz".
+ * - Múltiplos de 5 por la palabra "buzz".
+ * - Múltiplos de 3 y de 5 a la vez por la palabra "fizzbuzz".
+ */
+
+ """
+
+def funcion(var_1, var_2):
+
+    for i in range(1,101):
+        if i % 3 == 0 and i % 5 == 0:
+            print(f"el numero {i} es {var_1}{var_2}")
+        elif i % 3 == 0:
+            print(f"el numero {i} es {var_1}")
+        elif i % 5 == 0:
+            print(f"el numero {i} es {var_2}")
+
+funcion ("fizz", "buzz")
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_01.py b/retos_resueltos_alcaan16/ejer_01.py
new file mode 100644
index 000000000..73a848ea4
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_01.py
@@ -0,0 +1,30 @@
+"""
+#1-¿ES UN ANAGRAMA?
+/*
+ * Escribe una función que reciba dos palabras (String) y retorne
+ * verdadero o falso (Bool) según sean o no anagramas.
+ * - Un Anagrama consiste en formar una palabra reordenando TODAS
+ *   las letras de otra palabra inicial.
+ * - NO hace falta comprobar que ambas palabras existan.
+ * - Dos palabras exactamente iguales no son anagrama.
+ */
+"""
+
+def anagrama (var_1, var_2):
+    if var_1.lower() == var_2.lower():
+        #print ("las palabras son iguales")
+        return False
+    return sorted(var_1.lower()) == sorted (var_2.lower())
+    
+"""otra opcion
+    
+    elif sorted(var_1.lower()) == sorted (var_2.lower()):
+        #print ("las palabras son anagramas")
+        return True
+    else:
+        #print ("las palabras NO son anagramas")
+        return False
+"""
+
+print (anagrama("Caso", "saco"))
+
diff --git a/retos_resueltos_alcaan16/ejer_02.py b/retos_resueltos_alcaan16/ejer_02.py
new file mode 100644
index 000000000..f35fba61a
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_02.py
@@ -0,0 +1,18 @@
+"""
+#2-LA SUCESIÓN DE FIBONACCI
+/*
+ * Escribe un programa que imprima los 50 primeros números de la sucesión
+ * de Fibonacci empezando en 0.
+ * - La serie Fibonacci se compone por una sucesión de números en
+ *   la que el siguiente siempre es la suma de los dos anteriores.
+ *   0, 1, 1, 2, 3, 5, 8, 13...
+ */
+ """
+prev = 0
+next = 1
+
+for i in range(0,50):
+    print (prev)
+    fib = prev + next
+    prev = next
+    next = fib
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_03.py b/retos_resueltos_alcaan16/ejer_03.py
new file mode 100644
index 000000000..3ade83c28
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_03.py
@@ -0,0 +1,42 @@
+"""
+#3-¿ES UN NÚMERO PRIMO?
+/*
+ * Escribe un programa que se encargue de comprobar si un número es o no primo.
+ * Hecho esto, imprime los números primos entre 1 y 100.
+ */
+
+En matemáticas, un número primo es un número natural mayor que 1 
+que tiene únicamente dos divisores positivos distintos: él mismo y el 1.
+Los números primos son:
+2, 3, 5, 7, 11, 13, 17, 19, 23, 29
+
+"""
+def primo (numero):
+    if numero < 2:
+        return False
+    
+    for i in range(2,numero):
+        if numero %  i == 0:
+            return False
+
+    return True
+x = 13
+resultado = primo(x)
+print (f"el numero {x} es primo? {resultado}")
+
+
+#listado primos
+def list_primo ():
+    print ("\nlos primeros numeros primos son:")
+    for numero_2 in range(0,101):
+        if numero_2 >= 2:
+            divisible = False
+            for i in range(2,numero_2):
+                if numero_2 % i == 0:  
+                    divisible = True
+                    break
+            #if not divisible: #tambien es correcto
+            if divisible == False:    
+                print (numero_2)
+
+list_primo()
diff --git a/retos_resueltos_alcaan16/ejer_04.py b/retos_resueltos_alcaan16/ejer_04.py
new file mode 100644
index 000000000..b702dc9c8
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_04.py
@@ -0,0 +1,28 @@
+"""
+#4-ÁREA DE UN POLÍGONO
+/*
+ * Crea una única función (importante que sólo sea una) que sea capaz
+ * de calcular y retornar el área de un polígono.
+ * - La función recibirá por parámetro sólo UN polígono a la vez.
+ * - Los polígonos soportados serán Triángulo, Cuadrado y Rectángulo.
+ * - Imprime el cálculo del área de un polígono de cada tipo.
+ */
+
+*triangulo= base por altura dividido por 2.
+*cuadrado= multiplicamos Lado x Lado
+*rectangulo= multiplicamos el largo por el ancho.
+
+
+"""
+
+def area (num_1, num_2):
+        triangulo = (num_1 * num_2) /2
+        var = num_1 * num_2
+        print (f"el area del triangulo es {triangulo}")
+        print (f"el area del cuadrado es {var}")
+        print (f"el area del rectangulo es {var}")
+
+num_1 = 5
+num_2 = 2
+
+area(num_1, num_2)
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_05.py b/retos_resueltos_alcaan16/ejer_05.py
new file mode 100644
index 000000000..38f66ce22
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_05.py
@@ -0,0 +1,44 @@
+"""
+#5-ASPECT RATIO DE UNA IMAGEN
+/*
+ * Crea un programa que se encargue de calcular el aspect ratio de una
+ * imagen a partir de una url.
+ * - Url de ejemplo:
+ *   https://raw.githubusercontent.com/mouredevmouredev/master/mouredev_github_profile.png
+ * - Por ratio hacemos referencia por ejemplo a los "16:9" de una
+ *   imagen de 1920*1080px.
+ */
+
+Tienes que dividir la altura original por la anchura original 
+y luego multiplicar este número por la nueva anchura para obtener la nueva altura. 
+Estos pasos le darán la altura correcta para su imagen editada.
+
+
+
+def ratio(num_1, num_2):
+    var= num_1 / num_2
+    print (var)
+
+
+
+
+num_1 = 1920
+num_2 = 1080
+ratio(num_1, num_2)
+"""
+
+from PIL import Image
+import requests, math
+from io import BytesIO
+
+def get_aspect_ratio(image_url):
+    img_content = requests.get(image_url).content
+    try:
+        image = Image.open(BytesIO(img_content))
+        width, height = image.size
+        greatest_common_divisor = math.gcd(width, height)
+        aspect_ratio = f"{round(width / greatest_common_divisor)}:{round(height / greatest_common_divisor)}"
+        print(f"The Aspect Ratio is: {aspect_ratio}")
+    except Exception:
+        print("The provided URL is not a valid image.")
+get_aspect_ratio("https://wallpaperaccess.com/full/109676.jpg")
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_06.py b/retos_resueltos_alcaan16/ejer_06.py
new file mode 100644
index 000000000..ad807c585
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_06.py
@@ -0,0 +1,20 @@
+"""
+#6-INVIRTIENDO CADENAS
+/*
+ * Crea un programa que invierta el orden de una cadena de texto
+ * sin usar funciones propias del lenguaje que lo hagan de forma automática.
+ * - Si le pasamos "Hola mundo" nos retornaría "odnum aloH"
+ */
+"""
+
+def reves (texto):
+    texto_reves = ""
+    largo =  len(texto)
+    print (texto)
+    #print (largo)
+    for i in range (0, largo):
+        #print (texto[i])
+        texto_reves += texto[largo-i-1] 
+    return texto_reves
+
+print(reves("Hola mundo"))
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_07.py b/retos_resueltos_alcaan16/ejer_07.py
new file mode 100644
index 000000000..61e5d9e4f
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_07.py
@@ -0,0 +1,50 @@
+"""
+#7-CONTANDO PALABRAS
+/*
+ * Crea un programa que cuente cuantas veces se repite cada palabra
+ * y que muestre el recuento final de todas ellas.
+ * - Los signos de puntuación no forman parte de la palabra.
+ * - Una palabra es la misma aunque aparezca en mayúsculas y minúsculas.
+ * - No se pueden utilizar funciones propias del lenguaje que
+ *   lo resuelvan automáticamente.
+ */
+"""
+
+#funcion para eliminar los simbolos
+
+def corrector (frase):
+
+    simbolos = [".", ",", ":", ";", "!", "¡", "?", "¿", "(", ")", "{", "}", "[", "]", "-"]
+    frase_nueva = ""
+
+    #recorre la frase letra por letra y elimina los simbolos    
+    for letra in frase:
+       
+        if letra in simbolos:
+            letra = ("")
+                
+        frase_nueva += letra
+        
+    #devuelve la frase convertida en una lista y en minusculas
+    return frase_nueva.lower().split(" ")
+
+
+# funcion principal para contar
+def contar (frase):
+
+    frase_listada = corrector(frase)
+    contador = {}
+    #recorre en la frase listada nueva las palabras y las asigna a un diccionario
+    for palabra in frase_listada:
+        if palabra not in contador:
+            contador[palabra] = 1
+        else:
+            contador[palabra] += 1
+
+    #recorre el diccionario y lo muestra
+    print("el conteo es el siguiente: ")
+    for listado in contador:
+        print (f"{listado} : {contador[listado]}") 
+
+
+contar("esta es la Prueba, prueba? prueba:")
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_08.py b/retos_resueltos_alcaan16/ejer_08.py
new file mode 100644
index 000000000..047397dc8
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_08.py
@@ -0,0 +1,41 @@
+"""
+#8-DECIMAL A BINARIO
+/*
+ * Crea un programa se encargue de transformar un número
+ * decimal a binario sin utilizar funciones propias del lenguaje que lo hagan directamente.
+ */
+
+ Iterando cadena al revés. Haciendo uso de [::-1] se puede iterar la lista desde el último al primer elemento.
+
+texto = "Python"
+for i in texto[::-1]:
+    print(i) #n,o,h,t,y,P
+Itera la cadena saltándose elementos. Con [::2] vamos tomando un elemento si y otro no.
+
+texto = "Python"
+for i in texto[::2]:
+    print(i) #P,t,o
+
+"""
+
+def decimal_to_binary(decimal_number: int):
+    decimal_num = decimal_number
+    binary = ""
+    binary_result = ""
+
+    # Mientras el número sea diferente de 0, lo divide por 2 y añade el módulo a un String
+    while decimal_number != 0:
+        modulo = decimal_number % 2
+        decimal_number = decimal_number // 2
+        binary += str(modulo)
+
+    # Invierte el String para obtener el resultado final
+    for i in binary[::-1]:
+        binary_result += i
+
+    # Retorna el Resultado
+    print(f"El numero decimal {decimal_num}, en binario es {binary_result}.")
+
+
+# Test
+decimal_to_binary(7)
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_09.py b/retos_resueltos_alcaan16/ejer_09.py
new file mode 100644
index 000000000..bb759a247
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_09.py
@@ -0,0 +1,88 @@
+"""
+#9-CÓDIGO MORSE
+/*
+ * Crea un programa que sea capaz de transformar texto natural a código
+ * morse y viceversa.
+ * - Debe detectar automáticamente de qué tipo se trata y realizar
+ *   la conversión.
+ * - En morse se soporta raya "—", punto ".", un espacio " " entre letras
+ *   o símbolos y dos espacios entre palabras "  ".
+ * - El alfabeto morse soportado será el mostrado en
+ *   https://es.wikipedia.org/wiki/Código_morse.
+ */
+
+"""
+
+def traductor(texto):
+    
+    #definimos el diccionario de morse
+    morse = {"A":".-","B":"-...","C":"-.-.","D":"-..","E":".","F":"..-.","G":"--.","H":"....",
+            "I":"..","J":".---","K":"-.-","L":".-..","M":"--","N":"-.","Ñ":"--.--","O":"---",
+            "P":".--.","Q":"--.-","R":".-.","S":"...","T":"-","U":"..-","V":"...-","W":".--",
+            "X":"-..-","Y":"-.--","Z":"--..","0":"-----","1":".----","2":"..---","3":"...--",
+            "4":"....-","5":".....","6":"-....","7":"--...","8":"---..","9":"----.",".":".-.-.-",
+            ",":"--..--","?":"..--..",'"':".-..-.","/":"-..-.", " ":"  "}
+
+    #comprobamos si es morse o natural
+    if texto[0] == "-" or texto[0] == "." :
+
+        print ("es morse")
+        texto_nuevo = texto.split() #la cadena de texto la convierte en una lista
+        
+        for x in texto_nuevo: #recorremos la lista comparandola con el diccioneario
+            for clave in morse:
+                if morse[clave] == x:
+                    print(clave,end="") #imprime la palabra y al terminar no salta de linea
+    else:
+        print ("es natural")
+        texto_may = texto.upper() #mayusculas
+        palabra = ""
+        for letra in texto_may: #recorre el dicionario buscando las coincidencias
+            palabra += morse[letra]
+            palabra += " "
+        print (palabra)
+
+#traductor ("esto es la autentica prueba")
+traductor (". ... - ---  . ...  .-.. .-  .- ..- - . -. - .. -.-. .-  .--. .-. ..- . -... .- .-.-.")
+
+""" otra solucion
+        
+        for caracter in texto:
+            if caracter != " ":
+                letra += caracter
+                
+        for x in morse:
+            if morse[x] == letra:
+                print (x)
+                break
+        
+
+def codigo_morse(texto):
+    morse = {"A":".-","B":"-...","C":"-.-.","D":"-..","E":".","F":"..-.","G":"--.","H":"....",
+            "I":"..","J":".---","K":"-.-","L":".-..","M":"--","N":"-.","Ñ":"--.--","O":"---",
+            "P":".--.","Q":"--.-","R":".-.","S":"...","T":"-","U":"..-","V":"...-","W":".--",
+            "X":"-..-","Y":"-.--","Z":"--..","0":"-----","1":".----","2":"..---","3":"...--",
+            "4":"....-","5":".....","6":"-....","7":"--...","8":"---..","9":"----.",".":".-.-.-",
+            ",":"--..--","?":"..--..",'"':".-..-.","/":"-..-.", " ":"  "}
+
+    natural = '.-'
+
+    if texto[0] in natural:
+        codigo = texto.split()
+        for i in codigo:
+            for clave in morse:
+                if morse[clave] == i:
+                    print(clave,end="")
+        print()
+    else:
+        textom = texto.upper()
+        for i in textom:
+            print(morse.get(i),end=" ")
+        print()
+
+def main():
+    codigo_morse("..-. . .-.. .. --..    -. .- ...- .. -.. .- -..")
+    codigo_morse("Feliz Navidad")
+
+main()
+"""
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_10.py b/retos_resueltos_alcaan16/ejer_10.py
new file mode 100644
index 000000000..f2867d9f9
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_10.py
@@ -0,0 +1,67 @@
+"""
+#10-EXPRESIONES EQUILIBRADAS
+/*
+ * Crea un programa que comprueba si los paréntesis, llaves y corchetes
+ * de una expresión están equilibrados.
+ * - Equilibrado significa que estos delimitadores se abren y cieran
+ *   en orden y de forma correcta.
+ * - Paréntesis, llaves y corchetes son igual de prioritarios.
+ *   No hay uno más importante que otro.
+ * - Expresión balanceada: { [ a * ( c + d ) ] - 5 }
+ * - Expresión no balanceada: { a * ( c + d ) ] - 5 }
+ */
+
+"""
+
+def comprobacion(expresion):
+
+    #lista con los simbolos de apertura y cerrado
+    open = []
+    close = []
+    
+    #recorremos toda la expresion y la almacenamos en las listas correspondientes
+    for i in expresion:
+        if i == ("{") or i == ("(") or i == ("["):
+            #index += 1
+            #open [index] = i
+            open.append(i)
+        elif i == ("}") or i == (")") or i == ("]"):
+            #index_2 += 1
+            #close [index_2] = i
+            close.append(i)
+    
+    #print (f"simdolos de open {open}")
+    #print (f"simdolos de close {close}")
+    
+    #comprobamos las listas para encontrar diferencias
+    balanceada = True
+    if len(open) == len(close):
+        x=0
+        for z in open[::-1]: #recorre la lista de apertura al inverso
+            print (x)
+            print (z, close[x])
+            if  z == "(" and close[x] != ")":
+                print (z, x)
+                print ("comprobacion ()")
+                balanceada =False
+                break
+
+            elif  z == "{" and close[x] != "}":
+                print ("comprobacion{}")
+                balanceada =False
+                break
+                
+            elif  z == "[" and close[x] != "]":
+                print ("comprobacion[]")
+                balanceada =False
+                break
+                
+            x += 1
+    else:
+        balanceada = False
+
+    print (f"la expresion es balanceada? {balanceada}")
+
+comprobacion("{ [ a * ( c + d ) ] - 5 }")
+
+comprobacion("{ a * ( c + d ) ] - 5 }")
diff --git a/retos_resueltos_alcaan16/ejer_11.py b/retos_resueltos_alcaan16/ejer_11.py
new file mode 100644
index 000000000..90cebee01
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_11.py
@@ -0,0 +1,38 @@
+"""
+#11-ELIMINANDO CARACTERES
+/*
+ * Crea una función que reciba dos cadenas como parámetro (str1, str2)
+ * e imprima otras dos cadenas como salida (out1, out2).
+ * - out1 contendrá todos los caracteres presentes en la str1 pero NO
+ *   estén presentes en str2.
+ * - out2 contendrá todos los caracteres presentes en la str2 pero NO
+ *   estén presentes en str1.
+ */
+"""
+
+def eliminar(str1, str2):
+    
+    #inciamos variables
+    out1 = ""
+    out2 = ""
+    lista_1 =[]
+    lista_2 =[]
+
+    # convertimos las cadenas de texto en listas
+    for x in str1.lower():
+        lista_1 += x
+    for z in str2.lower():
+        lista_2 += z
+    
+    #recorremos las lista en busca de coincidencias
+    for var1 in lista_1:
+        if var1 not in lista_2:
+            out1 += var1
+    for var2 in lista_2:
+        if var2 not in lista_1:
+            out2 += var2
+
+
+    return out1,out2
+
+print (eliminar("Hola", "adios"))
diff --git a/retos_resueltos_alcaan16/ejer_12.py b/retos_resueltos_alcaan16/ejer_12.py
new file mode 100644
index 000000000..638fdab93
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_12.py
@@ -0,0 +1,103 @@
+"""
+#12-¿ES UN PALÍNDROMO?
+/*
+ * Escribe una función que reciba un texto y retorne verdadero o
+ * falso (Boolean) según sean o no palíndromos.
+ * Un Palíndromo es una palabra o expresión que es igual si se lee
+  * de izquierda a derecha que de derecha a izquierda.
+ * NO se tienen en cuenta los espacios, signos de puntuación y tildes.
+ * Ejemplo: Ana lleva al oso la avellana.
+ */
+"""
+
+#creamos un diccionario simbolos, sonde se buscara los simbolos
+simbolos = [",", ";", ":", ".", "·", "¿", "?", "¡", "!", "(", ")", "-", "_", "<", ">", "*", "'", "{", "}",
+            "[", "]", "^", "%", "/", "|", "\\"]
+
+#creamos un diccionario acentos, sonde se buscara los acentos
+acentos = {
+    "á": "a",
+    "à": "a",
+    "ä": "a",
+    "â": "a",
+    "é": "e",
+    "è": "e",
+    "ë": "e",
+    "ê": "e",
+    "í": "i",
+    "ì": "i",
+    "ï": "i",
+    "î": "i",
+    "ó": "o",
+    "ò": "o",
+    "ö": "o",
+    "ô": "o",
+    "ú": "u",
+    "ù": "u",
+    "ü": "u",
+    "û": "u"
+}
+
+def palindromo(texto):
+
+    texto_sin_acento = ""
+    texto_sin_simbolos = ""
+
+    print (texto)
+
+    #recorremos el texto, eliminando los acentos de las palabras.
+    #los acentos se encuentran en el diccionario acentos
+    for i in texto:
+        if i in acentos:
+            texto_sin_acento += acentos[i]
+        else:
+            texto_sin_acento += i
+
+    texto = texto_sin_acento
+
+    #recorremos el texto, para eliminar los simbolos de la frase
+    #los simbolos se encuentran en el diccionario simbolos
+    for i in texto:
+        if i not in simbolos:
+            texto_sin_simbolos += i
+    
+    texto = texto_sin_simbolos
+
+    texto_nuevo = ""
+    texto_reves = ""
+
+    #ponemos el texto del reves, eliminando los espacios
+    for i in texto[::-1]:
+        if i != " ":
+            texto_reves += i
+
+    #eliminamos los espacios del texto
+    for i in texto:
+        if i != " ":
+            texto_nuevo += i
+
+    #pasamos a minuscula
+    texto_reves = texto_reves.lower()
+    texto_nuevo = texto_nuevo.lower()
+
+    print (texto_nuevo)
+    palin = True
+
+    #comparamos los textos para cer si se lee de igual manera
+    if len(texto_reves) == len(texto_nuevo):
+        z = 0
+        for x in texto_nuevo:
+            if x != texto_reves[z]:
+                palin = False
+                break
+            z += 1
+    else:
+        palin = False
+    
+    return palin
+
+
+print ( palindromo ("Ana lleva al oso (/(/(la avellaná?¿"))
+print ( palindromo ("Anita lava la tina"))
+print ( palindromo ("MôureDév by {Brais Môüre}"))
+print ( palindromo ("¿Qué tal Hackermen?"))
diff --git a/retos_resueltos_alcaan16/ejer_13.py b/retos_resueltos_alcaan16/ejer_13.py
new file mode 100644
index 000000000..4c32c6540
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_13.py
@@ -0,0 +1,18 @@
+"""
+#13-FACTORIAL RECURSIVO
+/*
+ * Escribe una función que calcule y retorne el factorial de un número dado
+ * de forma recursiva. hay que multiplicar todos los números enteros positivos que hay entre ese número y el 1
+ */
+
+"""
+
+def calc (num: int):
+
+    total = 1
+    for x in range (1, num+1):
+        total = total * x 
+
+    print (f"el factorial de {num} es {total}")
+    
+calc (6)
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_14.py b/retos_resueltos_alcaan16/ejer_14.py
new file mode 100644
index 000000000..370f60283
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_14.py
@@ -0,0 +1,30 @@
+"""
+#14¿ES UN NÚMERO DE ARMSTRONG?
+/*
+ * Escribe una función que calcule si un número dado es un número de Armstrong
+ * (o también llamado narcisista).
+ * Si no conoces qué es un número de Armstrong, debes buscar información
+ * al respecto.
+ */
+
+Es un número que equivale a la suma de sus dígitos, cada uno elevado a una potencia. 
+Por ejemplo, si tienes un número como 153, es un Armstrong número porque 1^3 + 5^3 + 3^3 es igual a 153
+
+"""
+
+def calculadora (num):
+
+    num2 = str(num) #convertimos el numero en texto para poder interactuar con el
+    suma = 0
+
+    for i in range (len (num2)): #recorremos el numero y lo elevamos al numero de digitos que tiene 
+        suma += pow (int (num2[i]), len (num2))
+
+    if suma == num: # comprobamos 
+        print (f"el numero {num} SI es un número de Armstrong")
+    else:
+        print (f"el numero {num} NO es un número de Armstrong")
+
+calculadora (153)
+calculadora (8208)
+calculadora (1533)
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_15.py b/retos_resueltos_alcaan16/ejer_15.py
new file mode 100644
index 000000000..800e45263
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_15.py
@@ -0,0 +1,43 @@
+"""
+#15-¿CUÁNTOS DÍAS?
+/*
+ * Crea una función que calcule y retorne cuántos días hay entre dos cadenas
+ * de texto que representen fechas.
+ * - Una cadena de texto que representa una fecha tiene el formato "dd/MM/yyyy".
+ * - La función recibirá dos String y retornará un Int.
+ * - La diferencia en días será absoluta (no importa el orden de las fechas).
+ * - Si una de las dos cadenas de texto no representa una fecha correcta se
+ *   lanzará una excepción.
+ */
+"""
+
+#importamos date desde la bbiblioteca datetime
+from datetime import date
+
+def calculadora(var_1, var_2):
+
+    try: #comprueba que funciona
+        dia = int(var_1[0:2]) # a traves del index de la cadena de texto formamos la fecha correctamente
+        mes = int(var_1[3:5])
+        año = int(var_1[6:10])
+        fecha_1 = date (año,mes,dia)
+    
+        dia = int(var_2[0:2])
+        mes = int(var_2[3:5])
+        año = int(var_2[6:10])
+        fecha_2 = date (año,mes,dia)
+                    
+
+        print (fecha_1.strftime("%d/%m/%Y"))
+
+        print (fecha_2.strftime("%d/%m/%Y"))
+        
+
+        diferencia = abs(fecha_1 - fecha_2) #calculamos la diferencia de dias y en terminos absolutos con "abs"
+        
+        return diferencia.days
+    except:
+        diferencia = "error en el formato de la fecha"
+        return diferencia
+
+print (calculadora ("16/11/2024", "16/11/2025" ))
diff --git a/retos_resueltos_alcaan16/ejer_16.py b/retos_resueltos_alcaan16/ejer_16.py
new file mode 100644
index 000000000..63a4d99cc
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_16.py
@@ -0,0 +1,38 @@
+"""
+#16-EN MAYÚSCULA
+/*
+ * Crea una función que reciba un String de cualquier tipo y se encargue de
+ * poner en mayúscula la primera letra de cada palabra.
+ * - No se pueden utilizar operaciones del lenguaje que
+ *   lo resuelvan directamente.
+ */
+"""
+
+def convertir (texto):
+    print (texto)
+
+    lista = texto.split()#convertimos el texto en una lista para poder interactuar con ella
+
+    #print (lista)   
+    lista_mod = []
+    palabra_nueva = ""
+    for i in lista: #recorremos cada palabra una a una
+        var = 0
+        for x in i: #recorremos cada letra de la palabra
+            if var == 0:
+                palabra_nueva += x.upper() #convertimos la letra a mayuscula
+                var = 1
+            else:
+                palabra_nueva += x.lower()#convertimos la letra a minuscula
+        var = 0
+        lista_mod.append(palabra_nueva) #añadimos la palabra nueva a la lista
+        palabra_nueva = ""
+
+    texto_mod = ""
+    for i in lista_mod: #recorremos la lista modificada añadiendo un espacio y convirtiendola en texto
+        texto_mod += i
+        texto_mod += " "
+
+    return texto_mod
+    
+print(convertir ("hola y adIOs pero esto es una prueba de ensayo y error"))
\ No newline at end of file
diff --git a/retos_resueltos_alcaan16/ejer_17.py b/retos_resueltos_alcaan16/ejer_17.py
new file mode 100644
index 000000000..3a3398e98
--- /dev/null
+++ b/retos_resueltos_alcaan16/ejer_17.py
@@ -0,0 +1,47 @@
+"""
+#17
+LA CARRERA DE OBSTÁCULOS
+/*
+ * Crea una función que evalúe si un/a atleta ha superado correctamente una
+ * carrera de obstáculos.
+ * - La función recibirá dos parámetros:
+ *      - Un array que sólo puede contener String con las palabras
+ *        "run" o "jump"
+ *      - Un String que represente la pista y sólo puede contener "_" (suelo)
+ *        o "|" (valla)
+ * - La función imprimirá cómo ha finalizado la carrera:
+ *      - Si el/a atleta hace "run" en "_" (suelo) y "jump" en "|" (valla)
+ *        será correcto y no variará el símbolo de esa parte de la pista.
+ *      - Si hace "jump" en "_" (suelo), se variará la pista por "x".
+ *      - Si hace "run" en "|" (valla), se variará la pista por "/".
+ * - La función retornará un Boolean que indique si ha superado la carrera.
+ * Para ello tiene que realizar la opción correcta en cada tramo de la pista.
+ */
+"""
+
+def carrera (var1, var2):
+
+    print (var1)
+    print (var2)
+    val = True
+    z = 0
+    new = ""
+    if len(var2) == len(var1): #comprobamos que sean del mismo tamaño 
+        for x in var1: #recorremos las acciones y comprobamos
+            if x == "jump" and var2[z] != "|": 
+                new += "x"
+                val = False
+            if x == "run" and var2[z] != "_":
+                new += "/"
+                val = False
+            if (x == "jump" and var2[z] == "|") or (x == "run" and var2[z] == "_"):
+                new += var2[z]
+            z += 1
+        print (f"la nueva carrera es {new}") #imprimimos la nueva carrera
+        return val        
+
+    else:
+        print ("son diferentes")
+        return val
+    
+print (carrera(["run", "jump"], "|_"))
\ No newline at end of file