蒙蒂霍尔模拟未按预期工作

Question

为了在编码方面取得进展，我一直在尝试用Python解决monty hall问题问题，这就是为什么我尝试将所有的东西随机化。问题是:我遇到了一些麻烦。正如你们大多数人可能知道的那样，monty问题应该表明，改变门的风速(66%)高于待在选择的门上(33%)。由于一些奇怪的原因，虽然我的模拟显示，在这两种情况下，33%的风速，我真的不知道为什么。

下面是代码：

from random import *


def doorPriceRandomizer():
    door1 = randint(0,2) #If a door is defined 0, it has a price in it
    door2 = randint(0,2) #If a door is defined either 1 or 2, it has a goat in it.
    door3 = randint(0,2)
    while door2 == door1:
        door2 = randint(0,2)
    while door3 == door2 or door3 == door1:
        door3 = randint(0,2)
    return door1,door2,door3 #This random placement generator seems to be working fine.


while True:
    loopStart = 0
    amountWin = 0
    amountLose = 0
    try:
        loopEnd = int(input("How often would you like to run this simulation: "))
        if loopEnd < 0:
            raise ValueError
        doorChangeUser = int(input("[0] = Do not change door; [1] = Change door: "))
        if doorChangeUser not in range(0,2):
            raise ValueError
    except ValueError:
            print("Invalid input. Try again.\n")
    else:
        while loopStart != loopEnd:
            gameDoors = doorPriceRandomizer()
            inputUser = randint(0,2)
            if doorChangeUser == 0:
                if gameDoors[inputUser] == 0:
                    amountWin += 1
                    loopStart += 1
                else:
                    amountLose += 1
                    loopStart += 1
            elif doorChangeUser == 1:
                ChangeRandom = 0
                while gameDoors[ChangeRandom] == gameDoors[inputUser]:
                    ChangeRandom = randint(0,2)
                if gameDoors[ChangeRandom] == 0:
                    amountWin += 1
                    loopStart += 1
                else:
                    amountLose += 1
                    loopStart += 1

    print("Win amount: ",amountWin,"\tLose amount: ",amountLose)

我做错了什么？我真的很感激所有的帮助！提前感谢！

Answer 1

ChangeRandom = 0
while gameDoors[ChangeRandom] == gameDoors[inputUser]:
    ChangeRandom = randint(0,2)

这不像你想的那样。这不是检查ChangeRandom门是否与inputUser门相同，而是检查ChangeRandom门和inputUser门是否具有相同的价值--也就是说，它们要么都是赢家，要么都是输家。

话虽如此，那甚至不是你想要做的。你想要做的是找到一个不是用户输入的门，它是一个失败的门，然后切换到另一个不是用户输入的门。这可以通过对代码的最小更改来实现，如下所示：

other_wrong_door = next(c for c, v in enumerate(gameDoors) if v != 0 and c != inputUser)
new_door = next(c for c, _ in enumerate(gameDoors) if c != inputUser and c != other_wrong_door)

但老实说，这需要重新检查代码的结构。给我几分钟时间来整理一下，我会编辑这个答案，给你一个我如何实现这个问题的想法。

import random

DOORS = [1, 0, 0]

def runonce(switch=False):
    user_choice = random.choice(DOORS)
    if user_choice == 1:
        # immediate winner
        if switch:
            # if you won before and switch doors, you must lose now
            return False
        else:
            new_doors = [0, 0]  # remove the user-selected winner
            new_doors = [0]     # remove another loser
            return bool(random.choice(new_doors))
            # of course, this is always `0`, but
            # sometimes it helps to show it. In production you
            # wouldn't bother writing the extra lines and just return False
    else:
        if switch:
            new_doors = [1, 0]  # remove the user-selected loser
            new_doors = [1]     # remove another loser
            return bool(random.choice(new_doors))
            # as above: this is always True, but....
        else:
            return False  # if you lost before and don't switch, well, you lost.

num_trials = int(input("How many trials?"))
no_switch_raw = [run_once(switch=False) for _ in range(num_trials)]
switch_raw = [run_once(switch=True) for _ in range(num_trials)]

no_switch_wins = sum(1 for r in no_switch_raw if r)
switch_wins = sum(1 for r in switch_raw if r)

no_switch_prob = no_switch_wins / num_trials * 100.0
switch_prob = switch_wins / num_trials * 100.0

print( "         WINS    LOSSES   %\n"
      f"SWITCH:  {switch_wins:>4}    {num_trials-switch_wins:>6}  {switch_prob:.02f}\n"
      f"NOSWITCH:{no_switch_wins:>4}    {num_trials-no_switch_wins:>6}  {no_switch_prob:.02f}")

Answer 2

你把问题的机制搞错了，所以你得到了错误的结果。我已经重写了选择机制，但我将用户输入的内容留给您，以便您能够继续学习python。这是解决问题的许多方法之一，但希望它能向您展示一些东西。

def get_choices():
    valid_choices = [0, 1, 2] # these are the values for a valid sample
    shuffle(valid_choices)    # now randomly shuffle that list
    return valid_choices      # return the shuffled list

def get_door(user_choice):
    return user_choice.index(0)


def monty_sim(n, kind):
    """

    :param n: number of runs in this simulation
    :param kind: whether to change the door or not, 0 - don't change, 1 = change door
    :return: (win_rate, 1 - win_rate)
    """
    wins = 0
    for i in range(0, n):
        game_doors = get_choices()
        user_choice = get_door(get_choices()) # use the same method and find user door choice
        # so there are two branches.
        # In both, a door with a goat (game_door = 1) is chosen, which reduce the result to
        # a choice between two doors, rather than 3.
        if kind == 0:
            if user_choice == game_doors.index(0):
                wins += 1
        elif kind == 1:
            # so now, the user chooses to change the door
            if user_choice != game_doors.index(0):
                wins += 1
            # Because the original choice wasn't the right one, then the new
            # must be correct because the host already chose the other wrong one.

    win_rate = (wins / n) * 100
    return win_rate, 100 - win_rate


if __name__ == '__main__':
    n = 1000
    kind = 1
    wins, loses = monty_sim(n, kind)
    print(f'In a simulation of {n} experiments, of type {kind} user won {wins:02f} of the time, lost {loses:02f} of the time')