Programando una Lotería Mexicana en Python

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!")

https://linuxmanr4.com/wp-content/uploads/2021/09/loteria_mexicana_python_2.webm
¡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 y encontré estas. 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],
    [0, 0],
    [0, 0],
    [0, 0],
    [0, 0],
    [0, 0],
    [0, 0],
    [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.

¡Esta es la buena!

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!

2 comentarios en “Programando una Lotería Mexicana en Python”

  1. La suerte no es para quien la busca, si no para quien la encuentra.

    La mejor lotería es trabajo y economía.

    Aunque puestos a divagar pienso que la forma mas adecuada para un posible ganador estaría en la estadística. ¿Que carta ha salido mas veces?. ¿Cual ha sido el premio otorgado?. . . etc.

¡Me encantaría saber que opinas!

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Salir de la versión móvil