Simulaciones de Probabilidades con Dados en Python

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:0014:23

Simulaciones de Probabilidades con Dados en Python

Curso de Estadística Computacional con Python

Clase 11 de 24

Clase 11 / 24

Comentarios (324)324 comentarios

Ricardo Moreno

Hace 7 años

Que tal!! Modifique un poco el codigo para visualizar como conforme mas intentos realices tiende mas a un numero en especifico y en este caso 0.1666666:

Saludos!!

Emanuel Castañeda

Hace 6 años

Muestra el codigo

Ricardo Moreno

Hace 6 años

Lo siento, simpre muestro el código pero en este se me olvidó jaja -> https://colab.research.google.com/drive/116apfWpqs36LosNtdQdK8QBCOroAOR7V#scrollTo=Q-QHQE9bJK1J

Saludos!!!

Santiago Jose Ibarra Aquino

Hace 7 años

Me salio que la probabilidad es 0.2485 UwU

<import random

def tirar_dados(numero_de_intentos):
    secuencia_de_tiros = []

    for _ in range(numero_de_intentos):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        tiro2 = random.choice([1, 2, 3, 4, 5, 6])
        resultado = tiro + tiro2
        secuencia_de_tiros.append(resultado)


    return secuencia_de_tiros

def main(numeros_de_tiros, numero_de_intentos):
    tiros = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dados(numeros_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1

    probabilidad_de_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 12 en {numeros_de_tiros} es: {probabilidad_de_tiros_con_12}')



if __name__ == "__main__":
    numeros_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    main(numeros_de_tiros, numero_de_intentos)>

Matias Vega Maza

Hace 7 años

Hicimos lo mismo e.e

Winston Serrudo

Hace 6 años

yo pensando subir como lo hice y ya alguien lo hizo igualito xD

Italo Quevedo

Hace 6 años

TEORÍA:

RESULTADO:

CÓDIGO:

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([2,3,4,5,6,7,3,4,5,6,7,8,4,5,6,7,8,9,5,6,7,8,9,10,6,7,8,9,10,11,7,8,9,10,11,12])
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1
    
    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener x lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')


if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros del dado : '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion : '))

    main(numero_de_tiros, numero_de_intentos)```

Jairo Stiven Jimenez

Hace 6 años

Cordial saludo, compañeros. Es que estaba pensando un poco en el código y a mi el resultado me da un poco distintos. Me da que es aproximadamente del 2.7%.

Análiticamente solo es posible obtener un 12 cuando ambos dados son 6. La probabilidad de que en 1 tiro un dado sea 6 es 1/6 y que el otro dado sea 6 es 1/6. Por tanto, para que ambos sean 6 la probabilidad es: 1/6*1/6 que es 1/36=0.277777778 = 2.7%

Quedo atento a sus opiniones. Saludos

Kevin J. Zea Alvarado

Hace 6 años

Hola, Jairo. Te faltó un 0 en 0.277777778 para que sea 0.0277777778.

Fuera de eso, es correcto lo que dices. Ésa es la probabilidad de que en 1 tiro salga el 12. La cosa es que el reto pide la probabilidad de obtener, por lo menos, un 12 en 10 tiros diferentes. En ese caso, la probabilidad es mayor, ya que, entre más tiros hagas, es más probable que te dé, cuando menos, un 12.

Saludos.

Coren Ancco Calloapaza

Hace 6 años

implementacion para hallar un aproximado de la probabilidad de obtener una suma m con n dados

resultado con matemáticas El total de combinaciones de 2 dados es 36 y el total de combinaciones de 2 dados que nos dan de suma 12 es 1 entonces : Para 1 tiro de dados la probabilidad seria:

Para 10 tiros se usaría la Probabilidad "A o B". O sucede que en el primer tiro los dados suman 12 o sucede en el 2do tiro así sucesivamente Entonces

Resultado del programa Para 1 tiro:

Para 10 tiros:

ALDO MATUS MARTINEZ

Hace 6 años

HEY! Muchisimas gracias, no sabes cuanto me ayudó tu análisis :smiley: creo que lo fundamental es entender esto

Ángel David Roque Ayala

Hace 6 años

solucion para tirar un numero n de dados y buscar un valor n:

def tirar_dados(numero_de_tiros, numero_de_dados):
    secuencia_de_tiros = []
    if numero_de_dados <= 0:
        numero_de_dados = 1

    for _ in range(numero_de_tiros):
        tiro = 0
        for _ in range(numero_de_dados):
            tiro += random.choice([1,2,3,4,5,6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros   

def probabilidad_existir(tiros, numero_de_intentos,valor_del_dado_buscado):
    

    tiros_con_valor_buscado = 0
    for tiro in tiros:
        if valor_buscado in tiro:
            tiros_con_valor_buscado += 1

    probabiblidad_de_tiros_con_1 = tiros_con_valor_buscado / numero_de_intentos
    print(f'Cual es la probabiblidad de obtener por lo menos un {valor_buscado} en {numero_de__tiros} = {probabiblidad_de_tiros_con_1}')
    

def main(numero_de_tiros, numero_de_intentos, numero_de_dados, valor_buscado):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dados(numero_de_tiros, numero_de_dados)
        tiros.append(secuencia_de_tiros)


    probabilidad_existir(tiros, numero_de_intentos, valor_buscado)

    

if __name__ == "__main__":
    numero_de__tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    numero_de_dados = int(input('Numero de dados: '))
    valor_buscado = int(input('Cual es el valor buscado: '))

    main(numero_de__tiros, numero_de_intentos, numero_de_dados, valor_buscado)

Fabrizio Jesús Vásquez Auqui

Hace 6 años

Interesante triple for 😉

Andres Alvarez Becerra

Hace 6 años

Hola, alguien me podría explicar que significa el raya piso en el forloops

for _ in range(numero_de_intenteos):
...

CRISTIAN BARBERO PÉREZ

Hace 6 años

Hola, es el nombre que se le da a la variable que itera, podría ser cualquier nombre, pero cuando no se va a llamar se suele utilizar el _. Las siguientes líneas hacen lo mismo:

for _ in range(numero_de_intentos):
	print(_)

for i in range(numero_de_intentos):
	print(i)

En este ejemplo se ve quién es _:

Jesus Rafael Melendez Martin

Hace 6 años

Exactamente. Lo que pasa es que cuando utilizas un ciclo for, esa variable iteradora va almacenando los valores que contiene el elemento iterable.

Por conveción y legibilidad, esa variable iteradora se le pone un nombre relacionado a su papel (por ejemplo for numero in numeros, for pais in paises).

Cuando no necesitas ese valor, sino simplemente hacer algo una determinada cantidad de pasos (como ejecutar algo X numero de intentos), por buenas prácticas, se le pone _ como nombre.

johan Stever Rodriguez Molina

Hace 7 años

ya que han dejado el código, mi aporte sera analítico. La probabilidad de obtener por lo menos 12 en n tiros seria. (1/36)^n. Recuerden que se hace la suposición que los dados están marcados, esto nos permite "diferenciarlos", así las parejas serán del tipo (dado_1, dado_2), lo cual nos permite diferenciar por ejemplo (1,2) de (2,1) . Si no hacemos esta suposición solo tendríamos 36/2=18 resultados posibles distintos.

Ronaldo Carbajal Tapahuasco

Hace 6 años

Comparto mi codigo :D! Esta para realizarse con bokeh :D! espero feedback

import random
from bokeh.plotting import figure,show


def got_sequences(throws):
    sequence = []

    for _ in range(throws):
        option_got = random.choice([1, 2, 3, 4, 5, 6])
        sequence.append(option_got)
    return sequence



def graph(sim,prob,sum_to_reach,throws):
    plot = figure(title=print(f'Probability of having {sum_to_reach} in {throws} throws'),
                    x_axis_label = "Attempts",
                    y_axis_label = "Probability")
    plot.line(sim,prob)
    show(plot)



def main(throws, sum_to_reach, number_of_tries):
    favorable_cases = 0
    simulations = []
    probabilities = []
    j = 1
    ranges_of_simulations= range(1,number_of_tries,100)
    for r in range(number_of_tries):
        i=0
        for i in range(throws):
            throw_sequences_1 = got_sequences(throws)
            throw_sequences_2 = got_sequences(throws)
            if (throw_sequences_1[i]+throw_sequences_2[i]) == sum_to_reach:
                favorable_cases += 1
                break
            else:
                i = +1
        probability = favorable_cases/number_of_tries
        if r in ranges_of_simulations:
            simulations.append(r)
            probabilities.append(probability)
    print(f'La probabilidad de tener el numero 12 en {number_of_tries} intentos es de {probability}')
    graph(simulations,probabilities,sum_to_reach,throws)

if __name__ == "__main__":
    throws = int(input("How many throws do you want?"))
    sum_to_reach = int(input("What's goind to be the sum?"))
    number_of_tries = int(input("How many tries do you want?"))
    main(throws, sum_to_reach, number_of_tries)

Fredy Alberto Orozco Loaiza

Hace 7 años

El cambio que se la hace al código es en la parte tirar dado, como ya hay dos dados, entonces quieres decir que habrá un tiro_1, y tiro_2 salu2

import random

def tirar_dado(numero_tiros):
    secuencia_de_tiros = [ ]

    for _ in range(numero_tiros):
        tiro_1 = random.choice([1,2,3,4,5,6])
        tiro_2 = random.choice([1,2,3,4,5,6])
        tiro = tiro_1 + tiro_2
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros

def main(numero_de_tiros,numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_1=0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_1 += 1


    probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos
    print(f'Probabilidad de  obtener por lo menos un 1 en {numero_de_tiros} tiros={probabilidad_tiros_con_1}')



if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tidros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correrá la simulación: '))
    main(numero_de_tiros, numero_de_intentos)

Christian Giraldo Ospina

Hace 6 años

yo la hice a mi manera y pues eliges un valor entre 2 y 12 (valor minimo y maximo al tirar dos dados) y cuantos intentos quieres y ya te da la respuesta

import random

def tiro(repeticiones, valor_objetivo):
    resultado_positivos = 0
    
    for _ in range(repeticiones):
        suma_lanzamiento_dados = 0
        tiros_del_dado = 2 

        for _ in range(tiros_del_dado): 
            valor_dado = random.choice([1, 2, 3, 4, 5, 6]) # valor aleatorio del dado
            suma_lanzamiento_dados += valor_dado

        if suma_lanzamiento_dados==valor_objetivo:
            resultado_positivos += 1

    return print(f'la probabilidad de obtener {valor_objetivo} es de {(resultado_positivos/repeticiones)*100}%')  

if __name__ == "__main__":
    
    valor_objetivo = int(input("ingrese el valor del cual desea conocer la probabilidad al lanzar el dado 2 veces (valor entre 2 y 12) \n"))
    
    while (valor_objetivo < 2 or valor_objetivo > 12):
        valor_objetivo = int(input("ingrese el valor del cual desea conocer la probabilidad al lanzar el dado 2 veces (valor entre 2 y 12) \n"))
    
    repeticiones = int(input("cuantos veces quiere repetir la prueba \n"))

    tiro(repeticiones, valor_objetivo)

Daniel Andrés Giraldo Benites

Hace 6 años

gracias por tu aporte, muy buen código

Enrique Villamizar

Hace 6 años

Cuantos tiros del dado? 10 Cuantas veces quiere correr la simulación? 100000 Probabilidad de obtener por lo menos un 12 en 10 tiros es = 0.24691 Probabilidad de no obtener por lo menos un 12 en 10 tiros es = 0.75309

Solo modifique la función en donde se lanza el dado, para que lance 2 y sume el resultado:

<code>
def tirar_dado(numero_de_tiros):
    secuencia_de_tiros=[]
    for _ in range(numero_de_tiros):
        Dado1 = random.choice([1, 2, 3, 4, 5, 6])
        Dado2 = random.choice([1, 2, 3, 4, 5, 6])
        tiro = Dado1 + Dado2
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

Raúl Asperilla

Hace 6 años

Modifiqué la función para poder hallar la probabilidad de que en un número de tiradas sumen ese un número en concreto. Por ejemplo hallar la probabilidad de tirar 3 veces el dado y que los 3 resultados de las tiradas sumen 12.

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
    
    tiros_con_suma12 = 0
    for tiro in tiros:
        if sum(tiro) == sumatorio_probabilidad:
            tiros_con_suma12 += 1

    probabilidad_tiros_con_suma12 = tiros_con_suma12 / numero_de_intentos
    print(f'Probabilidad de obtener la suma de 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_suma12}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantas tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    sumatorio_probabilidad = int(input('De que número quieres hallar la probabilidad de la suma de las tiradas: '))

    main(numero_de_tiros, numero_de_intentos)

Nicolas Rocha

Hace 6 años

Hola, yo no logre por mi cuenta que me funcionara el código. Estaba viendo el que publicas pero creo que no esta tomando en cuenta que deben ser dos dados.

Lo probe bastante y aunque la probabilidad de 12 (6 en un dado y 6 en el otro en el mismo tiro) es baja no deberia ser siempre 0, en este momento es 0 siempre. Espero que sirva de algo el comentario. Saludos

Raúl Asperilla

Hace 6 años

Hola, gracias por tu mensaje, si si tuve en cuenta que deben ser dos dados pero puede resultar un poco confuso porque los 2 dados los establezco en el input de entrada de la variable "numero_de_tiros"(poniendo 2 cuando me lo pregunte). Ahí debería haber forzado al usuario a que se hagan siempre 2 tiros, pero lo deje un poco genérico porque queria probar a hallar la suma de 12 con mas de 2 dados(por ejemplo 3 o 4). Un saludo ;)

Emmanuel Guerra Sánchez

Hace 6 años

Comportamiento gráfico de la probabilidad de que aparezca una sumatoria de un numero dado (12 en este caso) según el número de tiros que se ejecuten:

Código

Daniel Andrés Giraldo Benites

Hace 6 años

buen grafico compañero y gracias por compartir tu código con la comunidad

Christian Armando Consuelo Mayén

Hace 7 años

Lo interesante es también tener en cuenta que la "aleatoriedad" no existe en el mundo de las ciencias de la computación. Todas son solo aproximaciones teóricas de aletariedad posibles a través de 0's y 1's.

Daniel Andrés Giraldo Benites

Hace 6 años

eso es cierto, hablando mas estadísticamente hay partes de la teoría de la probabilidad que nos ayudan a obtener una precisión de esto

Carlos José Manosalva

Hace 7 años

Lo hice de esta forma:

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([
            (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6),
            (1, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2),
            (1, 3), (2, 3), (3, 3), (4, 3), (5, 3), (6, 3),
            (1, 5), (2, 5), (3, 5), (4, 5), (5, 5), (6, 5),
            (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6),
            (1, 4), (2, 4), (3, 4), (4, 4), (5, 4), (6, 4)])
        secuencia_de_tiros.append(tiro)
    
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
    
    tiros_suma_12 = 0
    for tiro in tiros:
        if (6, 6) in tiro:
            tiros_suma_12 += 1
    
    probabilidad_tiros_suma_12 = tiros_suma_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un uno en {numero_de_intentos} tiros = {probabilidad_tiros_suma_12}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantaos tiros del dado: '))
    numero_de_intentos = int(input('Cuantaos veces corre la simulación: '))

    main(numero_de_tiros, numero_de_intentos)```

