Ball-passing game with a surprise ending

Question

You are organizing the following game:

Requirements:

Participants: About 15 players. You are Player 1, and the other 14 players have (preferably) no prior knowledge of the game.

Equipment: A basket containing 5 tennis balls (or easier yet, 5 beanbags). You, Player 1, hold the basket the whole time.

Space: Any flat, unobstructed ground, 30 x 30 feet (9 x 9 meters) or larger, indoors or outdoors

You instruct the players as follows:

“This is a game with no winners or losers, but it has a surprise ending, so I’m not going to tell you everything in advance. Just follow the instructions, and watch what happens. And don’t worry, this is a safe game. Everybody, please stand in a circle of about 20 feet (6 meters) in diameter.”

“I am Player 1, and I am tossing this ball to another player who is standing somewhere on the other side of the circle from me. Good catch, Player 2! Now, Player 2, toss the ball to another player who is standing somewhere on the other side of the circle from you, who has not already received the ball. Good! Everybody, please remember who you tossed the ball to. Now, Player 3, toss the ball to a new player who is standing somewhere on the other side of the circle from you. Each player, continue tossing the ball to a new player who is standing somewhere on the other side of the circle from you, until each player has received the ball once. If you haven’t received the ball yet, raise your hand so we know who's left … Now, Player 15, toss the ball back to me, Player 1.”

“Just to make sure everybody remembers who they’re tossing the ball to, let’s do one more round, tossing the ball to the same player that you did before, from Player 1 through Player 15, who tosses it back to me, Player 1 … Good!” At this point, everybody is still standing in a circle.

“Now, when I say Go, keep passing the ball to the same player that you've been passing to, but instead of tossing the ball, walk over to the player and hand the ball to them. And instead of one ball being in play, I’m going to add a new ball every 5 or 10 seconds, until there are 5 balls going at once. Keep passing the ball to the same player that you've been passing to, by walking to them and handing them the ball … Ready, Go!”

Within a minute or two, an interesting pattern emerges. What happens, and why?

I was introduced to this game in the late 1990's by a professional game organizer during (I think) a weekend getaway at Omega Institute in New York state. I don't know who invented it, or what it's called. If anybody knows, please add it to the comments, or to your answer, and I will update this puzzle to give credit to the inventor.

Answer 1

Given that it would make everyone's lives easier, I'd guess that:

The players ended up rearranging the circle such that each player was next to the person they'd receive the ball from and the player they'd pass it on to

Answer 2

I'm going to guess that the end state is where:

1. The original circle shrinks to a small circle where everyone is within arms reach of their "prior" and "next" neighbors.

2. The circle is reordered such that each person receives the ball from their right and passes it to the person on their left (or vice versa)

3. No one has to walk any more.

As far as why that happens, if you disregard the ball handoffs and just imagine each person following the person in front of them in the ordering, then it seems inevitable that they will rearrange such that each person gets closest to their "next" person, until the point where everyone is close enough to not have to move any more (which has to be in some kind of circular arrangement given that the order goes 1..15 and back to 1). The ball handoffs just slow down the process since not everyone is moving at the same time.

Answer 3

I believe that the end event will be

One person will have all 5 balls at any given time. This is assuming that, if your partner is in transit to or from the person they are supposed to pass the balls to, you cannot pass a ball to them. This is also assuming that there is no rule against a person accepting multiple balls if they have not left their starting position. Everyone will move at slightly different paces/will have different distances to travel, so small differences in travel time will quickly build up, resulting in a traffic-jam situation.

Answer 4

The players would form a circle formation that rolls around the inside of a larger circle, the original circle. You can test this with this online simulation, where you see each player is moving diametrically across the larger original circle and many players are moving at once.

Answer 5

Similar to other answers, but adding a novel element:

Not only does everyone contract into an arms-length, no-walking circle, but also someone picks up the basket, puts all five balls into it, and that is what is passed around. Quite possibly, everyone ends up just holding it with one hand each in the middle, perhaps shaking it occasionally.

Answer 6

So I made a little simulation for this puzzle here. (The simulation isn't 100% done at the time of this answer but running it several times gives a good guess on what would actually happen)

In the simulation, I did several runs and every time the players end up clustered. It's not always in a circle but they are mostly next to their "target" (the player they are supposed to pass their ball to).

Answer 7

No time to think about it logically, so lets just simulate it! The fascinating part is that this does not converge naturally (other stable patterns are reached) unless several conditions are met:

• there are multiple balls being passed - a single ball will mostly shuffle the items through each other
• you have specific delays between the balls, or a random chance of dropping
• a player moves to the side closest to their target (e.g. not always the left)

Started with a more refined approach to perform the operations but chose the obviously correct method instead, apologies for any eye-bleeds.

This chart shows the histogram of convergence times for a 1000 sample run against permutations of 15 people:

#!/usr/bin/env python


import random
random.seed(12345)

PLAYERS = 15

def main():
    positions = range(PLAYERS)
    pass_order = [0] + random.sample(positions[1:], PLAYERS - 1)
    index_order = sorted(positions, key=pass_order.__getitem__)
    passes_to = {i: j for i, j in zip(index_order, index_order[1:] + index_order[:1])}
    print 'Positions:  ', positions
    print 'Pass order: ', pass_order
    print 'Index order:', index_order
    print 'Passes to:  ', passes_to

    print 'Starting passes'
    passes = 1000
    current = [0]
    delay = [2, 2, 2, 2]
    show_positions(positions, current, pass_order)
    for p in xrange(passes):
        if delay:
            if delay[0] == 0:
                delay = delay[1:]
                current.append(0)
            else:
                delay[0] -= 1
        for i, c in enumerate(current):
            if random.random() < .1:
                continue
            positions, current[i] = hand_off_ball(positions, c, passes_to)
            show_positions(positions, [current[i]], pass_order)
        print
        show_positions(positions, current, pass_order)
        if positions == index_order:
            print 'Took %d rounds to converge' % p
            break


def show_positions(positions, current, pass_order):
    print ' '.join('%s%-2d' % ('*' if p in current else ' ', pass_order[p])
                   for p in positions)


def hand_off_ball(positions, current, passes_to):
    ''' Put player on the side closest to the person they pass to, circularly '''
    target = passes_to[current]
    i_c = positions.index(current)
    i_t = positions.index(target)
    on_left = ((i_c < i_t and i_t - i_c <= len(positions) / 2) or
               (i_c > i_t and i_c - i_t >= len(positions) / 2))
    min_, max_ = sorted((i_c, i_t))
    between = positions[min_ + 1:max_]
    pair = [current, target] if on_left else [target, current]
    between = between + pair if i_c < i_t else pair + between
    ret = positions[:]
    ret[min_: max_ + 1] = between
    # Keep 0 at the front for ease of display
    i_z = ret.index(0)
    ret = ret[i_z:] + ret[:i_z]
    return ret, target


if __name__ == '__main__':
    main()