📌  相关文章
📜  每个数组元素与所有其他数组元素的按位XOR的总和

📅  最后修改于: 2021-05-07 01:14:12             🧑  作者: Mango

给定长度为N的数组arr [] ,每个数组元素的任务是将其按位XOR与所有其他数组元素的和打印出来。

例子:

天真的方法:这个想法是遍历数组,对于每个数组元素,遍历数组,并计算其按位XOR与所有其他数组元素的总和。

时间复杂度: O(N 2 )
辅助空间: O(N)

高效的方法:为了优化上述方法,其思想是使用按位异或的属性,即异或在xor上给出相似的位,否则给出01 。请按照以下步骤解决问题:

  • 计算频率数组中数组所有元素在位置i0 <= i <= 32处的设置位的频率。
  • 对于数组中的每个元素X ,通过运行从i = 0到32的循环来计算xor之和,并检查X的i位是否已设置。
    • 如果是,则将(N – frequency [i])* 2 i加到xor之和,因为X在此位置的置位将使所有置位为零,所有未置位为1
    • 否则,将频率[i] * 2 i添加到异或和。
  • 计算数组每个元素的所有xor之和,然后返回答案。

下面是上述方法的实现:

C++
// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to calculate for each array
// element, sum of its Bitwise XOR with
// all other array elements
void XOR_for_every_i(int A[], int N)
{
    // Declare an array of size 64
    // to store count of each bit
    int frequency_of_bits[32]{};
 
    // Traversing the array
    for (int i = 0; i < N; i++) {
 
        int bit_position = 0;
        int M = A[i];
 
        while (M) {
 
            // Check if bit is present of not
            if (M & 1) {
                frequency_of_bits[bit_position] += 1;
            }
 
            // Increase the bit position
            bit_position += 1;
 
            // Reduce the number to half
            M >>= 1;
        }
    }
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
        int M = A[i];
 
        // Stores the bit position
        int value_at_that_bit = 1;
 
        // Stores the sum of Bitwise XOR
        int XOR_sum = 0;
 
        for (int bit_position = 0;
             bit_position < 32;
             bit_position++) {
 
            // Check if bit is present of not
            if (M & 1) {
                XOR_sum
                    += (N
                        - frequency_of_bits[bit_position])
                       * value_at_that_bit;
            }
            else {
                XOR_sum
                    += (frequency_of_bits[bit_position])
                       * value_at_that_bit;
            }
 
            // Reduce the number to its half
            M >>= 1;
 
            value_at_that_bit <<= 1;
        }
 
        // Print the sum for A[i]
        cout << XOR_sum << ' ';
    }
 
    return;
}
 
// Driver Code
int main()
{
 
    // Given array
    int A[] = { 1, 2, 3 };
 
    // Given N
    int N = sizeof(A) / sizeof(A[0]);
 
    // Function Call
    XOR_for_every_i(A, N);
 
    return 0;
}


Java
// Java program for the above approach
import java.util.*;
  
class GFG{
      
// Function to calculate for each array
// element, sum of its Bitwise XOR with
// all other array elements
static void XOR_for_every_i(int A[], int N)
{
     
    // Declare an array of size 64
    // to store count of each bit
    int frequency_of_bits[] = new int[32];
  
    // Traversing the array
    for(int i = 0; i < N; i++)
    {
        int bit_position = 0;
        int M = A[i];
  
        while (M != 0)
        {
             
            // Check if bit is present of not
            if ((M & 1) != 0)
            {
                frequency_of_bits[bit_position] += 1;
            }
  
            // Increase the bit position
            bit_position += 1;
  
            // Reduce the number to half
            M >>= 1;
        }
    }
  
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
        int M = A[i];
  
        // Stores the bit position
        int value_at_that_bit = 1;
  
        // Stores the sum of Bitwise XOR
        int XOR_sum = 0;
  
        for(int bit_position = 0;
                bit_position < 32;
                bit_position++)
        {
             
            // Check if bit is present of not
            if ((M & 1) != 0)
            {
                XOR_sum += (N -
                            frequency_of_bits[bit_position]) *
                            value_at_that_bit;
            }
            else
            {
                XOR_sum += (frequency_of_bits[bit_position]) *
                            value_at_that_bit;
            }
  
            // Reduce the number to its half
            M >>= 1;
  
            value_at_that_bit <<= 1;
        }
  
        // Print the sum for A[i]
        System.out.print( XOR_sum + " ");
    }
    return;
}
  
