Simulación de Montecarlo para Probabilidades en Juegos de Cartas

Curso de Estadística Computacional con Python

Contenido del curso

Introducción

1
Programación Dinámica y Estocástica: Optimización y Modelado de Datos
01:56 min

Programación Dinámica

Caminos Aleatorios

Programas Estocásticos

Simulaciones de Montecarlo

Muestreo e Intervalos de Confianza

Datos Experimentales

Conclusiones

24
Optimización de Programas con Programación Dinámica y Simulaciones
02:54 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0017:29

Simulación de Montecarlo para Probabilidades en Juegos de Cartas

Curso de Estadística Computacional con Python

Clase 17 de 24

Clase 17 / 24

Juan Ventrone

Hace 7 años

Aqui dejo un algoritmo que saca la probabilidad De la jerarquia del poker. Este fue el resultado que obtuve:

Luego de un Millon de intentos se obtujo este resultado. de un Millon de intento Una sola Escalera Real Siente Muy Afortunado si alguna vez te a salido Saludos Probabilidad de Par: 0.471806 Probabilidad de Doble Par: 0.047398 Probabilidad de Trio: 0.022473 Probabilidad de Poker: 0.000243 Probabilidad de Full House: 0.001419 Probabilidad de Color: 0.002055 Probabilidad de Escalera: 0.003924 Probabilidad de Escalera Color: 9e-06 Probabilidad de Escalera_Real: 1e-06

import random
import collections
PINTA=["pica","corazon","trebol","diamante"]
VALOR=[1,2,3,4,5,6,7,8,9,10,11,12,13]

manos=[]



def crear_baraja():
    barajas=[]
    for pinta in PINTA:
        for valor in VALOR:
            barajas.append((pinta,valor))
    return barajas


def obtener_mano(barajas, tamano_mano):
    mano= random.sample(barajas,tamano_mano)
    return mano


def can_manos(intentos):
     for _ in range(intentos):
        mano=obtener_mano(barajas,tamano_mano)
        manos.append(mano)

def main(manos):
    
    doble_par=0
    pares=0
    trio=0
    poker=0
    full_house=0
    escalera=0
    escaleram=0
    color=0
    escalera_color=0
    escalera_real=0

    for mano in manos:
        valores=[]
        pintas=[]
        for carta in mano:
            valores.append(carta[1])
            pintas.append(carta[0])
        
        counter= dict(collections.Counter(valores))
        counter_pintas=dict(collections.Counter(pintas))
        minando_escalera=sorted(list(dict(collections.Counter(valores)).keys()))


    
        def escalera_funcion(minando_escalera):
            esc=False
            escr=False
            # Identificando si tenemos escapera
            if len(minando_escalera)==5:
                    if (abs(minando_escalera[0]-minando_escalera[4])==4):
                        esc=True
                        
                    if (minando_escalera[0]==1):
                        if (minando_escalera[1]==10)&(abs(minando_escalera[1]-minando_escalera[4])==3):
                            escr=True
                            
            
            return esc,escr

  
        def color_funcion(counter_pintas):
            # Identificando si hay Color
            cr=False
            if len(counter_pintas)==1:
                cr=True
            return cr


        def valor_pareja(counter):
            # Funcion que Clasifica Los Valores par, doble par, Trio, Poker y Full 		 
                                House
            c=False
            dob_par=False
            par=False
            pok=False
            tr=False
            fh=False

            for val in counter.values():
                # Clasificando Poker
                if val==4:
                    pok=True
                # Clasificando Trio
                if val==3:
                    tr=True
                # Clasificando Doble Par
                if (val==2)&(c==True):
                    dob_par=True
                # Clasificando Par
                if (val==2)&(c==False):
                    par=True
                    c=True
                # Clasificando Full House
                if (tr==True)&(c==True):
                    fh=True
                   
            

            return  pok,fh,tr,par, dob_par
        

        # contadores de pares, poker, doble, trio, full house

        counter_pares=valor_pareja(counter)
        doble_par=doble_par+counter_pares[4]
        pares=pares+counter_pares[3]
        trio=trio+counter_pares[2]
        full_house=full_house+counter_pares[1]
        poker=poker+counter_pares[0]

        # contadores escalera

        contador_escaleras=escalera_funcion(minando_escalera)
        escalera=escalera+contador_escaleras[0]+contador_escaleras[1]
        
        # # contador Color

        contado_color=color_funcion(counter_pintas)
        color=color+contado_color

        # Indentificando Escalera Real
        if (contador_escaleras[1]==True)&(contado_color==True):
            escalera_real+=1
            print(f"Aparecio la mano Milagrosa {mano}")
        
        if (contador_escaleras[0]==True)&(contado_color==True):
            escalera_color+=1
            print(f"Escalera color {mano}")
    
    return pares, doble_par, trio,poker,full_house,color,escalera,escalera_color,escalera_real

