Son casos prácticos que se pueden resolver por varios métodos. Afortunadamente Python es un lenguaje de programación ideal para comenzar a programar e introducirse en el mundo del código.
Comenzaremos por el conocido "Hola mundo" e iremos aumentando progresivamente el nivel y abordando diferentes comandos del lenguaje.
Proponemos cada reto y puedes tomarte tu tiempo para resolverlo. Luego, puedes pulsar sobre la solución y ver el caso resuelto por varios métodos. Las diferentes formas de resolver cada reto suponen un buen sistema de entrenamiento.
Realmente dominas algo cuando eres capaz de hacerlo de varias formas
Si tienes nuevos retos puedes dejarlos en los comentarios, seguro que ayudarán a más personas en su capacitación en Python. Si tienes nuevos métodos de resolución para alguno de los retos también te invitamos a dejarlos en los comentarios correspondientes a cada reto.
¡Adelante con los ejercicios en Python!
Instalar Python
Instalar Python
Hola mundo
Imprimir la expresión "Hola mundo".
Operaciones con números
Dados dos números hacer con ellos las operaciones básicas.
Número mayor y menor
Dados dos números decir cuál es mayor, o si ambos son iguales.
Aleatorios
Generar un número aleatorio.
Intervalos
Generar un número aleatorio entre 1 y 120. Decir si se encuentra en el intervalo entre 10 y 50, o bien si es mayor de 50 hasta 100, o bien si es mayor de 100, o bien si es menor de 10.
Bucles
Listar los números del 1 al 10.
Pares
Listar los números pares del 10 al 20.
Series
Listar los números entre un valor inicial y uno final, con un cierto intervalo. Al final dar la suma de todos los valores listados.
Progresión geométrica
Calcular cuantos granos de trigo tendríamos que utilizar si por cada casilla de un tablero de ajedrez pusiéramos un grano en la primera casilla, dos en la segunda, cuatro en la tercera, y así doblando hasta la última.
Unir listas
Generar primero una lista con los números entre 0 y 10, luego generar otra lista con los números del 11 al 20. Unir ambas lista e imprimir el resultado.
Cadenas alfanuméricas
Listar los caracteres de la cadena ‘2001: A Space Odyssey’.
Media de dos números
Calcular la media de dos números.
Funciones
Crear una función que calcule el cuadrado de un número. Probar la función con los números entre -10 y +10. Crear otra función que lo único que hace es imprimir al final la frase “Programa finalizado”. Ejecutar ambas funciones.
Media de n valores
Calcular la media de n números.
Media ponderada
Calcular la media ponderada de una serie de valores.
Adivina el número secreto
Se genera un número aleatorio entero entre 1 y 100. El usuario debe adivinar el número secreto, diciendo en cada tirada si es mayor o menor.
Longitud de una cadena
Crear una función que calcule la longitud de una cadena alfanumérica. Crear otra función que dada una cadena devuelva el primer caracter en mayúsculas y el resto en minúsculas. Pasar una palabra por ambas funciones y dar el resultado.
Capitalización compuesta
Crear una aplicación que trabaje con la ley de capitalización compuesta.
Bisiesto
Crear una función que dado un año diga si es bisiesto.
Índice de masa corporal
Crear una función que calcule el Índice de Masa Corporal (Body Mass Index [BMI]).
Fecha y hora
Imprimir la fecha y hora actuales.
Calendario
Importar la librería calendar. Imprimir el calendario del mes actual.
Palíndromos
Dada una cadena decir si es un palíndromo.
Anagramas
Crear una función que detecte si dos palabras son anagramas.
Cifras pares e impares
Generar un número aleatorio entero entre un millón y dos millones. Imprimir ese número en pantalla y decir cuántas cifras pares e impares tiene.
Máximo y mínimo
Generar 10 números aleatorios y calcular el máximo y el mínimo.
Bucles anidados
Generar la tabla de multiplicar.
Pitágoras
Indicar las dimensiones de los triángulos rectángulos donde todas sus longitudes sean números enteros. Listarlos hasta el límite donde los catetos lleguen hasta 100.
Encriptación
Encriptar y desencriptar frases usando la clave MURCIELAGO. Cada letra de la frase que coincida con alguna letra de la clave se sustituye por un número siguiendo el orden 0123456789.
Acumulado
Listar los números entre 1 y 10. En la columna contigua sus cuadrados, y en la tercera columna sus cubos. Al final dar la suma de todos los valores de cada columna.
Ordenar números
Imprimir una lista de 10 números aleatorios sin repetición que varíen en el rango 80 a 99. Volver a imprimir la lista pero ordenada.
Aleatorios con excepciones
Generar números aleatorios pares entre 100 y 130, salvo 110 y 120.
Alternos con excepciones
Imprimir diez números aleatorios sin repetición entre 100 y 130, excepto los números 110, 115, 120 y alternando par, impar, comenzando por par.
Generar y ordenar palabras
Crear una serie de 10 palabras donde sus letras se obtienen de forma aleatoria. Mostrar estas palabras y mostrar esas mismas palabras ordenadas alfabéticamente.
Imprimir con color
Generar aleatoriamente la nota de diez alumnos. Calcular la media e imprimir en pantalla la nota de cada uno y la desviación de cada una de las notas respecto a la media. Los que estén por encima o por debajo de la media se imprimen en colores diferentes.
Cubo 3D
Generar las notas de 5 estudiantes, en 6 asignaturas, durante 4 cursos. Mostrar en pantalla los datos de forma que seleccionado un elemento lo muestre según su curso, asignatura o compañeros.
- Método 1
- Método 2
Polinomio
Dado el polinomio y=x^4-3x^2+2 calcular el valor de y para valores de x que varían en el rango -2, +2 con incremento de 0,1.
Fibonacci
Dar los n primeros valores de la sucesión de Fibonacci.
Tuplas
Crear una tupla con las cuatro estaciones del año. Imprimir la tupla, imprimir su longitud e imprimir los elemento de la tupla uno a uno.
Diccionarios
Dado un número del 1 al 12, mostrar el mes correspondiente y el número de días que tiene. Trabajar con diccionarios.
Diccionario con Tupla
Crear un diccionario donde la clave sean los números del 1 al 100, y para cada uno de los números tenemos una tupla como valor, donde la tupla contiene el cuadrado de ese número, e indica si el número es primo o no.
Letra del DNI
Calcular la letra del DNI.
Triángulos factibles
Dados tres lados decir si es posible construir un triángulo con ellos. En caso afirmativo decir si el triángulo formado es equilátero, isósceles o escaleno.
Booleanos
Generar aletoriamente un número del 100.000 al 200.000. Si ese número tiene un tres pierdes la partida y si carece de treses entonces has tenido éxito en el juego.
Números primos
Listar los n primeros números primos.
- Método 1
- Método 2
Criba de Eratóstenes
La criba de Eratóstenes es un algoritmo que permite hallar todos los números primos menores que un número dado.
- Método 1
- Método 2
Juego de la tirada más larga
Cada tirada genera una sucesión de números aleatorios entre 1 y 100. La tirada finaliza cuando se obtiene un número par, entre 40 y 60. El juego lanza 20 tiradas y al final se dice que tirada ha sido la más larga.
Frecuencias
Construir una lista que contenga el código de 6 aeropuertos internacionales: MAD, JFK, LHR, CDG, AMS, FRA. Generar un dado de seis caras, con las siguientes probabilidades 25%, 22%, 18%, 14%, 11%, 10%, que corresponden a cada uno de los aeropuertos respectivamente. Generar un listado de 100 aeropuertos extraídos entre los seis del array y que aparezcan de forma aleatoria cada uno según su probabilidad. Finalmente mostramos los aeropuertos y el número de veces que aparece cada uno de ellos.
Juego del número secreto
Se genera un número secreto entero entre 1 y 100 que debe adivinar el jugador. Por cada número que dice el jugador el programa contesta diciendo si el número secreto es mayor o menor hasta que llegue a adivinarlo.
- Método 1
- Método 2
Juego de la última piedra
Programar el juego de la última piedra.
- Método 1
- Método 2
Convertir segundos
Dados un cierto número se segundos expresarlos como días, horas, minutos y segundos.
Conversión de monedas y billetes
Dada una cantidad de dinero indicar cuantos billetes y monedas de cada tipo son necesarios como mínimo.
Ordenar las ciudades
Con la lista de ciudades que está abajo, pide al usuario que añada otra a la lista. Ahora imprime cuantas letras tiene cada ciudad y ordena el array de las que tengan menos letras a las que más.
Ciudades:
- Madrid
- Ottawa
- Estocolmo
- Oslo
- Solucíon
Dibujar un cuadrado
Dibujar un cuadrado que muestre también sus dos diagonales.
- Método 1
- Método 2
Intersección de rectas
Dadas dos rectas, calcular el punto de intersección y representarlas.
- Método 1
- Método 2
Camino aleatorio
Representar gráficamente el camino de un borracho. Comprobar si dados n pasos la distancia que alcanza tiende a la raiz cuadrada de n que es el valor teórico de esa distancia.
- Método 1
- Método 2
Movimiento en un canvas
Crear un cuadrado en un canvas que se vea cómo se mueve y gira.
- Método 1
- Método 2
Rectángulos aleatorios
Representar gráficamente rectángulos aleatorios.
- Método 1
- Método 2
Juego de la tortuga
Crear un juego donde se pueda dibujar en un canvas con los cursores del teclado.
- Método 1
- Método 2
Representar funciones
Representar gráficamente el polinomio y=x^4-3x^2+2.
- Método 1
- Método 2
Seno y coseno
Crear un CANVAS donde representar las funciones seno y coseno en dos colores diferentes.
- Método 1
- Método 2
Producto de polinomios
Crear un procedimiento que calcule el producto de dos polinomios.
- Método 1
- Método 2
Reversión a la media
Crear un vector de un millón de datos aleatorios según una distribución normal. Ir calculando la media a medida que se van generando los valores, e irla representando en un Canvas para ver como se tiende a la media a medida que aumenta el número de datos.
- Método 1
- Método 2
Máximo Común Divisor
Programar el algoritmo de Euclides para calcular el MCD (Máximo Común Divisor).
- Método 1
- Método 2
Mínimo común múltiplo
Calcular el mcm (mínimo común múltiplo).
- Método 1
- Método 2
Cuadrados latinos
Generar cuadrados latinos de tamaño n×n.
- Método 1
- Método 2
Resolver cuadrados latinos
Resolver cuadrados latinos.
- Método 1
- Método 2
Cálculo de determinantes
Calcular determinantes de orden nxn.
- Método 1
- Método 2
Hacer ceros
Reducir una matriz haciendo ceros por Gauss-Jordan.
- Método 1
- Método 2
Matriz inversa
Calcular una matriz inversa de orden nxn.
- Método 1
- Método 2
Tiro parabólico
Crear un Canvas para ilustrar el tiro parabólico calculando la distancia alcanzada en función del ángulo α y la velocidad inicial.
- Método 1
- Método 2
Guerra a cañonazos
Crear un juego donde los dos adversarios se disparan alternativamente balas de cañón variando el ángulo y la velocidad hasta que uno de ellos alcanza al otro.
- Método 1
- Método 2
Tres en raya
Programar el juego de las tres en raya.
- Método 1
- Método 2
Puzle
Programar un juego del tipo Sliding puzzle con los números del 1 al 8. https://tinyurl.com/puzzlemagnito
- Método 1
- Método 2
El juego de la vida
Programar el juego de la vida.
- Método 1
- Método 2
Si el reto 58 no me sale, donde puedo ver la solucion?
ResponderEliminarHola Damian.
ResponderEliminarEl reto 58 se titula "Juego de la tortuga" y dice: "Crear un juego donde se pueda dibujar en un canvas con los cursores del teclado".
Aún no está resuelto, ni publicado. Como ves la mayoría de los retos están resueltos por varios métodos y algunos únicamente están enunciados y su resolución está pendiente a futuro.
Si alguien que llegue por este blog quiere aportar su solución será bienvenida.
Un saludo.
Reto 65. Contraseñas aleatorias (Método)
ResponderEliminarimport random
consonantes = ["b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "ñ", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z"]
vocales = ["a", "e", "i", "o", "u"]
count_pass = 0
while count_pass<=19:
print(random.choice(consonantes).upper() + random.choice(vocales) + random.choice(consonantes) + random.choice(vocales) + random.choice(consonantes) + random.choice(vocales) + random.choice(consonantes) + random.choice(vocales) + "_" + str(random.randint(9,100)))
count_pass = count_pass + 1
MUY BUENO, ME INTERESA MUCHO APRENDER PYTHON
ResponderEliminarUwU
EliminarMiren la propuesta del Reto 35 Imprimir con color
ResponderEliminarimport random # Se importa el módulo para números aleatorios
from colorama import init, Fore, Back, Style # Módulo para textos y fondo a color
init()
L=[]
for i in range(10):
x=random.randint(1,9) # Crea números aleatorios de 1 al 9
z=random.randint(1,10)
d=z/10
w=x+d
L.append(w) # llena la lista L
print(L) # Imprime la lista L con las notas aleatorias
suma=0
for k in range(10):
suma+=L[k]
media=suma/10 # Saca el promedio
print('La media es :',round(media,2))
D_M=[]
for j in range(10):
D_M.append(round(abs(L[j] - media),2)) # Llena la lista con la desviación con respecto a la media
if L[j]<=media:
print(Fore.RED + str(L[j]) + ' ' + str(round(D_M[j],2))) # Imprime en rojo las notas menores que la media
else:
print(Fore.GREEN + str(L[j]) + ' ' + str(round(D_M[j],2)))
Hola.
EliminarEl código que envías está estupendo. Funciona muy bien. Gracias. Lo incluiremos dentro de los métodos de resolución del reto "Imprimir en color".
Un gran aportación.
ojo, cuidado con las indentaciones???
ResponderEliminarSi, gracias, ya puse las indentaciones en su lugar.
EliminarAlguno tiene la solución del reto 68?
ResponderEliminar#Creo haber entendido q es algo así:
Eliminara = list(range(int(input())))
b = [a[i:]+a[:i] for i in a]
print(b)
###RETO 74: TRES EN RAYA
ResponderEliminarfrom os import system
from random import randint, uniform,random
jugar = True
humano = ""
ordenador = ""
matriz = ["", "", "", "", "", "", "", "", ""]
def tablero():
system("cls")
print("-------TRES EN RAYA-------")
print("\t1 {} |\t2 {} |\t3 {} |".format(matriz[0],matriz[1],matriz[2]))
print("\t4 {} |\t5 {} |\t6 {} |".format(matriz[3], matriz[4], matriz[5]))
print("\t7 {} |\t8 {} |\t9 {} |".format(matriz[6], matriz[7], matriz[8]))
def ganador(letra):
return ((matriz[0] == matriz[1] == matriz[2] == letra) or
(matriz[3] == matriz[4] == matriz[5] == letra) or
(matriz[6] == matriz[7] == matriz[8] == letra) or
(matriz[0] == matriz[3] == matriz[6] == letra) or
(matriz[1] == matriz[4] == matriz[7] == letra) or
(matriz[2] == matriz[5] == matriz[8] == letra) or
(matriz[0] == matriz[4] == matriz[8] == letra) or
(matriz[2] == matriz[4] == matriz[6] == letra))
def insertarFicha(posicion, letra):
if (matriz[posicion] == "" and posicion < 9 and posicion >= 0):
matriz[posicion] = letra
return True
else: return False
def comprobarGanador():
if (ganador(humano)):
print("Enhorabuena has ganado esta partida. :)")
return True
elif(ganador(ordenador)):
print("Al menos lo has intentando, la próxima vez será. :(")
return True
elif(empate()):
print("Tablas en el marcador, partida reñida")
return True
else:
return False
def empate():
if ((matriz[0] != "" and matriz[1] != "" and matriz[2] != "") and
(matriz[3] != "" and matriz[4] != "" and matriz[5] != "") and
(matriz[6] != "" and matriz[7] != "" and matriz[8] != "")):
print("Tablas en el marcador")
return True
else:
return False
if __name__ == '__main__':
while jugar:
jugar = True
humano = ""
ordenador = ""
matriz = ["", "", "", "", "", "", "", "", ""]
print(humano)
while humano == "":
salida = input("Escoja el símbolo con el que desea jugar(x/o): \n")
ficha = salida.lower()
if ficha == "x" or ficha == "X":
humano = "X"
ordenador = "O"
elif ficha == "O" or ficha == "o":
humano = "O"
ordenador = "X"
salida = input("Desea empezar jugando (S/N)")
if(salida.lower()=="s"): turno=0
else: turno =1
while (not comprobarGanador()):
pos = False
if(turno == 0):
while not pos:
tablero()
salida = input("Seleccione una posición para introducir su ficha:")
posicion = int(salida)
if (insertarFicha(posicion - 1, humano)): pos = True
turno = 1
else:
while not pos:
tablero()
posicion = randint(0,8)
if(insertarFicha(posicion, ordenador)): pos = True
turno = 0
tablero()
salida = input(" Desea empezar una nueva partida???(S/N): ")
if (salida == "S" or salida == "s"):
jugar = True
else:
jugar = False
como lo puedo hacer programa en python que permita calcular la longitud de una recta
ResponderEliminaruna recta es infinita siempre, pero si te refieres a la longitud de un segmento, delimitado por dos puntos, la función sería:
ResponderEliminar#En 2D
#Siendo los puntos A (a1,a2) y B (b1,b2) la recta AB
longitud = ( (b1 - a1)**2 + (b2 - a2)**2 )**.5
#En 3D
#Siendo los puntos A (a1,a2,a3) y B (b1,b2,b3) la recta AB
longitud = ( (b1 - a1)**2 + (b2 - a2)**2 + (b3 - a3)**2 )**.5
Reto 47:
ResponderEliminar#Criba de Eratóstenes
c=int(input())+1
a,b=set(range(2,c)),-1
while b<len(a)-1:
d,b=list(a)[b],b+1
a.difference_update(set(range(d*2,c,d)))
print(list(a))
#Para el Reto 65
ResponderEliminardef mcd(a,b):
listaA=[]
listaB=[]
for i in range(1,a+1):
if a%i==0:
listaA.append(i)
for j in range(1,b+1):
if b%j==0:
listaB.append(j)
lista_divisores=[]
for x,y in zip(listaA,listaB):
if x==y:
lista_divisores.append(x)
maximo= max(lista_divisores, key=int)
print("el mcd de los números " + str(a) +" y " + str(b) +"= "+ str(maximo))
#reto54
ResponderEliminarciudades=['Madrid','Ottawa','Estocolmo','Oslo']
ciudad=input('Escribe un nombre de una ciudad: ')
if ciudad not in ciudades:
ciudades.append(ciudad)
orden=sorted(ciudades, key=len)
print(orden)
#reto 40
ResponderEliminarestaciones=('primavera','verano','otoño','invierno')
cont=0
print(estaciones,'\n')
for i in estaciones:
cont+=1
print( i)
print('\n',cont)
#reto 47
ResponderEliminar#!/usr/bin/env python
contador = 0
numero = int(input("Dime hasta que numero quieres poner en la criba "))
for x in range(1, numero + 1):
for y in range(1, x + 1):
if x % y == 0:
contador += 1
if contador == 2:
print("{}".format(x), end=" ")
contador = 0
#Reto 52
ResponderEliminardia=86400
hora=3600
min=60
x=int(input('dime csntidad de segundos: '))
print(x//dia,'',x%dia//hora,'horas',x%hora//min,'segundos')
#Reto45
ResponderEliminarimport random
def ver3(x):
x=str(x)
if '3' in x:
return True
else:
return False
numero=random.randint(100000,200001)
print(numero)
print(ver3(numero))
#reto 59
ResponderEliminarimport matplotlib.pyplot as plt
import matplotlib.patches as pc
import random
from random import randint
lista_colores=['#4682b4','#FFF0F5','#FF0099','#D2B48C','#CE4676','#563970','#FCF75E']
x=0
y=0
fig1 = plt.figure()
ax1 = fig1.add_subplot(111, aspect='equal')
plt.xlim(0, 1)
plt.ylim(0, 1)
def crea_rectangulo():
x=random.random()
y=random.random()
ax1.add_patch(
pc.Rectangle(
(x, y),
0.5,
0.15,
color=random.choice(lista_colores)
)
)
n=int(input('Cuantos rectángulos aleatorios quieres: '))
for i in range(n):
crea_rectangulo()
plt.show()
Dejo una propuesta para el Reto 50: Juego del número secreto
ResponderEliminarNo solo se pueden manejar las "oportunidades" para adivinar, también va dando algunas pistas.
import random
def pista(intentos, nro):
return f' y {"" if nro % intentos == 0 else "NO "}es múltiplo de {intentos}'
def juega(maximo, oportunidades):
nro = random.randint(1, maximo)
elegido = int(input(f'Elija un número del 1 al {maximo}: '))
gano = True
intentos=1
while nro != elegido and intentos < oportunidades:
intentos += 1
print(f'Error. El número es {"mayor" if nro > elegido else "menor"} {pista(intentos, nro)}')
elegido = int(input(f'Elija un número del 1 al {maximo}: '))
if elegido == nro:
gano = True
else:
gano = False
return f'{"¡Ganó! :D " if gano else "¡Perdió! :( "} el número era {nro}'
def run():
maximo = 100
oportunidades = 3
print(juega(maximo, oportunidades))
if __name__ == "__main__":
run()
Dejo el código para el PUZZLE (desafío 75). Imprime en pantalla las instrucciones, permite elegir la dificultad: 2, 3, 4, etc. Genera un cuadrado de dif de lado. Tiene un lector de teclado, con WASD se puede ir moviendo hacia la pieza libre, con ESCAPE se termina el juego.
ResponderEliminarPuse "####" donde debería haber una tabulación así se entiende bien... Si reemplazan # por ' ' funcionará.
import random
import os
from pynput import keyboard as kb
def crea_tablero(dif=3):
####'''
####Recibe un int(dif) de dificultad y devuelve una lista
####de listas de dimensión dif * dif.
####'''
####nros = list(range(dif * dif))
####random.shuffle(nros)
####lista = []
####for f in range(dif):
########fila = []
########for c in range(dif):
############fila.append(nros.pop())
########lista.append(fila)
####return lista
'''
Necesitamos crear estas variables de manera global para poner manipularlas y utilizarlas
dentro del la función que "atrapa" las teclas presionadas
'''
dif = int(input("Seleccione la dificultad (2, 3, 4, etc): "))
tablero = crea_tablero(dif)
def es_correcto():
####'''
####Verifica si el tabler contiene, en orden, los números
####desde el 1 hasta dif*dif-1 (es decir, el mayor posible del tablero -1)
####'''
####numero = 1
####while numero < dif**2:
########for f, filas in enumerate(tablero):
############for c, columnas in enumerate(filas):
################if tablero[f][c] != numero and (tablero[f][c] != 0):
####################return False
################numero +=1
####return True
########
def imprime():
####'''
####Limpia la consola e imprime el tablero junto a las instrucciones
####'''
####os.system("cls")
####for f in tablero:
########for c in f:
############print(F'{c if c != 0 else " ":^3}' , " ",end="")
########print("",end="\n")
####print("**** Presione W, A, S o D para mover ****")
####print("**** Presione ESCAPE para terminar ****")
def on_release(key):
####'''
####Función que atrapa la tecla presionada.
####Si es ESC, cancela, si está dentro del 'wasd', realiza el movimiento deseado
####y termina por imprimir nuevamente el tablero
####'''
####mueve = str(key)
####if mueve in "'w'a's'd'":
########if es_correcto():
############print("Ganaste!")
############return False
########else:
############for f, filas in enumerate(tablero):
################if 0 in filas:
####################indice = f, filas.index(0)
############nuevo_indice = list(indice)
############if mueve == "'w'" and indice[0] != dif-1:
################nuevo_indice[0] += 1
############if mueve == "'s'" and indice[0] != 0:
################nuevo_indice[0] -= 1
############if mueve == "'a'" and indice[1] != dif-1:
################nuevo_indice[1] += 1
############if mueve == "'d'" and indice[1] != 0:
################nuevo_indice[1] -= 1
############numero_cambia = tablero[nuevo_indice[0]][nuevo_indice[1]]
############tablero[indice[0]][indice[1]] = numero_cambia
############tablero[nuevo_indice[0]][nuevo_indice[1]] = 0
############imprime()
####if key == kb.Key.esc:
########return False
def run():
####'''
####Función principal que imprime el tablero y comienza a "escuchar" las teclas presionadas
####'''
####imprime()
####with kb.Listener(on_release=on_release) as listener:
########listener.join()
if __name__ == '__main__':
####run()
Tiro perabolico no está el código me lo pueden compartir por favor
ResponderEliminar