// Driver code
public static void main(String[] args)
{
     
    // Given array
    int A[] = { 1, 2, 3 };
  
    // Given N
    int N = A.length;
  
    // Function Call
    XOR_for_every_i(A, N);
}
}
 
// This code is contributed by susmitakundugoaldanga


Python3
# Python3 program for the above approach
  
# Function to calculate for each array
# element, sum of its Bitwise XOR with
# all other array elements
def XOR_for_every_i(A, N):
     
    # Declare an array of size 64
    # to store count of each bit
    frequency_of_bits = [0] * 32
  
    # Traversing the array
    for i in range(N):
        bit_position = 0
        M = A[i]
  
        while (M):
             
            # Check if bit is present of not
            if (M & 1 != 0):
                frequency_of_bits[bit_position] += 1
  
            # Increase the bit position
            bit_position += 1
  
            # Reduce the number to half
            M >>= 1
     
    # Traverse the array
    for i in range(N):
        M = A[i]
  
        # Stores the bit position
        value_at_that_bit = 1
  
        # Stores the sum of Bitwise XOR
        XOR_sum = 0
  
        for bit_position in range(32):
  
            # Check if bit is present of not
            if (M & 1 != 0):
                XOR_sum += ((N - frequency_of_bits[bit_position]) *
                            value_at_that_bit)
             
            else:
                XOR_sum += ((frequency_of_bits[bit_position]) *
                            value_at_that_bit)
             
            # Reduce the number to its half
            M >>= 1
  
            value_at_that_bit <<= 1
  
        # Print the sum for A[i]
        print(XOR_sum, end = " ")
     
    return
 
# Driver Code
 
# Given arr1[]
A = [ 1, 2, 3 ]
 
# Size of N
N = len(A)
  
# Function Call
XOR_for_every_i(A, N)
 
# This code is contributed by code_hunt


C#
// C# program for the above approach
using System;
class GFG
{
      
// Function to calculate for each array
// element, sum of its Bitwise XOR with
// all other array elements
static void XOR_for_every_i(int[] A, int N)
{
      
    // Declare an array of size 64
    // to store count of each bit
    int[] frequency_of_bits = new int[32];
   
    // Traversing the array
    for(int i = 0; i < N; i++)
    {
        int bit_position = 0;
        int M = A[i];
   
        while (M != 0)
        {
              
            // Check if bit is present of not
            if ((M & 1) != 0)
            {
                frequency_of_bits[bit_position] += 1;
            }
   
            // Increase the bit position
            bit_position += 1;
   
            // Reduce the number to half
            M >>= 1;
        }
    }
   
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
        int M = A[i];
   
        // Stores the bit position
        int value_at_that_bit = 1;
   
        // Stores the sum of Bitwise XOR
        int XOR_sum = 0;
   
        for(int bit_position = 0;
                bit_position < 32;
                bit_position++)
        {
              
            // Check if bit is present of not
            if ((M & 1) != 0)
            {
                XOR_sum += (N -
                            frequency_of_bits[bit_position]) *
                            value_at_that_bit;
            }
            else
            {
                XOR_sum += (frequency_of_bits[bit_position]) *
                            value_at_that_bit;
            }
   
            // Reduce the number to its half
            M >>= 1; 
            value_at_that_bit <<= 1;
        }
   
        // Print the sum for A[i]
        Console.Write( XOR_sum + " ");
    }
    return;
}
  
// Driver Code
public static void Main()
{
   
    // Given array
    int[] A = { 1, 2, 3 };
   
    // Given N
    int N = A.Length;
   
    // Function Call
    XOR_for_every_i(A, N);
}
}
 
// This code is contributed by sanjoy_62


Javascript


输出:
5 4 3

时间复杂度: O(N)
辅助空间: O(N)