Lucky alive person in a circle | Set - 2

// Java implementation of the above approach
import java.util.*;

public class Main {

  // Function to convert string to number
  public static int stringToNum(String s)
  {
    // The object has the value 12345 and stream
    // it to the integer x
    int x = Integer.parseInt(s);
    return x;
  }

  // Function to convert binary to decimal
  public static 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 != 0) {
      int last_digit = temp % 10;
      temp = temp / 10;
      dec_value += last_digit * base;
      base = base * 2;
    }
    return dec_value;
  }

  public static String itoa(int num, String str, int base)
  {
    int i = 0;
    boolean isNegative = false;

    /* Handle 0 explicitly, otherwise 
        empty string is printed for 0 */
    if (num == 0) {
      str += '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 += (rem > 9) ? (char)(rem - 10 + 'a')
        : (char)(rem + '0');
      num = num / base;
    }

    // If the number is negative, append '-'
    if (isNegative)
      str += '-';
    StringBuilder sb = new StringBuilder(str);

    // Reverse the string
    sb.reverse();
    return sb.toString();
  }

  public static char flip(char c)
  {
    return (c == '0') ? '1' : '0';
  }

  // Function to find the ones complement
  public static 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.charAt(i));
    return ones;
  }

  // Driver code
  public static void main(String[] args)
  {

    // 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;
    System.out.println(luckiest_person);
  }
}
// This code is contributed by Prajwal Kandekar

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

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

import java.util.*;

public class GFG {
  public static void main(String[] args) {
    int n = 5;
    System.out.println(find(n));
  }

  public static int find(int n) {

    // Obtain number less n in 2's power
    int twospower = (int) Math.pow(2, (int) (Math.log(n) / Math.log(2)));

    // 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;
  }
}