Nim
Nim is a mathematical game of strategy in which two players take turns removing objects from distinct heaps. On each turn, a player must remove at least one object, and may remove any number of objects provided they all come from the same heap. The goal of the game is to avoid being the player who must remove the last object.
Variants of Nim have been played since ancient times.^{[1]} The game is said to have originated in China—it closely resembles the Chinese game of 捡石子 jiǎnshízi, or "picking stones"^{[2]}—but the origin is uncertain; the earliest European references to Nim are from the beginning of the 16th century. Its current name was coined by Charles L. Bouton of Harvard University, who also developed the complete theory of the game in 1901,^{[3]} but the origins of the name were never fully explained.
Nim is typically played as a misère game, in which the player to take the last object loses. Nim can also be played as a normal play game, where the player taking the last object wins. This is called normal play because the last move is a winning move in most games; Nim is usually played so that the last move loses.
Normal play Nim (or more precisely the system of nimbers) is fundamental to the Sprague–Grundy theorem, which essentially says that in normal play every impartial game is equivalent to a Nim heap that yields the same outcome when played in parallel with other normal play impartial games (see disjunctive sum).
While all normal play impartial games can be assigned a Nim value, that is not the case under the misère convention. Only tame games can be played using the same strategy as misère nim.
Nim is a special case of a poset game where the poset consists of disjoint chains (the heaps).
At the 1940 New York World's Fair Westinghouse displayed a machine, the Nimatron, that played Nim.^{[4]} From May 11, 1940 to October 27, 1940 only a few people were able to beat the machine in that six week period, if they did they were presented with a coin that said Nim Champ.^{[5]}^{[6]} It was also one of the first ever electronic computerized games. Ferranti built a Nim playing computer which was displayed at the Festival of Britain in 1951. In 1952 Herbert Koppel, Eugene Grant and Howard Bailer, engineers from the W. L. Maxon Corporation, developed a machine weighing 50 pounds which played Nim against a human opponent and regularly won.^{[7]} A Nim Playing Machine has been described made from TinkerToy.^{[8]}
The game of Nim was the subject of Martin Gardner's February 1958 Mathematical Games column in Scientific American. A version of Nim is played—and has symbolic importance—in the French New Wave film Last Year at Marienbad (1961).^{[9]}
Contents
Game play and illustration
The normal game is between two players and played with three heaps of any number of objects. The two players alternate taking any number of objects from any single one of the heaps. The goal is to be the last to take an object. In misère play, the goal is instead to ensure that the opponent is forced to take the last remaining object.
The following example game is played between fictional players Bob and Alice who start with heaps of three, four and five objects.
Sizes of heaps Moves A B C 3 4 5 Bob takes 2 from A 1 4 5 Alice takes 3 from C 1 4 2 Bob takes 1 from B 1 3 2 Alice takes 1 from B 1 2 2 Bob takes entire A heap, leaving two 2s. 0 2 2 Alice takes 1 from B 0 1 2 Bob takes 1 from C leaving two 1s. (In misère play he would take 2 from C leaving (0, 1, 0).) 0 1 1 Alice takes 1 from B 0 0 1 Bob takes entire C heap and wins.
Winning positions
The practical strategy to win at the game of Nim is for a player to get the other into one of the following positions, and every successive turn afterwards they should be able to make one of the lower positions. Only the last move changes between misere and normal play.
2 Heaps  3 Heaps  4 Heaps 

