Let’s begin with a draft solution, one that doesn’t work but will start us in the right direction. And to keep things simple, let’s say all the tasks are done the minute the prisoners leave the meeting, so all they have left is to notify someone that they’re done.

Prisoner 1 is responsible for telling the guard once all the tasks are complete. We’ll call him the Leader. He keeps a counter called ‘num_done‘ which starts at 1 (denoting that prisoner 1 himself is done). When the leader enters the room, this is what he does:

if light is on:
    num_done = num_done + 1
    turn light off
else:
    do nothing
-

When any other prisoner enters the room, this is what he does:

if light is off and not turned_light_on:
    turn light on
    turned_light_on = true
else:
    do nothing
-

And each such prisoner maintains a flag called turned_light_on, initialized to ‘false’.

At the end of this, num_done should show the number of prisoners whose task is complete. And when num_done = n, prisoner 1 will notify the guard.

The problem is that this algorithm has an off-by-one error. If the light was originally on before any prisoner entered the room, then when the leader enters the room he will count that on-light as one prisoner. Therefore he’ll reach a count of n while only (n-1) prisoners reported in.

To solve this problem we need to modify the algorithm a bit, to handle the possible initial states of the light switch. We want to give the leader a chance to see the initial state before anyone else touches it. So the other prisoners start by doing nothing, until they get some sort of signal from the leader. This signal will be ‘flicking the switch’: They first want to see the light turned on, and then, when the time is right, they will turn it on themselves.

So now, each prisoner other than the leader maintains another flag called saw_light_on, which starts as ‘false’. The algorithm is:

if light is on:
    saw_light_on = true
else if saw_light_on and not turned_light_on:
    // light is OFF
    turn light on
    turned_light_on = true
else:
    do nothing
-

Next, the leader maintains an extra flag: saw_initial_state initialized to ‘false’. Her algorithm is:

if saw_initial_state:
	if light is on:
	    turn light off
	    num_done = num_done + 1
	else
	    // flick the switch to signal the others
	    turn light on
	    num_done = num_done - 1
