Sum of Bitwise AND of each array element with the elements of another array
Last Updated :
07 Sep, 2021
Given two arrays arr1[] of size M and arr2[] of size N, the task is to find the sum of bitwise AND of each element of arr1[] with the elements of the array arr2[].
Examples:
Input: arr1[] = {1, 2, 3}, arr2[] = {1, 2, 3}, M = 3, N = 3
Output: 2 4 6
Explanation:
For elements at index 0 in arr1[], Sum = arr1[0] & arr2[0] + arr1[0] & arr2[1] + arr1[0] & arr2[2], Sum = 1 & 1 + 1 & 2 + 1 & 3 = 2
For elements at index 1 in arr1[], Sum = arr1[1] & arr2[0] + arr1[1] & arr2[1] + arr1[1] & arr2[2], Sum= 2 & 1 + 2 & 2 + 2 & 3 = 4
For elements at index 2 in arr1[], Sum = arr1[2] & arr2[0] + arr1[2] & arr2[1] + arr1[2] & arr2[2], Sum= 3 & 1 + 3 & 2 + 3 & 3 = 6
Input: arr1[] = {2, 4, 8, 16}, arr2[] = {2, 4, 8, 16}, M = 4, N = 4
Output: 2 4 8 16
Naive Approach: The simplest approach to solve the problem is to traverse the array arr1[] and for each element of the array arr1[], traverse the array arr2[] and calculate the sum of Bitwise AND of the current elements of arr1[] with all elements of arr2[] for each element
Time Complexity: O(N2)
Auxiliary Space: O(N)
Efficient Approach: The idea is to use bit manipulation to solve the above problem. Suppose every element of the array can be represented using 32 bits only.
- According to the bitwise AND property, while performing the operation, the ith bit will be set bit only when both numbers have a set bit at the ith position, where 0?i<32.
- Therefore, for a number in arr1[], If the ith bit is a set bit, then the ith place will contribute a sum of K*2i, where K is the total number of numbers in arr2[] having set the bit at the ith position.
Follow the steps below to solve the problem:
- Initialize an integer array frequency[] to store the count of numbers in arr2[] having set the bit at ith position where 0?i<32
- Traverse in the array arr2[] and for each element represent it in binary form and increment the count in the frequency[] array by one at the position having 1 in the binary representation.
- Traverse the array arr1[]
- Initialize an integer variable bitwise_AND_sum with 0.
- Traverse in the range [0, 31] using a variable j.
- If the jth bit is set to bit in the binary representation of arr2[i] then increment bitwise_AND_sum by frequency[j]*2j.
- Print the sum obtained i.e., bitwise_AND_sum.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to compute the AND sum
// for each element of an array
void Bitwise_AND_sum_i(int arr1[], int arr2[], int M, int N)
{
// Declaring an array of
// size 32 for storing the
// count of each bit
int frequency[32] = { 0 };
// Traverse the array arr2[]
// and store the count of a
// bit in frequency array
for (int i = 0; i < N; i++) {
// Current bit position
int bit_position = 0;
int num = arr1[i];
// While num is greater
// than 0
while (num) {
// Checks if ith bit is
// set or not
if (num & 1) {
// Increment the count of
// bit by one
frequency[bit_position] += 1;
}
// Increment the bit position
// by one
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_AND_sum = 0;
// Traverse in the range [0, 31]
for (int bit_position = 0; bit_position < 32;
bit_position++) {
// Checks if current bit is set
if (num & 1) {
// Increment the bitwise sum
// by frequency[bit_position]
// * value_at_that_bit;
bitwise_AND_sum += frequency[bit_position]
* value_at_that_bit;
}
// Right shift num by one
num >>= 1;
// Left shift vale_at_that_bit by one
value_at_that_bit <<= 1;
}
// Print the sum obtained for ith
// number in arr1[]
cout << bitwise_AND_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[0]);
// Size of arr2[]
int M = sizeof(arr2) / sizeof(arr2[0]);
// Function Call
Bitwise_AND_sum_i(arr1, arr2, M, N);
return 0;
}
// Java program for the above approach
import java.io.*;
class GFG
{
// 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_AND_sum_i(arr1, arr2, M, N);
}
// Function to compute the AND sum
// for each element of an array
static void Bitwise_AND_sum_i(int arr1[], int arr2[],
int M, int N)
{
// Declaring an array of
// size 32 for storing the
// count of each bit
int[] frequency = new int[32];
// Traverse the array arr2[]
// and store the count of a
// bit in frequency array
for (int i = 0; i < N; i++)
{
// Current bit position
int bit_position = 0;
int num = arr1[i];
// While num is greater
// than 0
while (num != 0)
{
// Checks if ith bit is
// set or not
if ((num & 1) != 0)
{
// Increment the count of
// bit by one
frequency[bit_position] += 1;
}
// Increment the bit position
// by one
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_AND_sum = 0;
// Traverse in the range [0, 31]
for (int bit_position = 0; bit_position < 32;
bit_position++)
{
// Checks if current bit is set
if ((num & 1) != 0)
{
// Increment the bitwise sum
// by frequency[bit_position]
// * value_at_that_bit;
bitwise_AND_sum
+= frequency[bit_position]
* value_at_that_bit;
}
// Right shift num by one
num >>= 1;
// Left shift vale_at_that_bit by one
value_at_that_bit <<= 1;
}
// Print the sum obtained for ith
// number in arr1[]
System.out.print( bitwise_AND_sum + " ");
}
}
}
// This code is contributed by Dharanendra L V
# Python3 program for the above approach
# Function to compute the AND sum
# for each element of an array
def Bitwise_AND_sum_i(arr1, arr2, M, N):
# Declaring an array of
# size 32 for storing the
# count of each bit
frequency = [0]*32
# Traverse the array arr2[]
# and store the count of a
# bit in frequency array
for i in range(N):
# Current bit position
bit_position = 0
num = arr1[i]
# While num is greater
# than 0
while (num):
# Checks if ith bit is
# set or not
if (num & 1):
# Increment the count of
# bit by one
frequency[bit_position] += 1
# Increment the bit position
# by one
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_AND_sum = 0
# Traverse in the range [0, 31]
for bit_position in range(32):
# Checks if current bit is set
if (num & 1):
# Increment the bitwise sum
# by frequency[bit_position]
# * value_at_that_bit
bitwise_AND_sum += frequency[bit_position] * value_at_that_bit
# Right shift num by one
num >>= 1
# Left shift vale_at_that_bit by one
value_at_that_bit <<= 1
# Print sum obtained for ith
# number in arr1[]
print(bitwise_AND_sum, end = " ")
return
# Driver Code
if __name__ == '__main__':
# 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_AND_sum_i(arr1, arr2, M, N)
# This code is contributed by mohit kumar 29
// C# program for the above approach
using System;
class GFG
{
// Driver code
static public 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_AND_sum_i(arr1, arr2, M, N);
}
// Function to compute the AND sum
// for each element of an array
static void Bitwise_AND_sum_i(int[] arr1, int[] arr2,
int M, int N)
{
// Declaring an array of
// size 32 for storing the
// count of each bit
int[] frequency = new int[32];
// Traverse the array arr2[]
// and store the count of a
// bit in frequency array
for (int i = 0; i < N; i++)
{
// Current bit position
int bit_position = 0;
int num = arr1[i];
// While num is greater
// than 0
while (num != 0)
{
// Checks if ith bit is
// set or not
if ((num & 1) != 0)
{
// Increment the count of
// bit by one
frequency[bit_position] += 1;
}
// Increment the bit position
// by one
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_AND_sum = 0;
// Traverse in the range [0, 31]
for (int bit_position = 0; bit_position < 32;
bit_position++) {
// Checks if current bit is set
if ((num & 1) != 0)
{
// Increment the bitwise sum
// by frequency[bit_position]
// * value_at_that_bit;
bitwise_AND_sum
+= frequency[bit_position]
* value_at_that_bit;
}
// Right shift num by one
num >>= 1;
// Left shift vale_at_that_bit by one
value_at_that_bit <<= 1;
}
// Print the sum obtained for ith
// number in arr1[]
Console.Write(bitwise_AND_sum + " ");
}
}
}
// The code is contributed by Dharanendra L V
<script>
// Javascript program for the above approach
// Function to compute the AND sum
// for each element of an array
function Bitwise_AND_sum_i(arr1, arr2, M, N) {
// Declaring an array of
// size 32 for storing the
// count of each bit
let frequency = new Array(32).fill(0);
// Traverse the array arr2[]
// and store the count of a
// bit in frequency array
for (let i = 0; i < N; i++) {
// Current bit position
let bit_position = 0;
let num = arr1[i];
// While num is greater
// than 0
while (num) {
// Checks if ith bit is
// set or not
if (num & 1) {
// Increment the count of
// bit by one
frequency[bit_position] += 1;
}
// Increment the bit position
// by one
bit_position += 1;
// Right shift the num by one
num >>= 1;
}
}
// Traverse in the arr2[]
for (let i = 0; i < M; i++) {
let num = arr2[i];
// Store the ith bit
// value
let value_at_that_bit = 1;
// Total required sum
let bitwise_AND_sum = 0;
// Traverse in the range [0, 31]
for (let bit_position = 0; bit_position < 32; bit_position++) {
// Checks if current bit is set
if (num & 1) {
// Increment the bitwise sum
// by frequency[bit_position]
// * value_at_that_bit;
bitwise_AND_sum += frequency[bit_position] * value_at_that_bit;
}
// Right shift num by one
num >>= 1;
// Left shift vale_at_that_bit by one
value_at_that_bit <<= 1;
}
// Print the sum obtained for ith
// number in arr1[]
document.write(bitwise_AND_sum + ' ');
}
return;
}
// Driver Code
// Given arr1[]
let arr1 = [1, 2, 3];
// Given arr2[]
let arr2 = [1, 2, 3];
// Size of arr1[]
let N = arr1.length;
// Size of arr2[]
let M = arr2.length
// Function Call
Bitwise_AND_sum_i(arr1, arr2, M, N);
// This code is contributed by _saurabh_jaiswal
</script>
Time Complexity: O(N * 32)
Auxiliary Space: O(N * 32)
Similar Reads
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 = 3Output: 7 8 9Explanation: For arr[0]: Sum = arr1[0]|arr2[0] + arr1[
11 min read
Sum of Bitwise XOR of elements of an array with all elements of another array Given an array arr[] of size N and an array Q[], the task is to calculate the sum of Bitwise XOR of all elements of the array arr[] with each element of the array q[]. Examples: Input: arr[ ] = {5, 2, 3}, Q[ ] = {3, 8, 7}Output: 7 34 11Explanation:For Q[0] ( = 3): Sum = 5 ^ 3 + 2 ^ 3 + 3 ^ 3 = 7.For
9 min read
Sum of Bitwise XOR of each array element with all other array elements Given an array arr[] of length N, the task for every array element is to print the sum of its Bitwise XOR with all other array elements. Examples: Input: arr[] = {1, 2, 3}Output: 5 4 3Explanation:For arr[0]: arr[0] ^ arr[0] + arr[0] ^ arr[1] + arr[0] ^ arr[2] = 1^1 + 1^2 + 1^3 = 0 + 3 + 2 = 5For arr
9 min read
Rearrange an array to maximize sum of Bitwise AND of same-indexed elements with another array Given two arrays A[] and B[] of sizes N, the task is to find the maximum sum of Bitwise AND of same-indexed elements in the arrays A[] and B[] that can be obtained by rearranging the array B[] in any order. Examples: Input: A[] = {1, 2, 3, 4}, B[] = {3, 4, 1, 2}Output: 10Explanation: One possible wa
15 min read
Sum of Bitwise OR of every array element paired with all other array elements Given an array arr[] consisting of non-negative integers, the task for each array element arr[i] is to print the sum of Bitwise OR of all pairs (arr[i], arr[j]) ( 0 ≤ j ≤ N ). Examples: Input: arr[] = {1, 2, 3, 4}Output: 12 14 16 22Explanation:For i = 0 the required sum will be (1 | 1) + (1 | 2) + (
11 min read
Find last element in Array formed from bitwise AND of array elements Given an array A[] of size N, the task is to find the last remaining element in a new array B containing all pairwise bitwise AND of elements from A i.e., B consists of N?(N ? 1) / 2 elements, each of the form Ai & Aj for some 1 ? i < j ? N. And we can perform the following operation any numb
6 min read
Smallest element with K set bits such that sum of Bitwise AND of each array element with K is maximum Given an array arr[] consisting of N integers and integer K, the task is to find the smallest integer X with exactly K set bits such that the sum of Bitwise AND of X with every array element arr[i] is maximum. Examples: Input: arr[] = {3, 4, 5, 1}, K = 1Output: 4Explanation: Consider the value of X
8 min read
Check whether bitwise AND of a number with any subset of an array is zero or not Given an array and a Number N. The task is to check whether there exists any subset of this array such that the bitwise AND of this subset with N is zero. Examples: Input : arr[] = {1, 2, 4} ; N = 3 Output : YES Explanation: The subsets are: (1, 2 ), (1, 4), (1, 2, 4) Input : arr[] = {1, 1, 1} ; N =
6 min read
Generate an array having sum of Bitwise OR of same-indexed elements with given array equal to K Given an array arr[] consisting of N integers and an integer K, the task is to print an array generated such that the sum of Bitwise OR of same indexed elements of the generated array with the given array is equal to K. If it is not possible to generate such an array, then print "-1". Examples: Inpu
7 min read
Sum of array elements whose count of set bits are unique Given an array arr[] consisting of N positive integers, the task is to find the sum of all array elements having a distinct count of set bits in the array. Examples: Input: arr[] = {8, 3, 7, 5, 3}Output: 15Explanation:The count of set bits in each array of elements is: arr[0] = 8 = (1000)2, has 1 se
7 min read