1 1 *  1 1 1 **  1 1 1 1 * 
2 2  1 2 3  1 1 n n 
3 3  1 4 5  1 2 4 7 
4 4  1 6 7  1 2 5 6 
5 5  1 8 9  1 3 4 6 
6 6  2 4 6  1 3 5 7 
7 7  2 5 7  2 3 4 5 
8 8  3 4 7  2 3 6 7 
9 9  3 5 6  2 3 8 9 
(n n)  4 8 12  4 5 6 7 
4 9 13  4 5 8 9  
5 8 13  n n m m  
5 9 12  n n n n 
* Only valid for normal play.
** Only valid for misere. For the generalisations, n and m can be any value > 0, and they may be the same.
Mathematical theory
Nim has been mathematically solved for any number of initial heaps and objects, and there is an easily calculated way to determine which player will win and what winning moves are open to that player.
The key to the theory of the game is the binary digital sum of the heap sizes, that is, the sum (in binary) neglecting all carries from one digit to another. This operation is also known as "exclusive or" (xor) or "vector addition over GF(2)". Within combinatorial game theory it is usually called the nimsum, as it will be called here. The nimsum of x and y is written x ⊕ y to distinguish it from the ordinary sum, x + y. An example of the calculation with heaps of size 3, 4, and 5 is as follows:
Binary Decimal 011_{2} 3_{10} Heap A 100_{2} 4_{10} Heap B 101_{2} 5_{10} Heap C  010_{2} 2_{10} The nimsum of heaps A, B, and C, 3 ⊕ 4 ⊕ 5 = 2
An equivalent procedure, which is often easier to perform mentally, is to express the heap sizes as sums of distinct powers of 2, cancel pairs of equal powers, and then add what's left:
3 = 0 + 2 + 1 = 2 1 Heap A 4 = 4 + 0 + 0 = 4 Heap B 5 = 4 + 0 + 1 = 4 1 Heap C  2 = 2 What's left after canceling 1s and 4s
In normal play, the winning strategy is to finish every move with a nimsum of 0. This is always possible if the nimsum is not zero before the move. If the nimsum is zero, then the next player will lose if the other player does not make a mistake. To find out which move to make, let X be the nimsum of all the heap sizes. Find a heap where the nimsum of X and heapsize is less than the heapsize  the winning strategy is to play in such a heap, reducing that heap to the nimsum of its original size with X. In the example above, taking the nimsum of the sizes is X = 3 ⊕ 4 ⊕ 5 = 2. The nimsums of the heap sizes A=3, B=4, and C=5 with X=2 are
 A ⊕ X = 3 ⊕ 2 = 1 [Since (011) ⊕ (010) = 001 ]
 B ⊕ X = 4 ⊕ 2 = 6
 C ⊕ X = 5 ⊕ 2 = 7
