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

📌 相关文章

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

📅 最后修改于: 2021-05-06 22:50:07 🧑 作者: Mango

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

在奇数步，对数字与任何2 ^ M-1进行异或，其中M由您选择。
在偶数步中，将数字增加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
?>

输出：

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