Open main menu

In computer science and mathematics, the Josephus problem (or Josephus permutation) is a theoretical problem related to a certain counting-out game.

People are standing in a circle waiting to be executed. Counting begins at a specified point in the circle and proceeds around the circle in a specified direction. After a specified number of people are skipped, the next person is executed. The procedure is repeated with the remaining people, starting with the next person, going in the same direction and skipping the same number of people, until only one person remains, and is freed.

The problem — given the number of people, starting point, direction, and number to be skipped — is to choose the position in the initial circle to avoid execution.



The problem is named after Flavius Josephus, a Jewish historian living in the 1st century. According to Josephus' account of the siege of Yodfat, he and his 40 soldiers were trapped in a cave by Roman soldiers. They chose suicide over capture, and settled on a serial method of committing suicide by drawing lots. Josephus states that by luck or possibly by the hand of God, he and another man remained until the end and surrendered to the Romans rather than killing themselves. This is the story given in Book 3, Chapter 8, part 7 of Josephus' The Jewish War (writing of himself in the third person):

However, in this extreme distress, he was not destitute of his usual sagacity; but trusting himself to the providence of God, he put his life into hazard [in the manner following]: "And now," said he, "since it is resolved among you that you will die, come on, let us commit our mutual deaths to determination by lot. He whom the lot falls to first, let him be killed by him that hath the second lot, and thus fortune shall make its progress through us all; nor shall any of us perish by his own right hand, for it would be unfair if, when the rest are gone, somebody should repent and save himself." This proposal appeared to them to be very just; and when he had prevailed with them to determine this matter by lots, he drew one of the lots for himself also. He who had the first lot laid his neck bare to him that had the next, as supposing that the general would die among them immediately; for they thought death, if Josephus might but die with them, was sweeter than life; yet was he with another left to the last, whether we must say it happened so by chance, or whether by the providence of God. And as he was very desirous neither to be condemned by the lot, nor, if he had been left to the last, to imbrue his right hand in the blood of his countrymen, he persuaded him to trust his fidelity to him, and to live as well as himself.[1]

The details of the mechanism used in this feat are rather vague. According to Dowdy and Mays,[2] in 1612 Bachet suggested the specific mechanism of arranging the men in a circle and counting by threes to determine the order of elimination.[3] This story has been often repeated and the specific details vary considerably from source to source. For instance, Herstein and Kaplansky (1974) have Josephus and 39 comrades stand in a circle with every seventh man eliminated.[4] A history of the problem can be found in S. L. Zabell's Letter to the editor of the Fibonacci Quarterly.[5]

Josephus had an accomplice; the problem was then to find the places of the two last remaining survivors (whose conspiracy would ensure their survival). It is alleged that he placed himself and the other man in the 31st and 16th place respectively.[6]

Variants and generalizationsEdit

A Medieval version of the Josephus problem involves 15 Turks and 15 Christians on board a ship in a storm which will sink unless half the passengers are thrown overboard. All 30 stand in a circle and every ninth person is to be tossed into the sea. Where should the Christians stand to ensure that only the Turks are tossed?[7] In other versions the roles of Turks and Christians are interchanged.

In Concrete Mathematics: A Foundation for Computer Science, Graham, Knuth and Patashnik describe and study a "standard" variant:[8] Determine where the last survivor stands if there are n people to start and every second person (k = 2 below) is eliminated.

A generalization of this problem is as follows. We suppose that every mth person will be executed from a group of size n, in which the pth person is the survivor. If there is an addition of x people to the circle, then the survivor is in the p + mx-th position if this is less than or equal to n + x. If x is the smallest value for which (p + mx) > (n + x), then the survivor is in position (p + mx) − (n + x).[9]


In the following,   denotes the number of people in the initial circle, and   denotes the count for each step, that is,   people are skipped and the  -th is executed. The people in the circle are numbered from   to  .


We explicitly solve the problem when every second person will be killed, i.e.  . (For the more general case  , we outline a solution below.) We express the solution recursively. Let   denote the position of the survivor when there are initially   people (and  ). The first time around the circle, all of the even-numbered people die. The second time around the circle, the new 2nd person dies, then the new 4th person, etc.; it's as though there were no first time around the circle.

If the initial number of people was even, then the person in position   during the second time around the circle was originally in position   (for every choice of  ). Let  . The person at   who will now survive was originally in position  . This gives us the recurrence


If the initial number of people was odd, then we think of person 1 as dying at the end of the first time around the circle. Again, during the second time around the circle, the new 2nd person dies, then the new 4th person, etc. In this case, the person in position   was originally in position  . This gives us the recurrence


When we tabulate the values of   and   we see a pattern:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
  1 1 3 1 3 5 7 1 3 5 7 9 11 13 15 1

This suggests that   is an increasing odd sequence that restarts with   whenever the index n is a power of 2. Therefore, if we choose m and l so that   and  , then  . It is clear that values in the table satisfy this equation. Or we can think that after   people are dead there are only   people and we go to the  th person. He must be the survivor. So  . Below, we give a proof by induction.

