@anonymous/

# GrotesqueCreativeInitialization

## No description

Files
• main.py
main.py
```1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
```
```import decimal

# Helper method to save on typing
def d(num):
return decimal.Decimal(num)

def getNumber(msg):
print(msg)
try:
return int(input(" > "))
except EOFError:
return getNumber(msg)
except ValueError:
print("That's not a number!")
return getNumber(msg)

# Return the odds of a single draw *not* being one of the desired cards.
def singleDrawMissChance(copies, drawnSoFar):
return d(1) - (copies / d(38 - drawnSoFar))

# Return the odds of N draws, starting with a certain number of cards drawn so far, not being any of the desired cards.
def nDrawMissChance(copies, drawnSoFar, numDraws):
result = d(1)
for i in range(0, numDraws):
result = result * singleDrawMissChance(copies, drawnSoFar + i)

return result

# Return the odds of a single turn cycle - one replace and one draw - not being any of the desired cards.
# The replace doesn't make the deck any smaller, so drawnSoFar doesn't help.
def turnCycleMissChance(copies, drawnSoFar):
return singleDrawMissChance(copies, drawnSoFar) * singleDrawMissChance(copies, drawnSoFar)

# Return the odds that the desired cards are *not* drawn in the opening hand.
# Five draws + two replaces, with no restriction on which cards can come back.
# Both replaced cards are replaced at once, as far as I'm aware. This means one of them uses drawnSoFar=3
# and the other uses drawnSoFar=4.
def mulliganOdds(copies):
return nDrawMissChance(copies, 0, 5) * singleDrawMissChance(copies, 3) * singleDrawMissChance(copies, 4)

def main():
print("### How lucky is your Wanderer opponent? ###")

copies = getNumber("How many copies of the effect they need are in the deck?")
turn = getNumber("What turn did they need to draw it by?")

# Use Decimals for precision.
copies = d(copies)

# Accumulate the result. Start with an opening hand, then (turn - 1) turns, and a final replace.
missChance = mulliganOdds(copies)
# We draw one card from the deck per turn, on top of the five we removed during the opening hand.
# So on turn 1 we've already drawn 5 cards, by turn 2 we've drawn 6, etc.
drawnSoFar = 5
for i in range(1, turn):
missChance *= turnCycleMissChance(copies, drawnSoFar)
drawnSoFar += 1

# On the pivotal turn, there's another replace to resolve.
missChance *= singleDrawMissChance(copies, drawnSoFar)

# We now have the chance of failing to draw the needed card for the entire game up to this point.
# Invert it to get the result we need.
result = d(1) - missChance
percentage = 100 * result