The only heap that is reduced is heap A, so the winning move is to reduce the size of heap A to 1 (by removing two objects).
As a particular simple case, if there are only two heaps left, the strategy is to reduce the number of objects in the bigger heap to make the heaps equal. After that, no matter what move your opponent makes, you can make the same move on the other heap, guaranteeing that you take the last object.
When played as a misère game, Nim strategy is different only when the normal play move would leave no heap of size two or larger. In that case, the correct move is to leave an odd number of heaps of size one (in normal play, the correct move would be to leave an even number of such heaps).
In a misère game with heaps of sizes three, four and five, the strategy would be applied like this:
A B C nimsum 3 4 5 010_{2}=2_{10} I take 2 from A, leaving a sum of 000, so I will win. 1 4 5 000_{2}=0_{10} You take 2 from C 1 4 3 110_{2}=6_{10} I take 2 from B 1 2 3 000_{2}=0_{10} You take 1 from C 1 2 2 001_{2}=1_{10} I take 1 from A 0 2 2 000_{2}=0_{10} You take 1 from C 0 2 1 011_{2}=3_{10} The normal play strategy would be to take 1 from B, leaving an even number (2) heaps of size 1. For misère play, I take the entire B heap, to leave an odd number (1) of heaps of size 1. 0 0 1 001_{2}=1_{10} You take 1 from C, and lose.
Example implementation
The previous strategy for a misère game can be easily implemented (for example in Python, below).
import functools
MISERE = 'misere'
NORMAL = 'normal'
def nim(heaps, game_type):
"""
Computes next move for Nim, for both game types normal and misere.
if there is a winning move:
return tuple(heap_index, amount_to_remove)
else:
return "You will lose :("
 midgame scenarios are the same for both game types
>>> print(nim([1, 2, 3], MISERE))
misere [1, 2, 3] You will lose :(
>>> print(nim([1, 2, 3], NORMAL))
normal [1, 2, 3] You will lose :(
>>> print(nim([1, 2, 4], MISERE))
misere [1, 2, 4] (2, 1)
>>> print(nim([1, 2, 4], NORMAL))
normal [1, 2, 4] (2, 1)
 endgame scenarios change depending upon game type
>>> print(nim([1], MISERE))
misere [1] You will lose :(
>>> print(nim([1], NORMAL))
normal [1] (0, 1)
>>> print(nim([1, 1], MISERE))
misere [1, 1] (0, 1)
>>> print(nim([1, 1], NORMAL))
normal [1, 1] You will lose :(
>>> print(nim([1, 5], MISERE))
misere [1, 5] (1, 5)
>>> print(nim([1, 5], NORMAL))
normal [1, 5] (1, 4)
"""
print(game_type, heaps, end=' ')
is_misere = game_type == MISERE
is_near_endgame = False
count_non_0_1 = sum(1 for x in heaps if x > 1)
is_near_endgame = (count_non_0_1 <= 1)
# nim sum will give the correct endgame move for normal play but
# misere requires the last move be forced onto the opponent
if is_misere and is_near_endgame:
moves_left = sum(1 for x in heaps if x > 0)
is_odd = (moves_left % 2 == 1)
sizeof_max = max(heaps)
index_of_max = heaps.index(sizeof_max)
if sizeof_max == 1 and is_odd:
return "You will lose :("
# reduce the game to an odd number of 1's
return index_of_max, sizeof_max  int(is_odd)
nim_sum = functools.reduce(lambda x, y: x ^ y, heaps)
if nim_sum == 0:
return "You will lose :("
# Calc which move to make
for index, heap in enumerate(heaps):
target_size = heap ^ nim_sum
if target_size < heap:
amount_to_remove = heap  target_size
return index, amount_to_remove
if __name__ == "__main__":
import doctest
doctest.testmod()
Proof of the winning formula
The soundness of the optimal strategy described above was demonstrated by C. Bouton.
Theorem. In a normal Nim game, the player making the first move has a winning strategy if and only if the nimsum of the sizes of the heaps is nonzero. Otherwise, the second player has a winning strategy.
Proof: Notice that the nimsum (⊕) obeys the usual associative and commutative laws of addition (+) and also satisfies an additional property, x ⊕ x = 0 (technically speaking, that the nonnegative integers under ⊕ form an Abelian group of exponent 2).
Let x_{1}, ..., x_{n} be the sizes of the heaps before a move, and y_{1}, ..., y_{n} the corresponding sizes after a move. Let s = x_{1} ⊕ ... ⊕ x_{n} and t = y_{1} ⊕ ... ⊕ y_{n}. If the move was in heap k, we have x_{i} = y_{i} for all i ≠ k, and x_{k} > y_{k}. By the properties of ⊕ mentioned above, we have
t = 0 ⊕ t = s ⊕ s ⊕ t = s ⊕ (x_{1} ⊕ ... ⊕ x_{n}) ⊕ (y_{1} ⊕ ... ⊕ y_{n}) = s ⊕ (x_{1} ⊕ y_{1}) ⊕ ... ⊕ (x_{n} ⊕ y_{n}) = s ⊕ 0 ⊕ ... ⊕ 0 ⊕ (x_{k} ⊕ y_{k}) ⊕ 0 ⊕ ... ⊕ 0 = s ⊕ x_{k} ⊕ y_{k} (*) t = s ⊕ x_{k} ⊕ y_{k}.
The theorem follows by induction on the length of the game from these two lemmas.
Lemma 1. If s = 0, then t ≠ 0 no matter what move is made.
Proof: If there is no possible move, then the lemma is vacuously true (and the first player loses the normal play game by definition). Otherwise, any move in heap k will produce t = x_{k} ⊕ y_{k} from (*). This number is nonzero, since x_{k} ≠ y_{k}.
Lemma 2. If s ≠ 0, it is possible to make a move so that t = 0.
Proof: Let d be the position of the leftmost (most significant) nonzero bit in the binary representation of s, and choose k such that the dth bit of x_{k} is also nonzero. (Such a k must exist, since otherwise the dth bit of s would be 0.) Then letting y_{k} = s ⊕ x_{k}, we claim that y_{k} < x_{k}: all bits to the left of d are the same in x_{k} and y_{k}, bit d decreases from 1 to 0 (decreasing the value by 2^{d}), and any change in the remaining bits will amount to at most 2^{d}−1. The first player can thus make a move by taking x_{k} − y_{k} objects from heap k, then
t = s ⊕ x_{k} ⊕ y_{k} (by (*)) = s ⊕ x_{k} ⊕ (s ⊕ x_{k}) = 0.
The modification for misère play is demonstrated by noting that the modification first arises in a position that has only one heap of size 2 or more. Notice that in such a position s ≠ 0, therefore this situation has to arise when it is the turn of the player following the winning strategy. The normal play strategy is for the player to reduce this to size 0 or 1, leaving an even number of heaps with size 1, and the misère strategy is to do the opposite. From that point on, all moves are forced.
Variations
Dividing natural number
Give any natural number n, the two people can divide n by a prime power ( A000961) which is a factor of n (except 1), the person who gets 1 wins (or loses).
If , where is the kth prime, then it is a Nim game with k groups of stones, and the rth groups has stones.
If the divisor changes to "a power of squarefree numbers" ( A072774) except 1, it is Wythoff's game.
The divisor can also change to "a divisor of m" for fixed m, where m is a divisor of n. (m should be divisible by all of the prime factors of n and should be less than n)
Of course, you can choose a set of allowed divisors. For example, {2, 3, 4, 12, 15, 20, 24, 25, 30, 32, 36}.
The subtraction game S(1, 2, . . ., k)
In another game which is commonly known as Nim (but is better called the subtraction game S (1,2,...,k)), an upper bound is imposed on the number of objects that can be removed in a turn. Instead of removing arbitrarily many objects, a player can only remove 1 or 2 or ... or k at a time. This game is commonly played in practice with only one heap (for instance with k = 3 in the game Thai 21 on Survivor: Thailand, where it appeared as an Immunity Challenge).
Bouton's analysis carries over easily to the general multipleheap version of this game. The only difference is that as a first step, before computing the Nimsums, we must reduce the sizes of the heaps modulo k + 1. If this makes all the heaps of size zero (in misère play), the winning move is to take k objects from one of the heaps. In particular, in ideal play from a single heap of n objects, the second player can win if and only if
 n ≡ 0 (mod k + 1) (in normal play), or
 n ≡ 1 (mod k + 1) (in misère play).