else:
	// This is the first time the leader enters the room
	turn light off (if it's on)
	saw_initial_state = true
-

Note that the leader needs to continue flicking the switch forever. Otherwise, latecomers will never turn the light on. Also note that the leader must discount for his own flicking by decrementing num_done. Finally, as before, when num_done = n, the leader notifies the guard and the prisoners escape. There you have it!

prisoners are planning an escape. They bribed a guard to let them all meet once. Each prisoner was given a task to complete, such as digging or stealing some key. Once all the tasks are complete, the prisoners will notify the corrupt guard who will turn a blind eye while they escape. The problem is, the prisoners can’t talk to each other because they are all in solitary confinement.

Once a day, a prisoner chosen at random enters a storage room that has a single light bulb in it. The prisoner can either flick the switch (turning the light bulb on or off), or leave it as it is. At the time of the initial meeting, as they plan their strategy, the state of the switch is unknown.

Using only switch flicking, how can the prisoners coordinate their escape? Specifically, one of the prisoners must know at some point that all the tasks are done, so he can notify the guard and lead them all to freedom. If the guard is notified before all tasks are complete, the plan will fail and the prisoners will be caught.

(ready for the solution? here it is)

Solution: I’m sure there’s a simpler solution to this, but here goes. Let , which is an amount we can buy using only boxes of 6 nuggets. Let’s see how we can ‘fill in the gaps’ between two consecutive , by removing some 6′s and replacing them with 9′s and 20′s:

• (condition: n>=3)
• (n>=1)
• (n>=6)
• (n>=4)
• (n>=8)

Note that only the first two options are original — the rest are simply combinations of the first two. So, if n is large enough (n >= 8 ), we can fill in all the gaps between and by removing some boxes of 6 nuggets, and replacing them with various combinations of 9 and 20 nuggets.

This means that, starting with , we can buy any number of nuggets. What about the numbers between and ? According to the list above, given n=7 we can create all the numbers in this range except, perhaps, .

It’s easy to see that there’s indeed no way to buy 43 nuggets: 43 itself isn’t divisable by 3, so you can’t get 43 with a combination of 6′s and 9′s. So you must use either one or two boxes of 20. But 43-20=23 is again not divisable by 3, and 43-20*2=3 is less than 6.

Hence, 43 is the largest amount of nuggets you can’t buy at McDonald’s.

This is one of my favorite riddles, because the solution actually uses some nice mathematical concepts.

We are looking for a solution that will work regardless of how the table is rotated after each flip we make. It will be nice if we can place all the possible table states into classes that aren’t affected by the rotation. That way we can develop an algorithm to progress through the states without worrying about the rotation at each turn.

Let’s define the following states:

1. A: All coins are the same (all heads or all tails) – in this case we win
2. B: Two opposing coins are heads, and the other two are tails.
3. C: Two adjoining coins are heads, and the other two are tails.
4. D: One coin is different from the other three.

The last three states are illustrated below.

It’s clear that if a state is in a given category, then any rotation of it remains in the same category. Formally we can say that these categories are equivalence classes, using the relation that connects two states iff one can be reached from the other via rotation.

Okay, so our goal is to transform a state of any class to class A. We notice that coin flips change some classes but not others:

• Flip two opposing coins: This changes a B state to A (i.e. we win), but doesn’t transform either a C state or a D state to a different class
• Flip two adjoining coins: C -> B or A, and D doesn’t change
• Flip one coin: D -> C or B or A

The winning strategy is thus:

1. Flip North, South
2. Flip North, East
3. Flip North, South
4. Flip North
5. Flip North, East
6. Flip North, South

This works as follows:

• If we start out in class B, we win after step 1
• If we start out in class C, we win after step 2 or 3
• If we start out in class D, we win after step 4, 5, or 6

The point here is that when we handle class B, we don’t change either C or D. When we handle C, we don’t change D. So there you have it — victory in just six steps!

The solution: First, let’s show that there’s a multiple of p that is written as a series of 1′s, followed by a series of 0′s (e.g. 1111000). Consider the set of numbers {1, 11, 111, 1111, …}. For each item, calculate its ‘modulu p’: {1 mod p, 11 mod p, …}. Each of these is an integer between 0 and p-1. Because the original set is infinite, it must therefore contain two different items that are the same mod p (pigeonhole principle). Let’s call them a and b and assume a>b. Then (a-b) is the desired number, because:
(a-b mod p) = (a mod p) – (b mod p) = 0.

Okay, so for the prime p we have a number x that’s divisable by p, and:

x = 111…10…0 = 111…1 * 10^n

We can divide x by 10^n to get rid of the zeros and get y = x / 10^n = 111…1. y is still divisable by p because p isn’t 2 or 5.

If you control the initial placement and movement directions of the ants, what is the longest an ant can remain on the stick?

The answer: An ant can stay on the stick for at most one second.

The given situation is that when two ants meet, they both turn around and start walking in opposite directions. But this is exactly the same as a situation where the ants never interact, so when they meet they just pass through one another and continue walking in their original directions.

An single ant will remain the longest on the stick if you place it at one edge of the stick and let it walk towards the other edge. This will take exactly 1 second. And because the ants are indepedent, this is also the answer for 100 ants.

Say the other person chooses numbers n

P(win) = 0.5*p(n) + 0.5*(1-p(m)) = 0.5*(1 + p(n) – p(m)) > 0.5

That last step is where I use the fact that the series of probabilities descends: n < m and so p(n) > p(m). Finally, because P(win) is larger than 0.5 for every n,m pair that can be chosen, we expect to win with probability greater than 0.5.

I’ll now explain how I found this solution, and that will shed some light on why it works in the first place. The explanation is a bit long and verbose, because I tried to make it as clear as possible. The first thing I noticed when thinking about the riddle is that, if the first number I get is 1, then the second number must be higher. So if I get 1, I can say ‘higher’ and be correct every time. I then devised my first strategy: If the number is 1, say ‘higher’. Otherwise say ‘higher’ with probability 0.5.

If the other person has a chance of giving me 1, then I will obviously win in the long run. The other person knows my strategy, so he cannot ever give me 1. Okay, so the minimum number I get is 2… Maybe if I get 2 I can say ‘higher’, and be correct. And maybe I can follow this line of reasoning and do the same with 3, 4, 5, … ad infinitum. Well, this of course doesn’t work, because eventually the other person must choose some number and I won’t always be right.

So this strategy isn’t scalable, so to speak. But there is some knowledge here: The other person is less likely to choose 1 as one of the numbers, because then she has a 0.5 chance of giving it to me as the first number and letting me win. So if I get 2, I know that it is likely that the other number is higher than 2. But how do we quantify this increased likelihood, given that the other person can choose any strategy she likes?

Turns out we can let the math do the work for us. Let’s define the following strategy: If we get 1, we say ‘higher’. If we get 2, we say ‘higher’ with probability p. Otherwise we say ‘higher’ with probability 0.5. Our goal is to find the optimal ‘p’. Let’s say the other person first chooses 2, and then chooses a number greater than 2 with probability q, and a number lower than 2 (i.e. 1) with probablity 1-q. Our chances of winning in this case are:

P(win) = q*(0.5*0.5 + 0.5*p) + (1-q)*(0.5*(1-p) + 0.5*1)

Let’s explain this. There are actually three options: The other person can choose either greater than 2 or 1, we can get either 2 or the other number, and we can say ‘higher’ or ‘lower’. So the first term, q*0.5*0.5, is the case where the other person chooses a number higher than 2 (prob. q), we get that number (prob. 0.5), and we say ‘lower’ (prob. 0.5). Note that the last term is the one where the person chooses 1 and we get it, so we say ‘higher’ and are correct with prob. 1. Now let’s simplify this:

P(win) = 0.5*[q*0.5 + q*p + (1-q)(2-p)] = 0.5*[2 - p + q*(0.5 - 2 + 2*p)] = 1 – 0.5*p + 0.5*q*(2*p – 3/2)

This last expression is quite cool. By choosing p=3/4, we can make the last term vanish and get P(win)=5/8 > 0.5 ! This is the crux of this method: We can choose a p that eliminates our dependence on q, which is the only control the other person has. So in effect this method allows us to take control of the problem, and to ensure our victory.

We can go on and solve the same problem in case we get 3, 4, and so on, finding the optimal probability for each. I won’t go into the calculation, but the resulting probabilities are: p(n) = 0.5*(0.5 + p(n-1)), i.e. the next probability is the average between 0.5 and the current probability, and p(1)=1 as before.
As you can see, this forms a descending series of probabilities, and we already showed that such a series allows us to win the game. In a sense, this is the optimal series of probabilities. And now you can see why this method works: It’s because the natural numbers have a minimal item, and we can use this leverage inductively to form a winning strategy.

Another related and interesting characteristic of this solution is that it is applicable to other number spaces, but only to those the have a minimum. For example, you can choose two real numbers in the interval [0,1]. In this case, we can use a descending function of probabilities p(x) to obtain the same result. But if the other person chooses two integer numbers (i.e. allowing both positive and negative), this method breaks down. Compare this with the first solution, which works for any number space.

The question is: How can player B guess correctly at probability > 0.5 on average?

There are some additional conditions: Player A knows the strategy player B uses to obtain the result, and he can use whatever counter-strategy he likes to select the two numbers. His only constraints are that the numbers must be different, and that the number that is revealed to player B is selected at random.

I know of two solutions to this riddle. I’ll present the first one here and leave the other to another post.

After player B receives the number, she selects a natural number using some distribution, making sure the new number is different from the number in the envelope, and making sure each natural number has a non-zero chance of being selected. Given the two numbers, this is what player B says:

1. If the new number is larger than the envelope number, the answer is ‘higher’
2. Otherwise, the answer is ‘lower’

Now, if both numbers in the envelopes are smaller than the number player B chooses, then player B is right with 0.5 probability (because the first envelope is selected at random). This is also true if both numbers are larger than the number player B chooses. But if the number she chooses is higher than one envelope number and smaller than the other, then player B is always correct.

Therefore, the chance of player B being correct is greater than 0.5 on average.

Note that the same solution would apply if we played with real or integer numbers instead of natural numbers.