Programar Juegos Arcade
con Python y Pygame

Chapter 6: Volvemos A Los Bucles

Los juegos requieren un montón de bucles complicados. Este es un “capítulo desafiante ” en lo que es aprender cómo ser un experto en bucles. Si consigues entender los problemas planteados aquí, al final, podrás asegurar que te has convertido en todo un experto en bucles.

Si tu objetivo no es convertirte en un experto en bucles, al menos deberías intentar responder a las preguntas planteadas en los ocho primeros problemas. Esto te proporcionará el conocimiento necesario para poder continuar con este libro. (Nadie ha conseguido una cita por ser experto en bucles, excepto el protagonista de la película Atrapado en el Tiempo)

Existen vídeos explicativos para las preguntas online, y el código de las respuestas se “anima”. Solo presiona el botón “inicio” para ver como funciona.

6.1 Imprimir Caracteres de Fin de Línea

Al final de cada instrucción print, ésta imprime por defecto un retorno de carro. Tal como se explicó en el primer capítulo, este retorno de carro es un carácter que traslada la siguiente línea, un renglón abajo. La mayoría de las veces esto es lo que justamente queremos. Pero otras no. Si queremos continuar imprimiendo en la misma línea, podemos cambiar el carácter final impreso por defecto. En este ejemplo aún no hemos cambiado ese carácter final:

print("Pulpo")
print("Rosa")

...lo que imprimirá:

Pulpo
Rosa

Pero si lo que queríamos es que todo se imprimiera sobre la misma línea, podemos conseguirlo usando una nueva opción; end. Por ejemplo:

print("Pulpo", end="")
print("Rosa")

Esto imprimirá:

PulpoRosa

También podemos usar un espacio en lugar de que sea una cadena vacía:

print("Pulpo", end=" ")
print("Rosa")

Y ahora:

Pulpo Rosa

Este es otro ejemplo, empleando una variable:

i = 0
print(i, end=" ")
i = 1
print(i, end=" ")

Esto imprimirá:

0 1