This follows from calculating the nimsequence of S(1,2,...,k),
from which the strategy above follows by the Sprague–Grundy theorem.
The 21 game
The game "21" is played as a misère game with any number of players who take turns saying a number. The first player says "1" and each player in turn increases the number by 1, 2, or 3, but may not exceed 21; the player forced to say "21" loses. This can be modeled as a subtraction game with a heap of 21–n objects. The winning strategy for the twoplayer version of this game is to always say a multiple of 4; it is then guaranteed that the other player will ultimately have to say 21 – so in the standard version where the first player opens with "1", they start with a losing move.
The 21 game can also be played with different numbers, like "Add at most 5; lose on 34".
A sample game of 21 in which the second player follows the winning strategy:
Player Number 1 1 2 4 1 5, 6 or 7 2 8 1 9, 10 or 11 2 12 1 13, 14 or 15 2 16 1 17, 18 or 19 2 20 1 21
The 100 game
A similar version is the "100 game": two players start from 0 and alternatively add a number from 1 to 10 to the sum. The player who reaches 100 wins. The winning strategy is to reach a number in which the digits are subsequent (e.g. 01, 12, 23, 34,...) and control the game by jumping through all the numbers of this sequence. Once reached 89, the opponent has lost (he can only tell numbers from 90 to 99, and the next answer can in any case be 100).
A multipleheap rule
In another variation of Nim, besides removing any number of objects from a single heap, one is permitted to remove the same number of objects from each heap.
Circular Nim
Yet another variation of Nim is 'Circular Nim', where any number of objects are placed in a circle, and two players alternately remove one, two or three adjacent objects. For example, starting with a circle of ten objects,
. . . . . . . . . .
three objects are taken in the first move
_ . . . . . . . _ _
then another three
_ . _ _ _ . . . _ _
then one
_ . _ _ _ . . _ _ _
but then three objects cannot be taken out in one move.
Grundy's game
In Grundy's game, another variation of Nim, a number of objects are placed in an initial heap, and two players alternately divide a heap into two nonempty heaps of different sizes. Thus, six objects may be divided into piles of 5+1 or 4+2, but not 3+3. Grundy's game can be played as either misère or normal play.
Greedy Nim
Greedy Nim is a variation where the players are restricted to choosing stones from only the largest pile.^{[10]} It is a finite impartial game. Greedy Nim Misère has the same rules as Greedy Nim, but here the last player able to make a move loses.
Let the largest number of stones in a pile be m, the second largest number of stones in a pile be n. Let p_{m} be the number of piles having m stones, p_{n} be the number of piles having n stones. Then there is a theorem that game positions with p_{m} even are P positions. ^{[11]} This theorem can be shown by considering the positions where p_{m} is odd. If p_{m} is larger than 1, all stones may be removed from this pile to reduce p_{m} by 1 and the new p_{m} will be even. If p_{m} = 1 (i.e. the largest heap is unique), there are two cases:
 If p_{n} is odd, the size of the largest heap is reduced to n (so now the new p_{m} is even).
 If p_{n} is even, the largest heap is removed entirely, leaving an even number of largest heaps.
