# ─────────────────────────────────────────────
# BLOQUE 0: Código comentado (desactivado)
# ─────────────────────────────────────────────
# Las líneas que empiezan con # son comentarios y Python las ignora.
# Este bloque está "apagado" a propósito para que no se ejecute.
# Es un ejemplo sencillo de bucles anidados que el autor dejó como referencia.
# Si quitas los # de cada línea verás cómo funciona:
# El exterior (i) daría dos vueltas: i=1 e i=2
# El interior (j) daría tres vueltas por cada vuelta del exterior: j=1, j=2, j=3
# Total de líneas impresas: 2 × 3 = 6
# Resultado si lo activaras:
# 1 1
# 1 2
# 1 3
# 2 1
# 2 2
# 2 3
# for i in range(1,3):
# for j in range(1,4):
# print(i,j)
# ─────────────────────────────────────────────
# BLOQUE 1: Tablas de multiplicar del 1 al 10
# ─────────────────────────────────────────────
# Bucle exterior: recorre los números del 1 al 10.
# En cada vuelta, 'numero' es la tabla que estamos calculando (1, 2, 3... 10).
# range(1,11) genera del 1 al 10 — el 11 no se incluye nunca en range.
for numero in range(1,11):
# Mostramos el encabezado de cada tabla.
# \n dentro de una f-string es un salto de línea extra (línea en blanco).
# Así cada tabla empieza con un poco de espacio visual.
print(f"Tabla de multiplicar del numero {numero}\n")
# Bucle interior: recorre los multiplicadores del 1 al 10.
# Se ejecuta completo (10 vueltas) por cada vuelta del exterior.
# Total de multiplicaciones: 10 tablas × 10 líneas = 100 líneas en total.
for i in range(1,11):
# Imprimimos la operación y su resultado.
# i*numero calcula el resultado directamente dentro de la f-string.
# Ejemplo cuando numero=3 e i=4: "4 x 3 = 12"
print(f"{i} x {numero} = {i*numero}")
# Esta línea está DENTRO del exterior pero FUERA del interior.
# Se ejecuta UNA VEZ al terminar cada tabla, dibujando una línea separadora.
# "="*50 repite el carácter "=" 50 veces seguidas: ==================================================
print("="*50)
# ─────────────────────────────────────────────
# BLOQUE 2: Combinaciones de tallas y colores
# ─────────────────────────────────────────────
# Dos listas con los valores de cada dimensión.
# El objetivo es generar todas las combinaciones posibles: 3 colores × 4 tallas = 12 combinaciones.
tallas=["S","M","L","XL"]
colores=["verde","azul","amarillo"]
# Bucle exterior: recorre los colores (3 vueltas en total).
for color in colores:
# Bucle interior: recorre las tallas (4 vueltas por cada color).
# Por cada color se generan las 4 tallas posibles.
for talla in tallas:
# Imprimimos la combinación actual.
# Ejemplo: "verde | S", "verde | M", "verde | L", "verde | XL"
# Luego pasará a "azul | S", "azul | M"... y así con cada color.
print(f"{color} | {talla}")
# Traza completa de las combinaciones generadas:
# verde | S verde | M verde | L verde | XL
# azul | S azul | M azul | L azul | XL
# amarillo | S amarillo | M amarillo | L amarillo | XL
# Sugerencia: si quisieras el orden inverso (primero tallas, luego colores)
# solo habría que intercambiar los dos bucles:
# for talla in tallas:
# for color in colores:
# print(f"{color} | {talla}")
# Línea en blanco para separar visualmente el siguiente bloque.
# \n dentro del print añade un salto de línea extra además del salto normal.
print("\n")
# ─────────────────────────────────────────────
# BLOQUE 3: Cuadrícula de # con bucles anidados (versión 1)
# ─────────────────────────────────────────────
# Dibujamos una cuadrícula de 5×5 usando dos bucles anidados.
# El exterior controla las filas (5 filas).
# El interior controla las columnas (5 columnas por fila).
for filas in range(5): # filas toma los valores 0, 1, 2, 3, 4
for columnas in range(5): # columnas toma los valores 0, 1, 2, 3, 4
# end=" " es un parámetro de print que cambia el carácter final.
# Por defecto print termina con \n (salto de línea).
# Con end=" " termina con un espacio, así los # se imprimen en la MISMA línea.
# Resultado de las 5 vueltas del interior: " # # # # # "
print(" #",end=" ")
# Este print está DENTRO del exterior pero FUERA del interior.
# Se ejecuta una vez al terminar cada fila.
# \n añade una línea en blanco entre filas para que la cuadrícula respire.
print("\n")
# Resultado visual:
# # # # # #
#
# # # # # #
#
# # # # # # ... (5 filas)
# ─────────────────────────────────────────────
# BLOQUE 4: Cuadrícula de # sin bucle interior (versión 2, más compacta)
# ─────────────────────────────────────────────
# Esta versión consigue el mismo resultado visual pero con un solo bucle.
# " # "*5 repite la cadena " # " cinco veces: " # # # # # "
# Es equivalente al bucle interior del bloque anterior pero en una sola línea.
for filas in range(5):
print(" # "*5)
# Resultado: 5 filas de " # # # # # "
# La diferencia con el bloque anterior es que aquí no hay línea en blanco entre filas
# porque no tiene el print("\n") extra.
# Conclusión: el bloque 3 y el bloque 4 hacen casi lo mismo.
# El bloque 3 usa dos bucles (más flexible si quisieras cambiar algo en cada celda).
# El bloque 4 usa multiplicación de cadena (más corto y elegante para casos simples).
# Sugerencia: si quisieras una cuadrícula de tamaño variable con el bloque 4:
# tamanyo = 7
# for filas in range(tamanyo):
# print(" # " * tamanyo)
# ─────────────────────────────────────────────
# BLOQUE 5: Tablero de ajedrez con emojis
# ─────────────────────────────────────────────
# Definimos el tamaño del tablero. Con 8 obtenemos un tablero 8×8 como el ajedrez real.
# Cambiando este valor obtenemos tableros de cualquier tamaño sin tocar el resto del código.
tamanyo=8
# Bucle exterior: recorre las filas (0, 1, 2... 7).
for filas in range(tamanyo):
# Bucle interior: recorre las columnas (0, 1, 2... 7).
for columnas in range(tamanyo):
# El truco del tablero está en la suma filas+columnas.
# Cuando la suma es PAR (resto 0 al dividir entre 2) → casilla negra ⬛
# Cuando la suma es IMPAR (resto 1 al dividir entre 2) → casilla blanca ⬜
#
# Veamos por qué funciona:
# Fila 0, Col 0: 0+0=0 par → ⬛ Fila 0, Col 1: 0+1=1 impar → ⬜
# Fila 0, Col 2: 0+2=2 par → ⬛ Fila 0, Col 3: 0+3=3 impar → ⬜
# Fila 1, Col 0: 1+0=1 impar → ⬜ Fila 1, Col 1: 1+1=2 par → ⬛
# Los colores se alternan automáticamente tanto en horizontal como en vertical.
if (filas+columnas)%2==0:
print("⬛",end="") # end="" evita el espacio entre emojis para que queden juntos
else:
print("⬜",end="") # end="" igual que arriba
# Al terminar cada fila (los 8 cuadros) imprimimos una cadena vacía con salto de línea.
# print("") es equivalente a print() — simplemente baja a la siguiente línea.
# Sin esta línea, todos los emojis aparecerían en una sola fila larga.
print("")
# Resultado visual (tablero 8×8):
# ⬛⬜⬛⬜⬛⬜⬛⬜
# ⬜⬛⬜⬛⬜⬛⬜⬛
# ⬛⬜⬛⬜⬛⬜⬛⬜
# ⬜⬛⬜⬛⬜⬛⬜⬛
# ⬛⬜⬛⬜⬛⬜⬛⬜
# ⬜⬛⬜⬛⬜⬛⬜⬛
# ⬛⬜⬛⬜⬛⬜⬛⬜
# ⬜⬛⬜⬛⬜⬛⬜⬛
#
# Sugerencia: prueba a cambiar tamanyo=4 para un tablero más pequeño,
# o intercambia ⬛ y ⬜ para que empiece por blanco en vez de negro.
# También puedes usar "X " y "O " si los emojis no se ven bien en tu entorno.