6.2 Problemas Avanzados de Bucles

  1. Escribe el código para imprimir diez asteriscos (*) de la siguiente manera:
    * * * * * * * * * *
    

    Lo puedes hacer usando un bucle for, que imprima individualmente cada asterisco, en lugar de imprimir diez asteriscos con una sola instrucción print. Esto se puede lograr con dos líneas de código; un bucle for y una instrucción print.

    Cuando lo hayas averiguado, o te hayas rendido, aquí encontrarás la respuesta:
    ProgramArcadeGames.com/chapters/06_back_to_looping/problem_1_es.php

  2. Escribe el código para imprimir esto:
    * * * * * * * * * *
    * * * * *
    * * * * * * * * * * * * * * * * * * * *
    

    Este es parecido al problema anterior, pero además, imprime cinco y veinte estrellas. Copia y pega el código anterior y ajusta el bucle for para lograrlo.

    Cuando lo hayas averiguado, o te hayas rendido, aquí encontrarás la respuesta:
    ProgramArcadeGames.com/chapters/06_back_to_looping/problem_2_es.php

  3. Usa dos bucles for, uno anidado en el otro, para imprimir el siguiente rectángulo de 10 x 10:
    * * * * * * * * * *
    * * * * * * * * * *
    * * * * * * * * * *
    * * * * * * * * * *
    * * * * * * * * * *
    * * * * * * * * * *
    * * * * * * * * * *
    * * * * * * * * * *
    

    Para empezar, mira el Problema 1. El código en él genera una línea de asteriscos. Necesitamos repetirlo diez veces. Trabaja en este problema al menos diez minutos antes de mirar la respuesta.

    Cuando lo hayas averiguado, o te hayas rendido, aquí encontrarás la respuesta:
    ProgramArcadeGames.com/chapters/06_back_to_looping/10x10box_es.php

  4. Usa dos bucles for, uno de ellos anidado, para imprimir el siguiente rectángulo de 5 x 10:
    * * * * *
    * * * * *
    * * * * *
    * * * * *
    * * * * *
    * * * * *
    * * * * *
    * * * * *
    * * * * *
    * * * * *
    

    Este se parece muchísimo al problema anterior. Experimenta con los rangos de los bucles hasta encontrar exactamente los números que usará la función range.

    Cuando lo hayas averiguado, o te hayas rendido, aquí encontrarás la respuesta:
    ProgramArcadeGames.com/chapters/06_back_to_looping/problem_4_es.php

  5. Usa dos bucles for, uno de ellos anidado, para imprimir el siguiente rectángulo de 20x5:
    * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
    

    Una vez más, parecido a los Problemas 3 y 4, pero con diferentes valores para range.

    Cuando lo hayas averiguado, o te hayas rendido, aquí encontrarás la respuesta:
    ProgramArcadeGames.com/chapters/06_back_to_looping/problem_5_es.php

  6. Escribe el código para conseguir:
    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8 9
    

    Usa dos bucles anidados. Imprime la primera línea con un bucle, y no con:

    print("0 1 2 3 4 5 6 7 8 9")
    

    Una pista: Primero, crea un bucle que imprima la primera línea. Luego, envuélvelo en otro bucle que repita esa línea 10 veces. Usa variables índice i o j para aquello que imprime el programa. Este ejemplo y el siguiente, ayudan a reforzar lo que este tipo de variables hacen.

    Trabaja en este problema al menos durante diez minutos antes de ver la respuesta. El proceso de pasarse diez minutos trabajando en la respuesta, es de lejos, más importante que la propia respuesta..
    ProgramArcadeGames.com/chapters/06_back_to_looping/number_square_answer_es.php

  7. Ajusta el programa anterior para obtener:
    0 0 0 0 0 0 0 0 0 0 
    1 1 1 1 1 1 1 1 1 1 
    2 2 2 2 2 2 2 2 2 2 
    3 3 3 3 3 3 3 3 3 3 
    4 4 4 4 4 4 4 4 4 4 
    5 5 5 5 5 5 5 5 5 5 
    6 6 6 6 6 6 6 6 6 6 
    7 7 7 7 7 7 7 7 7 7 
    8 8 8 8 8 8 8 8 8 8 
    9 9 9 9 9 9 9 9 9 9 
    

    Respuesta:
    ProgramArcadeGames.com/chapters/06_back_to_looping/problem_7_es.php

  8. Escribe el código que imprimirá esto:
    0
    0 1
    0 1 2
    0 1 2 3
    0 1 2 3 4
    0 1 2 3 4 5
    0 1 2 3 4 5 6
    0 1 2 3 4 5 6 7
    0 1 2 3 4 5 6 7 8
    0 1 2 3 4 5 6 7 8 9
    

    Una pista: Esto es como el Problema 6, pero el bucle interno ya no itera un número fijo de veces. No uses range(10), en cambio ajusta la dimensión del rango.

    Luego de haber trabajo al menos diez minutos en este problema, aquí tienes la solución:
    ProgramArcadeGames.com/chapters/06_back_to_looping/top_right_triangle_es.php

    Asegúrate de que eres capaz de escribir el código para el siguiente ejercicio, al igual que para los anteriores. Sí, esta práctica es laboriosa, pero más tarde se verá recompensada y ahorrarás mucho tiempo.

  9. Escribe el código para conseguir:
    0 1 2 3 4 5 6 7 8 9
      0 1 2 3 4 5 6 7 8
        0 1 2 3 4 5 6 7
          0 1 2 3 4 5 6
            0 1 2 3 4 5
              0 1 2 3 4
                0 1 2 3
                  0 1 2
                    0 1
                      0
    

    Este es difícil. Un pista: necesitamos dos bucles dentro de otro bucle externo que controle cada fila. Primero, un bucle imprime espacios, luego el otro bucle imprime los números. Itera ambos para cada línea. Para empezar, intenta escribir solamente un bucle interno que imprima:

    0 1 2 3 4 5 6 7 8 9
    0 1 2 3 4 5 6 7 8
    0 1 2 3 4 5 6 7
    0 1 2 3 4 5 6
    0 1 2 3 4 5
    0 1 2 3 4
    0 1 2 3
    0 1 2
    0 1
    0
    

    Una vez que esté funcionando, añade un bucle después del comienzo del bucle externo y antes del ya existente bucle interno. Usa este nuevo bucle para imprimir los espacios necesarios que justifiquen por la derecha los otros bucles.

    Luego de haber trabajo al menos diez minutos en este problema, aquí tienes la solución:
    ProgramArcadeGames.com/chapters/06_back_to_looping/bottom_left_triangle_es.php

  10. Escribe el código para obtener (Conseguir el alineamiento es difícil, al menos escribe los números):
      1   2   3   4   5   6   7   8   9 
      2   4   6   8  10  12  14  16  18 
      3   6   9  12  15  18  21  24  27 
      4   8  12  16  20  24  28  32  36 
      5  10  15  20  25  30  35  40  45 
      6  12  18  24  30  36  42  48  54 
      7  14  21  28  35  42  49  56  63 
      8  16  24  32  40  48  56  64  72 
      9  18  27  36  45  54  63  72  81 
    

    Una pista: Empieza por ajustar el código del Problema 1 para que imprima:

     0  0  0  0  0  0  0  0  0  0 
     0  1  2  3  4  5  6  7  8  9 
     0  2  4  6  8  10  12  14  16  18 
     0  3  6  9  12  15  18  21  24  27 
     0  4  8  12  16  20  24  28  32  36 
     0  5  10  15  20  25  30  35  40  45 
     0  6  12  18  24  30  36  42  48  54 
     0  7  14  21  28  35  42  49  56  63 
     0  8  16  24  32  40  48  56  64  72 
     0  9  18  27  36  45  54  63  72  81 
    

    Luego ajusta el código para que haga esto:

     1  2  3  4  5  6  7  8  9 
     2  4  6  8  10  12  14  16  18 
     3  6  9  12  15  18  21  24  27 
     4  8  12  16  20  24  28  32  36 
     5  10  15  20  25  30  35  40  45 
     6  12  18  24  30  36  42  48  54 
     7  14  21  28  35  42  49  56  63 
     8  16  24  32  40  48  56  64  72 
     9  18  27  36  45  54  63  72  81 
    

    Finalmente, si el número ha imprimir es menor a 10, usa una instrucción if que imprima los espacios .

    Luego de haber trabajo al menos diez minutos en este problema, aquí tienes la solución:
    ProgramArcadeGames.com/chapters/06_back_to_looping/multiplication_table_es.php

  11. Construye los siguiente:
                      1
                    1 2 1
                  1 2 3 2 1
                1 2 3 4 3 2 1
              1 2 3 4 5 4 3 2 1
            1 2 3 4 5 6 5 4 3 2 1
          1 2 3 4 5 6 7 6 5 4 3 2 1
        1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
      1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
    

    Una pista: primero escribe el código que realice esto:

    1 
    1 2 
    1 2 3 
    1 2 3 4 
    1 2 3 4 5 
    1 2 3 4 5 6 
    1 2 3 4 5 6 7 
    1 2 3 4 5 6 7 8 
    1 2 3 4 5 6 7 8 9 
    

    Luego el que realice esto otro:

    1 
    1 2 1 
    1 2 3 2 1 
    1 2 3 4 3 2 1 
    1 2 3 4 5 4 3 2 1 
    1 2 3 4 5 6 5 4 3 2 1 
    1 2 3 4 5 6 7 6 5 4 3 2 1 
    1 2 3 4 5 6 7 8 7 6 5 4 3 2 1 
    1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1 
      

    Por último añade espacios para obtener el resultado final.

    Luego de haber trabajo al menos diez minutos en este problema, aquí tienes la solución:
    ProgramArcadeGames.com/chapters/06_back_to_looping/top_triangle_es.php

  12. Construye:
                      1
                    1 2 1
                  1 2 3 2 1
                1 2 3 4 3 2 1
              1 2 3 4 5 4 3 2 1
            1 2 3 4 5 6 5 4 3 2 1
          1 2 3 4 5 6 7 6 5 4 3 2 1
        1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
      1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
        1 2 3 4 5 6 7 8
          1 2 3 4 5 6 7
            1 2 3 4 5 6
              1 2 3 4 5
                1 2 3 4
                  1 2 3
                    1 2
                      1
    

    Esto se puede lograr combinando los Problemas 11 y 9.

    Luego de haber trabajo al menos diez minutos en este problema, aquí tienes la solución:
    ProgramArcadeGames.com/chapters/06_back_to_looping/three_quarters_es.php

  13. Escribe el código para conseguir:
                      1
                    1 2 1
                  1 2 3 2 1
                1 2 3 4 3 2 1
              1 2 3 4 5 4 3 2 1
            1 2 3 4 5 6 5 4 3 2 1
          1 2 3 4 5 6 7 6 5 4 3 2 1
        1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
      1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
        1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
          1 2 3 4 5 6 7 6 5 4 3 2 1
            1 2 3 4 5 6 5 4 3 2 1
              1 2 3 4 5 4 3 2 1
                1 2 3 4 3 2 1
                  1 2 3 2 1
                    1 2 1
                      1
    
    
    

    Luego de haber trabajo al menos diez minutos en este problema, aquí tienes la solución:
    ProgramArcadeGames.com/chapters/06_back_to_looping/full_diamond_es.php

6.3 Repaso

6.3.1 Test

Haz click para ir al Test.

6.3.2 Ejercicios

Haz click para ir a los Ejercicios.

6.3.3 Taller

Haz click para ir al Taller.


You are not logged in. Log in here and track your progress.