Thus there exists a move to a state where p_{m} is even. Conversely, if p_{m} is even, if any move is possible (p_{m} ≠ 0) then it must take the game to a state where p_{m} is odd. The final position of the game is even (p_{m} = 0). Hence each position of the game with p_{m} even must be a P position.
Indexk Nim
A generalization of multiheap Nim was called "Nim" or "indexk" Nim by E. H. Moore,^{[12]} who analyzed it in 1910. In indexk Nim, instead of removing objects from only one heap, players can remove objects from at least one but up to k different heaps. The number of elements that may be removed from each heap may be either arbitrary, or limited to at most r elements, like in the "subtraction game" above.
The winning strategy is as follows: Like in ordinary multiheap Nim, one considers the binary representation of the heap sizes (or heap sizes modulo r + 1). In ordinary Nim one forms the XORsum (or sum modulo 2) of each binary digit, and the winning strategy is to make each XOR sum zero. In the generalization to indexk Nim, one forms the sum of each binary digit modulo k + 1.
Again the winning strategy is to move such that this sum is zero for every digit. Indeed, the value thus computed is zero for the final position, and given a configuration of heaps for which this value is zero, any change of at most k heaps will make the value nonzero. Conversely, given a configuration with nonzero value, one can always take from at most k heaps, carefully chosen, so that the value will become zero.
Building Nim
Building Nim is a variant of Nim where the two players first construct the game of Nim. Given n stones and s empty piles, the players alternate turns placing exactly one stone into a pile of their choice.^{[13]} Once all the stones are placed, a game of Nim begins, starting with the next player that would move. This game is denoted BN(n,s).
See also
 Dr. NIM
 Fibonacci nim
 Fuzzy game
 Nimber
 Nimrod (computing)
 Octal games
 Star (game theory)
 Subtract a square
 Zero game
 Android Nim
 Raymond Redheffer
 Notakto
