Retos en Python

Aprender haciendo. Esa es la idea. Vamos a proponer una serie de ejemplos para programar código en Python pensando en quien inicia su formación en este lenguaje.

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

      25 comentarios:

      1. Si el reto 58 no me sale, donde puedo ver la solucion?

        ResponderEliminar
      2. Hola Damian.
        El 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.

        ResponderEliminar
      3. Reto 65. Contraseñas aleatorias (Método)

        import 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

        ResponderEliminar
      4. MUY BUENO, ME INTERESA MUCHO APRENDER PYTHON

        ResponderEliminar
      5. Miren la propuesta del Reto 35 Imprimir con color

        import 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)))

        ResponderEliminar
        Respuestas
        1. Hola.
          El 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.

          Eliminar
      6. ojo, cuidado con las indentaciones???

        ResponderEliminar
      7. Alguno tiene la solución del reto 68?

        ResponderEliminar
        Respuestas
        1. #Creo haber entendido q es algo así:
          a = list(range(int(input())))
          b = [a[i:]+a[:i] for i in a]
          print(b)

          Eliminar
      8. ###RETO 74: TRES EN RAYA
        from 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

        ResponderEliminar
      9. como lo puedo hacer programa en python que permita calcular la longitud de una recta

        ResponderEliminar
      10. una recta es infinita siempre, pero si te refieres a la longitud de un segmento, delimitado por dos puntos, la función sería:

        #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

        ResponderEliminar
      11. Reto 47:

        #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))

        ResponderEliminar
      12. #Para el Reto 65
        def 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))

        ResponderEliminar
      13. #reto54
        ciudades=['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)

        ResponderEliminar
      14. #reto 40
        estaciones=('primavera','verano','otoño','invierno')
        cont=0
        print(estaciones,'\n')
        for i in estaciones:
        cont+=1
        print( i)
        print('\n',cont)

        ResponderEliminar
      15. #reto 47

        #!/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

        ResponderEliminar
      16. #Reto 52


        dia=86400
        hora=3600
        min=60

        x=int(input('dime csntidad de segundos: '))
        print(x//dia,'',x%dia//hora,'horas',x%hora//min,'segundos')

        ResponderEliminar
      17. #Reto45

        import 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))

        ResponderEliminar
      18. #reto 59


        import 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()

        ResponderEliminar
      19. Dejo una propuesta para el Reto 50: Juego del número secreto
        No 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()

        ResponderEliminar
      20. 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.

        Puse "####" 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()

        ResponderEliminar
      21. Tiro perabolico no está el código me lo pueden compartir por favor

        ResponderEliminar