将给定的整数X转换为2 ^ N – 1的形式

给定整数x 。任务是通过在x上以指定顺序执行以下操作，将x转换为2 ⁿ – 1形式：

1. 您可以选择任何非负整数n并更新x = x xor(2 ⁿ – 1)
2. 将x替换为x + 1 。

所应用的第一个操作必须是第一种类型，第二个必须是第二种类型，第三个又是第一种类型，依此类推。形式上，如果我们按执行顺序从一个操作开始编号，则奇数操作必须是第一种类型，偶数操作必须是第二种类型。任务是找到将x转换为2 ⁿ – 1形式所需的操作数。

例子：

Input: x = 39
Output: 4
Operation 1: Pick n = 5, x is transformed into (39 xor 31) = 56.
Operation 2: x = 56 + 1 = 57
Operation 3: Pick n = 3, x is transformed into (57 xor 7) = 62.
Operation 4: x = 62 + 1 = 63 i.e. (2⁶ – 1).
So, total number of operations are 4.

Input: x = 7
Output: 0
As 2³ -1 = 7.
So, no operation is required.

方法：取大于x的最小数字，其形式为2 ⁿ – 1表示num ，然后更新x = x x或num ，然后x = x + 1执行两次运算。重复该步骤，直到x的形式为2 ⁿ – 1 。最后打印执行的操作数。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
const int MAX = 24;
  
// Function to return the count
// of operations required
int countOp(int x)
{
  
    // To store the powers of 2
    int arr[MAX];
    arr[0] = 1;
    for (int i = 1; i < MAX; i++)
        arr[i] = arr[i - 1] * 2;
  
    // Temporary variable to store x
    int temp = x;
  
    bool flag = true;
  
    // To store the index of
    // smaller number larger than x
    int ans;
  
    // To store the count of operations
    int operations = 0;
  
    bool flag2 = false;
  
    for (int i = 0; i < MAX; i++) {
  
        if (arr[i] - 1 == x)
            flag2 = true;
  
        // Stores the index of number
        // in the form of 2^n - 1
        if (arr[i] > x) {
            ans = i;
            break;
        }
    }
  
    // If x is already in the form
    // 2^n - 1 then no operation is required
    if (flag2)
        return 0;
  
    while (flag) {
  
        // If number is less than x increase the index
        if (arr[ans] < x)
            ans++;
  
        operations++;
  
        // Calculate all the values (x xor 2^n-1)
        // for all possible n
        for (int i = 0; i < MAX; i++) {
            int take = x ^ (arr[i] - 1);
            if (take <= arr[ans] - 1) {
  
                // Only take value which is
                // closer to the number
                if (take > temp)
                    temp = take;
            }
        }
  
        // If number is in the form of 2^n - 1 then break
        if (temp == arr[ans] - 1) {
            flag = false;
            break;
        }
  
        temp++;
        operations++;
        x = temp;
  
        if (x == arr[ans] - 1)
            flag = false;
    }
  
    // Return the count of operations
    // required to obtain the number
    return operations;
}
  
// Driver code
int main()
{
    int x = 39;
  
    cout << countOp(x);
  
    return 0;
}

Java

// Java implementation of the approach
import java.io.*;
  
class GFG
{
  
static int MAX = 24;
  
// Function to return the count
// of operations required
static int countOp(int x)
{
  
    // To store the powers of 2
    int arr[] = new int[MAX];
    arr[0] = 1;
    for (int i = 1; i < MAX; i++)
        arr[i] = arr[i - 1] * 2;
  
    // Temporary variable to store x
    int temp = x;
  
    boolean flag = true;
  
    // To store the index of
    // smaller number larger than x
    int ans =0;
  
    // To store the count of operations
    int operations = 0;
  
    boolean flag2 = false;
  
    for (int i = 0; i < MAX; i++) 
    {
  
        if (arr[i] - 1 == x)
            flag2 = true;
  
        // Stores the index of number
        // in the form of 2^n - 1
        if (arr[i] > x) 
        {
            ans = i;
            break;
        }
    }
  
    // If x is already in the form
    // 2^n - 1 then no operation is required
    if (flag2)
        return 0;
  
    while (flag) 
    {
  
        // If number is less than x increase the index
        if (arr[ans] < x)
            ans++;
  
        operations++;
  
        // Calculate all the values (x xor 2^n-1)
        // for all possible n
        for (int i = 0; i < MAX; i++) 
        {
            int take = x ^ (arr[i] - 1);
            if (take <= arr[ans] - 1) 
            {
  
                // Only take value which is
                // closer to the number
                if (take > temp)
                    temp = take;
            }
        }
  
        // If number is in the form of 2^n - 1 then break
        if (temp == arr[ans] - 1) 
        {
            flag = false;
            break;
        }
  
        temp++;
        operations++;
        x = temp;
  
        if (x == arr[ans] - 1)
            flag = false;
    }
  
    // Return the count of operations
    // required to obtain the number
    return operations;
}
  
    // Driver code
    public static void main (String[] args) 
    {
        int x = 39;
        System.out.println(countOp(x));
    }
}
  
// This code is contributed by anuj_67..

Python3

# Python3 implementation of the approach 
  
MAX = 24; 
  
# Function to return the count 
# of operations required 
def countOp(x) : 
  
    # To store the powers of 2 
    arr = [0]*MAX ; 
    arr[0] = 1; 
    for i in range(1, MAX) : 
        arr[i] = arr[i - 1] * 2; 
  
    # Temporary variable to store x 
    temp = x; 
  
    flag = True; 
  
    # To store the index of 
    # smaller number larger than x 
    ans = 0; 
  
    # To store the count of operations 
    operations = 0; 
  
    flag2 = False; 
  
    for i in range(MAX) :
  
        if (arr[i] - 1 == x) :
            flag2 = True; 
  
        # Stores the index of number 
        # in the form of 2^n - 1 
        if (arr[i] > x) :
            ans = i; 
            break; 
      
    # If x is already in the form 
    # 2^n - 1 then no operation is required 
    if (flag2) :
        return 0; 
  
    while (flag) : 
  
        # If number is less than x increase the index 
        if (arr[ans] < x) :
            ans += 1; 
  
        operations += 1; 
  
        # Calculate all the values (x xor 2^n-1) 
        # for all possible n 
        for i in range(MAX) :
            take = x ^ (arr[i] - 1); 
              
            if (take <= arr[ans] - 1) :
  
                # Only take value which is 
                # closer to the number 
                if (take > temp) :
                    temp = take; 
  
        # If number is in the form of 2^n - 1 then break 
        if (temp == arr[ans] - 1) : 
            flag = False; 
            break; 
  
        temp += 1; 
        operations += 1; 
        x = temp; 
  
        if (x == arr[ans] - 1) :
            flag = False; 
  
    # Return the count of operations 
    # required to obtain the number 
    return operations; 
  
  
# Driver code 
if __name__ == "__main__" : 
  
    x = 39; 
  
    print(countOp(x)); 
  
    # This code is contributed by AnkitRai01

C#

// C# implementation of the approach
using System;
  
class GFG
{
      
static int MAX = 24;
  
// Function to return the count
// of operations required
static int countOp(int x)
{
  
    // To store the powers of 2
    int []arr = new int[MAX];
    arr[0] = 1;
    for (int i = 1; i < MAX; i++)
        arr[i] = arr[i - 1] * 2;
  
    // Temporary variable to store x
    int temp = x;
  
    bool flag = true;
  
    // To store the index of
    // smaller number larger than x
    int ans = 0;
  
    // To store the count of operations
    int operations = 0;
  
    bool flag2 = false;
  
    for (int i = 0; i < MAX; i++) 
    {
  
        if (arr[i] - 1 == x)
            flag2 = true;
  
        // Stores the index of number
        // in the form of 2^n - 1
        if (arr[i] > x) 
        {
            ans = i;
            break;
        }
    }
  
    // If x is already in the form
    // 2^n - 1 then no operation is required
    if (flag2)
        return 0;
  
    while (flag) 
    {
  
        // If number is less than x increase the index
        if (arr[ans] < x)
            ans++;
  
        operations++;
  
        // Calculate all the values (x xor 2^n-1)
        // for all possible n
        for (int i = 0; i < MAX; i++) 
        {
            int take = x ^ (arr[i] - 1);
            if (take <= arr[ans] - 1) 
            {
  
                // Only take value which is
                // closer to the number
                if (take > temp)
                    temp = take;
            }
        }
  
        // If number is in the form of 2^n - 1 then break
        if (temp == arr[ans] - 1) 
        {
            flag = false;
            break;
        }
  
        temp++;
        operations++;
        x = temp;
  
        if (x == arr[ans] - 1)
            flag = false;
    }
  
    // Return the count of operations
    // required to obtain the number
    return operations;
}
  
// Driver code
static public void Main ()
{
      
    int x = 39;
    Console.WriteLine(countOp(x));
}
}
  
// This code is contributed by ajit.

输出：

4