Josephus problem | Set 1 (A O(n) Solution)

07 Jun, 2022
In computer science and mathematics, the Josephus Problem (or Josephus permutation) is a theoretical problem. Following is the problem statement:
There are n people standing in a circle waiting to be executed. The counting out begins at some point in the circle and proceeds around the circle in a fixed direction. In each step, a certain number of people are skipped and the next person is executed. The elimination proceeds around the circle (which is becoming smaller and smaller as the executed people are removed), until only the last person remains, who is given freedom. Given the total number of person n and a number k which indicates that k-1 persons are skipped and the kth person is killed in a circle. The task is to choose the place in the initial circle so that you are the last one remaining and so survive.For example, if n = 5 and k = 2, then the safe position is 3. Firstly, the person at position 2 is killed, then the person at position 4 is killed, then the person at position 1 is killed. Finally, the person at position 5 is killed. So the person at position 3 survives. If n = 7 and k = 3, then the safe position is 4. The persons at positions 3, 6, 2, 7, 5, and 1 are killed in order, and the person at position 4 survives.
The problem has the following recursive structure.  
  josephus(n, k) = (josephus(n - 1, k) + k-1) % n + 1
  josephus(1, k) = 1
After the first person (kth from the beginning) is killed, n-1 persons are left. So we call Josephus(n – 1, k) to get the position with n-1 persons. But the position returned by Josephus(n – 1, k) will consider the position starting from k%n + 1. So, we must make adjustments to the position returned by Josephus(n – 1, k). 
The following is a simple recursive implementation of the Josephus problem. The implementation simply follows the recursive structure mentioned above.  
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
C++
C
Java
Python3
C#
PHP
Javascript
#include <iostream>using namespace std; int josephus(int n, int k){    if (n == 1)        return 1;    else        /* The position returned by josephus(n - 1, k)        is adjusted because the recursive call        josephus(n - 1, k) considers the        original position k % n + 1 as position 1 */        return (josephus(n - 1, k) + k - 1) % n + 1;} // Driver Program to test above functionint main(){    int n = 14;    int k = 2;    cout << "The chosen place is " << josephus(n, k);    return 0;} // This code is contributed by shubhamsingh10
#include <stdio.h> int josephus(int n, int k){    if (n == 1)        return 1;    else        /* The position returned by josephus(n - 1, k) is           adjusted because the recursive call josephus(n -           1, k) considers the original position           k%n + 1 as position 1 */        return (josephus(n - 1, k) + k - 1) % n + 1;} // Driver Program to test above functionint main(){    int n = 14;    int k = 2;    printf("The chosen place is %d", josephus(n, k));    return 0;}
// Java code for Josephus Problemimport java.io.*; class GFG {     static int josephus(int n, int k)    {        if (n == 1)            return 1;        else            /* The position returned by josephus(n - 1, k)            is adjusted because the recursive call            josephus(n - 1, k) considers the original            position k%n + 1 as position 1 */            return (josephus(n - 1, k) + k - 1) % n + 1;    }     // Driver Program to test above function    public static void main(String[] args)    {        int n = 14;        int k = 2;        System.out.println("The chosen place is "                           + josephus(n, k));    }} // This code is contributed by Prerna Saini
# Python code for Josephus Problem  def josephus(n, k):     if (n == 1):        return 1    else:         # The position returned by        # josephus(n - 1, k) is adjusted        # because the recursive call        # josephus(n - 1, k) considers        # the original position        # k%n + 1 as position 1        return (josephus(n - 1, k) + k-1) % n + 1 # Driver Program to test above function  n = 14k = 2 print("The chosen place is ", josephus(n, k)) # This code is contributed by# Sumit Sadhakar
// C# code for Josephus Problemusing System; class GFG {     static int josephus(int n, int k)    {        if (n == 1)            return 1;        else            /* The position returned            by josephus(n - 1, k) is            adjusted because the            recursive call josephus(n            - 1, k) considers the            original position k%n + 1            as position 1 */            return (josephus(n - 1, k) + k - 1) % n + 1;    }     // Driver Program to test above    // function    public static void Main()    {        int n = 14;        int k = 2;        Console.WriteLine("The chosen "                          + "place is " + josephus(n, k));    }} // This code is contributed by anuj_67.
<?php// PHP code for// Josephus Problem function josephus($n, $k){    if ($n == 1)        return 1;    else        /* The position returned by           josephus(n - 1, k) is           adjusted because the           recursive call josephus           (n - 1, k) considers the           original position k%n + 1           as position 1 */        return (josephus($n - 1, $k) +                    $k - 1) % $n + 1;}     // Driver Code    $n = 14;    $k = 2;    echo "The chosen place is ", josephus($n, $k); // This code is contributed by ajit.?>
<script>     // Javascript code for Josephus Problem         function josephus(n, k)    {        if (n == 1)            return 1;        else            /* The position returned            by josephus(n - 1, k) is            adjusted because the            recursive call josephus(n            - 1, k) considers the            original position k%n + 1            as position 1 */            return (josephus(n - 1, k)                       + k-1) % n + 1;    }           let n = 14;    let k = 2;    document.write("The chosen " + "place is " + josephus(n, k));     </script>
The chosen place is 13
Time Complexity: O(n)Auxiliary Space: O(n)
Another Approach using List: The simple approach is to create a list and add all values from 1 to n to it. Create a recursive function that takes a list, start (position at which counting will start), and k ( number of people to be skipped) as an argument. If the size of the list is one i.e. only one person left then return this position. Otherwise, start counting the k person in a clockwise direction from starting position and remove the person at the kth position. Now the person at the kth position is removed and now counting will start from this position. This process continues till only one person is left.
pseudo-code :

