Algorithm 求两个值为2的整数之间的异或值

给定一个由N个整数组成的数组。能找到号码吗

---

（a[i]，a[j]）对，使得该问题的有效解可以是时间复杂度

O（n）

。这个想法基于这样一个事实：

arr[i]^arr[j]

等于

2

当且仅当

arr[i]^2

等于

arr[j]

1) Initialize result as 0.
2) Create an empty hash set "s".
3) Do following for each element arr[i] in arr[]
   (a)    If 2 ^ arr[i] is in "s", then increment result by 1.
   (b)    Insert arr[i] into the hash set "s".
3) return result.

这里是C++实现：

int xorPairCount(vector<int>& arr) {
    int n= (int)arr.size();
    int result = 0;

    unordered_set<int> s;

    for (int i = 0; i < n ; i++) {
        // If there exist an element in set s
        // with XOR equals to 2^arr[i], that means
        // there exist an element such that the
        // XOR of element with arr[i] is equal to
        // 2, then increment count.
        if (s.find(2^arr[i]) != s.end())
            result++;

        // Make element visited
        s.insert(arr[i]);
    }

    return result;
}

int xorPairCount（向量和arr）{
int n=（int）arr.size（）；
int结果=0；
无序的集合；
对于（int i=0；i

注意，对于这个解决方案，我假设数组中没有重复项。如果允许复制，那么解决方案将有所不同。让我知道

更新 如果数组中存在重复项，请使用hashmap而不是hashset来计算每个数字的频率，因为对于每次出现，将有一个计数。以下是上述代码的更新：

int xorPairCount(vector<int>& arr) {
    int n= (int)arr.size();
    int result = 0;

    unordered_map<int, int> m;

    for (int i = 0; i < n ; i++) {
        int curr_xor =  2^arr[i];
        if (m.find(curr_xor) != m.end())
            result += m[curr_xor];

        m[arr[i]]++;
    }

    return result;
}

int xorPairCount（向量和arr）{
int n=（int）arr.size（）；
int结果=0；
无序地图m；
对于（int i=0；i
这个问题的有效解决方案可以是时间复杂度
O（n）
。这个想法基于这样一个事实：
arr[i]^arr[j]
等于
2
当且仅当
arr[i]^2
等于
arr[j]

1) Initialize result as 0.
2) Create an empty hash set "s".
3) Do following for each element arr[i] in arr[]
   (a)    If 2 ^ arr[i] is in "s", then increment result by 1.
   (b)    Insert arr[i] into the hash set "s".
3) return result.

这里是C++实现：
int xorPairCount(vector<int>& arr) {
    int n= (int)arr.size();
    int result = 0;

    unordered_set<int> s;

    for (int i = 0; i < n ; i++) {
        // If there exist an element in set s
        // with XOR equals to 2^arr[i], that means
        // there exist an element such that the
        // XOR of element with arr[i] is equal to
        // 2, then increment count.
        if (s.find(2^arr[i]) != s.end())
            result++;

        // Make element visited
        s.insert(arr[i]);
    }

    return result;
}

int xorPairCount（向量和arr）{
int n=（int）arr.size（）；
int结果=0；
无序的集合；
对于（int i=0；i

注意，对于这个解决方案，我假设数组中没有重复项。如果允许复制，那么解决方案将有所不同。让我知道

更新
如果数组中存在重复项，请使用hashmap而不是hashset来计算每个数字的频率，因为对于每次出现，将有一个计数。以下是上述代码的更新：

int xorPairCount(vector<int>& arr) {
    int n= (int)arr.size();
    int result = 0;

    unordered_map<int, int> m;

    for (int i = 0; i < n ; i++) {
        int curr_xor =  2^arr[i];
        if (m.find(curr_xor) != m.end())
            result += m[curr_xor];

        m[arr[i]]++;
    }

    return result;
}

int xorPairCount（向量和arr）{
int n=（int）arr.size（）；
int结果=0；
无序地图m；
对于（int i=0；i
@alvits请避免讽刺，最好教OP如何提出一个好问题。@Ripi2-诚实的评论中的讽刺在哪里？这个问题是在我发表评论后编辑的。下面的答案与我的评论一致。@alvits“使用评论来询问更多信息或提出改进建议。”（和此评论）@alvits请避免讽刺，最好教OP如何提出一个好问题。@Ripi2-诚实的评论中的讽刺在哪里？这个问题是在我发表评论后编辑的。下面的答案与我的评论一致。@alvits“使用评论询问更多信息或提出改进建议。”（和此评论）非常感谢提供解决方案。非常感谢提供解决方案。