X 和 Y 的 X 和 Y 的按位 XOR 的不同值的计数，最多为 N

给定一个整数N ，任务是找到X和Y的按位异或可能的不同值的数量，其中1 ≤ X，Y ≤ N。

例子：

Input: N = 1
Output: 1
Explanation: The possible xor values are 1⊕1=0 which has 1 unique value.

Input: N = 2
Output: 2
Explanation: The possible xor values are 1⊕1 = 0, 1⊕2 = 1, 2⊕2 = 0 which has 2 unique values.

编程需要懂一点英语

方法：对于N的值等于1和2 ，答案很简单。对于其余情况，考虑N≥3。将p视为2^p ≤ N的最大幂。假设2^p < N ，则可以得到从0到2^{p+1} -1的所有数。这可以通过以下方式实现：

For example,
let N = 12, then x = 3.
Number 12 (1100 in binary ) can be formed by (2^3(1000), 4(0100)).
By the property of xor, num⊕1 is either num +1 or num -1.
So if 1 < num ≤ 2^p < N, 1 ≤ num⊕1 ≤ N.
Hence these pairs of numbers will always be valid.

编程需要懂一点英语

现在，如果2^p = N 会发生什么？除num = 2^p 的情况外，上述所有情况均成立。这不能从(1 ≤ X, Y ≤ 2^p)的任何 xor 对(X, Y)获得。由于唯一设置了位p的数字是2^p ，我们必须保持i = 2^p 。那么对于X ⊕ Y=2*p，保持Y = 0 ，因为Y ≥ 1不能做到。因此，在这种情况下，除了2^p之外，可以获得从0到2^{p + 1} -1的任何数字的异或对。请按照以下步骤解决问题：

将变量ans初始化为1。
如果N等于2 ，则打印2并返回。
在 while 循环中遍历直到ans小于N并将ans乘以2。
如果ans等于N则将ans乘以2并将其值减1。
执行上述步骤后，打印ans的值作为答案。

下面是上述方法的实现。

C++

// C++ program for the above approach
#include 
using namespace std;
int MOD = 1e9 + 7;
 
// Function to find the possible values
void find(long long N)
{
    long long ans = 1;
 
    // Special case
    if (N == 2) {
        cout << 2 << endl;
        return;
    }
 
    while (ans < N) {
        ans *= 2;
    }
 
    if (ans == N) {
        ans *= 2;
        ans--;
    }
 
    cout << ans % MOD;
}
 
// Driver Code
int main()
{
    long long N = 7;
    find(N);
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
  // Function to find the possible values
  static void find(long N)
  {
    long MOD = 1000000007;
    long ans = 1;
 
    // Special case
    if (N == 2) {
      System.out.println("2");
      return;
    }
 
    while (ans < N) {
      ans *= 2;
    }
 
    if (ans == N) {
      ans *= 2;
      ans--;
    }
    long temp = ans % MOD;
    System.out.print(temp);
  }
 
  // Driver Code
  public static void main (String[] args) {
    long N = 7;
    find(N);
  }
}
 
// This code is contributed by hrithikgarg03188.

Python

# Python program for the above approach
 
# Function to find the possible values
def find(N):
   
    MOD = 1000000007
    ans = 1
 
    # Special case
    if (N == 2):
        print(2)
        return;
 
    while ans < N:
        ans *= 2
     
 
    if (ans == N):
        ans *= 2
        ans -= 1
 
    print(ans % MOD)
 
if __name__ == "__main__":
 
    N = 7
    find(N)
    
  # This code is contributed by hrithikgarg03188.

C#

// C# program to implement
// the above approach
using System;
class GFG
{
 
// Function to find the possible values
  static void find(long N)
  {
    long MOD = 1000000007;
    long ans = 1;
 
    // Special case
    if (N == 2) {
      Console.WriteLine("2");
      return;
    }
 
    while (ans < N) {
      ans *= 2;
    }
 
    if (ans == N) {
      ans *= 2;
      ans--;
    }
    long temp = ans % MOD;
    Console.Write(temp);
  }
 
// Driver Code
public static void Main()
{
    long N = 7;
    find(N);
}
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript

输出

时间复杂度： O(log(N))
辅助空间： O(1)