Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Sum of Bitwise AND of each array element with the 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 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.

Follow the steps below to solve the problem:

  1. Initialize an integer array frequency[] to store the count of numbers in arr2[] having set the bit at ithposition where 0?i<32
  2. 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.
  3. Traverse the array arr1[]
    1. Initialize an integer variable bitwise_AND_sum with 0.
    2. Traverse in the range [0, 31] using a variable j.
    3. If the jth bit is set to bit in the binary representation of arr2[i] then increment bitwise_AND_sum by frequency[j]*2j.
    4. Print the sum obtained i.e., bitwise_AND_sum.

Below is the implementation of the above approach:




// 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>


















                        






                        








Output: 

2 4 6


 


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

	

        Article Tags : 
        

            Arrays
Bit Magic
DSA
Hash        


		
	

	


      

      

          
Recommended Articles

      

      

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

          
2. Form an array of distinct elements with each element as sum of an element from each array

          
3. Total pairs in an array such that the bitwise AND, bitwise OR and bitwise XOR of LSB is 1

          
4. Sum of Bitwise XOR of elements of an array with all elements of another array

          
5. Smallest element with K set bits such that sum of Bitwise AND of each array element with K is maximum

          
6. Sum of Bitwise XOR of each array element with all other array elements

          
7. Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND

          
8. Calculate Bitwise OR of two integers from their given Bitwise AND and Bitwise XOR values

          
9. Check if each element of an Array is the Sum of any two elements of another Array

          
10. Sum of Bitwise AND of sum of pairs and their Bitwise AND from a given array

          
11. Maximize sum of squares of array elements possible by replacing pairs with their Bitwise AND and Bitwise OR

          
12. Rearrange an array to maximize sum of Bitwise AND of same-indexed elements with another array

          
13. Remaining array element after repeated removal of last element and subtraction of each element from next adjacent element

          
14. Find triplet A, B, C having bitwise AND of bitwise OR with each other as K

          
15. Sum of product of each element with each element after it

          
16. Generate original Array from the bitwise AND and Bitwise OR of adjacent elements

          
17. Sum of Bitwise AND of the sum of all leaf and non-leaf nodes for each level of a Binary Tree

          
18. Leftover element after performing alternate Bitwise OR and Bitwise XOR operations on adjacent pairs

          
19. Maximize product of array by replacing array elements with its sum or product with element from another array

          
20. Non-negative pairs with sum of Bitwise OR and Bitwise AND equal to N

          
21. Rearrange array elements such that Bitwise AND of first N - 1 elements is equal to last element

          
22. Sum of Bitwise OR of every array element paired with all other array elements

          
23. Find mean of K adjacent elements on each sides for each Array element

          
24. Maximum sum of Array formed by replacing each element with sum of adjacent elements

          
25. Check if an Array exists with Bitwise OR as A and Bitwise AND as B