Print steps to make a number in form of 2^X – 1

Given a number N, there are two steps to be performed. 

1. At odd step, XOR the number with any 2^M-1, where M is chosen by you.
2. At even step, increase the number by 1.

Keep performing the steps until N becomes 2^X-1 (where x can be any integer). The task is to print all the steps. 
Examples:

Input: 39 
Output:
Step1: Xor with 31 
Step2: Increase by 1 
Step3: Xor with 7 
Step4: Increase by 1 
Pick M = 5, N is transformed into 39 ^ 31 = 56. 
Increase N by 1 changing its value to N = 57. 
Pick M = 3, x is transformed into 57 ^ 7 = 62. 
Increase X by 1, changing its value to 63 = 2^6 – 1.
Input: 7 
Output: No steps required. 

Approach: The following steps can be followed to solve the above problem: 

• At every odd step, find the leftmost unset bit (say position x in terms of 1 indexing) in the number and do a xor with 2^x-1.
• At every even step, increase the number by 1.
• If at any step, the number has no more unset bits, then return.

Below is the implementation of the above approach: 

C++

// C++ program to implement
// the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the leftmost
// unset bit in a number.
int find_leftmost_unsetbit(int n)
{
    int ind = -1;
    int i = 1;
    while (n) {
        if (!(n & 1))
            ind = i;

        i++;
        n >>= 1;
    }
    return ind;
}

// Function that perform
// the step
void perform_steps(int n)
{

    // Find the leftmost unset bit
    int left = find_leftmost_unsetbit(n);

    // If the number has no bit
    // unset, it means it is in form 2^x -1
    if (left == -1) {
        cout << "No steps required";
        return;
    }

    // Count the steps
    int step = 1;

    // Iterate till number is of form 2^x - 1
    while (find_leftmost_unsetbit(n) != -1) {

        // At even step increase by 1
        if (step % 2 == 0) {
            n += 1;
            cout << "Step" << step << ": Increase by 1\n";
        }

        // Odd step xor with any 2^m-1
        else {

            // Find the leftmost unset bit
            int m = find_leftmost_unsetbit(n);

            // 2^m-1
            int num = pow(2, m) - 1;

            // Perform the step
            n = n ^ num;

            cout << "Step" << step
                 << ": Xor with " << num << endl;
        }

        // Increase the steps
        step += 1;
    }
}

// Driver code
int main()
{
    int n = 39;
    perform_steps(n);
    return 0;
}

Java

// Java program to implement
// the above approach

class GFG
{

    // Function to find the leftmost
    // unset bit in a number.
    static int find_leftmost_unsetbit(int n)
    {
        int ind = -1;
        int i = 1;
        while (n > 0)
        {
            if ((n % 2) != 1)
            {
                ind = i;
            }

            i++;
            n >>= 1;
        }
        return ind;
    }

    // Function that perform
    // the step
    static void perform_steps(int n)
    {

        // Find the leftmost unset bit
        int left = find_leftmost_unsetbit(n);

        // If the number has no bit
        // unset, it means it is in form 2^x -1
        if (left == -1)
        {
            System.out.print("No steps required");
            return;
        }

        // Count the steps
        int step = 1;

        // Iterate till number is of form 2^x - 1
        while (find_leftmost_unsetbit(n) != -1)
        {

            // At even step increase by 1
            if (step % 2 == 0)
            {
                n += 1;
                System.out.println("Step" + step + ": Increase by 1");
            }

            // Odd step xor with any 2^m-1
            else
            {

                // Find the leftmost unset bit
                int m = find_leftmost_unsetbit(n);

                // 2^m-1
                int num = (int) (Math.pow(2, m) - 1);

                // Perform the step
                n = n ^ num;

                System.out.println("Step" + step
                        + ": Xor with " + num);
            }

            // Increase the steps
            step += 1;
        }
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 39;
        perform_steps(n);
    }
}

// This code contributed by Rajput-Ji

Python3

# Python3 program to implement
# the above approach

# Function to find the leftmost
# unset bit in a number.
def find_leftmost_unsetbit(n):
    ind = -1;
    i = 1;
    while (n):
        if ((n % 2) != 1):
            ind = i;

        i += 1;
        n >>= 1;
    return ind;

# Function that perform
# the step
def perform_steps(n):

    # Find the leftmost unset bit
    left = find_leftmost_unsetbit(n);

    # If the number has no bit
    # unset, it means it is in form 2^x -1
    if (left == -1):
        print("No steps required");
        return;

    # Count the steps
    step = 1;

    # Iterate till number is of form 2^x - 1
    while (find_leftmost_unsetbit(n) != -1):

        # At even step increase by 1
        if (step % 2 == 0):
            n += 1;
            print("Step" , step ,
                  ": Increase by 1\n");

        # Odd step xor with any 2^m-1
        else:

            # Find the leftmost unset bit
            m = find_leftmost_unsetbit(n);

            # 2^m-1
            num = (2**m) - 1;

            # Perform the step
            n = n ^ num;

            print("Step" , step,
                  ": Xor with" , num );

        # Increase the steps
        step += 1;

# Driver code
n = 39;
perform_steps(n);

# This code contributed by PrinciRaj1992

C#

// C# program to implement
// the above approach
using System;

class GFG
{

    // Function to find the leftmost
    // unset bit in a number.
    static int find_leftmost_unsetbit(int n)
    {
        int ind = -1;
        int i = 1;
        while (n > 0)
        {
            if ((n % 2) != 1)
            {
                ind = i;
            }

            i++;
            n >>= 1;
        }
        return ind;
    }

    // Function that perform
    // the step
    static void perform_steps(int n)
    {

        // Find the leftmost unset bit
        int left = find_leftmost_unsetbit(n);

        // If the number has no bit
        // unset, it means it is in form 2^x -1
        if (left == -1)
        {
            Console.Write("No steps required");
            return;
        }

        // Count the steps
        int step = 1;

        // Iterate till number is of form 2^x - 1
        while (find_leftmost_unsetbit(n) != -1)
        {

            // At even step increase by 1
            if (step % 2 == 0)
            {
                n += 1;
                Console.WriteLine("Step" + step + ": Increase by 1");
            }

            // Odd step xor with any 2^m-1
            else
            {

                // Find the leftmost unset bit
                int m = find_leftmost_unsetbit(n);

                // 2^m-1
                int num = (int) (Math.Pow(2, m) - 1);

                // Perform the step
                n = n ^ num;

                Console.WriteLine("Step" + step
                        + ": Xor with " + num);
            }

            // Increase the steps
            step += 1;
        }
    }

    // Driver code
    static public void Main ()
    {
        int n = 39;
        perform_steps(n);
    }
}

// This code contributed by ajit.

PHP

<?php
// Php program to implement
// the above approach

// Function to find the leftmost
// unset bit in a number.
function find_leftmost_unsetbit($n)
{
    $ind = -1;
    $i = 1;
    while ($n)
    {
        if (!($n & 1))
            $ind = $i;

        $i++;
        $n >>= 1;
    }
    return $ind;
}

// Function that perform
// the step
function perform_steps($n)
{

    // Find the leftmost unset bit
    $left = find_leftmost_unsetbit($n);

    // If the number has no bit
    // unset, it means it is in form 2^x -1
    if ($left == -1)
    {
        echo "No steps required";
        return;
    }

    // Count the steps
    $step = 1;

    // Iterate till number is of form 2^x - 1
    while (find_leftmost_unsetbit($n) != -1)
    {

        // At even step increase by 1
        if ($step % 2 == 0)
        {
            $n += 1;
            echo "Step",$step, ": Increase by 1\n";
        }

        // Odd step xor with any 2^m-1
        else
        {

            // Find the leftmost unset bit
            $m = find_leftmost_unsetbit($n);

            // 2^m-1
            $num = pow(2, $m) - 1;

            // Perform the step
            $n = $n ^ $num;

            echo "Step",$step ,": Xor with ", $num ,"\n";
        }

        // Increase the steps
        $step += 1;
    }
}

    // Driver code
    $n = 39;
    perform_steps($n);

    // This code is contributed by Ryuga
?>

Javascript

<script>

// Javascript program to implement
// the above approach

// Function to find the leftmost
// unset bit in a number.
function find_leftmost_unsetbit(n)
{
    let ind = -1;
    let i = 1;
    while (n) {
        if (!(n & 1))
            ind = i;

        i++;
        n >>= 1;
    }
    return ind;
}

// Function that perform
// the step
function perform_steps(n)
{

    // Find the leftmost unset bit
    let left = find_leftmost_unsetbit(n);

    // If the number has no bit
    // unset, it means it is in form 2^x -1
    if (left == -1) {
        document.write("No steps required");
        return;
    }

    // Count the steps
    let step = 1;

    // Iterate till number is of form 2^x - 1
    while (find_leftmost_unsetbit(n) != -1) {

        // At even step increase by 1
        if (step % 2 == 0) {
            n += 1;
            document.write(
            "Step" + step + ": Increase by 1<br>"
            );
        }

        // Odd step xor with any 2^m-1
        else {

            // Find the leftmost unset bit
            let m = find_leftmost_unsetbit(n);

            // 2^m-1
            let num = Math.pow(2, m) - 1;

            // Perform the step
            n = n ^ num;

            document.write("Step" + step
                 + ": Xor with " + num + "<br>");
        }

        // Increase the steps
        step += 1;
    }
}

// Driver code
    let n = 39;
    perform_steps(n);

</script>

Output:

Step1: Xor with 31
Step2: Increase by 1
Step3: Xor with 7
Step4: Increase by 1

Time Complexity: O(logN*logN), as we are using a loop to traverse logN times and in each traversal we are calling the function find_leftmost_unsetbit which costs logN.

Auxiliary Space: O(1), as we are not using any extra space.