# Coin flip game: HH vs HT in a sequence of flips

An interesting thought experiment involving flipping a fair is going around X/Twitter:

Flip a fair coin 100 times—it gives a sequence of heads (H) and tails (T). For each HH in the sequence of flips, Alice gets a point; for each HT, Bob does, so e.g. for the sequence THHHT Alice gets 2 points and Bob gets 1 point. Who is most likely to win?

The answer, that Bob is more likely to win, seems counterintuitive. I can of course brute-force the problem to show that 'Bob' is the correct answer - it does seem to be related in somewhat to Bob having a lower variance than Alice. But I'm having a hard time seeing why it would be that the variances differ.

library(dplyr)

sim.flip = function(X){
s2 = sample(x = c(0,1),size = X,replace = T) %>% as.character() %>% as.matrix()

s3 = s2 %>% matrix(ncol = 2,byrow = T)
s4 =  s2[-c(1,X)] %>% matrix(ncol = 2,byrow = T)

s5=apply(s3,1,function(X){paste(X,collapse="",sep="")})
s6=apply(s4,1,function(X){paste(X,collapse="",sep="")})

A = length(grep(x = s5,pattern = "00") )+
length(grep(x = s6,pattern = "00"))

B = length(grep(x = s5,pattern = "01"))+
length(grep(x = s6,pattern = "01"))

return(data.frame(A=A,B=B))
}

set.seed(12345)
sims = sapply(c(1:10000),function(X){sim.flip(X=100)}) %>% unlist() %>% matrix(ncol = 2,byrow = T) %>% as.data.frame()
colnames(sims) = c("Alice","Bob")

sims$$winner = ifelse(sims$$Alice > sims$$Bob,yes = "Alice","Bob") sims$$winner[sims$$Alice == sims$$Bob] = "Tie"

table(sims$winner) Alice Bob Tie 4626 4791 583 # Expected value is the same mean(sims$$Alice) [1] 24.7837 mean(sims$$Bob) [1] 24.7572 # Variance differs var(sims$$Alice) [1] 30.36575 var(sims$$Bob) [1] 6.229471  • I felt the coin tossing theory developed by William Feller in his masterpiece An Introduction to Probability Theory and Its Applications, Chapter 4 might help. Commented Mar 20 at 20:07 • See stats.stackexchange.com/questions/12174 for some intuition and techniques. For other closely related threads see the hits when searching for coin HT. – whuber Commented Mar 20 at 20:17 • @whuber While the problem you cited is similar to this problem in many aspects, I don't agree with that they are "duplicated" -- this one requires clearly much more technical analysis as the brutal-force enumeration becomes infeasible (because the length of HT sequence is 100 instead of 4). Commented Mar 20 at 21:16 • @whuber: I was initially going to close this question as a duplicate but decided that it is actually a variant of other questions which is asking a substantively different thing (see answer below, which focuses on skewness of the string-count). Personally, I recommend reopening, but happy to defer to your judgment. – Ben Commented Mar 20 at 21:20 • It may be worth looking at 3 rather than 100 tosses for the intuition: Bob wins with probability$\frac38$(HTH, HTT, THT each by 1 point) while Alice wins with probability$\frac28\$ (HHH by 2 points or THH by 1 point) so Bob is more likely to win despite the expected gap being 0, balanced by Alice sometimes winning by a large number of points. This (im)balance continues with more flips. Commented Mar 21 at 23:18

#### This result occurs due to higher positive skewness in the string-count for Alice

This type of problem relates to "string-counts", which in turn relate to deterministic finite automata (DFAs) for strings. Your question is closely related to other string-count questions for coin-flipping here and here. The simplest way to understand these problems is to construct a DFA for the "language" of interest in the problem (i.e., the set of strings being counted) and the use this to construct a Markov chain tracking the evolution of the string-states. In the figure below I show the minimised DFA for your problem, with heads represented by the blue arrows and tails represented by the red arrows. There are four different states in the minimised DFA, and the final states of interest for Alice and Bob are at the bottom of the figure. As you can see from the picture, the transitions in the DFA are not symmetric with respect to these final states. I recommend you have a look at this figure and satisfy yourself that it represents the minimised figure for the relevant string-states and transitions in the problem.

