Ejercicios

Aquí están todos los ejercicios del curso en un solo lugar. Primero 50 ejercicios independientes, desde «Hola, mundo» hasta el camino más corto en una cuadrícula, cada uno con un ejemplo y una solución en Python comprobada con un compilador real. Después, los ejercicios de las lecciones, por módulos: cada uno lleva a la lección que explica lo que necesitas.

50 ejercicios para practicar

1. Hello World
Imprime en la consola el texto Hello, World!; el programa no tiene entrada.
Sin entrada.
Salida
```
Hello, World!
```
Lo que necesitas está en la lección: Tu primer programa
Solución
```
print("Hello, World!")
```
2. Saluda al usuario
Lee un nombre de una línea y saluda a la persona por su nombre con la forma «Hola, <nombre>!».
Entrada
```
María
```
Salida
```
Hola, María!
```
Lo que necesitas está en la lección: Entrada y salida
Solución
```
name = input()
print("Hola, " + name + "!")
```
3. Imprime la edad
Lee la edad del usuario (un número entero), guárdala en una variable e imprímela en una frase.
Entrada
```
17
```
Salida
```
Tienes 17 años.
```
Lo que necesitas está en la lección: Variables y tipos
Solución
```
age = int(input())
print("Tienes " + str(age) + " años.")
```
4. Conversor de unidades
Lee una longitud en pulgadas (puede ser un número decimal) y conviértela a centímetros: 1 pulgada = 2.54 cm. Imprime el resultado con 2 decimales.
Entrada
```
12.5
```
Salida
```
31.75 cm
```
Lo que necesitas está en la lección: Operadores y aritmética
Solución
```
inches = float(input())
print(f"{inches * 2.54:.2f} cm")
```

5. Par o impar

Lee un número entero e imprime si es par o impar.

7 es impar.

Lo que necesitas está en la lección: Condiciones

Solución

number = int(input())
if number % 2 == 0:
    print(str(number) + " es par.")
else:
    print(str(number) + " es impar.")

6. Suma de dos números
Lee dos números enteros, cada uno en su propia línea, e imprime su suma.
Entrada
```
12
30
```
Salida
```
La suma es 42.
```
Lo que necesitas está en la lección: Operadores y aritmética
Solución
```
first = int(input())
second = int(input())
print("La suma es " + str(first + second) + ".")
```
7. Área de un cuadrado
Lee el lado de un cuadrado (un número entero) e imprime su área.
Entrada
```
5
```
Salida
```
El área es 25.
```
Lo que necesitas está en la lección: Operadores y aritmética
Solución
```
side = int(input())
print("El área es " + str(side * side) + ".")
```
8. Volumen de una esfera
Lee el radio r (puede ser un número decimal) e imprime el volumen de la esfera V = 4/3 · π · r³ con 2 decimales.
Entrada
```
3
```
Salida
```
El volumen es 113.10.
```
Lo que necesitas está en la lección: Operadores y aritmética
Solución
```
import math

r = float(input())
volume = 4 / 3 * math.pi * r ** 3
print(f"El volumen es {volume:.2f}.")
```
9. Compara dos números
Lee dos números enteros, cada uno en su propia línea, e imprime el mayor (si son iguales, cualquiera de los dos).
Entrada
```
8
15
```
Salida
```
El mayor es 15.
```
Lo que necesitas está en la lección: Condiciones
Solución
```
a = int(input())
b = int(input())
if a > b:
    print("El mayor es " + str(a) + ".")
else:
    print("El mayor es " + str(b) + ".")
```
10. ¿Es un triángulo?
Lee tres números enteros, cada uno en su propia línea, y comprueba si pueden ser los lados de un triángulo: la suma de dos cualesquiera tiene que ser mayor que el tercero.
Entrada
```
3
4
5
```
Salida
```
Pueden formar un triángulo.
```
Lo que necesitas está en la lección: Condiciones
Solución
```
a = int(input())
b = int(input())
c = int(input())
if a + b > c and a + c > b and b + c > a:
    print("Pueden formar un triángulo.")
else:
    print("No pueden formar un triángulo.")
```
11. La nota en palabras
Lee una nota de la escala búlgara del 2 al 6 (puede ser decimal) e imprímela en palabras: desde 5.50 es Excelente, desde 4.50 Muy bien, desde 3.50 Bien, desde 3.00 Suficiente y por debajo de 3.00 Insuficiente.
Entrada
```
4.75
```
Salida
```
Muy bien
```
Lo que necesitas está en la lección: Condiciones
Solución
```
grade = float(input())
if grade >= 5.5:
    print("Excelente")
elif grade >= 4.5:
    print("Muy bien")
elif grade >= 3.5:
    print("Bien")
elif grade >= 3:
    print("Suficiente")
else:
    print("Insuficiente")
```
12. De horas a segundos
Lee un número de horas (un número entero) e imprime cuántos segundos son.
Entrada
```
2
```
Salida
```
7200 segundos
```
Lo que necesitas está en la lección: Operadores y aritmética
Solución
```
hours = int(input())
print(str(hours * 3600) + " segundos")
```
13. Contar hasta N
Lee un número entero N e imprime los números del 1 al N, cada uno en una línea nueva.
Entrada
```
5
```
Salida
```
1
2
3
4
5
```
Lo que necesitas está en la lección: Bucles
Solución
```
n = int(input())
for i in range(1, n + 1):
    print(i)
```
14. Valor ASCII
Lee un carácter (el primer carácter de la línea) e imprime su código ASCII, es decir, el número con el que la computadora lo guarda.
Entrada
```
A
```
Salida
```
El código de A es 65.
```
Lo que necesitas está en la lección: Cadenas: trabajar con texto
Solución
```
symbol = input()[0]
print("El código de " + symbol + " es " + str(ord(symbol)) + ".")
```

