¿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?
¿Cómo calculamos las probabilidades?
El cálculo de probabilidades sigue estos pasos esenciales:
¿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.
Ricardo Moreno
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
Muestra el codigo
Ricardo Moreno
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
Matias Vega Maza
Hicimos lo mismo e.e
Winston Serrudo
yo pensando subir como lo hice y ya alguien lo hizo igualito xD
Italo Quevedo
Jairo Stiven Jimenez
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
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.
implementacion para hallar un aproximado de la probabilidad de obtener una suma m con n dados
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:
Ángel David Roque Ayala
Fabrizio Jesús Vásquez Auqui
Interesante triple for 😉
Andres Alvarez Becerra
Hola, alguien me podría explicar que significa el raya piso en el forloops
for _ in range(numero_de_intenteos): ...
CRISTIAN BARBERO PÉREZ
Jesus Rafael Melendez Martin
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.
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
Fredy Alberto Orozco Loaiza
Christian Giraldo Ospina
Daniel Andrés Giraldo Benites
gracias por tu aporte, muy buen código
Enrique Villamizar
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
Nicolas Rocha
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
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
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
buen grafico compañero y gracias por compartir tu código con la comunidad
Christian Armando Consuelo Mayén
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
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
Héctor Atilio Signoriello
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
genial gran aporte compañero
Diego Alejandro Muñoz Camayo
Sebastián Andrade
Sebastián Andrade
haya **
Thomas Gualdi
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
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
Excelente. Muchas gracias
freddy Mejia
Daniel Andrés Giraldo Benites
muchas gracias por compartir tu código
Héctor Atilio Signoriello
Dagoberto Porras Plata
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
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
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)
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)>
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)```
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)
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 _:
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)
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)
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)
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)
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)```
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)
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
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!
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)```