Formal analysis of string-counts can be conducted here by looking at the Markov chain with these four states and counting the number of times the chain enters the relevant final states (also called "counting states") for the two strings (i.e., the states $$\text{HH}$$ and $$\text{HT}$$). Assuming that this is a fair coin (i.e., tosses have independent outcomes with equal chance of a head or tail) the transition probability matrix for the string-states in the Markov chain (including state labels) is:

$$\mathbf{P} = \begin{bmatrix} & \text{NULL} & \text{H} & \text{HH} & \text{HT} \\ \text{NULL} & \tfrac{1}{2} & \tfrac{1}{2} & 0 & 0 \\ \text{H} & 0 & 0 & \tfrac{1}{2} & \tfrac{1}{2} \\ \text{HH} & 0 & 0 & \tfrac{1}{2} & \tfrac{1}{2} \\ \text{HT} & \tfrac{1}{2} & \tfrac{1}{2} & 0 & 0 \\ \end{bmatrix}.$$

The problem here is to find the probability that the string-count for state $$\text{HH}$$ is higher/equal/lower than the string-count for state $$\text{HT}$$ after $$n=100$$ coin tosses. To determine this we need to find the joint distribution of the string-counts for these two states (i.e., the number of times the chain enters these states) over the stipulated number of transitions in the chain. This can be computed analytically (see below) or we can simulate from the Markov chain to obtain the relevant string-counts (i.e., number of times the chain enters each counting state) over a large number of simulations. It turns out that the expected string-count for each string is the same for both $$\text{HH}$$ and $$\text{HT}$$ but their distributions are different, with the former having higher variance and higher positive skewness.

By looking at the transitions in the DFA, we can already see why we would get a higher variance in the string-count for the state $$\text{HH}$$ (Alice) than for the string-count for $$\text{HT}$$ (Bob). The reason is that the former string has a direct recurring path that means it can occur several times in a row, but if it transitions away to another state it has a longer path, on average, to come back. Contrarily, the latter string has no direct recurring path to occur in consecutive coin-flips but it transitions away to another states that are, on average, closer to it as a return state. In fact, this same phenomenon also leads to a higher skewness in the string-count for the state $$\text{HH}$$ (Alice) than for the string-count for $$\text{HT}$$ (Bob). (You can easily confirm this in your own simulations --- the positive skewness for Alice is about ten times the skewness for Bob.) This occurs because the former state tends to get some extreme cases of a high number of recurring consecutive outcomes, whereas the latter state does not. This higher skewness for $$\text{HH}$$, coupled with having the same expected value, means that Alice tends to win slightly less often than Bob, but when she wins, she tends to win by more points.

Exact computation of outcome probabilities for the game: We can compute the exact joint distribution of the string-counts using recursive computation for the specified Markov chain in R. To avoid arithmetic underflow it is best to conduct computations in log-space for the Markov chain and then convert back to probabilities for the final computations of the distributions and outcome probabilities. In the code below we compute the log-probabilities for all relevant joint states (i.e., the state of the Markov chain and the states of the two string-counts) for each iteration $$n=0,1,...,100$$ and we also compute the joint and marginal probability distributions for the points.

#Set log-probability array
N <- 100
LOGPROBS <- array(-Inf,
dim = c(4, N+1, N+1, N+1),
dimnames = list(c('NULL', 'H', 'HH', 'HT'),
sprintf('Alice[%s]', 0:N),
sprintf('Bob[%s]', 0:N),
sprintf('n[%s]', 0:N)))

#Compute log-probabilities for joint states starting in NULL state
LOGPROBS[1, 1, 1, 1] <- 0
for (n in 1:N) {
for (a in 0:n) {
for (b in 0:n) {
LOGPROBS[1, a+1, b+1, n+1] <- matrixStats::logSumExp(c(LOGPROBS[1, a+1, b+1, n] - log(2), LOGPROBS[4, a+1, b+1, n] - log(2)))
LOGPROBS[2, a+1, b+1, n+1] <- LOGPROBS[1, a+1, b+1, n+1]
if (a > 0) { LOGPROBS[3, a+1, b+1, n+1] <- matrixStats::logSumExp(c(LOGPROBS[2, a, b+1, n] - log(2), LOGPROBS[3, a, b+1, n] - log(2))) }
if (b > 0) { LOGPROBS[4, a+1, b+1, n+1] <- matrixStats::logSumExp(c(LOGPROBS[2, a+1, b, n] - log(2), LOGPROBS[3, a+1, b, n] - log(2))) } } } }

