打印步骤以2 ^ X – 1的形式制作数字

给定数字N ，需要执行两个步骤。

1. 在奇数步，对数字与任何2 ^ M-1进行异或，其中M由您选择。
2. 在偶数步中，将数字增加1 。

继续执行这些步骤，直到N变为2 ^ X-1 (其中x可以是任何整数)。任务是打印所有步骤。
例子：

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. 
 

方法：可以按照以下步骤解决上述问题：

• 在每个奇数步处，找到数字中最左边的未设置位(用1个索引表示位置x)，然后对2 ^ x-1进行异或。
• 在每个偶数步，将数字增加1。
• 如果在任何步骤中，该数字都没有更多的未设置位，则返回。

下面是上述方法的实现：

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

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

输出：

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

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。