Héctor Atilio Signoriello

Hace 7 años

para ahorrarme el tener que hacer la secuencias de dado utilice esta función

def dado():
  return random.choice([1, 2, 3, 4, 5,6])

def tirar_dado(numero_de_tiros):
  secuencia_de_tiros = []

  for _ in range(numero_de_tiros):
    tiro = (dado(), dado())
    secuencia_de_tiros.append(tiro)

  return secuencia_de_tiros

Daniel Andrés Giraldo Benites

Hace 6 años

genial gran aporte compañero

Diego Alejandro Muñoz Camayo

Hace 6 años

Hola, al momento de hacer la probabilidad me da "0.0", mi código es el siguiente:

import random 

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []
    secuencia_de_tiros2 = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        tiro2 = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)
        secuencia_de_tiros2.append(tiro2)

    return secuencia_de_tiros, secuencia_de_tiros2

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    tiros2 = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
        secuencia_de_tiros2 = tirar_dado(numero_de_tiros)
        tiros2.append(secuencia_de_tiros2)


    tiros_con_dado_1 = 0
    for tiro in tiros:
        if 6 in tiro:
            tiros_con_1 += 1 

    tiros_con_dado_2 = 0
    for tiro2 in tiros2:
        if 6 in tiro2:
            tiros_con_1 += 1 
    
    probabilidad_tiros_con_1 = tiros_con_dado_1 / numero_de_intentos * tiros_con_dado_2 /numero_de_intentos 
    print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_1}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantos veces correra la simulación: '))

    main(numero_de_tiros, numero_de_intentos)