15. Ecuación cuadrática

Lee a, b y c, cada uno en su propia línea, y resuelve ax² + bx + c = 0. Con dos raíces imprime «x1 = …, x2 = …» (x1 usa +√D), con una raíz «x = …», con 2 decimales; si no hay raíces reales o a es 0, dilo.

1
-3
2

x1 = 2.00, x2 = 1.00

Lo que necesitas está en la lección: Condiciones

Solución

import math

a = float(input())
b = float(input())
c = float(input())
if a == 0:
    print("No es una ecuación cuadrática")
else:
    d = b * b - 4 * a * c
    if d > 0:
        x1 = (-b + math.sqrt(d)) / (2 * a)
        x2 = (-b - math.sqrt(d)) / (2 * a)
        print(f"x1 = {x1:.2f}, x2 = {x2:.2f}")
    elif d == 0:
        print(f"x = {-b / (2 * a):.2f}")
    else:
        print("No hay raíces reales")

16. Positivo o negativo
Lee un número entero e imprime si es positivo, negativo o cero.
Entrada
```
-4
```
Salida
```
Negativo
```
Lo que necesitas está en la lección: Condiciones
Solución
```
number = int(input())
if number > 0:
    print("Positivo")
elif number < 0:
    print("Negativo")
else:
    print("Cero")
```

17. Estaciones

Lee un número de mes (1–12) e imprime su estación: 12, 1 y 2 son Invierno, 3–5 Primavera, 6–8 Verano y 9–11 Otoño. Para cualquier otro número imprime «Mes no válido».

Primavera

Lo que necesitas está en la lección: Condiciones

Solución

month = int(input())
if month < 1 or month > 12:
    print("Mes no válido")
elif month == 12 or month <= 2:
    print("Invierno")
elif month <= 5:
    print("Primavera")
elif month <= 8:
    print("Verano")
else:
    print("Otoño")

18. Número al revés
Lee un número entero positivo e imprime el número con sus cifras en orden inverso: 123 se convierte en 321. Los ceros que quedan delante desaparecen (1200 se convierte en 21). Toma la última cifra con % 10 y quítala dividiendo entre 10.
Entrada
```
9071
```
Salida
```
1709
```
Lo que necesitas está en la lección: Bucles
Solución
```
n = int(input())
reversed_n = 0
while n > 0:
    reversed_n = reversed_n * 10 + n % 10
    n //= 10
print(reversed_n)
```
19. Conversor de temperatura
Lee una temperatura en grados Celsius (puede llevar punto decimal) e imprímela en Fahrenheit con dos decimales. La fórmula es F = C * 9 / 5 + 32.
Entrada
```
36.6
```
Salida
```
97.88 °F
```
Lo que necesitas está en la lección: Operadores y aritmética
Solución
```
celsius = float(input())
fahrenheit = celsius * 9 / 5 + 32
print(f"{fahrenheit:.2f} °F")
```
20. El nombre más largo
La primera línea tiene la cantidad de nombres n, y cada una de las n líneas siguientes tiene un nombre. Imprime el nombre con más letras y su cantidad entre paréntesis; si dos nombres son igual de largos, imprime el primero de ellos.
Entrada
```
4
Ana
Alejandra
Juan
Guadalupe
```
Salida
```
Alejandra (9 letras)
```
Lo que necesitas está en la lección: Cadenas: trabajar con texto
Solución
```
n = int(input())
longest = ""
for i in range(n):
    name = input()
    if len(name) > len(longest):
        longest = name
print(f"{longest} ({len(longest)} letras)")
```
21. Contador de palabras
Lee una línea de texto e imprime cuántas palabras tiene. Las palabras están separadas por uno o más espacios, así que los trozos vacíos entre dos espacios no son palabras.
Entrada
```
Escribo  código cada día y   mejoro
```
Salida
```
6
```
Lo que necesitas está en la lección: Cadenas: trabajar con texto
Solución
```
line = input()
words = line.split()
print(len(words))
```

