Skip to content
Related Articles

Related Articles

Improve Article

Lucky alive person in a circle | Set – 2

  • Difficulty Level : Easy
  • Last Updated : 01 Sep, 2021
Geek Week

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

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

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

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
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

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :