Skip to content
Related Articles
Lucky alive person in a circle | Set – 2
• Difficulty Level : Easy
• Last Updated : 06 Jun, 2021

Given that N person (numbered 1 to N) standing as to form a circle. They all have the gun in their hand which is pointed to their leftmost Partner.

Every one shoots such that 1 shoot 2, 3 shoots 4, 5 shoots 6 …. (N-1)the shoot N (if N is even otherwise N shoots 1).
Again on the second iteration, they shoot the rest of remains as above mentioned logic (now for n as even, 1 will shoot to 3, 5 will shoot to 7 and so on).

The task is to find which person is the luckiest(didn’t die)?

Examples

Input: N = 3
Output:
As N = 3 then 1 will shoot 2, 3 will shoot 1 hence 3 is the luckiest person.

Input: N = 8
Output:
Here as N = 8, 1 will shoot 1, 3 will shoot 4, 5 will shoot 6, 7 will shoot 8, Again 1 will shoot 3, 5 will shoot 7, Again 1 will shoot 5 and hence 1 is the luckiest person.

This problem has already been discussed in Lucky alive person in a circle | Code Solution to sword puzzle. In this post, a different approach is discussed.

Approach:

1. Take the Binary Equivalent of N.
2. Find its 1’s compliment and convert its equal decimal number N`.
3. find |N – N`|.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;` `// Function to convert string to number``int` `stringToNum(string s)``{` `    ``// object from the class stringstream``    ``stringstream geek(s);` `    ``// The object has the value 12345 and stream``    ``// it to the integer x``    ``int` `x = 0;``    ``geek >> x;` `    ``return` `x;``}` `// Function to convert binary to decimal``int` `binaryToDecimal(string n)``{``    ``int` `num = stringToNum(n);``    ``int` `dec_value = 0;` `    ``// Initializing base value to 1, i.e 2^0``    ``int` `base = 1;` `    ``int` `temp = num;``    ``while` `(temp) {``        ``int` `last_digit = temp % 10;``        ``temp = temp / 10;` `        ``dec_value += last_digit * base;` `        ``base = base * 2;``    ``}` `    ``return` `dec_value;``}` `string itoa(``int` `num, string str, ``int` `base)``{``    ``int` `i = 0;``    ``bool` `isNegative = ``false``;` `    ``/* Handle 0 explicitly, otherwise``    ``empty string is printed for 0 */``    ``if` `(num == 0) {``        ``str[i++] = ``'0'``;``        ``return` `str;``    ``}` `    ``// In standard itoa(), negative numbers``    ``// are handled only with base 10.``    ``// Otherwise numbers are considered unsigned.``    ``if` `(num < 0 && base == 10) {``        ``isNegative = ``true``;``        ``num = -num;``    ``}` `    ``// Process individual digits``    ``while` `(num != 0) {``        ``int` `rem = num % base;``        ``str[i++] = (rem > 9) ? (rem - 10) + ``'a'` `: rem + ``'0'``;``        ``num = num / base;``    ``}` `    ``// If the number is negative, append '-'``    ``if` `(isNegative)``        ``str[i++] = ``'-'``;` `    ``// Reverse the string``    ``reverse(str.begin(), str.end());` `    ``return` `str;``}` `char` `flip(``char` `c)``{``    ``return` `(c == ``'0'``) ? ``'1'` `: ``'0'``;``}` `// Function to find the ones complement``string onesComplement(string bin)``{``    ``int` `n = bin.length(), i;` `    ``string ones = ``""``;` `    ``// for ones complement flip every bit``    ``for` `(i = 0; i < n; i++)``        ``ones += flip(bin[i]);` `    ``return` `ones;``}` `// Driver code``int` `main()``{``    ``// Taking the number of a person``    ``// standing in a circle.``    ``int` `N = 3;``    ``string arr = ``""``;` `    ``// Storing the binary equivalent in a string.``    ``string ans(itoa(N, arr, 2));` `    ``// taking one's compelement and``    ``// convert it to decimal value``    ``int` `N_dash = binaryToDecimal(onesComplement(ans));` `    ``int` `luckiest_person = N - N_dash;` `    ``cout << luckiest_person;` `    ``return` `0;``}`
Output:
`3`

Alternate Shorter Implementation :
The approach used here is same.

## C++

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;` `int` `luckiest_person(``int` `n)``{``    ``// to calculate the number of bits in``    ``// the binary equivalent of n``    ``int` `len = log2(n) + 1;` `    ``// Finding complement by inverting the``    ``// bits one by one from last``    ``int` `n2 = n;``    ``for` `(``int` `i = 0; i < len; i++) {` `        ``// XOR of n2 with (1<

## Java

 `// Java implementation of the above approach``import` `java.io.*;` `class` `GFG{` `static` `int` `luckiest_person(``int` `n)``{``    ` `    ``// To calculate the number of bits in``    ``// the binary equivalent of n``    ``int` `len = (``int``)(Math.log(n) / Math.log(``2``)) + ``1``;` `    ``// Finding complement by inverting the``    ``// bits one by one from last``    ``int` `n2 = n;``    ``for``(``int` `i = ``0``; i < len; i++)``    ``{``        ` `        ``// XOR of n2 with (1<
Output:
`3`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up