 GFG App
Open App Browser
Continue

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

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 Code` `int` `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 approach ` `import` `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``[``32``];` `    ``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 code` `public` `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 ``=` `[``0``] ``*` `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 Call` `Bitwise_OR_sum_i(arr1, arr2, M, N)`   `# This code is contributed by code_hunt`

## C#

 `// C# program for the above approach ` `using` `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 Code` `public` `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(1) because size of frequency array is constant

My Personal Notes arrow_drop_up