#Compute log-probabilities for string-counts at n = 100
LOGPROBS.FINAL <- array(-Inf,
dim = c(N+1, N+1),
dimnames = list(sprintf('Alice[%s]', 0:N),
sprintf('Bob[%s]', 0:N)))
for (a in 0:N) {
for (b in 0:N) {
LOGPROBS.FINAL[a+1, b+1] <- matrixStats::logSumExp(LOGPROBS[, a+1, b+1, N+1]) } }

#Compute joint probability distribution of points
PROBS.JOINT <- exp(LOGPROBS.FINAL)

#Compute marginal probability distributions of points
PROBS.MARG <- matrix(0, nrow = 2, ncol = N+1)
rownames(PROBS.MARG) <- c('Alice', 'Bob')
colnames(PROBS.MARG) <- 0:N
for (a in 0:N) { PROBS.MARG[1, a+1] <- exp(matrixStats::logSumExp(LOGPROBS.FINAL[a+1, ])) }
for (b in 0:N) { PROBS.MARG[2, b+1] <- exp(matrixStats::logSumExp(LOGPROBS.FINAL[, b+1])) }


This now allows us to compute the exact probabilities of the three possible outcomes of the game at $$n=100$$ (where either Alice wins, Bob wins, or we have a tied game).

#Compute outcome probabilities
LOGPROBS.WIN <- c(-Inf, -Inf, -Inf)
names(LOGPROBS.WIN) <- c('Alice Wins', 'Tie', 'Bob Wins')
for (a in 0:N) {
for (b in 0:N) {
if (a > b)  { LOGPROBS.WIN[1] <- matrixStats::logSumExp(c(LOGPROBS.WIN[1], LOGPROBS.FINAL[a+1, b+1])) }
if (a == b) { LOGPROBS.WIN[2] <- matrixStats::logSumExp(c(LOGPROBS.WIN[2], LOGPROBS.FINAL[a+1, b+1])) }
if (a < b)  { LOGPROBS.WIN[3] <- matrixStats::logSumExp(c(LOGPROBS.WIN[3], LOGPROBS.FINAL[a+1, b+1])) } } }

#Plot outcome probabilities
PROBS.WIN <- exp(LOGPROBS.WIN)
barplot(PROBS.WIN, ylim = c(0,1), col = 'darkblue',
main = 'Outcome Probabilities (n = 100)',
ylab = 'Probability')

#Print outcome probabilities
PROBS.WIN
Alice Wins        Tie   Bob Wins
0.45764026 0.05652694 0.48583280


We see from this computation that there is a 45.76% chance that Alice wins the game, a 48.58% chance that Bob wins the game and a 5.65% chance that the game ends in a tie. This confirms that Bob is more likely to win the game than Alice. We can also plot the marginal distributions of the points for each player and their moments to see the differences.

#Compute moments
PA <- unname(PROBS.MARG[1, ])
PB <- unname(PROBS.MARG[2, ])
MEAN.A <- sum(PA*(0:N))
MEAN.B <- sum(PB*(0:N))
VAR.A  <- sum(PA*(0:N - MEAN.A)^2)
VAR.B  <- sum(PB*(0:N - MEAN.B)^2)
SKEW.A <- sum(PA*(0:N - MEAN.A)^3)/VAR.A^(3/2)
SKEW.B <- sum(PB*(0:N - MEAN.B)^3)/VAR.B^(3/2)
KURT.A <- sum(PA*(0:N - MEAN.A)^4)/VAR.A^2
KURT.B <- sum(PB*(0:N - MEAN.B)^4)/VAR.B^2
MOMENTS <- data.frame(Mean      = c(MEAN.A, MEAN.B),
Var       = c(VAR.A,  VAR.B),
Skew      = c(SKEW.A, SKEW.B),
Kurt      = c(KURT.A, KURT.B),
Ex.Kurt   = c(KURT.A, KURT.B) - 3,
row.names = c('Alice', 'Bob'))

#Print moments
MOMENTS
Mean     Var         Skew     Kurt     Ex.Kurt
Alice 24.75 30.8125 2.148656e-01 3.024579  0.02457941
Bob   24.75  6.3125 1.185231e-13 2.980198 -0.01980198

#Plot marginal points distributions
PA <- unname(PROBS.MARG[1, ])
PB <- unname(PROBS.MARG[2, ])
for (a in 0:N) { if (PA[a+1] < 1e-4) { PA[a+1] <- NA } }
for (b in 0:N) { if (PB[b+1] < 1e-4) { PB[b+1] <- NA } }
plot(0,
xlim = c(0, N), ylim = c(-0.16, 0.16), type = 'n', yaxt='n',
main = 'Points Distribution (n = 100)',
xlab = 'Points', ylab = '')
barplot(height =  PA, col = 'red', add = TRUE, axes = FALSE)
barplot(height = -PB, col = 'blue', add = TRUE, axes = FALSE)
text(x = 60, y =  0.030, labels = 'Alice', col = 'darkred',  cex = 1.4)
text(x = 60, y = -0.028, labels = 'Bob',   col = 'darkblue', cex = 1.4)


• +1. This is also an example of a more general phenomenon that win probabilities, which are functions of joint distributions, behave much less intuitively than expectations, which are functions of marginal distributions. Commented Mar 20 at 22:01
• What does the null state represent? Is it just a name for all the irrelevant states, i.e. T, TH etc.? Commented Mar 21 at 10:35
• I don't believe your argument rigorously holds. If we're looking at the distribution of Alice's points minus Bob's points, a positive skew or a long right tail away from the mean does not always imply the median is less than the mean - for many counterexamples see tandfonline.com/doi/pdf/10.1080/10691898.2005.11910556. These counterexamples are certainly rare in some sense, so I agree that this argument still provides a good amount of intuition. Commented Mar 21 at 18:26
• @Alexander51413: The rigour here is the exact calculation; the stuff about skewness is to aid the intuition. Also note that part of my intuitive argument here is that the skewness is higher in one case but the means are the same. Moments obscure the exact distribution, so this cannot be made to be an exact argument, but it aids intuition.
– Ben
Commented Mar 21 at 22:48
• Did anyone find an actual rigorous proof? (other than direct computation) Commented Mar 30 at 7:10

Edit: I have posted an expanded version of this answer on arxiv (link) where among other things, I provide a rigorous proof that Bob is more likely to win for every value of n (n=number of flips).

Ben's answer has already identified the thrust of the matter- I'll offer an alternative way of thinking about it. I'll also show this alternative method gives a very interesting numerical result: namely after n flips, the difference in win probabilities goes as $${\frac 1 2}{\frac 1 {\sqrt{n\pi}}}$$.

Start with the observation that if the current flip is a T, then the next flip cannot result in either player getting a point. This implies that we can throw out the runs of T without changing the score. More precisely, we can decompose the original sequence into successive blocks like:

(H...HT)(T...T)(H...HT)(T...T)...

where each block may have a different size (the T blocks may be of size zero). If we only keep the (H...HT) blocks, then the HT and HH counts will be the same as in the original sequence of flips.

Thus, we are left with a collection of disjoint (H...HT) blocks; the length of each block clearly has a geometric distribution and by the (strong) Markov property the lengths are independent of each other. If we define $$X_i$$= (Alice's score on block i)-(Bob's score on Block i), then we see that $$X_i=\operatorname{Geom}(1/2)-1$$.

We can see already that while $$EX_1=0$$ that Bob is more likely to win within a single block (Bob wins on 50 percent of blocks, and Alice wins on 25 percent, with the remaining 25 percent being a tie). After $$n$$ blocks, the difference in scores is $$S_n:=\sum_{i=1}^n X_i$$ which follows a (shifted) negative binomial distribution. The negative binomial distribution has positive skew (median<mean). In other words, $$P(S_n<0)>P(S_n>0)$$. So Alice loses more often even though the average scores are equal ($$ES_n=0$$).

Exact computation using dynamic programming:

The above argument had a few steps that are a bit hand-wavey. We can easily compute the exact probabilities, which allows us to check the quality of the approximation.

Let $$F_i$$ denote the outcome of the $$i$$th flip. Let $$Y_n$$ be the difference in scores after $$n$$ flips.

We'll compute the quantities $$p_{n,k,T}:=P(Y_n=k|F_n=T)$$ and $$p_{n,k,H}=P(Y_n=k|F_n=H)$$ by induction on $$n$$. Once we have these, then we can easily compute $$P(Y_n=k)={\frac 1 2}p_{n,k,T}+{\frac 1 2}p_{n,k,H}$$ and $$P(\textrm{Bob Wins})=\sum_{k<0}P(Y_n=k)$$.

To derive the recurrence, observe that

