Simule o problema de Monty Hall usando Python

Se você é um garoto dos anos 70, pode ter crescido assistindo ao popular game show, Let's Make a Deal. Desde então, as pessoas discutem vividamente o quebra-cabeça de Monty Hall e se divertem ao replicá-lo. O suspense e o drama incompreensíveis criados quando o competidor escolhe uma das três portas é divertido de assistir todas as vezes.

Usando matemática e um pouco de programação, você construirá um Monty Hall Simulator usando Python. Com isso, você poderá decidir de uma vez por todas que trocar de porta aumenta suas chances de ganhar.

Qual é o problema de Monty Hall?

O problema de Monty Hall é um quebra-cabeças com o nome do apresentador do gameshow, Monty Hall. Existem três portas, das quais apenas uma contém o prêmio desejado. Depois de escolher uma porta, Monty - quem sabe o que está atrás deles - abre outra porta, revelando uma cabra. Agora você tem a opção de manter sua decisão original ou mudar para a outra porta.

Devido à sua natureza surpreendente e imprevisível, o quebra-cabeça Monty Hall é muito popular. Embora lide com probabilidades, a solução desafia a intuição. Serve como uma excelente demonstração de como os cálculos de probabilidade podem ser confusos. O quebra-cabeça nos ensina como ignorar as impressões de acontecimentos aparentemente aleatórios e, em vez disso, focar no raciocínio e nos fatos.

Os Módulos Random e Tkinter

Para construir uma simulação de Monty Hall em Python, comece com os módulos Random e Tkinter.

Existem várias funções para produzir números aleatórios no módulo Random. Você pode usar esses algoritmos para gerar sequências embaralhadas, movimentos de jogo e números inteiros pseudo-aleatórios. É freqüentemente usado em jogos como críquete de mão, ou um teste de digitação simples, bem como para simular jogadas de dados e embaralhar listas.

Tkinter é a biblioteca GUI padrão para Python. Usando-o, você pode criar aplicativos GUI fantásticos. Você pode criar um aplicativo de lista de tarefas, editor de texto ou calculadora simples. Você pode colocar seu conhecimento em prática e aprimorar suas habilidades de programação usando Python e Tkinter para construir aplicativos básicos de desktop.

Abra um terminal e execute o seguinte comando para adicionar o Tkinter ao seu sistema:

pip instalar tkinter

Como construir um simulador de Monty Hall usando Python

Você pode encontrar o código-fonte do Monty Hall Simulator neste Repositório GitHub.

Importe os módulos random e Tkinter. A função StringVar facilita o controle do valor de um widget como um Label ou Entry. Você pode usar um Label para exibir algum texto na tela e uma Entry para buscar a entrada do usuário.

Inicialize a instância do Tkinter e exiba a janela raiz. Defina as dimensões da janela para 600 pixels de largura e 200 pixels de altura usando o geometria() método. Defina um título de janela apropriado e proíba seu redimensionamento.

importar aleatório
de tkinter importar StringVar, Rótulo, Tk, Entrada
janela = Tk()
janela.geometria("600x200")
janela.título("Simulação de Monty Hall")
janela.resizable(0, 0)

Em seguida, configure dois pares de widgets e variáveis ​​para armazenar os resultados da simulação. Seu aplicativo solicitará várias execuções para concluir. A cada rodada, ele simulará o jogo e registrará o resultado em cada caso: se o jogador decide trocar ou manter a mesma escolha.

Usando StringVar(), defina os valores iniciais da mesma escolha e escolha alternada para 0. Defina um widget Entry e defina seu tamanho de fonte para 5. Declare dois rótulos para exibir o mesmo e a opção comutada e posicione-a. Declare mais dois rótulos que exibirão o valor das variáveis ​​que você definiu anteriormente. Por fim, posicione o widget Entry abaixo desses quatro rótulos.

mesma_escolha = StringVar()
opção_comutada = StringVar()
same_choice.set(0)
opção_comutada.set(0)
no_sample = Entrada (fonte =5)
Rótulo (texto="Mesma Escolha").lugar (x=230, y=58)
Rótulo (texto="Escolha Mudada").lugar (x=230, y=90)
Rótulo (textvariable=mesma_escolha, fonte=(50)).lugar (x=350, y=58)
Rótulo (textvariable=switched_choice, fonte=(50)).lugar (x=350, y=90)
no_sample.place (x=200, y=120)

Defina uma função, simular. Inicialize as variáveis ​​de resultado e obtenha o valor de amostra inserido pelo usuário. Declare uma lista que contenha os itens que as portas revelarão.

Em cada corrida, faça uma lista duplicada das portas originais e embaralhe-a em ordem aleatória. Escolha uma porta aleatória e remova-a - isso simula a escolha do jogador. Em seguida, simule a revelação de Monty: se a primeira porta não contiver o prêmio, abra-a, caso contrário, abra a segunda porta. Remova essa escolha e deixe a porta restante como a opção para a qual mudar.

defsimular(evento):
 same_choice_result = 0
 switch_choice_result = 0
 amostras = int (no_sample.get())
 portas = ["ouro", "cabra", "cabra"]
para _ em intervalo (amostras):
 simulated_doors = portas.copy()
 random.shuffle (simulated_doors)
 first_choice = random.choice (simulated_doors)
 simulad_doors.remove (first_choice)
 porta_aberta = portas_simuladas[0] se portas_simuladas[0] != "ouro"outro portas_simuladas[1]
 simulad_doors.remove (opened_door)
 comutado_second_choice = simulated_doors[0]

Se a primeira escolha contiver o prêmio desejado, incremente o resultado da mesma escolha em um e reflita na tela. Caso contrário, execute a mesma operação para a opção comutada.

se primeira_escolha == "ouro":
 same_choice_result += 1
 same_choice.set (same_choice_result)
elif switch_second_choice == "ouro":
 switch_choice_result += 1
 switch_choice.set (switched_choice_result)

Uma etapa importante é vincular a tecla Enter a um evento na janela do Tkinter. Isso garante que, quando o jogador pressionar Digitar, uma função específica será executada. Para conseguir isso, passe o string e a função de simulação como parâmetros para o vincular() função.

O circuito principal() A função diz ao Python para executar o loop de eventos Tkinter e ouvir eventos (como pressionamentos de botão) até que você feche a janela.

no_sample.bind("", simular)
window.mainloop()

Junte tudo e execute seu programa para simular o quebra-cabeça em ação.

Saída do Monty Hall Simulator usando Python

Ao executar o programa, você verá uma janela simples com os rótulos de escolha Same e Switched. Insira um número de amostra no campo na parte inferior para visualizar os resultados simulados. Nesta amostra de 3 execuções, o programa mostra que ganha uma vez com a mesma escolha e duas vezes com uma troca.

Esses resultados são aleatórios, mas você pode executar a simulação com um tamanho de amostra maior para obter mais precisão. No seguinte tamanho de amostra de 100, a escolha trocada ganha 65 vezes.

Resolvendo problemas usando programação

O Monty Hall Simulator é uma excelente demonstração de como você pode usar a programação para resolver problemas da vida real. Você pode desenvolver vários algoritmos e treinar modelos para executar tarefas específicas, como classificar uma matriz ou melhorar a eficácia de um sistema para produção ideal.

Diferentes linguagens de programação oferecem diferentes capacidades e funções para facilitar a programação. Usando o Python, você pode criar modelos que podem prever os valores futuros de um conjunto de dados com maior precisão. Além disso, você pode automatizar operações repetitivas, diminuir o trabalho chato e melhorar a velocidade e a precisão.