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

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

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

My Personal Notes arrow_drop_up