Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Last Updated : 27 Apr, 2021

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

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :