GeeksforGeeks App
Open App
Browser
Continue

Find bitwise AND (&) of all possible sub-arrays

Given an array A of size N where . The task is to find the AND of all possible sub-arrays of A and then the AND of all these results.

Examples:

Input : 1 2 3
Output : 0
All possible subarrays are
{1}, {2}, {3}, {1, 2}, {2, 3} and {1, 2, 3}
ANDs of these subarrays are 1, 2, 3, 0, 2, 0.
AND of these ANDs is 0.

Input : 100 500 1000
Output : 96 

Approach: The Naive solution is to find the AND of all the sub-arrays and then print the AND of their results. This will lead to O(N2) solution.

Optimal Solution: Using the properties of i:e it doesn’t matter how many times an element comes, its ANDing will be counted as one only. Thus, our problem is reduced to finding the AND of all the elements of the array only.

Implementation:

C++

 // C++ program to find of all the sub-arrays#include using namespace std; // function to return AND of sub-arraysint AND(int a[], int n){    int ans = a[0];    for (int i = 0; i < n; ++i)        ans &= a[i];     return ans;} // Driver programint main(){    int a[] = { 1, 2, 3 };     // size of the array    int n = sizeof(a) / sizeof(a[0]);     // print and of all subarrays    cout << AND(a, n);     return 0;}

Java

 //Java program to find of all the sub-arrayspublic class GFG {     //function to return AND of sub-arrays    static int AND(int a[], int n)    {     int ans = a[0];     for (int i = 0; i < n; ++i)         ans &= a[i];      return ans;    }     // Driver code    public static void main(String[] args) {             int a[] = { 1, 2, 3 };          // size of the array         int n = a.length;          // print and of all subarrays         System.out.println(AND(a, n));    }}

Python 3

 # Python 3 Program  to find of all the sub-arrays # function to return AND of sub-arraysdef AND(arr, n) :     res = arr[0]    for i in range(1, n):        res &= arr[i]        if res == 0:            return 0    return res   # Driver Codeif __name__ == "__main__" :     a = [ 100, 500, 1000]     # size of the array    n = len(a)     # print and of all subarrays    print(AND(a, n)) # This code is contributed by ANKITRAI1

C#

 //C# program to find of all the sub-arrays  using System; public class GFG {       //function to return AND of sub-arrays    static int AND(int []a, int n)    {     int ans = a[0];     for (int i = 0; i < n; ++i)          ans &= a[i];       return ans;    }       // Driver code    public static void Main() {               int []a = { 1, 2, 3 };            // size of the array         int n = a.Length;            // print and of all subarrays         Console.WriteLine(AND(a, n));    }}

PHP

 

Javascript

 

Output

0

Time Complexity: O(N)

Auxiliary Space: O(1)

Approach: Finding AND of all subarrays using bit manipulation and hashing.

We can use the bitwise AND operator to get the AND of all sub-arrays. The idea is to count the number of times each bit is set in the sub-arrays. If a bit is set in all the sub-arrays, then it will be set in the result. We can use a hash table to count the number of times each bit is set. Then, we can check if the bit is set in all the sub-arrays or not.

Algorithm:

• Initialize a hash table to count the number of times each bit is set.
• Traverse the array and for each element, traverse all the bits and if the bit is set, increment the count of that bit in the hash table.
• Initialize the result variable to 0.
• Traverse the hash table and for each bit, if the count is equal to the length of the array, set the bit in the result variable.
• Return the result variable.

Here is the implementation of above algorithm:-

C++

 #include #include using namespace std; int AND(int arr[], int n) {    unordered_map<int, int> bit_count;    for (int i = 0; i < n; i++) {        int num = arr[i];        int pos = 0;        while (num > 0) {            if (num & 1) {                if (bit_count.find(pos) == bit_count.end()) {                    bit_count[pos] = 1;                } else {                    bit_count[pos]++;                }            }            num >>= 1;            pos++;        }    }    int res = 0;    for (auto it : bit_count) {        if (it.second == n) {            res |= (1 << it.first);        }    }    return res;} int main() {    int arr[] = {1, 2, 3};    int n = sizeof(arr)/sizeof(arr[0]);    cout << AND(arr, n) << endl;    return 0;}

Java

 import java.util.HashMap;import java.util.Map; public class Main {    static int AND(int[] arr) {        int n = arr.length;        Map bit_count = new HashMap<>();        for (int i = 0; i < n; i++) {            int num = arr[i];            int pos = 0;            while (num > 0) {                if ((num & 1) == 1) {                    if (!bit_count.containsKey(pos)) {                        bit_count.put(pos, 1);                    } else {                        bit_count.put(pos, bit_count.get(pos) + 1);                    }                }                num >>= 1;                pos++;            }        }        int res = 0;        for (Map.Entry entry : bit_count.entrySet()) {            if (entry.getValue() == n) {                res |= (1 << entry.getKey());            }        }        return res;    }     public static void main(String[] args) {        int[] arr = {1, 2, 3};        System.out.println(AND(arr));    }}

Python

 def AND(arr):    n = len(arr)    bit_count = {}    for i in range(n):        num = arr[i]        pos = 0        while num > 0:            if num & 1:                if pos not in bit_count:                    bit_count[pos] = 1                else:                    bit_count[pos] += 1            num >>= 1            pos += 1    res = 0    for bit, count in bit_count.items():        if count == n:            res |= (1 << bit)    return res arr = [1, 2, 3]print(AND(arr))

C#

 using System;using System.Collections.Generic; public class Program {    static int AND(int[] arr) {        int n = arr.Length;        Dictionary<int, int> bit_count = new Dictionary<int, int>();        for (int i = 0; i < n; i++) {            int num = arr[i];            int pos = 0;            while (num > 0) {                if ((num & 1) == 1) {                    if (!bit_count.ContainsKey(pos)) {                        bit_count.Add(pos, 1);                    } else {                        bit_count[pos]++;                    }                }                num >>= 1;                pos++;            }        }        int res = 0;        foreach (KeyValuePair<int, int> pair in bit_count) {            if (pair.Value == n) {                res |= (1 << pair.Key);            }        }        return res;    }     static void Main(string[] args) {        int[] arr1 = new int[] { 1, 2, 3 };        Console.WriteLine(AND(arr1));         int[] arr2 = new int[] { 100, 500, 1000 };        Console.WriteLine(AND(arr2));    }}

Javascript

 function AND(arr) {    const n = arr.length;    const bit_count = new Map();    for (let i = 0; i < n; i++) {        let num = arr[i];        let pos = 0;        while (num > 0) {            if (num & 1) {                if (!bit_count.has(pos)) {                    bit_count.set(pos, 1);                } else {                    bit_count.set(pos, bit_count.get(pos) + 1);                }            }            num >>= 1;            pos++;        }    }    let res = 0;    for (let [bit, count] of bit_count) {        if (count === n) {            res |= (1 << bit);        }    }    return res;} const arr1 = [1, 2, 3];console.log(AND(arr1)); // expected output: 0 const arr2 = [100, 500, 1000];console.log(AND(arr2)); // expected output: 96

Output

0


The Time complexity of this approach is O(N * L), where N is the length of the input array and L is the maximum number of bits required to represent any number in the array.

The Space complexity of this approach is also O(L), as we are using a dictionary to store the count of set bits for each position.

My Personal Notes arrow_drop_up