22. Número primo

Lee un número entero n y comprueba si es primo: mayor que 1 y divisible solo entre 1 y entre sí mismo. Basta con probar los divisores i para los que i * i <= n.

91 no es primo

Lo que necesitas está en la lección: Bucles

Solución

n = int(input())
prime = n > 1
i = 2
while i * i <= n:
    if n % i == 0:
        prime = False
        break
    i += 1
if prime:
    print(f"{n} es primo")
else:
    print(f"{n} no es primo")

23. Día de la semana
Lee un número del 1 al 7 e imprime el nombre de ese día de la semana, donde 1 es el lunes. Guarda los nombres en un array; para cualquier otro número imprime «No existe ese día».
Entrada
```
5
```
Salida
```
Viernes
```
Lo que necesitas está en la lección: Listas
Solución
```
day = int(input())
days = ["Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"]
if 1 <= day <= 7:
    print(days[day - 1])
else:
    print("No existe ese día")
```
24. Factorial
Lee un número entero n del 0 al 15 e imprime n! = 1 * 2 * ... * n (0! es 1). Ya 13! no cabe en un int, así que en Java y C# guarda el producto en un long.
Entrada
```
15
```
Salida
```
15! = 1307674368000
```
Lo que necesitas está en la lección: Bucles
Solución
```
n = int(input())
factorial = 1
for i in range(2, n + 1):
    factorial *= i
print(f"{n}! = {factorial}")
```

25. Fecha válida

Lee un día, un mes y un año, cada uno en su propia línea, e imprime «Fecha válida» o «Fecha no válida». El año es al menos 1, el mes va del 1 al 12 y el día del 1 al número de días de ese mes; febrero tiene 29 días en un año bisiesto (divisible entre 4 pero no entre 100, salvo que sea divisible entre 400).

29
2
2100

Fecha no válida

Lo que necesitas está en la lección: Condiciones

Solución

day = int(input())
month = int(input())
year = int(input())
leap = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
if month == 2:
    days = 29 if leap else 28
elif month in (4, 6, 9, 11):
    days = 30
else:
    days = 31
if year >= 1 and 1 <= month <= 12 and 1 <= day <= days:
    print("Fecha válida")
else:
    print("Fecha no válida")

26. Frecuencia de letras
Lee una línea de texto e imprime cuántas veces aparece cada letra en ella, sin distinguir mayúsculas y minúsculas. Imprime las letras en orden alfabético, una por línea, con la forma «a: 5»; los espacios y los signos de puntuación no se cuentan.
Entrada
```
¡Hola, Mundo!
```
Salida
```
a: 1
d: 1
h: 1
l: 1
m: 1
n: 1
o: 2
u: 1
```
Lo que necesitas está en la lección: dict y set
Solución
```
text = input().lower()
counts = {}
for c in text:
    if c.isalpha():
        counts[c] = counts.get(c, 0) + 1
for c in sorted(counts):
    print(f"{c}: {counts[c]}")
```

27. Mínimo y máximo en un array

La primera línea tiene la cantidad n, y cada una de las n líneas siguientes tiene un número entero. Léelos en un array e imprime el menor y el mayor, empezando por el primer elemento y comparándolo con los demás.

Mínimo: -3
Máximo: 12

Lo que necesitas está en la lección: Listas

Solución

n = int(input())
numbers = []
for i in range(n):
    numbers.append(int(input()))
smallest = numbers[0]
largest = numbers[0]
for number in numbers:
    if number < smallest:
        smallest = number
    if number > largest:
        largest = number
print(f"Mínimo: {smallest}")
print(f"Máximo: {largest}")