References

^ Jorgensen, Anker Helms (2009), "Context and driving forces in the development of the early computer game Nimbi", IEEE Annals of the History of Computing, 31 (3): 44–53, doi:10.1109/MAHC.2009.41, MR 2767447,
The twoperson mathematical game Nim, which many believe originated in China, is probably one of the oldest games in the world.
 ^ Yaglom, I. M. (2001), "Two games with matchsticks", in Tabachnikov, Serge, Kvant Selecta: Combinatorics, I, Volume 1, Mathematical world, 17, American Mathematical Society, pp. 1–8, ISBN 9780821821718.
 ^ Bouton, C. L. (1901–1902), "Nim, a game with a complete mathematical theory", Annals of Mathematics, 3 (14): 35–39, doi:10.2307/1967631..
 ^ Flesch, Rudolf (1951). The Art of Clear Thinking. New York: Harper and Brothers Publishers. p. 3.
 ^ http://www.expomuseum.com/1939n/
 ^ http://platinumpiotr.blogspot.com/2016/01/1940nimatron.html
 ^ Grant, Eugene F.; Lardner, Rex (August 2, 1952). "The Talk of the Town – It". The New Yorker.
 ^ Cohen, Harvey A. "How to Construct NIM Playing Machine" (PDF).
 ^ Morrissette, Bruce (1968), "Games and game structures in RobbeGrillet", Yale French Studies, 41: 159–167, doi:10.2307/2929672. Morrissette writes that Alain RobbeGrillet, one of the screenwriters for the film, "thought he had invented" the game.
 ^  (2001). Winning Ways for your Mathematical Plays. 4 vols. (2nd ed.). A K Peters Ltd.; vol. 1. ISBN 1568811306.; vol. 2. ISBN 156881142X.; vol. 3. ISBN 1568811438.; vol. 4. ISBN 1568811446..
 ^ M H Albert, R. J. Nowakowski (2004). "Nim Restrictions" (PDF). Integers: Electronic Journal of Combinatorial Number Theory 4.G01 (2004): G01: 2.
 ^ Moore, E. H. A Generalization of the Game Called Nim. Annals of Mathematics 11 (3), 1910, pp. 93–94
 ^ Larsson, Urban; Heubach, Silvia; Dufour, Matthieu; Duchêne, Eric. "Building Nim". arXiv:1502.04068 .
Additional reading
 W. W. Rouse Ball: Mathematical Recreations and Essays, The Macmillan Company, 1947.
 John D. Beasley: The Mathematics of Games, Oxford University Press, 1989.
 Elwyn R. Berlekamp, John H. Conway, and Richard K. Guy: Winning Ways for your Mathematical Plays, Academic Press, Inc., 1982.
 Manfred Eigen and Ruthild Winkler: Laws of the Game, Princeton University Press, 1981.
 Walter R. Fuchs: Computers: Information Theory and Cybernetics, Rupert HartDavis Educational Publications, 1971.
 G. H. Hardy and E. M. Wright: An Introduction to the Theory of Numbers, Oxford University Press, 1979.
 Edward Kasner and James Newman: Mathematics and the Imagination, Simon and Schuster, 1940.
 M. Kaitchik: Mathematical Recreations, W. W. Norton, 1942.
 Donal D. Spencer: Game Playing with Computers, Hayden Book Company, Inc., 1968.
External links
Wikimedia Commons has media related to Nim. 
 50pound computer plays Nim The New Yorker magazine "Talk of the Town" August, 1952(subscription required)
 The hot game of Nim – Nim theory and connections with other games at cuttheknot
 Nim and 2dimensional SuperNim at cuttheknot
 Subtraction Game: a Subtraction Game illustration on Appstore.
 Classic Nim  Implementation of Nim for iOS.
 Matchstick Nim  Implementation of Nim for Android devices.