if __name__=="__main__":
    tamano_mano=5
    intentos=int(input("cuantos numeros de intentos"))
    barajas=crear_baraja()
    manos_1=can_manos(intentos)
    probabilidades=main(manos)
    j=["Par","Doble Par","Trio","Poker","Full House","Color","Escalera","Escalera Color","Escalera_Real"]
    for i in range(len(probabilidades)):
        print(f"Probabilidad de {j[i]}: {probabilidades[i]/intentos}")```

Luis Fernando Pedroza Taborda

Hace 6 años

Gracias por compartir tu solución Juan

Gonzalo Blasco

Hace 6 años

Interesante solución, pero siendo honesto no me gusta demasiado cómo abreviaste las variables...

tengo entendido que uno de los principios del Python es hacerlo legible y usar también espaciados y demás... al no tener espacios ni nada, se hace complicado leer el código a simple vista...

quizá te pueda ayudar espiar PEP 8 -- Style Guide for Python Code donde están definidos las reglas generales del espaciado y las variables y demás...

espero no moleste mi comentario, pero me chocó al leerlo... suerte...

Comentarios (249)249 comentarios

Ricardo Moreno

Sebastian CA

Facundo Nicolás García Martoni

Profesor

Alberto Perdomo

Daniel Andrés Giraldo Benites

Ronaldo Carbajal Tapahuasco

Raúl Asperilla

Luis Fernando Úbeda Camacho

David Vallejo Herrera

Daniel Reyes Barrera

johan Stever Rodriguez Molina

Jesus Perez

Gabriel Andrés Alzate Acuña

Reinaldo Orozco

Samuel Rolon Cicciari

Luciano Nicolas Pereira

David Alejandro Ortiz Duque

Harvi Calle

Andres Giovanny Rodriguez Escobar

Miguel Torres

Diego Diego

jose zuñiga

Angel Estrada

David Martínez Jiménez

Santiago Restrepo Escalante

Alberto Castro Flores

Delfina Merola Moreschi

Joan Federico Marin Ruiz

JESUS ALBERTO CARREÑO MARTINEZ

Jose Fernando Jaramillo Boon

Daniel Felipe Galvis Ballesteros

Guillermo Sanchez

Wilson Jerez

Hace 5 años

Fernando Campos

Kevin Salvador Casas

Kevin J. Zea Alvarado

Introducción

Programación Dinámica y Estocástica: Optimización y Modelado de Datos

Programación Dinámica

Programación Dinámica: Optimización de Problemas con Memorización

Optimización de Algoritmos con Programación Dinámica en Python

Caminos Aleatorios

Simulaciones con Caminos Aleatorios en Programación

Camino Aleatorio en Programación Orientada a Objetos

Algoritmo de Caminata Aleatoria en Python: Clase Borracho

Simulación de Caminata Aleatoria con Python

Visualización de Caminatas Aleatorias con Python y Bokeh

Programas Estocásticos

Programación Estocástica: Aplicaciones y Ejemplos Prácticos

Cálculo de Probabilidades y Simulación de Montecarlo

Simulaciones de Probabilidades con Dados en Python

Inferencia Estadística: Conceptos y Aplicaciones Prácticas

Cálculo de la Media Aritmética en Python paso a paso

Media, Varianza y Desviación Estándar en Estadística

Distribución Normal: Propiedades y Aplicaciones Estadísticas

Simulaciones de Montecarlo

Simulaciones de Montecarlo: Historia y Aplicaciones Prácticas

Simulación de Montecarlo para Probabilidades en Juegos de Cartas

Simulaciones de Montecarlo para Aproximar Pi

Estimación de Pi mediante Monte Carlo y Simulación Estadística

Muestreo e Intervalos de Confianza

Muestreo Estadístico: Aleatorio y Estratificado

Teorema del Límite Central: Transformación de Distribuciones

Datos Experimentales

Validación de teorías científicas con datos experimentales

Regresión Lineal con NumPy y Matplotlib en Google Colab

Conclusiones

Optimización de Programas con Programación Dinámica y Simulaciones

Simulación de Montecarlo para Probabilidades en Juegos de Cartas