Sebastián Andrade

Hace 6 años

Hola diego, creo que tu problema esta aqui

tiros_con_dado_1 = 0
    for tiro in tiros:
        if6in tiro:
            tiros_con_1 += 1 

    tiros_con_dado_2 = 0
    for tiro2 in tiros2:
        if6in tiro2:
            tiros_con_1 += 1

corrigelo de la siguiente manera, tienes un problema con las variables

tiros_con_dado_1 = 0
    for tiro in tiros:
        if6in tiro:
            tiros_con_dado_1 += 1 

    tiros_con_dado_2 = 0
    for tiro2 in tiros2:
        if6in tiro2:
            tiros_con_dado_2 += 1

Si te fijas pusiste "tiros_con_1" y el nombre de la variable era "tiros_con_dado_1"

espero ese halla sido el problema y haberte ayudado

Sebastián Andrade

Hace 6 años

haya **

Thomas Gualdi

Hace 6 años

Buenas, tengo una duda con lo siguiente: tiros_con_1 = 0 for tiro in tiros: if 1 not in tiro: tiros_con_1 += 1 ¿que representaria tiro? como lee python a la variable tiro?

Sergio Rubiano

Hace 6 años

Hola Tomy!

La variable tiro lo que representa es la iteración del rango que va recorrer tu ciclo for, puede ser tiro o otra variable, la lee de la forma secuencial.

