Sum of Bitwise OR of each array element of an array with all elements of another array

• Last Updated : 10 Jun, 2021

Given two arrays arr1[] of size M and arr2[] of size N, the task is to find the sum of bitwise OR of each element of arr1[] with every element of the array arr2[].

Examples:

Input: arr1[] = {1, 2, 3}, arr2[] = {1, 2, 3}, M = 3, N = 3
Output: 7 8 9
Explanation:
For arr: Sum = arr1|arr2 + arr1|arr2 + arr1|arr2, Sum = 1|1 + 1|2 + 1|3 = 7
For arr, Sum = arr1|arr2 + arr1|arr2 + arr1|arr2, Sum= 2|1 + 2|2 + 2|3 = 8
For arr, Sum = arr1|arr2 + arr1|arr2 + arr1|arr2, Sum = 3|1 + 3|2 + 3|3 = 9

Input: arr1[] = {2, 4, 8, 16}, arr2[] = {2, 4, 8, 16}, M = 4, N = 4
Output: 36 42 54 78

Naive Approach: The simplest0 approach to solve this problem to traverse the array arr1[] and for each array element in the array arr[], calculate Bitwise OR of each element in the array arr2[]

Time Complexity: O(N2)
Auxiliary Space: O(N)

Efficient Approach: To optimize the above approach, the idea is to use Bit Manipulation to solve the above problem.

• According to the Bitwise OR property, while performing the operation, the ith bit will be set bit only when either of both numbers has a set bit at the ith position, where 0 ≤ i <32.
• Therefore, for a number in arr1[], if the ith bit is not a set bit, then the ith place will contribute a sum of K * 2i , where K is the total number in arr2[] having set bit at the ith position.
• Otherwise, if the number has a set bit at the ith place, then it will contribute a sum of N * 2i.

Follow the steps below to solve the problem:

1. Initialize an integer array, say frequency[], to store the count of numbers in arr2[] having set-bit at ith position ( 0 ≤ i < 32).
2. Traverse the array arr2[] and represent each array element in its binary form and increment the count in the frequency[] array by one at the positions having set bit in the binary representations.
3. Traverse the array arr1[].
1. Initialize an integer variable, say bitwise_OR_sum with 0.
2. Traverse in the range [0, 31] using variable j.
3. If the jth bit is set in the binary representation of arr2[i], then increment bitwise_OR_sum by N * 2j. Otherwise, increment by frequency[j] * 2j
4. Print the sum obtained bitwise_OR_sum.

Below is the implementation of the above approach:

C++

 // C++ program for the above approach #include using namespace std; // Function to compute sum of Bitwise OR// of each element in arr1[] with all// elements of the array arr2[]void Bitwise_OR_sum_i(int arr1[], int arr2[],                      int M, int N){     // Declaring an array of    // size 32 to store the    // count of each bit    int frequency = { 0 };     // Traverse the array arr1[]    for (int i = 0; i < N; i++) {         // Current bit position        int bit_position = 0;        int num = arr1[i];         // While num exceeds 0        while (num) {             // Checks if i-th bit            // is set or not            if (num & 1) {                 // Increment the count at                // bit_position by one                frequency[bit_position] += 1;            }             // Increment bit_position            bit_position += 1;             // Right shift the num by one            num >>= 1;        }    }     // Traverse in the arr2[]    for (int i = 0; i < M; i++) {         int num = arr2[i];         // Store the ith bit value        int value_at_that_bit = 1;         // Total required sum        int bitwise_OR_sum = 0;         // Traverse in the range [0, 31]        for (int bit_position = 0;             bit_position < 32;             bit_position++) {             // Check if current bit is set            if (num & 1) {                 // Increment the Bitwise                // sum by N*(2^i)                bitwise_OR_sum                    += N * value_at_that_bit;            }            else {                bitwise_OR_sum                    += frequency[bit_position]                       * value_at_that_bit;            }             // Right shift num by one            num >>= 1;             // Left shift valee_at_that_bit by one            value_at_that_bit <<= 1;        }         // Print the sum obtained for ith        // number in arr1[]        cout << bitwise_OR_sum << ' ';    }     return;} // Driver Codeint main(){     // Given arr1[]    int arr1[] = { 1, 2, 3 };     // Given arr2[]    int arr2[] = { 1, 2, 3 };     // Size of arr1[]    int N = sizeof(arr1) / sizeof(arr1);     // Size of arr2[]    int M = sizeof(arr2) / sizeof(arr2);     // Function Call    Bitwise_OR_sum_i(arr1, arr2, M, N);     return 0;}

