Can You Play ‘The Price Is Right’ Continuously?

Players $A$ and $B$ take turns at a wheel that returns a real number uniform on $[0,1]$. $A$ goes first: spin once, or spin twice and add the two results, but a total above $1$ is an instant loss. Then $B$ does the same, knowing $A$’s result. Whoever ends with the higher total at or below $1$ wins. With both playing optimally, what is $A$’s probability of winning?

The Fiddler, Zach Wissner-Gross, April 26, 2024(original post)

Solution

Work backwards from $B$. Suppose $A$ finishes with a valid total $t$. If $B$’s first spin exceeds $t$, $B$ stops and wins; otherwise $B$ must spin again and clear $t$ without busting, which happens with probability $1-t$. So $B$ wins with probability $(1-t)+t(1-t)=1-t^2$, and $A$ wins with probability exactly $t^2$ (a bust by $B$ counts for $A$).

So $A$ should maximise the expected value of $t^2$. After a first spin $x$, stopping scores $x^2$, while spinning again scores $\int_0^{1-x}(x+y)^2\,\mathrm dy=\tfrac{1-x^3}{3}$. Stopping wins once $x^2\ge\tfrac{1-x^3}{3}$, that is past the root $c\approx0.532$ of $x^3+3x^2-1=0$. Therefore $$P(A)=\int_c^1 x^2\,\mathrm dx+\int_0^c\frac{1-x^3}{3}\,\mathrm dx,$$ which evaluates to $$\boxed{\ \frac34-\frac{\cos(2\pi/9)}{2}+\frac{\sin(\pi/18)}{2}\ }\approx0.4538.$$ Going first is a real disadvantage: $A$ wins less than half the time.

The computation

Play the game under the optimal rules: $A$ stops if its first spin reaches $c$, otherwise spins again; $B$, knowing $A$’s total $t$, stops if its first spin beats $t$, otherwise spins again. The simulated win frequency for $A$ matches the closed form.

import numpy as np
from scipy.optimize import brentq
rng = np.random.default_rng(0)
c = brentq(lambda x: x**3 + 3*x**2 - 1, 0, 1)       # optimal stop threshold ~0.532
N = 8_000_000
x, y = rng.random(N), rng.random(N)
tA = np.where(x >= c, x, np.where(x + y <= 1, x + y, 0.0))   # A stops at first spin >= c
u, v = rng.random(N), rng.random(N)
tB = np.where(u > tA, u, np.where(u + v <= 1, u + v, 0.0))   # B stops at first spin beating A
print((tA > tB).mean())                                     # ~0.4538

Extra Credit

Now three players $A$, $B$, $C$ spin in turn, each once or twice, highest valid total wins. What is $A$’s probability of winning?

Solution

The backward induction gains one layer. The last player $C$, facing the current best total $b$, stops on any first spin above $b$ and otherwise spins again, beating $b$ with probability $1-b$, so $C$ overtakes a total $t$ with probability $1-t^2$. Knowing this, the middle player $B$, holding $A$’s total $a$, values stopping at a first spin $u$ at $u^2$ (it beats $A$ but $C$ may overtake) and spinning again at $\tfrac{1-\max(u,a)^3}{3}$; comparing the two, $B$’s optimal cutoff rises to $\max(a,c)$, with $c\approx0.532$ the two-player threshold. The first player $A$, now exposed to two opponents, raises its own first-spin threshold to about $0.65$. Sweeping that threshold and playing the game out gives $$\boxed{P(A)\approx0.305,}$$ and the order penalty deepens: first, middle, and last win roughly $30\%$, $33\%$, and $37\%$. Spinning last, with full information and no one to follow, is worth the most. (A closed form is more than the puzzle needs; this is the numerical optimum.)

The computation

Encode all three players with their optimal rules ($C$ stops above the best, $B$ at $\max(a,c)$) and sweep $A$’s first-spin threshold, taking the best.

import numpy as np
from scipy.optimize import brentq
rng = np.random.default_rng(0)
c = brentq(lambda x: x**3 + 3*x**2 - 1, 0, 1)       # optimal stop threshold ~0.532
N = 4_000_000
def shares(tA_thr):
    x, y = rng.random(N), rng.random(N)
    tA = np.where(x >= tA_thr, x, np.where(x + y <= 1, x + y, 0.0))
    u, v = rng.random(N), rng.random(N)
    thrB = np.maximum(tA, c)                                 # B's optimal cutoff
    tB = np.where(u > thrB, u, np.where(u + v <= 1, u + v, 0.0))
    best = np.maximum(tA, tB)
    uc, vc = rng.random(N), rng.random(N)
    tC = np.where(uc > best, uc, np.where(uc + vc <= 1, uc + vc, 0.0))
    return [((p > q) & (p > r)).mean() for p, q, r in
            [(tA, tB, tC), (tB, tA, tC), (tC, tA, tB)]]
best = max((shares(t)[0], t) for t in np.linspace(0.55, 0.75, 11))
print(round(best[0], 3), "at", round(best[1], 2))           # ~0.305 at 0.65