Thomas Gualdi

Hace 6 años

Excelente. Muchas gracias

freddy Mejia

Hace 7 años

la probabilidad de par 6 en 1 lanzamientos es de: 3.1 % número de simulaciones: 1000

la probabilidad de par 6 en 4 lanzamientos es de: 11.4 % número de simulaciones: 1000

la probabilidad de par 6 en 4 lanzamientos es de: 10.96 % número de simulaciones: 10000

from dado import Dado

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    dado = Dado()
    for _ in range(numero_de_intentos):
        secuencia_de_tiros_1 = dado.lanzar_dado(numero_de_tiros)
        secuencia_de_tiros_2 = dado.lanzar_dado(numero_de_tiros)
        tiros.append([secuencia_de_tiros_1, secuencia_de_tiros_2])

    tiros_par_6 = 0
    for secuencia in tiros:
        for idx in range(len(secuencia[0])):
            if secuencia[0][idx] == secuencia[1][idx] and secuencia[0][idx] == 6:
                tiros_par_6 += 1

    probabilidad_de_tiros_par_6 = (tiros_par_6 / numero_de_intentos) * 100
    print(f'la probabilidad de par 6 en {numero_de_tiros} lanzamientos es de: {probabilidad_de_tiros_par_6} %')

        

if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros del dado quieres dar: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulación: '))

    main(numero_de_tiros, numero_de_intentos)

Hora de ir al casino!

