Ejercicio 1: Números narcisistas

Un número narcisista (también llamado número de Armstrong) es un número de n dígitos donde la suma de cada dígito elevado a la potencia n es igual al propio número.

for num in range(100, 1000):
    centenas = num // 100
    decenas = (num // 10) % 10
    unidades = num % 10
    if centenas**3 + decenas**3 + unidades**3 == num:
        print(f"{num} es un número narcisista")

Ejercicio 2: Números rosa de cuatro hojas

Los números rosa de cuatro hojas son números narcisistas de 4 dígitos.

for num in range(1000, 10000):
    millares = num // 1000
    centenas = (num // 100) % 10
    decenas = (num // 10) % 10
    unidades = num % 10
    if millares**4 + centenas**4 + decenas**4 + unidades**4 == num:
        print(f"{num} es un número rosa de cuatro hojas")

Ejercicio 3: Invertir una cadena

Método 1: Usando slicing

cadena = input("Introduce una cadena: ")
print(cadena[::-1])

Método 2: Usando un bucle

cadena = input("Introduce una cadena: ")
invertida = []
for i in range(len(cadena) - 1, -1, -1):
    invertida.append(cadena[i])
print(''.join(invertida))

Ejercicio 4: Juego de adivinanza de números

El juego ganera un número aleatorio entre 0 y 100. El jugador tiene 10 intentos para adivinarlo.

import random
secreto = random.randint(0, 100)
intentos_max = 10
for intento in range(intentos_max):
    intento_usuario = int(input("Adivina el número (0-100): "))
    if intento_usuario > secreto:
        print("Demasiado alto.")
    elif intento_usuario < secreto:
        print("Demasiado bajo.")
    else:
        print(f"¡Correcto! Lo adivinaste en {intento + 1} intentos.")
        break
    print(f"Te quedan {intentos_max - intento - 1} intentos.")
else:
    print(f"Se acabaron los intentos. El número era {secreto}.")

Ejercicio 5: Problema de los cien pollos y cien monedas

Encuentra todas las combinaciones posibles para comprar 100 pollos por 100 monedas, donde un gallo cuesta 5, una gallina 3 y tres pollitos 1.

combinaciones = 0
for gallos in range(1, 21):
    for gallinas in range(1, 34):
        pollitos = 100 - gallos - gallinas
        if pollitos > 0 and pollitos % 3 == 0:
            if 5 * gallos + 3 * gallinas + pollitos // 3 == 100:
                combinaciones += 1
                print(f"Combinación {combinaciones}: Gallos={gallos}, Gallinas={gallinas}, Pollitos={pollitos}")

Ejercicio 6: Año bisiesto y día del año

Determina si un año es bisiesto y calcula qué día del año es la fecha dada.

year = int(input("Año: "))
mes = int(input("Mes: "))
dia = int(input("Día: "))

es_bisiesto = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
dias_mes = [31, 29 if es_bisiesto else 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

print(f"{year} {'es' if es_bisiesto else 'no es'} un año bisiesto.")
dia_del_anio = dia + sum(dias_mes[:mes - 1])
print(f"{day}/{mes}/{year} es el día {dia_del_anio} del año.")

Ejercicio 7: Problema del mono y los melocotones

Un mono come melocotones durante 10 días. Cada día come la mitad más uno. El décimo día queda uno. ¿Cuántos había al principio?

melocotones = 1
for dia in range(9, 0, -1):
    melocotones = (melocotones + 1) * 2
print(f"El mono recogió inicialmente {melocotones} melocotones.")

Ejercicio 8: Ordenamiento burbuja

import random
lista = [random.randint(1, 100) for _ in range(10)]
print("Lista original:", lista)
n = len(lista)
for i in range(n - 1):
    for j in range(n - i - 1):
        if lista[j] > lista[j + 1]:
            lista[j], lista[j + 1] = lista[j + 1], lista[j]
print("Lista ordenada:", lista)

Ejercicio 9: Búsqueda binaria

Encuentra un elemento en una lista ordenada dividiendo repetidamente el espacio de búsqueda por la mitad.

def busqueda_binaria(elemento, lista):
    bajo, alto = 0, len(lista) - 1
    while bajo <= alto:
        medio = (bajo + alto) // 2
        if lista[medio] == elemento:
            return medio
        elif lista[medio] < elemento:
            bajo = medio + 1
        else:
            alto = medio - 1
    return -1

ejemplo_lista = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
objetivo = 23
resultado = busqueda_binaria(objetivo, ejemplo_lista)
print(f"El elemento {objetivo} está en el índice {resultado}.")

Ejercicio 10: Ordenamiento por selección

import random
datos = [random.randint(1, 100) for _ in range(10)]
n = len(datos)
for i in range(n - 1):
    indice_min = i
    for j in range(i + 1, n):
        if datos[j] < datos[indice_min]:
            indice_min = j
    datos[i], datos[indice_min] = datos[indice_min], datos[i]
print("Lista ordenada por selección:", datos)

Ejercicio 11: Piedra, papel o tijera

Un juego interactivo contra la computadora con sistema de puntuación.

import random
opciones = ["piedra", "papel", "tijera"]
puntos_jugador = 100
while True:
    computadora = random.choice(opciones)
    jugador = input("Elige (piedra/papel/tijera): ").lower()
    if jugador not in opciones:
        print("Opción no válida.")
        continue
    print(f"La computadora eligió: {computadora}")
    if jugador == computadora:
        print("¡Empate!")
    elif (jugador == "piedra" and computadora == "tijera") or \
         (jugador == "papel" and computadora == "piedra") or \
         (jugador == "tijera" and computadora == "papel"):
        puntos_jugador += 10
        print("¡Ganaste la ronda!")
    else:
        puntos_jugador -= 10
        print("Perdiste la ronda.")
    print(f"Puntos: {puntos_jugador}")
    if puntos_jugador <= 0:
        print("Game Over. Te quedaste sin puntos.")
        break
    elif puntos_jugador >= 200:
        print("¡Felicidades! Alcanzaste 200 puntos.")
        break

Ejercicio 12: Números felices

Un número es feliz si la suma de los cuadrados de sus dígitos eventualmente converge a 1.

def suma_cuadrados_digitos(n):
    return sum(int(d)**2 for d in str(n))

def es_feliz(numero):
    vistos = set()
    while numero != 1 and numero not in vistos:
        vistos.add(numero)
        numero = suma_cuadrados_digitos(numero)
    return numero == 1

print("¿Es 19 un número feliz?", es_feliz(19))

Ejercicio 13: Adivinar edades (I)

Encuentra dos edades cuyo producto sea 6 veces su suma y la diferencia sea menor a 8.

for edad1 in range(1, 100):
    for edad2 in range(1, edad1):
        if edad1 * edad2 == 6 * (edad1 + edad2) and (edad1 - edad2) < 8:
            print(f"Las edades son {edad1} y {edad2}.")

Ejercicio 14: Adivinarr edades (II)

Encuentra una edad donde su cubo sea un número de 4 dígitos, su cuarta potencia sea de 6 dígitos, y juntos usen todos los dígitos del 0 al 9 exactamente una vez.

for edad in range(10, 30):
    cubo = str(edad ** 3)
    cuarta = str(edad ** 4)
    if len(cubo) == 4 and len(cuarta) == 6:
        if len(set(cubo + cuarta)) == 10:
            print(f"La edad es {edad}.")

Ejercicio 15: Implementar el método split

Divide una cadena usando un delimitador sin usar el método split integrado.

def mi_split(cadena, delimitador=''):
    resultado = []
    inicio = 0
    for i in range(len(cadena)):
        if cadena[i] == delimitador:
            if i > inicio:
                resultado.append(cadena[inicio:i])
            inicio = i + 1
    if inicio < len(cadena):
        resultado.append(cadena[inicio:])
    return resultado

print(mi_split("hola-mundo-python", '-'))

Ejercicio 16: Serie de Da Yan

Genera los primeros 100 términos de la serie según la regla: para posición par, (n²)/2; para impar, (n²-1)/2.

for n in range(1, 101):
    if n % 2 == 0:
        termino = n**2 // 2
    else:
        termino = (n**2 - 1) // 2
    print(termino)

Ejercicio 17: Análisis de frecuencia de caracteres

Encuentra el carácter que más se repite en una cadena.

def caracter_mas_frecuente(cadena):
    frecuencias = {}
    for c in cadena:
        frecuencias[c] = frecuencias.get(c, 0) + 1
    max_car = max(frecuencias, key=frecuencias.get)
    return max_car, frecuencias[max_car]

car, cant = caracter_mas_frecuente("programacion")
print(f"El carácter más frecuente es '{car}' con {cant} apariciones.")

Ejercicio 18: Dibujar un diamante con asteriscos

Imprime un diamante de asteriscos de lado n.

def diamante(n):
    for i in range(1, n + 1):
        print(' ' * (n - i) + '*' * (2 * i - 1))
    for i in range(n - 1, 0, -1):
        print(' ' * (n - i) + '*' * (2 * i - 1))

diamante(5)

Ejercicio 19: Concepto de recursividad

La recursividad es cuando una función se llama a sí misma.

def cuenta_regresiva(n):
    if n <= 0:
        print("¡Despegue!")
    else:
        print(n)
        cuenta_regresiva(n - 1)

cuenta_regresiva(5)

Ejercicio 20: Sucesión de Fibonacci

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

for i in range(10):
    print(fibonacci(i), end=" ")

Ejercicio 21: Encontrar el máximo de tres números

Sin usar funciones integradas.

a, b, c = 10, 6, 18
maximo = a
if b > maximo:
    maximo = b
if c > maximo:
    maximo = c
print("El máximo es:", maximo)

Ejercicio 22: Números perfectos

Un número es perfecto si es igual a la suma de sus divisores propios.

def suma_divisores(n):
    return sum(i for i in range(1, n) if n % i == 0)

for num in range(1, 10000):
    if num == suma_divisores(num):
        print(f"{num} es un número perfecto.")

Ejercicio 23: Suma de factoriales

Calcula la suma 1! + 2! + ... + 10!.

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

total = sum(factorial(i) for i in range(11))
print("La suma es:", total)

Ejercicio 24: Paréntesis válidos

Verifica si una cadena de paréntesis, corchetes y llaves está balanceada.

def validar_parentesis(cadena):
    pila = []
    pares = {')': '(', ']': '[', '}': '{'}
    for caracter in cadena:
        if caracter in pares.values():
            pila.append(caracter)
        elif caracter in pares.keys():
            if not pila or pila.pop() != pares[caracter]:
                return False
    return len(pila) == 0

print(validar_parentesis("{[()]}"))
print(validar_parentesis("{[(])}"))

Ejercicio 25: Números palíndromos

Un palíndromo se lee igual de izquierda a derecha y de derecha a izquierda.

def es_palindromo(numero):
    if numero < 0:
        return False
    cadena = str(numero)
    return cadena == cadena[::-1]

# Método sin convertir a cadena
def es_palindromo_numerico(n):
    if n < 0:
        return False
    original = n
    invertido = 0
    while n > 0:
        invertido = invertido * 10 + n % 10
        n //= 10
    return original == invertido

print("¿Es 12321 un palíndromo?", es_palindromo(12321))
print("¿Es 12321 un palíndromo (numérico)?", es_palindromo_numerico(12321))