Skip to content
Related Articles

Related Articles

Lucky alive person in a circle | Set – 2

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Easy
  • Last Updated : 15 Jun, 2022

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 <bits/stdc++.h>
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 <bits/stdc++.h>
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<<i) to flip
        // the last (i+1)th bit of binary equivalent of n2
        n2 = n2 ^ (1 << i);
    }
 
    // n2 will be the one's complement of n
    return abs(n - n2);
}
int main()
{
    int N = 3;
    int lucky_p = luckiest_person(N);
    cout << lucky_p;
 
    return 0;
}

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<<i) to flip the last
            // (i+1)th bit of binary equivalent of n2
            n2 = n2 ^ (1 << i);
        }
 
        // n2 will be the one's complement of n
        return Math.abs(n - n2);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int N = 3;
        int lucky_p = luckiest_person(N);
 
        System.out.println(lucky_p);
    }
}
 
// This code is contributed by rishavmahato348

Python3




# Python3 implementation of the above approach
import math
 
def luckiest_person(n):
 
    # to calculate the number of bits in
    # the binary equivalent of n
    len_ = int(math.log(n, 2)) + 1
 
    # Finding complement by inverting the
    # bits one by one from last
    n2 = n
    for i in range(len_):
 
        # XOR of n2 with (1<<i) to flip
        # the last (i+1)th bit of binary equivalent of n2
        n2 = n2 ^ (1 << i)
 
    # n2 will be the one's complement of n
    return abs(n - n2)
 
# Driver Code
N = 3
lucky_p = luckiest_person(N)
print(lucky_p)
 
# this code is contributed by phasing17

C#




// C# implementation of the above approach
using System;
 
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<<i) to flip the last
            // (i+1)th bit of binary equivalent of n2
            n2 = n2 ^ (1 << i);
        }
 
        // n2 will be the one's complement of n
        return Math.Abs(n - n2);
    }
 
    // Driver code
    public static void Main()
    {
        int N = 3;
        int lucky_p = luckiest_person(N);
 
        Console.Write(lucky_p);
    }
}
 
// This code is contributed by subhammahato348

Javascript




<script>
 
// JavaScript implementation of the above approach
 
function luckiest_person(n)
{
    // to calculate the number of bits in
    // the binary equivalent of n
    let len = parseInt(Math.log(n) / Math.log(2)) + 1;
 
    // Finding complement by inverting the
    // bits one by one from last
    let n2 = n;
    for (let i = 0; i < len; i++) {
 
        // XOR of n2 with (1<<i) to flip
        // the last (i+1)th bit of binary equivalent of n2
        n2 = n2 ^ (1 << i);
    }
 
    // n2 will be the one's complement of n
    return Math.abs(n - n2);
}
 
// Driver Code
    let N = 3;
    let lucky_p = luckiest_person(N);
    document.write(lucky_p);
 
</script>

Output

3

Alternate Implementation in O(1) : The approach used here is same, but the operations used are of constant time.

C++




// Here is a O(1) solution for this problem
// it will work for 32 bit integers]
#include <bits/stdc++.h>
using namespace std;
 
// function to find the highest power of 2
// which is less than n
int setBitNumber(int n)
{
    // Below steps set bits after
    // MSB (including MSB)
 
    // Suppose n is 273 (binary
    // is 100010001). It does following
    // 100010001 | 010001000 = 110011001
    n |= n >> 1;
 
    // This makes sure 4 bits
    // (From MSB and including MSB)
    // are set. It does following
    // 110011001 | 001100110 = 111111111
    n |= n >> 2;
 
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
 
    // Increment n by 1 so that
    // there is only one set bit
    // which is just before original
    // MSB. n now becomes 1000000000
    n = n + 1;
 
    // Return original MSB after shifting.
    // n now becomes 100000000
    return (n >> 1);
}
 
int luckiest_person(int n)
{
    // to calculate the highest number which
    // is power of 2 and less than n
    int nearestPower = setBitNumber(n);
 
    // return the correct answer as per the
    // approach in above article
    return 2 * (n - nearestPower) + 1;
}
int main()
{
    int N = 8;
    int lucky_p = luckiest_person(N);
    cout << lucky_p;
    return 0;
}
 
// This code is contributed by Ujesh Maurya

Java




/*package whatever //do not write package name here */
 
import java.io.*;
 
// Here is a O(1) solution for this problem
// it will work for 32 bit integers]
class GFG {
    static int setBitNumber(int n)
    {
 
        // Below steps set bits after
        // MSB (including MSB)
 
        // Suppose n is 273 (binary
        // is 100010001). It does following
        // 100010001 | 010001000 = 110011001
        n |= n >> 1;
 
        // This makes sure 4 bits
        // (From MSB and including MSB)
        // are set. It does following
        // 110011001 | 001100110 = 111111111
        n |= n >> 2;
 
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;
 
        // Increment n by 1 so that
        // there is only one set bit
        // which is just before original
        // MSB. n now becomes 1000000000
        n = n + 1;
 
        // Return original MSB after shifting.
        // n now becomes 100000000
        return (n >> 1);
    }
 
    static int luckiest_person(int n)
    {
        // to calculate the highest number which
        // is power of 2 and less than n
        int nearestPower = setBitNumber(n);
 
        // return the correct answer as per the
        // approach in above article
        return 2 * (n - nearestPower) + 1;
    }
   
    // Driver Code
    public static void main(String[] args)
    {
        int N = 8;
        int lucky_p = luckiest_person(N);
 
        System.out.print(lucky_p);
    }
}
 
// This code is contributed by Ujesh Maurya

C#




// Here is a O(1) solution for this problem
// it will work for 32 bit integers]
using System;
 
class GFG {
 
    // function to find the highest power of 2
    // which is less than n
    static int setBitNumber(int n)
    {
        // Below steps set bits after
        // MSB (including MSB)
 
        // Suppose n is 273 (binary
        // is 100010001). It does following
        // 100010001 | 010001000 = 110011001
        n |= n >> 1;
 
        // This makes sure 4 bits
        // (From MSB and including MSB)
        // are set. It does following
        // 110011001 | 001100110 = 111111111
        n |= n >> 2;
 
        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;
 
        // Increment n by 1 so that
        // there is only one set bit
        // which is just before original
        // MSB. n now becomes 1000000000
        n = n + 1;
 
        // Return original MSB after shifting.
        // n now becomes 100000000
        return (n >> 1);
    }
 
    static int luckiest_person(int n)
    {
 
        // to calculate the highest number which
        // is power of 2 and less than n
        int nearestPower = setBitNumber(n);
 
        // return the correct answer as per the
        // approach in above article
        return 2 * (n - nearestPower) + 1;
    }
 
    // Driver code
    public static void Main()
    {
        int N = 8;
        int lucky_p = luckiest_person(N);
 
        Console.Write(lucky_p);
    }
}
 
// This code is contributed by Ujesh Maurya

Javascript




<script>
// Javascript program for the above approach
 
// Here is a O(1) solution for this problem
// it will work for 32 bit integers]
function setBitNumber(n) {
 
    // Below steps set bits after
    // MSB (including MSB)
 
    // Suppose n is 273 (binary
    // is 100010001). It does following
    // 100010001 | 010001000 = 110011001
    n |= n >> 1;
 
    // This makes sure 4 bits
    // (From MSB and including MSB)
    // are set. It does following
    // 110011001 | 001100110 = 111111111
    n |= n >> 2;
 
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
 
    // Increment n by 1 so that
    // there is only one set bit
    // which is just before original
    // MSB. n now becomes 1000000000
    n = n + 1;
 
    // Return original MSB after shifting.
    // n now becomes 100000000
    return (n >> 1);
}
 
function luckiest_person(n) {
    // to calculate the highest number which
    // is power of 2 and less than n
    let nearestPower = setBitNumber(n);
 
    // return the correct answer as per the
    // approach in above article
    return 2 * (n - nearestPower) + 1;
}
 
// Driver Code
let N = 8;
let lucky_p = luckiest_person(N);
 
document.write(lucky_p);
 
// This code is contributed by Saurabh Jaiswal
</script>

Output

1

Another approach in O(1) : On the basis of the pattern that forms in given question, which is displayed in following table.

n 1 23 4567 89101112131415 16
  1 13 1357 13579111315 1

C++




#include <bits/stdc++.h>
#include <iostream>
using namespace std;
 
// Driven code
int find(int n)
{
    // Obtain number less n in 2's power
    int twospower = pow(2, (int)log2(n));
 
    // Find p-position of odd number, in odd series
    int diff = n - twospower + 1;
 
    // Value of pth odd number
    int diffthodd = (2 * diff) - 1;
 
    return diffthodd;
}
// Driver code
int main()
{
    int n = 5;
    cout << find(n);
    return 0;
}
 
// This code is contributed by Dharmik Parmar

Output

3


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!