Theorem: If   and  , then  .

Proof: We use strong induction on  . The base case   is true. We consider separately the cases when   is even and when   is odd.

If   is even, then choose   and   such that   and  . Note that  . We have  , where the second equality follows from the induction hypothesis.

If   is odd, then choose   and   such that   and  . Note that  . We have  , where the second equality follows from the induction hypothesis. This completes the proof.

We can solve for   to get an explicit expression for  :


The most elegant form of the answer involves the binary representation of size  :   can be obtained by a one-bit left cyclic shift of   itself. If we represent   in binary as  , then the solution is given by  . The proof of this follows from the representation of   as   or from the above expression for  .

Implementation: If n denotes the number of people, the safe position is given by the function   ,where   and  .

Now if we represent the number in binary format, the first bit denotes   and remaining bits will denote  . For example, when n=41, its binary representation is

n = 1 0 1 0 0 1

2m = 1 0 0 0 0 0

l = 0 1 0 0 1

	 * @param n the number of people standing in the circle
	 * @return the safe position who will survive the execution 
	 *   f(N) = 2L + 1 where N =2^M + L and 0 <= L < 2^M
	public int getSafePosition(int n) {
		// find value of L for the equation
		int valueOfL = n - Integer.highestOneBit(n);
		int safePosition = 2 * valueOfL  + 1;
		return safePosition;


In 1997, Lorenz Halbeisen and Norbert Hungerbühler discovered a closed-form for the case  . They showed that there is a certain constant


that can be computed to arbitrary precision. Given this constant, choose   to be the greatest integer such that   (this will be either   or  ). Then, then the final survivor is

  if we rounded up else  

for all  .

As an example computation, Halbeisen and Hungerbühler give   (which is actually the original formulation of Josephus' problem). They compute:

  and therefore  
  (note that we rounded down)

We can verify this looking at each successive pass on the numbers   through  :



The easiest way to find the safe position is by using bitwise operators. In this approach shifting the most-significant set bit of n to the least significant bit will return the safe position.[10] Input must be a positive integer.

n = 1 0 1 0 0 1

n = 0 1 0 0 1 1

	 * @param n (41) the number of people standing in the circle
	 * @return the safe position who will survive the execution 
	 * ~Integer.highestOneBit(n*2)
	 * Multiply n by 2, get the first set bit and take its complement
	 * ((n<<1) | 1)
	 * Left Shift n and flipping the last bit
	 * ~Integer.highestOneBit(n*2) & ((n<<1) | 1) 
	 * Bitwise And to copy bits exists in both operands.
	public int getSafePosition(int n) {
		return ~Integer.highestOneBit(n*2) & ((n<<1) | 1);

The general caseEdit

Dynamic programming is used to solve this problem in the general case by performing the first step and then using the solution of the remaining problem. When the index starts from one, then the person at   shifts from the first person is in position  , where n is the total number of persons. Let   denote the position of the survivor. After the  -th person is killed, we're left with a circle of  , and we start the next count with the person whose number in the original problem was  . The position of the survivor in the remaining circle would be   if we start counting at  ; shifting this to account for the fact that we're starting at   yields the recurrence


which takes the simpler form


if we number the positions from   to   instead.

This approach has running time  , but for small   and large   there is another approach. The second approach also uses dynamic programming but has running time  . It is based on considering killing k-th, 2k-th, ...,  -th people as one step, then changing the numbering.[citation needed]

This improved approach takes the form



  1. ^ Flavius Josephus, Wars of the Jews III. 8. 7. (Translation by William Whiston).
  2. ^ Dowdy & Mays 1989, p. 125
  3. ^ Bachet, C. G. (1612). Problemes Plaisants ed Delectables qui se font par les Nombres. p. 174.
  4. ^ Herstein, I. N.; Kaplansky, I. (1974). Matters Mathematical. Harper and Row. pp. 121–126.
  5. ^ Zabell, S. L. (1976). "Letter to the editor". Fibonacci Quarterly. 14: 48, 51.
  6. ^ Rouse Ball, W. W. (1896). Mathematical Recreations and Essays (2nd ed.). Macmillan.
  7. ^ Newman, J. R. (1988). "The World of Mathematics". 4. Tempus: 2403–2405.
  8. ^ Graham, R. L.; Knuth, D. E.; Patashnik, O. (1989). Concrete Mathematics: A Foundation for Computer Science. Addison Wesley. p. 8. ISBN 978-0-201-14236-5.
  9. ^ Robinson, W. J. (1960). "The Josephus Problem". The Mathematical Gazette. 44 (347): 47–52. doi:10.2307/3608532. JSTOR 3608532.
  10. ^ "Josephus Problem using Bitwise Operation (Java)". GitHub. January 7, 2018. Retrieved January 7, 2018.


External linksEdit