28. Ordenar un array
La primera línea tiene la cantidad n, y cada una de las n líneas siguientes tiene un número entero. Ordénalos tú mismo de menor a mayor con el método de la burbuja (n - 1 pasadas; en cada una intercambias los vecinos que están en el orden equivocado) e imprímelos en una línea, separados por espacios.
Entrada
```
6
5
2
9
1
5
6
```
Salida
```
1 2 5 5 6 9
```
Lo que necesitas está en la lección: Listas
Solución
```
n = int(input())
numbers = []
for i in range(n):
    numbers.append(int(input()))
for p in range(n - 1):
    for i in range(n - 1 - p):
        if numbers[i] > numbers[i + 1]:
            numbers[i], numbers[i + 1] = numbers[i + 1], numbers[i]
print(*numbers)
```
29. Reemplazar las vocales
Lee una línea de texto e imprímela con cada vocal, mayúscula o minúscula, reemplazada por el carácter *. Las vocales son a, e, i, o, u, también con tilde (á, é, í, ó, ú).
Entrada
```
Me encanta programar
```
Salida
```
M* *nc*nt* pr*gr*m*r
```
Lo que necesitas está en la lección: Cadenas: trabajar con texto
Solución
```
text = input()
vowels = "aeiouáéíóú"
result = ""
for c in text:
    if c.lower() in vowels:
        result += "*"
    else:
        result += c
print(result)
```
30. Suma de las cifras
Lee un número entero no negativo e imprime la suma de sus cifras. La última cifra es n % 10, y n / 10 la quita (n // 10 en Python).
Entrada
```
9875
```
Salida
```
29
```
Lo que necesitas está en la lección: Bucles
Solución
```
n = int(input())
total = 0
while n > 0:
    total += n % 10
    n //= 10
print(total)
```
31. Palíndromo
Lee una línea de texto y comprueba si es un palíndromo, es decir, si se lee igual al revés. Las mayúsculas y las minúsculas cuentan como iguales y los espacios se saltan. Imprime «Palíndromo» o «No es palíndromo».
Entrada
```
Anita lava la tina
```
Salida
```
Palíndromo
```
Lo que necesitas está en la lección: Cadenas: trabajar con texto
Solución
```
text = input().lower().replace(" ", "")
if text == text[::-1]:
    print("Palíndromo")
else:
    print("No es palíndromo")
```

32. Contraseña segura

Lee contraseñas, una por línea, hasta que llegue una segura: al menos 8 caracteres, al menos una cifra, una letra mayúscula y una minúscula. Para cada contraseña débil imprime la primera regla que no cumple, en este orden («Demasiado corta», «Sin cifra», «Sin mayúscula», «Sin minúscula»); para la segura imprime «Contraseña aceptada» y detente.

kotka
kotkamiau
kotkamiau7
Kotkamiau7

Demasiado corta
Sin cifra
Sin mayúscula
Contraseña aceptada

Lo que necesitas está en la lección: Cadenas: trabajar con texto

Solución

while True:
    password = input()
    digit = False
    upper = False
    lower = False
    for c in password:
        if c.isdigit():
            digit = True
        elif c.isupper():
            upper = True
        elif c.islower():
            lower = True
    if len(password) < 8:
        print("Demasiado corta")
    elif not digit:
        print("Sin cifra")
    elif not upper:
        print("Sin mayúscula")
    elif not lower:
        print("Sin minúscula")
    else:
        print("Contraseña aceptada")
        break

33. Array al revés
La primera línea tiene la cantidad n, y cada una de las n líneas siguientes tiene un número entero. Léelos en un array e imprímelos en orden inverso en una línea, separados por espacios: recorre el array desde el último índice hasta el cero.
Entrada
```
4
10
-2
7
3
```
Salida
```
3 7 -2 10
```
Lo que necesitas está en la lección: Listas
Solución
```
n = int(input())
numbers = []
for i in range(n):
    numbers.append(int(input()))
line = ""
for i in range(n - 1, -1, -1):
    line += str(numbers[i])
    if i > 0:
        line += " "
print(line)
```
34. Contar los elementos
Lee una línea de palabras separadas por un solo espacio e imprime cuántas veces aparece cada palabra, con la forma «palabra: cantidad». Las palabras salen en el orden en que aparecieron por primera vez.
Entrada
```
manzana pera manzana ciruela pera manzana
```
Salida
```
manzana: 3
pera: 2
ciruela: 1
```
Lo que necesitas está en la lección: dict y set
Solución
```
line = input()
counts = {}
for word in line.split(" "):
    counts[word] = counts.get(word, 0) + 1
for word in counts:
    print(f"{word}: {counts[word]}")
```

35. Números primos

Lee un número N e imprime en una línea, separados por espacios, todos los números primos del 2 al N.

2 3 5 7 11 13 17 19 23 29

Lo que necesitas está en la lección: Bucles

Solución

n = int(input())
primes = []
for i in range(2, n + 1):
    prime = True
    d = 2
    while d * d <= i:
        if i % d == 0:
            prime = False
            break
        d += 1
    if prime:
        primes.append(str(i))
print(" ".join(primes))

36. Media
Una línea tiene números enteros separados por espacios. Imprime su media con dos decimales.
Entrada
```
5 8 12 6
```
Salida
```
Media: 7.75
```
Lo que necesitas está en la lección: Listas
Solución
```
parts = input().split()
total = 0
for part in parts:
    total += int(part)
average = total / len(parts)
print(f"Media: {average:.2f}")
```

37. Ordenar por longitud

Una línea tiene palabras separadas por espacios. Ordénalas por longitud, de la más corta a la más larga (las palabras de igual longitud mantienen el orden de la entrada), e imprímelas en una línea.

cereza higo banana kiwi ciruela

higo kiwi cereza banana ciruela

Lo que necesitas está en la lección: Cadenas: trabajar con texto

Solución

words = input().split()
for i in range(len(words) - 1):
    for j in range(len(words) - 1 - i):
        if len(words[j]) > len(words[j + 1]):
            words[j], words[j + 1] = words[j + 1], words[j]
print(" ".join(words))

38. Contador de oraciones

Lee una línea de texto e imprime cuántas oraciones tiene. Una oración termina con un punto, un signo de exclamación o un signo de interrogación; una serie de esos signos (como «...» o «?!») es un solo final.

¡Hola! ¿Cómo estás? Estoy bien... ¿Y tú?!

Oraciones: 4

Lo que necesitas está en la lección: Cadenas: trabajar con texto

Solución

text = input()
ends = ".!?"
count = 0
for i in range(len(text)):
    is_end = text[i] in ends
    next_is_end = i + 1 < len(text) and text[i + 1] in ends
    if is_end and not next_is_end:
        count += 1
print(f"Oraciones: {count}")

39. Números de Fibonacci
La sucesión de Fibonacci empieza con 1, 1, y cada número siguiente es la suma de los dos anteriores. Lee N (del 1 al 50) e imprime el N-ésimo número de la sucesión.
Entrada
```
40
```
Salida
```
102334155
```
Lo que necesitas está en la lección: Bucles
Solución
```
n = int(input())
previous = 0
current = 1
for i in range(1, n):
    previous, current = current, previous + current
print(current)
```
40. Calcular la mediana
Una línea tiene números enteros separados por espacios. Imprime su mediana con un decimal: el número del medio una vez ordenados, o la media de los dos del medio cuando la cantidad es par.
Entrada
```
12 3 7 9 1 8
```
Salida
```
Mediana: 7.5
```
Lo que necesitas está en la lección: Listas: append, remove y sort
Solución
```
numbers = []
for part in input().split():
    numbers.append(int(part))
numbers.sort()
n = len(numbers)
if n % 2 == 1:
    median = numbers[n // 2]
else:
    median = (numbers[n // 2 - 1] + numbers[n // 2]) / 2
print(f"Mediana: {median:.1f}")
```

41. Gráfico de caracteres

Lee una línea de texto. Para cada carácter que no sea el espacio, en el orden en que aparece por primera vez, imprime una línea «carácter | estrellas» con una estrella por cada vez que aparece en el texto.

pan de banana

p | *
a | ****
n | ***
d | *
e | *
b | *

Lo que necesitas está en la lección: Cadenas: trabajar con texto

Solución

text = input()
for i in range(len(text)):
    c = text[i]
    if c != " " and text.index(c) == i:
        count = 0
        for other in text:
            if other == c:
                count += 1
        print(c + " | " + "*" * count)

42. Trasponer una matriz

La primera línea tiene el número de filas R y de columnas C, y le siguen R líneas con C números separados por espacios. Imprime la matriz traspuesta: C líneas con R números, donde las filas pasan a ser columnas.

2 3
1 2 3
4 5 6

1 4
2 5
3 6

Lo que necesitas está en la lección: Arrays bidimensionales

Solución

size = input().split()
rows = int(size[0])
cols = int(size[1])
matrix = []
for r in range(rows):
    row = []
    for part in input().split():
        row.append(int(part))
    matrix.append(row)
for c in range(cols):
    line = []
    for r in range(rows):
        line.append(str(matrix[r][c]))
    print(" ".join(line))

43. Caminos en un laberinto

La primera línea tiene R y C, y le siguen R líneas de C caracteres: «.» es una celda libre y «#» es una pared. Moviéndote solo a la derecha o hacia abajo y sin pisar nunca una pared, imprime el número de todos los caminos desde la esquina superior izquierda hasta la inferior derecha.

4 5
.....
.#.#.
...#.
#....

Caminos: 4

Lo que necesitas está en la lección: Recursión

Solución

def count_paths(maze, r, c):
    if r >= len(maze) or c >= len(maze[0]) or maze[r][c] == "#":
        return 0
    if r == len(maze) - 1 and c == len(maze[0]) - 1:
        return 1
    return count_paths(maze, r + 1, c) + count_paths(maze, r, c + 1)


size = input().split()
rows = int(size[0])
maze = []
for r in range(rows):
    maze.append(input())
print(f"Caminos: {count_paths(maze, 0, 0)}")

44. Estadística de notas

Una línea tiene notas del 2 al 6 (la escala escolar búlgara, 6 es la mejor), separadas por espacios. Imprime cuántas son excelentes, muy bien, bien, suficientes e insuficientes, cada categoría en su propia línea.

6 4 5 6 3 5 2 6 5 4

Excelente (6): 3
Muy bien (5): 3
Bien (4): 2
Suficiente (3): 1
Insuficiente (2): 1

Lo que necesitas está en la lección: Listas

Solución

names = ["", "", "Insuficiente", "Suficiente", "Bien", "Muy bien", "Excelente"]
counts = [0] * 7
for part in input().split():
    counts[int(part)] += 1
for grade in range(6, 1, -1):
    print(f"{names[grade]} ({grade}): {counts[grade]}")

45. Números romanos

Lee un número entero del 1 al 3999 e imprímelo en números romanos (I, V, X, L, C, D, M, donde 4 es IV, 9 es IX, 40 es XL, etc.).

MCMXCIV

Lo que necesitas está en la lección: Listas

Solución

number = int(input())
values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
symbols = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman = ""
for i in range(len(values)):
    while number >= values[i]:
        roman += symbols[i]
        number -= values[i]
print(roman)

46. Simulación de una moneda
Lee una semilla x (del 1 al 2147483646) y un número de lanzamientos N, cada uno en su propia línea. En cada lanzamiento haz x = x * 16807 % 2147483647; un x par es cara (C) y un x impar es cruz (X). Imprime los lanzamientos en una línea y después cuántas veces salió cara y cuántas cruz.
Entrada
```
42
10
```
Salida
```
CXXXCXXCCX
Cara: 4
Cruz: 6
```
Lo que necesitas está en la lección: Bucles
Solución
```
x = int(input())
n = int(input())
tosses = ""
heads = 0
for i in range(n):
    x = x * 16807 % 2147483647
    if x % 2 == 0:
        tosses += "C"
        heads += 1
    else:
        tosses += "X"
print(tosses)
print(f"Cara: {heads}")
print(f"Cruz: {n - heads}")
```

47. Array simétrico

Una línea tiene números enteros separados por espacios. Comprueba si el array es simétrico, es decir, si se lee igual de izquierda a derecha y de derecha a izquierda.

1 2 3 2 1

Simétrico

Lo que necesitas está en la lección: Listas

Solución

numbers = []
for part in input().split():
    numbers.append(int(part))
symmetric = True
for i in range(len(numbers) // 2):
    if numbers[i] != numbers[len(numbers) - 1 - i]:
        symmetric = False
        break
print("Simétrico" if symmetric else "No simétrico")

48. Paréntesis equilibrados

Lee una línea de texto y comprueba si sus paréntesis (), [] y {} están equilibrados: cada uno que abre tiene uno que cierra del mismo tipo y los pares no se cruzan. Los demás caracteres no cuentan.

(a + [b) * c]

No equilibrados

Lo que necesitas está en la lección: Pila, cola y lista enlazada

Solución

text = input()
opening = "([{"
closing = ")]}"
stack = []
balanced = True
for c in text:
    if c in opening:
        stack.append(c)
    elif c in closing:
        if not stack or opening.index(stack.pop()) != closing.index(c):
            balanced = False
            break
if balanced and not stack:
    print("Equilibrados")
else:
    print("No equilibrados")

49. Serie de elementos iguales

Una línea tiene números enteros separados por espacios. Encuentra la serie más larga de números vecinos iguales e imprímela en una línea; si varias series tienen la misma longitud, imprime la primera.

2 1 1 3 3 3 2 2 2 5

3 3 3

Lo que necesitas está en la lección: Listas

Solución

numbers = []
for part in input().split():
    numbers.append(int(part))
best_value = numbers[0]
best_length = 1
length = 1
for i in range(1, len(numbers)):
    if numbers[i] == numbers[i - 1]:
        length += 1
    else:
        length = 1
    if length > best_length:
        best_length = length
        best_value = numbers[i]
print(" ".join([str(best_value)] * best_length))

50. Camino más corto en una cuadrícula

La primera línea tiene R y C, y le siguen R líneas de C caracteres: «.» es una celda libre, «#» es una pared, «S» es el inicio y «E» es la meta. Moviéndote hacia arriba, abajo, izquierda y derecha, imprime el menor número de movimientos de S a E, o «No hay camino» si E no se puede alcanzar.

5 6
S.#...
.##.#.
...#..
#.#..#
...E.#

Lo que necesitas está en la lección: Pila, cola y lista enlazada

Solución

from collections import deque

size = input().split()
rows = int(size[0])
cols = int(size[1])
grid = []
for r in range(rows):
    grid.append(input())
dist = []
queue = deque()
for r in range(rows):
    dist.append([-1] * cols)
    for c in range(cols):
        if grid[r][c] == "S":
            dist[r][c] = 0
            queue.append((r, c))
moves = [(-1, 0), (1, 0), (0, -1), (0, 1)]
answer = "No hay camino"
while queue:
    r, c = queue.popleft()
    if grid[r][c] == "E":
        answer = str(dist[r][c])
        break
    for dr, dc in moves:
        nr = r + dr
        nc = c + dc
        if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] != "#" and dist[nr][nc] == -1:
            dist[nr][nc] = dist[r][c] + 1
            queue.append((nr, nc))
print(answer)

Ejercicios de las lecciones

Fundamentos del lenguaje

Tu primer programa: Hello World · Tarjeta de visita · Marco
Variables y tipos: Intercambio · Edad · La ficha de un hotel
Entrada y salida: Saludo por nombre · Suma de dos números · Dos textos en uno · π con dos cifras
Operadores y aritmética: Media de tres números · Segundos en horas · Volumen de una esfera · Celsius a Fahrenheit
Condiciones: Una entrada de cine · Una minicalculadora · Una ecuación cuadrática · Una fecha válida
Bucles: Tabla de multiplicar · Número primo · Las cifras de un número · Adivina el número
Listas: Suma, pares, impares · Al revés · Mínimo, máximo, media
Listas: Ordenación · La racha más larga · Estadística de notas
Arrays bidimensionales: Diagonales y filas · Gira la tabla
Arrays bidimensionales: ¿Cuántos caminos hay? · El camino más corto
Cadenas: trabajar con texto: El nombre al revés · Número de palabras · Palíndromo
Cadenas: trabajar con texto: Contraseña segura

Funciones

Funciones: Recibo · Triángulo
Parámetros y return: Media aritmética · Número primo · Temperaturas · Calculadora · Un triángulo con parámetro
Parámetros y return
Valores por defecto: El mayor · Nota media · Una línea del recibo · Envío gratis
Recursión: Factorial de dos formas · Suma de cifras · Fibonacci · Palíndromo

Clases y objetos

Clases y objetos: Libro · Coche · El carrito · El más caro primero
Constructores y self: Persona · Animal · Paso de baile
Métodos de instancia
Métodos de instancia
Encapsulamiento: Persona · Una cuenta sin números rojos · Animal
Lo que comparten todos los objetos: atributos de clase: Pedidos · Calculadora · Cambio de divisas

Herencia y polimorfismo

Herencia: Coche familiar · Estudiante · Breakdance · Coche eléctrico
Polimorfismo: Refugio de animales · El estudiante se presenta · Fiesta
Clases abstractas: Área y perímetro · Animales
Clases abstractas: Vehículos · Actuaciones
Interfaces como clases abstractas: Claxon · Datos · Baile · DJ · El estanque
Comprobaciones de tipo: Aparcamiento · Bailes · Flota · Zoológico
Principios de la POO
Principios de la POO: Un autónomo · La terraza sin if

Errores y excepciones

Excepciones: Texto a número · No hay tal producto · Pedido medio
try, except y finally: Precio por persona · Calculadora
Lanzar excepciones y crear las tuyas: Tienda de música · Una cuenta con reglas · Edad no válida

Texto y archivos

Cadenas: Palíndromo · Un recibo con columnas · Palabras al revés
Expresiones regulares: Fecha · Número de móvil · Email · Lista de la compra
Expresiones regulares: grupos y reemplazo: Buscar y reemplazar · Palabras con prefijo · Direcciones en un texto · Fechas a ISO
Archivos: Un archivo de configuración · Un filtro de archivo de registro · El contenido de una carpeta · Un archivo índice
Datos en archivos: Análisis de un CSV · Guardar al héroe · Texto duplicado

Colecciones

Listas: append, remove y sort: Una estantería · Un registro de eventos · Un cuaderno · Cálculo mental
Pila, cola y lista enlazada: Un tren de juguete · Una línea de autobús · Un indicador de bolsa · Paréntesis equilibrados · Tu propia lista enlazada
dict y set: Una tabla de usuarios · Frecuencia de palabras · Documentos por palabra clave · Una red de contactos
Códigos hash y funciones hash: Un hash para una persona · El robot del almacén · El hash de un archivo
Clases anidadas y datos: Carrito de compras · Monitor de un servidor web · Administrador de un edificio · Clasificación

Python moderno

Lambdas: Ordenar por varios campos · Filtrar pedidos · Descuentos uno tras otro
Listas por comprensión y generadores: Ventas por categoría · Los 3 mejores productos · Nota media · Las palabras de un texto
dataclass, match y patrones: Figuras · Precio del envío · Un punto como clave
Patrones de diseño: Descuentos como estrategias · «Avísame cuando haya stock» · Una fábrica de notificaciones · Un termómetro antiguo

Programas en el mundo real

Tests con unittest: La calculadora de descuentos · La cuenta · El error en la nota media
Hilos: Suma en paralelo · Descarga con un grupo · Un contador sin pérdidas
Programación en red: Servidor de eco · Un servidor con comandos · Un chat para dos
Bases de datos: Catálogo · Búsqueda por parte del nombre · Una transferencia que falla a medias
Reflexión y decoradores: Todos los campos, clase por clase · Mini JSON · Tu propio ejecutor de pruebas

Hagamos un juego

Cómo pensar un juego: Una carrera para dos · Adivina el número · ¿Quién ganó al tres en raya?
RPG 1: los héroes: Un sexto héroe · La lista del grupo · ¿Quién es el más fuerte?
RPG 2: la batalla: Un monstruo nuevo · Una poción curativa · Un informe de batalla
RPG 3: el juego completo: Un menú · Progreso · Un jefe
Epic Cosmos 1: los objetos en el espacio: El sistema solar · Distancia · El árbol completo
Epic Cosmos 2: recursos, edificios, naves: 100 de metal lo más rápido posible · Una nave de carga · Una simulación de 10 turnos
El laboratorio cerrado 1: salas y comandos: Inventario · Una sala nueva · Sinónimos
El laboratorio cerrado 2: acertijos y la salida: El sótano oscuro · Un temporizador · Una pista por un movimiento

Las crónicas de Arcanum

Epic Cosmos: el imperio

Proyecto

Reservas de hotel: Cambio de habitación

Creado por Ivo Gergov como parte de la campaña de Evo Tech por una educación accesible en programación ·

Ejercicios

50 ejercicios para practicar

1. Hello World

2. Saluda al usuario

3. Imprime la edad

4. Conversor de unidades

5. Par o impar

6. Suma de dos números

7. Área de un cuadrado

8. Volumen de una esfera

9. Compara dos números

10. ¿Es un triángulo?

11. La nota en palabras

12. De horas a segundos

13. Contar hasta N

14. Valor ASCII

15. Ecuación cuadrática

16. Positivo o negativo

17. Estaciones

18. Número al revés

19. Conversor de temperatura

20. El nombre más largo

21. Contador de palabras

22. Número primo

23. Día de la semana

24. Factorial

25. Fecha válida

26. Frecuencia de letras

27. Mínimo y máximo en un array

28. Ordenar un array

29. Reemplazar las vocales

30. Suma de las cifras

31. Palíndromo

32. Contraseña segura

33. Array al revés

34. Contar los elementos

35. Números primos

36. Media

37. Ordenar por longitud

38. Contador de oraciones

39. Números de Fibonacci

40. Calcular la mediana

41. Gráfico de caracteres

42. Trasponer una matriz

43. Caminos en un laberinto

44. Estadística de notas

45. Números romanos

46. Simulación de una moneda

47. Array simétrico

48. Paréntesis equilibrados

49. Serie de elementos iguales

50. Camino más corto en una cuadrícula

Ejercicios de las lecciones

Fundamentos del lenguaje

Funciones

Clases y objetos

Herencia y polimorfismo

Errores y excepciones

Texto y archivos

Colecciones

Python moderno

Programas en el mundo real

Hagamos un juego

Las crónicas de Arcanum

Epic Cosmos: el imperio

Proyecto

Cookies