Daniel Andrés Giraldo Benites

Hace 6 años

muchas gracias por compartir tu código

Héctor Atilio Signoriello

Hace 7 años

lo solucione así, ademas de agregar la posibilidad de buscar cualquier numero entre 2 a 12

import random

def dado():
  return random.choice([1, 2, 3, 4, 5,6])

def tirar_dado(numero_de_tiros):
  secuencia_de_tiros = []

  for _ in range(numero_de_tiros):
    tiro = (dado(), dado())
    secuencia_de_tiros.append(tiro)

  return secuencia_de_tiros

def main(numero,numero_de_tiros, numero_de_intentos):
  tiros_dado = []
  for _ in range(numero_de_intentos):
    secuencia_de_tiros = tirar_dado(numero_de_tiros)
    tiros_dado.append(secuencia_de_tiros)

  tiros_con_numero = 0
  for tiro in tiros_dado: 
    if sum(tiro[0]) == numero:
      tiros_con_numero +=1
    
  probabilidad_tiros_con_numero = tiros_con_numero / numero_de_intentos
  print(f'Probabilidad de no obtener por lo menos un {numero} en {numero_de_tiros} tiro = {probabilidad_tiros_con_numero}')

if __name__ == '__main__':
  numero = int(input('Ingrese numero a calcular: '))
  numero_de_tiros = int(input('Cuantos tiros del dado: '))
  numero_de_intentos = int(input('Cuantos veces correra la simulacion: '))

  main(numero, numero_de_tiros, numero_de_intentos)```

Dagoberto Porras Plata

Hace 7 años

Hola Héctor, estuve revisando tu código y te encontré un problemita, y es que solo estas sumando el primero tiro, de cada intento:

if sum(tiro[0]) == numero:

Héctor Atilio Signoriello

Hace 7 años

hola Dagoberto tiro es un array con una sola posición por lo tanto al poner

print(f'Tiro[0] {tiro[0]}') sum(tiro[0])

me da la tupla en dicha posición Tiro[0] (4, 5)

Jesús Carlos Cárdenas Piñuelas

Hace 6 años

import random
# obtener un 12 en 10 tiros

def dado(tiros):
	sec_tiros = []
	for _ in range(tiros):
		d1 = random.choice([1,2,3,4,5,6])
		d2 = random.choice([1,2,3,4,5,6])
		sec_tiros.append(d1 + d2)
	return sec_tiros

def main(tiros, intentos):
	n_tiros = []
	for _ in range(intentos):
		secuencia = dado(tiros)
		n_tiros.append(secuencia)
	tiros_12 = 0
	for tiro in n_tiros:
		if 12 in tiro:
			tiros_12 += 1
	prob_12 = tiros_12 / intentos
	print(prob_12)

if __name__ == '__main__':
	tiros = int(input("Total de tiros: "))
	intentos = int(input("Total de intentos: "))
	main(tiros, intentos)

Recursos

¿Cómo calcular probabilidades mediante simulación?

La simulación nos ofrece una poderosa herramienta para calcular probabilidades de eventos complejos de manera intuitiva. A diferencia de los métodos analíticos, que pueden ser complejos y laboriosos, las simulaciones son más accesibles y permiten experimentar con distintos parámetros de manera sencilla. En este enfoque, utilizaremos las simulaciones para ejecutar experimentos sobre el lanzamiento de dados, explorando diversas variaciones para obtener resultados probabilísticos.

¿Cómo implementamos la simulación en Python?

Para realizar la simulación en Python, primero debemos configurar nuestro entorno y entender los componentes básicos del código. Utilizamos la biblioteca random para generar lanzamientos de dados aleatorios. A continuación, mostramos el código esencial:

import random

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia = tirar_dado(numero_de_tiros)
        tiros.append(secuencia)
    
    tiros_con_uno = sum(1 for tiro in tiros if 1 in tiro)
    probabilidad = tiros_con_uno / numero_de_intentos
    print(f'La probabilidad de obtener al menos un uno en {numero_de_tiros} tiros es: {probabilidad}')

def tirar_dado(numero_de_tiros):
    secuencia = []
    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia.append(tiro)
    return secuencia

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuántos tiros del dado: '))
    numero_de_intentos = int(input('Cuántas veces correras la simulación: '))
    main(numero_de_tiros, numero_de_intentos)

¿Qué son las variables clave en la simulación?

Número de tiros: Determina cuántas veces lanzamos el dado en cada intento.
Número de intentos: Total de veces que repetimos el experimento para obtener un promedio significativo.
Secuencia de tiros: Lista que contiene los resultados de cada lanzamiento de dado por intento.

¿Cómo calculamos las probabilidades?

El cálculo de probabilidades sigue estos pasos esenciales:

Inicialización: Almacenamos el número de veces que ocurre cierto evento (como obtener un '1' al lanzar el dado) en una variable.
Iteración: Ejecutamos el experimento varias veces para cubrir un rango amplio de posibilidades y obtener resultados confiables.
Comparación: Comparamos cuántas veces obtuvo el resultado deseado respecto al número total de intentos.
Cálculo: Dividimos el número de éxitos por el total de intentos para calcular la probabilidad.

¿Cómo validamos los resultados?

La Ley de los Grandes Números nos respalda: mientras más veces corramos la simulación, más nos aproximaremos a las probabilidades reales. Por lo tanto, si nuestros resultados son consistentes después de múltiples simulaciones, podremos considerarlos confiables.

¿Cómo podemos modificar el programa para experimentar con diferentes escenarios?

Expandir este programa es un interesante reto. Podemos, por ejemplo, modificarlo para usar dos dados y calcular la probabilidad de obtener un 12 en los resultados de múltiples lanzamientos. Aquí te dejo el reto de implementar esta idea y comprobar tus resultados.

¡Te animo a seguir experimentando y descubriendo el fascinante mundo de la simulación! Si tienes dudas o deseas compartir tus resultados, no dudes en dejar un comentario. La comunidad y yo estamos aquí para ayudarte.

<import random

def tirar_dados(numero_de_intentos):
    secuencia_de_tiros = []

    for _ in range(numero_de_intentos):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        tiro2 = random.choice([1, 2, 3, 4, 5, 6])
        resultado = tiro + tiro2
        secuencia_de_tiros.append(resultado)


    return secuencia_de_tiros

def main(numeros_de_tiros, numero_de_intentos):
    tiros = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dados(numeros_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1

    probabilidad_de_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 12 en {numeros_de_tiros} es: {probabilidad_de_tiros_con_12}')



if __name__ == "__main__":
    numeros_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    main(numeros_de_tiros, numero_de_intentos)>

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([2,3,4,5,6,7,3,4,5,6,7,8,4,5,6,7,8,9,5,6,7,8,9,10,6,7,8,9,10,11,7,8,9,10,11,12])
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1
    
    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener x lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')


if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros del dado : '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion : '))

    main(numero_de_tiros, numero_de_intentos)```