$$p_{n,k,T}={\frac 1 2}P(Y_{n}=k|F_{n-1}=T,F_n=T)+{\frac 1 2}P(Y_{n}=k|F_{n-1}=H,F_n=T)$$

For the first term, we know that neither player can get a point for a subsequence that starts with $$T$$. Thus if the last two flips are $$TT$$ and the cumulative score is $$k$$, then the cumulative score must already have been $$k$$ after only $$n-1$$ flips. So the first term is $$P(Y_{n}=k|F_{n-1}=T,F_n=T)=P(Y_{n-1}=k|F_{n-1}=T,F_n=T)=p_{n-1,k,T}$$ (since $$Y_{n-1}$$ is independent of $$F_n$$). As for the second term, if the last two flips are $$HT$$, then this gives 1 point for Bob, and therefore the score difference after the first $$n-1$$ flips must have been $$k+1$$. So this is $$p_{n-1,k+1,H}$$. Thus we obtain the recurrence $$p_{n,k,T}={\frac 1 2}p_{n-1,k,T}+{\frac 1 2}p_{n-1,k+1,H}$$

Similarly, we can derive the recurrence

$$p_{n,k,H}={\frac 1 2}p_{n-1,k,T}+{\frac 1 2}p_{n-1,k-1,H}$$

Now, if we want to compute the distribution $$p_{n,\dots,H}$$, then we have $$O(n)$$ values of $$k$$, and each requires constant time to compute, conditional on knowing $$p_{n-1,\dots,\dots}$$. Therefore the computation takes $$O(n^2)$$ time. Note that in Ben's answer the exact computation is $$O(n^3)$$ due to the presence of a triple nested for loop.

We indeed obtain the same result as Ben for the exact win probabilities: 48.58% for Bob and 45.76% for Alice.

How good is the negative binomial approximation?

Now we can compare the exact result to the heuristic result which ended up being a negative binomial distribution. Here, we expect $$(n-1)/4$$ blocks that start with $$H$$ and end with $$T$$, so the actual distribution would be $$\operatorname{NegBinom}((n-1)/4,.5)$$, shifted to have a mean of zero.

(Note that both of these are actually discrete distributions, but I've drawn them as line graphs because I find it easier to see the overall shape than in a bar or scatterplot).

The negative binomial captures overall the shape of the distribution pretty well, although we can see some small deviations. In particular, it slightly overestimates the win probabilities for both Bob (51.42%) and Alice (48.57%). However, the difference between the two probabilities is very close to the true difference (2.85% estimated from negative binomial, vs. 2.82% true difference).

The negative binomial approximation becomes extremely accurate for larger n. Below, I plot $$\log |1-\Delta_{\textrm{approx}}/\Delta_{\textrm{true}}|$$ as a function of $$\log(n)$$, where $$\Delta_{\textrm{true}}=p(\textrm{Bob wins})-p(\textrm{Alice wins})$$ and $$\Delta_{\textrm{approx}}$$ is the estimate of this difference using the negative binomial approximation.

This is pretty noteworthy when we consider that the exact computation of $$\Delta_{\textrm{true}}$$ takes $$O(n^2)$$ time while for the negative binomial approximation, we would just need to look up the values of the negative binomial cdf at two points, which in most statistical software packages is basically instantaneous. For example, when $$n=1000$$, computing $$\Delta_{\textrm{approx}}$$ is about 5000x faster than computing $$\Delta_{\textrm{true}}$$ on my computer, while having a relative error of only .1%.

Asymptotics of P(Bob)-P(Alice)

If we believe the negative binomial approximation converges to the true distribution, we can make very precise predictions about the true win probabilities. Recall that we defined $$\Delta_n$$ to be probability that Bob wins minus the probability that Alice wins. Let's denote $$\tilde{\Delta}_n$$ as the approximation to this using the negative binomial distribution. We saw previously that $$\tilde{\Delta}_n$$ is already an excellent approximation for just moderately large $$n$$.

Proposition: For large $$n$$, $$\tilde{\Delta}_n\sim {\frac 1 {2\sqrt{\pi n}}}$$ to leading order in $$n$$.

Note that this is actually a rigorous result, and I will sketch the proof at the end of this answer. However, it applies to the approximate differences $$\tilde{\Delta}_n$$ rather than the true differences. But insofar as we saw before that $$\tilde{\Delta}_n$$ appear empirically to converge to $$\Delta_n$$, it seems very likely that we would also have $$\Delta_n\sim {\frac 1 {2\sqrt{n\pi}}}$$. And as shown below, we indeed see numerically that the true values follow this functional form extremely closely.

Code for exact probabilities:

#after 1 flip, both scores are 0
pH=dict({0:1})
pT=dict({0:1})
n=100
for i in range(2,n+1): #total number of flips
pHnew=dict({})
pTnew=dict({})
for k in range(-(i-1),i): #abs value of score after i flips is <=|i-1|
p=(pT[k]/2 if k in pT else 0)+(pH[k-1]/2 if k-1 in pH else 0)
pHnew[k]=p
p=(pT[k]/2 if k in pT else 0)+(pH[k+1]/2 if k+1 in pH else 0)
pTnew[k]=p
pH=pHnew
pT=pTnew

vals=list(pH.keys())
probs=[(pH[k]+pT[k])/2 for k in vals]


Proof of proposition about $$\tilde{\Delta}_n$$:

Under the negative binomial approximation, we have Alice score-Bob score $$\sim \operatorname {NegBinom}((n-1)/4,.5)$$, thus $$\tilde{\Delta}_n=2F((n-1)/4)-1$$ where $$F$$ is the negative binomial cdf. The explicit form is $$F((n-1)/4)=I_{.5}((n-1)/4, (n+3)/4)$$ where $$I$$ is the regularized incomplete Beta function. We combine several properties:

1. $$I_{x}(a,b)=B(x,a,b)/B(a,b)$$, where $$B$$ is the beta function and $$B(x,a,b)$$ is the incomplete beta function.

2. $$B_{.5}(a,a)/2-B_{.5}(a+1,a)={\frac 1 {a2^{1+2a}}}$$ (cf. https://math.stackexchange.com/questions/1883404/how-can-i-derive-an-asymptotic-expression-for-the-incomplete-beta-function)

3. $$I_{x}(a,b)=1-I_{1-x}(b,a)$$

4. $$B_{.5}(a,a)=\operatorname {Beta}(a,a)/2$$

5. $$\operatorname{Beta}(a,a)=\sqrt{\pi}2^{1-2a}\Gamma(a)/\Gamma(a+1/2)$$

The proof consists of just applying these identities until we have written the cdf in terms of values of the gamma function, then applying Stirling's formula.

• This is a very nice answer (+1). The method here is specific to this particular case and therefore less generalisable than my own answer, but it adds useful insight to this particular case and gives a more parsimonious computation. Great stuff.
– Ben
Commented Apr 5 at 6:39
• Simon, I have edited your formatting in your post. Check if it okay, otherwise you can undo them. Commented Apr 9 at 14:28

The key insight is that although both players can expect to get the same number of points over a set of games, Alice's wins (ie where she got the most points) tend to be bigger but rarer. Bob's wins have a smaller margin, and happen more often. Looking at all the possibilities in a 3-flip game, we see:

Game Score (A vs B) Winner
$$HHH$$ 2 vs 0 A
$$HHT$$ 1 vs 1 -
$$HTH$$ 0 vs 1 B
$$HTT$$ 0 vs 1 B
$$THH$$ 1 vs 0 A
$$THT$$ 0 vs 1 B
$$TTH$$ 0 vs 0 -
$$TTT$$ 0 vs 0 -

In this case, each player got 4 points over all the games, but Bob wins 3 games to 2.

Essentially, Alice's points are squandered by being thrown at games she's already won (just the $$HHH$$ one in this case). It's similar to any game where you play by winning intermediate sub-games (games/sets in tennis, constituencies in FPTP elections etc), as each sub-game win is a non-linear decision function that ignores the magnitude of the win.

And that's why it's counter-intuitive: it takes effort to realize the consequences that arise when equally-likely points are not spread evenly over the possible games.

It's even 50/50. I simulated it myself. They are confusing this riddle with HHT HTT which is not even. An easy way to check is to look at 4 flips, write out all 16 permutations. They each get 12 points

• Hi Jason, I think you've misunderstood the puzzle. It isn't how many points (which is even as you say) it's who gets the most, and has greater likelihood of winning. If Alice wins, she tends to have more points; Bob's wins have a smaller margin, and they happen more often. If played regularly, Bob gets more wins. In your example with 4 flips, Bob wins 6 games to 4. Commented Mar 21 at 20:07
• Cool, the riddle is more interesting than I thought. Commented Mar 21 at 20:16