Java

 // Java program for the above approachimport java.util.*;  class GFG{      // Function to compute sum of Bitwise OR// of each element in arr1[] with all// elements of the array arr2[]static void Bitwise_OR_sum_i(int arr1[], int arr2[],                             int M, int N){         // Declaring an array of    // size 32 to store the    // count of each bit    int frequency[] = new int;    Arrays.fill(frequency, 0);      // Traverse the array arr1[]    for(int i = 0; i < N; i++)    {                 // Current bit position        int bit_position = 0;        int num = arr1[i];          // While num exceeds 0        while (num != 0)        {                         // Checks if i-th bit            // is set or not            if ((num & 1) != 0)            {                                 // Increment the count at                // bit_position by one                frequency[bit_position] += 1;            }              // Increment bit_position            bit_position += 1;              // Right shift the num by one            num >>= 1;        }    }      // Traverse in the arr2[]    for(int i = 0; i < M; i++)    {                 int num = arr2[i];          // Store the ith bit value        int value_at_that_bit = 1;          // Total required sum        int bitwise_OR_sum = 0;          // Traverse in the range [0, 31]        for(int bit_position = 0;                bit_position < 32;                bit_position++)        {              // Check if current bit is set            if ((num & 1) != 0)            {                                 // Increment the Bitwise                // sum by N*(2^i)                bitwise_OR_sum += N * value_at_that_bit;            }            else            {                bitwise_OR_sum += frequency[bit_position] *                                  value_at_that_bit;            }              // Right shift num by one            num >>= 1;              // Left shift valee_at_that_bit by one            value_at_that_bit <<= 1;        }          // Print the sum obtained for ith        // number in arr1[]        System.out.print(bitwise_OR_sum + " ");    }    return;}  // Driver codepublic static void main(String[] args){         // Given arr1[]    int arr1[] = { 1, 2, 3 };      // Given arr2[]    int arr2[] = { 1, 2, 3 };      // Size of arr1[]    int N = arr1.length;      // Size of arr2[]    int M = arr2.length;      // Function Call    Bitwise_OR_sum_i(arr1, arr2, M, N);}} // This code is contributed by susmitakundugoaldanga

Python3

 # Python3 program for the above approach  # Function to compute sum of Bitwise OR# of each element in arr1[] with all# elements of the array arr2[]def Bitwise_OR_sum_i(arr1, arr2, M, N):      # Declaring an array of    # size 32 to store the    # count of each bit    frequency =  * 32      # Traverse the array arr1[]    for i in range(N):          # Current bit position        bit_position = 0        num = arr1[i]          # While num exceeds 0        while (num):              # Checks if i-th bit            # is set or not            if (num & 1 != 0):                  # Increment the count at                # bit_position by one                frequency[bit_position] += 1                         # Increment bit_position            bit_position += 1              # Right shift the num by one            num >>= 1                 # Traverse in the arr2[]    for i in range(M):        num = arr2[i]          # Store the ith bit value        value_at_that_bit = 1          # Total required sum        bitwise_OR_sum = 0          # Traverse in the range [0, 31]        for bit_position in range(32):              # Check if current bit is set            if (num & 1 != 0):                  # Increment the Bitwise                # sum by N*(2^i)                bitwise_OR_sum += N * value_at_that_bit                         else:                bitwise_OR_sum += (frequency[bit_position] *                                   value_at_that_bit)                         # Right shift num by one            num >>= 1              # Left shift valee_at_that_bit by one            value_at_that_bit <<= 1                 # Print the sum obtained for ith        # number in arr1[]        print(bitwise_OR_sum, end = " ")         return # Driver Code # Given arr1[]arr1 = [ 1, 2, 3 ]  # Given arr2[]arr2 = [ 1, 2, 3 ]  # Size of arr1[]N = len(arr1)  # Size of arr2[]M = len(arr2)  # Function CallBitwise_OR_sum_i(arr1, arr2, M, N) # This code is contributed by code_hunt

C#

 // C# program for the above approachusing System;class GFG{      // Function to compute sum of Bitwise OR// of each element in arr1[] with all// elements of the array arr2[]static void Bitwise_OR_sum_i(int[] arr1, int[] arr2,                             int M, int N){          // Declaring an array of    // size 32 to store the    // count of each bit    int[] frequency = new int;    for(int i = 0; i < 32; i++)    {        frequency[i] = 0;    }     // Traverse the array arr1[]    for(int i = 0; i < N; i++)    {                  // Current bit position        int bit_position = 0;        int num = arr1[i];           // While num exceeds 0        while (num != 0)        {                          // Checks if i-th bit            // is set or not            if ((num & 1) != 0)            {                                  // Increment the count at                // bit_position by one                frequency[bit_position] += 1;            }               // Increment bit_position            bit_position += 1;               // Right shift the num by one            num >>= 1;        }    }       // Traverse in the arr2[]    for(int i = 0; i < M; i++)    {                int num = arr2[i];           // Store the ith bit value        int value_at_that_bit = 1;           // Total required sum        int bitwise_OR_sum = 0;           // Traverse in the range [0, 31]        for(int bit_position = 0;                bit_position < 32;                bit_position++)        {               // Check if current bit is set            if ((num & 1) != 0)            {                                  // Increment the Bitwise                // sum by N*(2^i)                bitwise_OR_sum += N * value_at_that_bit;            }            else            {                bitwise_OR_sum += frequency[bit_position] *                                  value_at_that_bit;            }               // Right shift num by one            num >>= 1;               // Left shift valee_at_that_bit by one            value_at_that_bit <<= 1;        }           // Print the sum obtained for ith        // number in arr1[]        Console.Write(bitwise_OR_sum + " ");    }    return;}  // Driver Codepublic static void Main(){       // Given arr1[]    int[] arr1 = { 1, 2, 3 };       // Given arr2[]    int[] arr2 = { 1, 2, 3 };       // Size of arr1[]    int N = arr1.Length;       // Size of arr2[]    int M = arr2.Length;       // Function Call    Bitwise_OR_sum_i(arr1, arr2, M, N);}} // This code is contributed by sanjoy_62

Javascript


Output:
7 8 9

Time Complexity: O(N*32)
Auxiliary Space: O(N*32)

My Personal Notes arrow_drop_up