Josephus( list , start , k){
   if list.size = 1
       return list[0]
   start = (start + k) % list.size
   list.remove( start )
   return Josephus( list, start, k)
}
C++ Code
C++
Java
Python3
C#
Javascript
#include <bits/stdc++.h> using namespace std; void Josh(vector<int> person, int k, int index){    // Base case , when only one person is left    if (person.size() == 1) {        cout << person[0] << endl;        return;    }     // find the index of first person which will die    index = ((index + k) % person.size());     // remove the first person which is going to be killed    person.erase(person.begin() + index);     // recursive call for n-1 persons    Josh(person, k, index);} int main(){    int n = 14; // specific n and k  values for original                // josephus problem    int k = 2;    k--; // (k-1)th person will be killed    int index        = 0; // The index where the person which will die     vector<int> person;    // fill the person vector    for (int i = 1; i <= n; i++) {        person.push_back(i);    }     Josh(person, k, index);}
import java.util.*; class GFG{    static void Josh(List<Integer> person, int k, int index)  {         // Base case , when only one person is left    if (person.size() == 1) {      System.out.println(person.get(0));      return;    }     // find the index of first person which will die    index = ((index + k) % person.size());     // remove the first person which is going to be killed    person.remove(index);     // recursive call for n-1 persons    Josh(person, k, index);  }   // Driver code  public static void main(String [] args)  {    int n = 14; // specific n and k  values for original    // josephus problem    int k = 2;    k--; // (k-1)th person will be killed    int index      = 0; // The index where the person which will die     List<Integer> person = new ArrayList<>();         // fill the person vector    for (int i = 1; i <= n; i++) {      person.add(i);    }     Josh(person, k, index);  }} // This code is contributed by umadevi9616
# Python code for Josephus Problemdef Josh(person, k, index):     # Base case , when only one person is left  if len(person) == 1:    print(person[0])    return     # find the index of first person which will die  index = ((index+k)%len(person))      # remove the first person which is going to be killed  person.pop(index)     # recursive call for n-1 persons  Josh(person,k,index) # Driver Program to test above functionn = 14 # specific n and k  values for original josephus problemk = 2k-=1   # (k-1)th person will be killed index = 0 # fill the person vectorperson=[]for i in range(1,n+1):  person.append(i) Josh(person,k,index) # This code is contributed by# Gaurav Kandel
using System;using System.Collections.Generic;class GFG {         static void Josh(List<int> person, int k, int index)    {        // Base case , when only one person is left        if (person.Count == 1) {            Console.WriteLine(person[0]);            return;        }              // find the index of first person which will die        index = ((index + k) % person.Count);              // remove the first person which is going to be killed        person.RemoveAt(index);              // recursive call for n-1 persons        Josh(person, k, index);    }   // Driver code  static void Main()  {    int n = 14; // specific n and k  values for original                // josephus problem    int k = 2;    k--; // (k-1)th person will be killed    int index        = 0; // The index where the person which will die      List<int> person = new List<int>();    // fill the person vector    for (int i = 1; i <= n; i++) {        person.Add(i);    }      Josh(person, k, index);  }} // This code is contributed by divyesh072019.
<script>    function Josh( person , k , index) {         // Base case , when only one person is left        if (person.length == 1) {            document.write(person[0]);            return;        }         // find the index of first person which will die        index = ((index + k) % person.length);         // remove the first person which is going to be killed         if (index > -1) {       person.splice(index, 1);    }         // recursive call for n-1 persons        Josh(person, k, index);    }     // Driver code             var n = 14; // specific n and k values for original        // josephus problem        var k = 2;        k--; // (k-1)th person will be killed        var index = 0; // The index where the person which will die         var person = [];         // fill the person vector        for (var i = 1; i <= n; i++) {            person.push(i);        }         Josh(person, k, index);         // This code is contributed by umadevi9616</script>
13

Time Complexity: O(n2)
Example : 
Input: n = 5,  k = 2Output: 3
Explanation :Add all values from 1 to n in the list. We will call the recursive function with start = 0 and k = 1 (0-indexing)
Now the element at 1-index (person number 2) will be killed. And it is removed from the list. The new counting will begin from 1-index, the person at 1-index killed so now person at 2-index (person number 3) comes to 1-index and counting starts from here now.
Now we have 4 people, counting starting from 1-index (person number 3) and the person at kth (2-index ) position will be killed. 
The person at 2-index (person number 4) was killed so now we have 3 people left and the person (person number 5) at 3-index shifted to 2-index. And counting starts from here.
The person at the 0-index was killed and we have now two-person left in the circle. And the person at 1-index shifted to 0-index i.e. person number 3.
Final counting done and the person at 1-index killed and the only person who is left is at position 3.
This is a solution to the Josephus problem in C++.For n = 47 and k = 5.
C++
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; int Josephus(int, int); int Josephus(int n, int k){    k--;    int arr[n];     // Makes all the 'n' people alive by    // assigning them value = 1    for (int i = 0; i < n; i++) {        arr[i] = 1;    }    int cnt = 0, cut = 0,        // Cut = 0 gives the sword to 1st person.        num = 1;     // Loop continues till n-1 person dies.    while (cnt < (n - 1)) {         // Checks next (kth) alive persons.        while (num <= k) {            cut++;             // Checks and resolves overflow            // of Index.            cut = cut % n;            if (arr[cut] == 1) {                // Updates the number of persons                // alive.                num++;            }        }         // Refreshes value to 1 for next use.        num = 1;         // Kills the person at position of 'cut'        arr[cut] = 0;         // Updates the no. of killed persons.        cnt++;        cut++;         // Checks and resolves overflow of Index.        cut = cut % n;         // Checks the next alive person the        // sword is to be given.        while (arr[cut] == 0) {            cut++;             // Checks and resolves overflow            // of Index.            cut = cut % n;        }    }     // Output is the position of the last    // man alive(Index + 1);    return cut + 1;} // Driver codeint main(){    int n = 14, k = 2;    cout << Josephus(n, k);    return 0;} // THIS CODE IS PRESENTED BY SHISHANK RAWAT
// Java code to implement the above approachimport java.io.*;class GFG {     public static void main(String[] args)    {        int n = 14, k = 2;        System.out.println(Josephus(n, k));    }     public static int Josephus(int n, int k)    {        k--;        int arr[] = new int[n];        for (int i = 0; i < n; i++) {            arr[i] = 1; // Makes all the 'n' people alive by            // assigning them value = 1        }        int cnt = 0, cut = 0,            num            = 1; // Cut = 0 gives the sword to 1st person.        while (            cnt            < (n               - 1)) // Loop continues till n-1 person dies.        {            while (num                   <= k) // Checks next (kth) alive persons.            {                cut++;                cut = cut                      % n; // Checks and resolves overflow                // of Index.                if (arr[cut] == 1) {                    num++; // Updates the number of persons                    // alive.                }            }            num = 1; // refreshes value to 1 for next use.            arr[cut] = 0; // Kills the person at position of                          // 'cut'            cnt++; // Updates the no. of killed persons.            cut++;            cut = cut % n; // Checks and resolves overflow                           // of Index.            while (arr[cut]                   == 0) // Checks the next alive person the            // sword is to be given.            {                cut++;                cut = cut                      % n; // Checks and resolves overflow                // of Index.            }        }        return cut            + 1; // Output is the position of the last        // man alive(Index + 1);    }} // This code is contributed by Shubham Singh
def Josephus(n, k):         k -= 1    arr = [0]*n    for i in range(n):        arr[i] = 1 # Makes all the 'n' people alive by        # assigning them value = 1    cnt = 0    cut = 0    num = 1 # Cut = 0 gives the sword to 1st person.    while (cnt < (n - 1)):               # Loop continues till n-1 person dies.        while (num <= k):                       # Checks next (kth) alive persons.            cut += 1            cut = cut % n # Checks and resolves overflow            # of Index.            if (arr[cut] == 1):                num+=1 # Updates the number of persons                # alive.                 num = 1 # refreshes value to 1 for next use.        arr[cut] = 0 # Kills the person at position of 'cut'        cnt += 1 # Updates the no. of killed persons.        cut += 1        cut = cut % n # Checks and resolves overflow of Index.        while (arr[cut] == 0):                       # Checks the next alive person the            # sword is to be given.            cut += 1            cut = cut % n # Checks and resolves overflow            # of Index.         return cut + 1 # Output is the position of the last                    # man alive(Index + 1) # Driver Coden, k = 14, 2 #map (int, input().splut())print(Josephus(n, k)) # This code is contributed by ShubhamSingh
// C# code to implement the above approachusing System;using System.Linq; public class GFG{   public static void Main ()  {    int n = 14, k = 2;    Console.Write(Josephus(n, k));  }   public static int Josephus(int n, int k)  {    k--;    int[] arr = new int[n];    for (int i = 0; i < n; i++) {      arr[i] = 1; // Makes all the 'n' people alive by      // assigning them value = 1    }    int cnt = 0, cut = 0,    num = 1; // Cut = 0 gives the sword to 1st person.    while (      cnt      < (n - 1)) // Loop continues till n-1 person dies.    {      while (num <= k) // Checks next (kth) alive persons.      {        cut++;        cut = cut % n;                 // Checks and resolves overflow        // of Index.        if (arr[cut] == 1)        {          num++; // Updates the number of persons          // alive.        }      }      num = 1; // refreshes value to 1 for next use.      arr[cut]        = 0; // Kills the person at position of 'cut'      cnt++; // Updates the no. of killed persons.      cut++;      cut = cut        % n; // Checks and resolves overflow of Index.      while (arr[cut]             == 0) // Checks the next alive person the        // sword is to be given.      {        cut++;        cut = cut % n; // Checks and resolves overflow        // of Index.      }    }    return cut + 1; // Output is the position of the last    // man alive(Index + 1);  }} // This code is contributed by Shubham Singh
<script>    // Javascript code to implement the above approach         let n = 14, k = 2;    document.write(Josephus(n, k));         function Josephus(n, k)    {      k--;      let arr = new Array(n);      for (let i = 0; i < n; i++)      {                 // Makes all the 'n' people alive by        // assigning them value = 1        arr[i] = 1;      }             // Cut = 0 gives the sword to 1st person.      let cnt = 0, cut = 0,      num = 1;             // Loop continues till n-1 person dies.      while (cnt < (n - 1))      {              // Checks next (kth) alive persons.        while (num <= k)        {          cut++;          cut = cut % n;           // Checks and resolves overflow          // of Index.          if (arr[cut] == 1)          {                          // Updates the number of persons            // alive.            num++;          }        }                 // refreshes value to 1 for next use.        num = 1;        arr[cut] = 0; // Kills the person at position of 'cut'                  // Updates the no. of killed persons.        cnt++;        cut++;                 // Checks and resolves overflow of Index.        cut = cut % n;                 // Checks the next alive person the        // sword is to be given.        while (arr[cut] == 0)        {          cut++;                     // Checks and resolves overflow          // of Index.          cut = cut % n;        }      }              // Output is the position of the last      // man alive(Index + 1);      return cut + 1;    }     // This code is contributed by decode2207.</script>
13
Please visit set-2: Josephus problem | Set 2 (A Simple Solution when k = 2)
Source: http://en.wikipedia.org/wiki/Josephus_problemPlease write comments if you find anything incorrect, or if you want to share more information about the topic discussed above. 
jit_t
vt_m
Akanksha_Rai
SHUBHAMSINGH10
hritikrommie
sk1122
rameshtravel07
shishankrawt93774
RiteshYadav7
surindertarika1234
qwcllh9fr90rljmmxnhnev0o49esfddve93ojc2o
subham348
divyesh072019
kandelgaurav7
surinderdawra388
umadevi9616
decode2207
harendrakumar123
Walmart
Bit Magic
Mathematical
Recursion
Walmart
Mathematical
Recursion
Bit Magic
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Little and Big Endian Mystery
Bits manipulation (Important tactics)
Binary representation of a given number
Add two numbers without using arithmetic operators
Rotate bits of a number
Program for Fibonacci numbers
Set in C++ Standard Template Library (STL)
Write a program to print all permutations of a given string
C++ Data Types
Operators in C / C++