def tirar_dados(numero_de_tiros, numero_de_dados):
    secuencia_de_tiros = []
    if numero_de_dados <= 0:
        numero_de_dados = 1

    for _ in range(numero_de_tiros):
        tiro = 0
        for _ in range(numero_de_dados):
            tiro += random.choice([1,2,3,4,5,6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros   

def probabilidad_existir(tiros, numero_de_intentos,valor_del_dado_buscado):
    

    tiros_con_valor_buscado = 0
    for tiro in tiros:
        if valor_buscado in tiro:
            tiros_con_valor_buscado += 1

    probabiblidad_de_tiros_con_1 = tiros_con_valor_buscado / numero_de_intentos
    print(f'Cual es la probabiblidad de obtener por lo menos un {valor_buscado} en {numero_de__tiros} = {probabiblidad_de_tiros_con_1}')
    

def main(numero_de_tiros, numero_de_intentos, numero_de_dados, valor_buscado):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dados(numero_de_tiros, numero_de_dados)
        tiros.append(secuencia_de_tiros)


    probabilidad_existir(tiros, numero_de_intentos, valor_buscado)

    

if __name__ == "__main__":
    numero_de__tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    numero_de_dados = int(input('Numero de dados: '))
    valor_buscado = int(input('Cual es el valor buscado: '))

    main(numero_de__tiros, numero_de_intentos, numero_de_dados, valor_buscado)

import random
from bokeh.plotting import figure,show


def got_sequences(throws):
    sequence = []

    for _ in range(throws):
        option_got = random.choice([1, 2, 3, 4, 5, 6])
        sequence.append(option_got)
    return sequence



def graph(sim,prob,sum_to_reach,throws):
    plot = figure(title=print(f'Probability of having {sum_to_reach} in {throws} throws'),
                    x_axis_label = "Attempts",
                    y_axis_label = "Probability")
    plot.line(sim,prob)
    show(plot)



def main(throws, sum_to_reach, number_of_tries):
    favorable_cases = 0
    simulations = []
    probabilities = []
    j = 1
    ranges_of_simulations= range(1,number_of_tries,100)
    for r in range(number_of_tries):
        i=0
        for i in range(throws):
            throw_sequences_1 = got_sequences(throws)
            throw_sequences_2 = got_sequences(throws)
            if (throw_sequences_1[i]+throw_sequences_2[i]) == sum_to_reach:
                favorable_cases += 1
                break
            else:
                i = +1
        probability = favorable_cases/number_of_tries
        if r in ranges_of_simulations:
            simulations.append(r)
            probabilities.append(probability)
    print(f'La probabilidad de tener el numero 12 en {number_of_tries} intentos es de {probability}')
    graph(simulations,probabilities,sum_to_reach,throws)

if __name__ == "__main__":
    throws = int(input("How many throws do you want?"))
    sum_to_reach = int(input("What's goind to be the sum?"))
    number_of_tries = int(input("How many tries do you want?"))
    main(throws, sum_to_reach, number_of_tries)

import random

def tirar_dado(numero_tiros):
    secuencia_de_tiros = [ ]

    for _ in range(numero_tiros):
        tiro_1 = random.choice([1,2,3,4,5,6])
        tiro_2 = random.choice([1,2,3,4,5,6])
        tiro = tiro_1 + tiro_2
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros

def main(numero_de_tiros,numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_1=0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_1 += 1


    probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos
    print(f'Probabilidad de  obtener por lo menos un 1 en {numero_de_tiros} tiros={probabilidad_tiros_con_1}')



if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tidros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correrá la simulación: '))
    main(numero_de_tiros, numero_de_intentos)

import random

def tiro(repeticiones, valor_objetivo):
    resultado_positivos = 0
    
    for _ in range(repeticiones):
        suma_lanzamiento_dados = 0
        tiros_del_dado = 2 

        for _ in range(tiros_del_dado): 
            valor_dado = random.choice([1, 2, 3, 4, 5, 6]) # valor aleatorio del dado
            suma_lanzamiento_dados += valor_dado

        if suma_lanzamiento_dados==valor_objetivo:
            resultado_positivos += 1

    return print(f'la probabilidad de obtener {valor_objetivo} es de {(resultado_positivos/repeticiones)*100}%')  

if __name__ == "__main__":
    
    valor_objetivo = int(input("ingrese el valor del cual desea conocer la probabilidad al lanzar el dado 2 veces (valor entre 2 y 12) \n"))
    
    while (valor_objetivo < 2 or valor_objetivo > 12):
        valor_objetivo = int(input("ingrese el valor del cual desea conocer la probabilidad al lanzar el dado 2 veces (valor entre 2 y 12) \n"))
    
    repeticiones = int(input("cuantos veces quiere repetir la prueba \n"))

    tiro(repeticiones, valor_objetivo)

<code>
def tirar_dado(numero_de_tiros):
    secuencia_de_tiros=[]
    for _ in range(numero_de_tiros):
        Dado1 = random.choice([1, 2, 3, 4, 5, 6])
        Dado2 = random.choice([1, 2, 3, 4, 5, 6])
        tiro = Dado1 + Dado2
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
    
    tiros_con_suma12 = 0
    for tiro in tiros:
        if sum(tiro) == sumatorio_probabilidad:
            tiros_con_suma12 += 1

    probabilidad_tiros_con_suma12 = tiros_con_suma12 / numero_de_intentos
    print(f'Probabilidad de obtener la suma de 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_suma12}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantas tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    sumatorio_probabilidad = int(input('De que número quieres hallar la probabilidad de la suma de las tiradas: '))

    main(numero_de_tiros, numero_de_intentos)

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([
            (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6),
            (1, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2),
            (1, 3), (2, 3), (3, 3), (4, 3), (5, 3), (6, 3),
            (1, 5), (2, 5), (3, 5), (4, 5), (5, 5), (6, 5),
            (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6),
            (1, 4), (2, 4), (3, 4), (4, 4), (5, 4), (6, 4)])
        secuencia_de_tiros.append(tiro)
    
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
    
    tiros_suma_12 = 0
    for tiro in tiros:
        if (6, 6) in tiro:
            tiros_suma_12 += 1
    
    probabilidad_tiros_suma_12 = tiros_suma_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un uno en {numero_de_intentos} tiros = {probabilidad_tiros_suma_12}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantaos tiros del dado: '))
    numero_de_intentos = int(input('Cuantaos veces corre la simulación: '))

    main(numero_de_tiros, numero_de_intentos)```

def dado():
  return random.choice([1, 2, 3, 4, 5,6])

def tirar_dado(numero_de_tiros):
  secuencia_de_tiros = []

  for _ in range(numero_de_tiros):
    tiro = (dado(), dado())
    secuencia_de_tiros.append(tiro)

  return secuencia_de_tiros

import random 

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []
    secuencia_de_tiros2 = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        tiro2 = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)
        secuencia_de_tiros2.append(tiro2)

    return secuencia_de_tiros, secuencia_de_tiros2

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    tiros2 = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
        secuencia_de_tiros2 = tirar_dado(numero_de_tiros)
        tiros2.append(secuencia_de_tiros2)


    tiros_con_dado_1 = 0
    for tiro in tiros:
        if 6 in tiro:
            tiros_con_1 += 1 

    tiros_con_dado_2 = 0
    for tiro2 in tiros2:
        if 6 in tiro2:
            tiros_con_1 += 1 
    
    probabilidad_tiros_con_1 = tiros_con_dado_1 / numero_de_intentos * tiros_con_dado_2 /numero_de_intentos 
    print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_1}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantos veces correra la simulación: '))

    main(numero_de_tiros, numero_de_intentos)

tiros_con_dado_1 = 0
    for tiro in tiros:
        if6in tiro:
            tiros_con_1 += 1 

    tiros_con_dado_2 = 0
    for tiro2 in tiros2:
        if6in tiro2:
            tiros_con_1 += 1 

tiros_con_dado_1 = 0
    for tiro in tiros:
        if6in tiro:
            tiros_con_dado_1 += 1 

    tiros_con_dado_2 = 0
    for tiro2 in tiros2:
        if6in tiro2:
            tiros_con_dado_2 += 1 

from dado import Dado

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    dado = Dado()
    for _ in range(numero_de_intentos):
        secuencia_de_tiros_1 = dado.lanzar_dado(numero_de_tiros)
        secuencia_de_tiros_2 = dado.lanzar_dado(numero_de_tiros)
        tiros.append([secuencia_de_tiros_1, secuencia_de_tiros_2])

    tiros_par_6 = 0
    for secuencia in tiros:
        for idx in range(len(secuencia[0])):
            if secuencia[0][idx] == secuencia[1][idx] and secuencia[0][idx] == 6:
                tiros_par_6 += 1

    probabilidad_de_tiros_par_6 = (tiros_par_6 / numero_de_intentos) * 100
    print(f'la probabilidad de par 6 en {numero_de_tiros} lanzamientos es de: {probabilidad_de_tiros_par_6} %')

        

if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros del dado quieres dar: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulación: '))

    main(numero_de_tiros, numero_de_intentos)

import random

def dado():
  return random.choice([1, 2, 3, 4, 5,6])

def tirar_dado(numero_de_tiros):
  secuencia_de_tiros = []

  for _ in range(numero_de_tiros):
    tiro = (dado(), dado())
    secuencia_de_tiros.append(tiro)

  return secuencia_de_tiros

def main(numero,numero_de_tiros, numero_de_intentos):
  tiros_dado = []
  for _ in range(numero_de_intentos):
    secuencia_de_tiros = tirar_dado(numero_de_tiros)
    tiros_dado.append(secuencia_de_tiros)

  tiros_con_numero = 0
  for tiro in tiros_dado: 
    if sum(tiro[0]) == numero:
      tiros_con_numero +=1
    
  probabilidad_tiros_con_numero = tiros_con_numero / numero_de_intentos
  print(f'Probabilidad de no obtener por lo menos un {numero} en {numero_de_tiros} tiro = {probabilidad_tiros_con_numero}')

if __name__ == '__main__':
  numero = int(input('Ingrese numero a calcular: '))
  numero_de_tiros = int(input('Cuantos tiros del dado: '))
  numero_de_intentos = int(input('Cuantos veces correra la simulacion: '))

  main(numero, numero_de_tiros, numero_de_intentos)```

import random
# obtener un 12 en 10 tiros

def dado(tiros):
	sec_tiros = []
	for _ in range(tiros):
		d1 = random.choice([1,2,3,4,5,6])
		d2 = random.choice([1,2,3,4,5,6])
		sec_tiros.append(d1 + d2)
	return sec_tiros

def main(tiros, intentos):
	n_tiros = []
	for _ in range(intentos):
		secuencia = dado(tiros)
		n_tiros.append(secuencia)
	tiros_12 = 0
	for tiro in n_tiros:
		if 12 in tiro:
			tiros_12 += 1
	prob_12 = tiros_12 / intentos
	print(prob_12)

if __name__ == '__main__':
	tiros = int(input("Total de tiros: "))
	intentos = int(input("Total de intentos: "))
	main(tiros, intentos)

Resumen

¿Cómo calcular probabilidades mediante simulación?

¿Cómo implementamos la simulación en Python?

import random

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia = tirar_dado(numero_de_tiros)
        tiros.append(secuencia)
    
    tiros_con_uno = sum(1 for tiro in tiros if 1 in tiro)
    probabilidad = tiros_con_uno / numero_de_intentos
    print(f'La probabilidad de obtener al menos un uno en {numero_de_tiros} tiros es: {probabilidad}')

def tirar_dado(numero_de_tiros):
    secuencia = []
    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia.append(tiro)
    return secuencia

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuántos tiros del dado: '))
    numero_de_intentos = int(input('Cuántas veces correras la simulación: '))
    main(numero_de_tiros, numero_de_intentos)

¿Qué son las variables clave en la simulación?

Número de tiros: Determina cuántas veces lanzamos el dado en cada intento.
Número de intentos: Total de veces que repetimos el experimento para obtener un promedio significativo.
Secuencia de tiros: Lista que contiene los resultados de cada lanzamiento de dado por intento.

¿Cómo calculamos las probabilidades?

El cálculo de probabilidades sigue estos pasos esenciales:

Inicialización: Almacenamos el número de veces que ocurre cierto evento (como obtener un '1' al lanzar el dado) en una variable.
Iteración: Ejecutamos el experimento varias veces para cubrir un rango amplio de posibilidades y obtener resultados confiables.
Comparación: Comparamos cuántas veces obtuvo el resultado deseado respecto al número total de intentos.
Cálculo: Dividimos el número de éxitos por el total de intentos para calcular la probabilidad.

¿Cómo validamos los resultados?

¿Cómo podemos modificar el programa para experimentar con diferentes escenarios?

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

Simulaciones de Probabilidades con Dados en Python