Uno de los juegos mexicanos más populares es sin duda La Lotería Mexicana. Todos la hemos jugado alguna vez y la verdad es un juego muy divertido para pasar un rato en familia (pero sin celulares por favor).
Una forma de aprender lenguajes de programación es reproduciendo juegos sencillos. En el 2014 ya había hecho este mismo experimento pero usando Ruby . Pero de un tiempo para acá me he adaptado mucho mejor a Python, así que decidí hacer el mismo ejercicio con este lenguaje.
El azar en los juegos
El planteamiento es muy sencillo, en una lista almacenare todos los nombres de las cartas. En otra lista voy a almacenar la misma información pero en desorden gracias a la función sample a la que llamare reborujado.
Para usar la función es necesario importarla de random que es la librería de números pseudoaleatorios de Python . Que es lo que le añade esa pizca de azar al juego.
from random import sample
Lo bonito de la función sample es que puede extraer un subconjunto de la lista cartas. Para eso le paso como parámetro el tamaño total de la lista con la función len, para no excluir ninguna carta.
Una pausa por favor
Otra función que agrego al código es sleep para darle una pequeña pausa a la ejecución del código y dar la impresión de que se están cantando las cartas. La librería time incluye algunas funciones relacionadas con el tiempo, pero como se maneja el tiempo en Linux creo que es tema para un artículo completo aparte, ya saben que me obsesionan esos temas.
from time import sleep
En este caso ajuste la pausa a 3 segundos, pero se puede modificar fácilmente en el código.
El código
Ahora solo falta mostrarlo todo junto.
from random import sample
from time import sleep
velocidad = 3
cartas = ["1 El Gallo",
"2 El Diablito",
"3 La Dama",
"4 El catrín",
"5 El paraguas",
"6 La sirena",
"7 La escalera",
"8 La botella",
"9 El barril",
"10 El árbol",
"11 El melón",
"12 El valiente",
"13 El gorrito",
"14 La muerte",
"15 La pera",
"16 La bandera",
"17 El bandolón",
"18 El violoncello",
"19 La garza",
"20 El pájaro",
"21 La mano",
"22 La bota",
"23 La luna",
"24 El cotorro",
"25 El borracho",
"26 El negrito",
"27 El corazón",
"28 La sandía",
"29 El tambor",
"30 El camarón",
"31 Las jaras",
"32 El músico",
"33 La araña",
"34 El soldado",
"35 La estrella",
"36 El cazo",
"37 El mundo",
"38 El apache",
"39 El nopal",
"40 El alacrán",
"41 La rosa",
"42 La calavera",
"43 La campana",
"44 El cantarito",
"45 El venado",
"46 El sol",
"47 La corona",
"48 La chalupa",
"49 El pino",
"50 El pescado",
"51 La palma",
"52 La maceta",
"53 El arpa",
"54 La rana"]
# A reborujar las cartas
reborujado = sample(cartas, len(cartas))
# Correeeee correeee y se va.
print("Correeeee correeee y se va !!!")
for carta in reborujado:
sleep(velocidad)
print(carta)
print("\n¡Lotería!")
¡Corre, corre y se vaaaaa!
¡Lotería!
Gracias al comentario de CHAPEAU mi mente divagó un poco. Con este programa puedo jugar muchas veces ¿Existirá una tabla ganadora? De niños cuando no ganábamos era común cambiar de tabla por que la que teníamos no tenía “suerte”. Pero ¿Y si no era suerte?.
Para averiguarlo tuve que conseguir unas tablas, no tenía ninguna a la mano, así que busqué un poco en internet. Las tablas ocupan 16 figuras de las cartas, pero ninguna se repite. Todas las tablas de un juego de lotería son diferentes.
Para efectos de código decidí omitir los nombres de las figuras y quedarme solamente con los números. Entonces declaré 3 variables principales.
- cartas. Una lista de los números de las cartas del 1 al 54.
- tablas. Una matriz con el contenido de figuras de cada tabla.
- resultados. Del lado izquierdo de la matriz voy acumulando las veces que ha ganado esa tabla. En el lado derecho voy juntando los “frijolitos”.
Durante el juego cada vez que sale una carta reviso todas las tablas para ver si esta presente. Si es así, entonces le pongo un frijolito a la tabla. Es tabla llena si logra acumular 16 frijolitos.
En caso de que una tabla sea tabla llena incremento la cantidad de veces que ha ganado. Pero esto lo tengo que revisar en todas las tablas, porque se puede dar el caso de tener más de una tabla ganadora con la misma carta. A todos nos ha pasado.
Luego tuve que ajustar el código para hacer procedimientos para hacerlo un poco más modular y claro el código.
from random import sample
# Para mostrar de una mejor forma las matrices.
def matriz2cadena(matriz):
cadena = ''
for i in range(len(matriz)):
cadena += '['
for j in range(len(matriz[i])):
cadena += '{:>4s}'.format(str(matriz[i][j]))
cadena += ']\n'
return cadena
# Juego completo, hasta encontrar la tabla ganadora.
def juego():
# A reborujar las cartas
reborujado = sample(cartas, len(cartas))
for carta in reborujado:
for x in range(0, 10):
# Buscamos la carta en todas las tablas (puede aparecer en más de una).
if carta in tablas[x]:
# Si aparece, agregamos un frijolito a la tabla.
resultados[x][1] += 1
if tabla_llena():
break
# Dice si ya existe una (o varias tablas) con 16 frijolitos (tabla llena).
def tabla_llena():
conteo = 0
for x in range(0, 10):
if resultados[x][1] == 16:
conteo += 1
if conteo > 0:
return True
else:
return False
# Lleva un contador de las tablas ganadoras.
def acumular_resultados():
for x in range(0,10):
if resultados[x][1] == 16:
resultados[x][0] += 1
resultados[x][1] = 0 # Quita los frijolitos de la tabla.
cartas = list(range(1, 55))
# https://tuloteriamexicana.com/wp-content/uploads/CartasNormal4x4_1_10.pdf
tablas = [
[1, 2, 3, 4, 10, 11, 12, 13, 19, 20, 21, 22, 28, 29, 30, 31],
[6, 7, 8, 9, 15, 16, 17, 18, 24, 25, 26, 27, 33, 34, 35, 36],
[2, 3, 4, 5, 7, 8, 9, 10, 12, 13, 14, 15, 17, 18, 19, 20],
[43, 44, 45, 21, 52, 53, 54, 26, 7, 8, 9, 31, 16, 17, 18, 36],
[22, 23, 24, 25, 27, 28, 29, 30, 32, 33, 34, 35, 37, 38, 39, 40],
[21, 22, 23, 24, 30, 31, 32, 33, 39, 40, 41, 42, 48, 49, 50, 51],
[25, 26, 27, 41, 34, 35, 36, 46, 43, 44, 45, 51, 52, 53, 54, 32],
[42, 43, 44, 45, 47, 48, 49, 50, 52, 53, 54, 1, 40, 10, 19, 20],
[41, 42, 37, 38, 50, 51, 46, 47, 5, 6, 1, 2, 14, 15, 10, 11],
[39, 40, 19, 20, 48, 49, 28, 29, 3, 4, 37, 38, 12, 13, 46, 47]
]
# Del lado izquierdo llevo el conteo de las veces que la tabla ha ganado.
# Y en el lado derecho los frijolitos que acumula cada tabla.
resultados = [
[0, 0],
[0, 0]
]
# Ejecutamos 100 mil juegos. Veamos que pasa.
for x in range(0,100000):
juego()
acumular_resultados()
print(matriz2cadena(resultados))
No sean muy rudos con el código, no está optimizado, pero eso sí, se aceptan sugerencias.
¡Tenemos un resultado!
Okey, llegó el momento de la verdad. Ejecuté el código con ciclos de 100 juegos varias veces, pero no noté diferencias. En unas ocasiones ganaba una tabla, luego otra, nada concluyente.
Lo mismo pasó al hacer ciclos de 1000 juegos. Decidí echar toda la carne al asador e hice ciclos de 100 mil juegos. Entonces una tabla empezó a destacar.
La tabla que ganó en más ocasiones después de 100 mil juegos fue (redoble de tambores) ¡La Tabla 08!
Consistentemente fue la más ganadora.
Con pocas modificaciones se puede ajustar a un mayor número de tablas o con distinta distribución. Por el momento, si imprimo estas tablas definitivamente me quedo con la que aparece en la imagen.
Ahora si, mi mente ya puede descansar un poco, simplemente no me pude quedar con la duda ¿Les ha pasado?
¡Hasta la próxima!