# Count subsequences with same values of Bitwise AND, OR and XOR

• Difficulty Level : Medium
• Last Updated : 28 Nov, 2022

We are given an array arr of n element. We need to count number of non-empty subsequences such that these individual subsequences have same values of bitwise AND, OR and XOR. For example, we need to count a subsequence (x, y, z) if (x | y | z) is equal to (x & y & z) and (x ^ y ^ z). For a single element subsequence, we consider the element itself as result of XOR, AND and OR. Therefore all single-element subsequences are always counted as part of result.

Examples:

```Input :  a = [1, 3, 7]
Output : 3
Explanation:
There are 7 non empty subsequence .
subsequence   OR  AND  XOR
{1}            1    1    1
{3}            3    3    3
{7}            7    7    7
{1, 3}         3    1    2
{1, 7}         7    1    6
{3, 7}         7    3    4
{1, 3, 7}      7    1    5
Out of 7, there are 3 subsequences {1}
{3} {7} which have same values of AND,
OR and XOR.

Input :  a[] = [0, 0, 0]
Output : 7
Explanation:  All 7 non empty subsequences
have same values of AND, OR and XOR.

Input : a[] = [2, 2, 2, 3, 4]
Output : 6
Explanation:  subsequence {2}, {2}, {2},
{2, 2, 2}, {3}, {4} have same values of
AND, OR and XOR.
```

1) If there are n occurrences of zeroes in the given array, then will be 2n – 1 subsequences contributed by these zeroes.
2) If there are n occurrences of a non-zero element x, then there will be 2n-1 subsequences contributed by occurrences of this element. Please note that, in case of non-zero elements, only odd number of occurrences can cause same results for bitwise operators.
Find count of each element in the array then apply the above formulas.

## C++

 `#include ``using` `namespace` `std;` `// function for finding count of  possible subsequence``int` `countSubseq(``int` `arr[], ``int` `n)``{``    ``int` `count = 0;` `    ``// creating a map to count the frequency of each element``    ``unordered_map<``int``, ``int``> mp;` `    ``// store frequency of each element``    ``for` `(``int` `i = 0; i < n; i++)``        ``mp[arr[i]]++;` `    ``// iterate through the map``    ``for` `(``auto` `i : mp) {` `        ``// add all possible combination for key equal zero``        ``if` `(i.first == 0)``            ``count += ``pow``(2, i.second) - 1;` `        ``// add all (odd number of elements) possible``        ``// combination for key other than zero``        ``else``            ``count += ``pow``(2, i.second - 1);``    ``}``    ``return` `count;``}` `// driver function``int` `main()``{``    ``int` `arr[] = { 2, 2, 2, 5, 6 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << countSubseq(arr, n);``    ``return` `0;``}`

## Java

 `import` `java .io.*;``import` `java.util.*;`  `class` `GFG {`` ` `// function for finding count of  possible subsequence``static` `int` `countSubseq(``int` `arr[], ``int` `n)``{``    ``int` `count = ``0``;`` ` `    ``// creating a map to count the frequency of each element``    ``HashMapmp=``new` `HashMap();`` ` `    ``// store frequency of each element``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``if` `(mp.containsKey(arr[i]))``            ``mp.put(arr[i],mp.get(arr[i])+``1``);``        ``else``            ``mp.put(arr[i],``1``);`` ` `    ``// iterate through the map``    ``for` `(Map.Entryentry:mp.entrySet()) {`` ` `        ``// add all possible combination for key equal zero``        ``if` `(entry.getKey() == ``0``)``            ``count += Math.pow(``2``, entry.getValue()) - ``1``;`` ` `        ``// add all (odd number of elements) possible``        ``// combination for key other than zero``        ``else``            ``count += Math.pow(``2``, entry.getValue()- ``1``);``    ``}``    ``return` `count;``}`` ` `// driver function``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``2``, ``2``, ``2``, ``5``, ``6` `};``    ``int` `n=arr.length;``    ``System.out.println(countSubseq(arr, n));``}``}` `// This code is contributed by apurva raj`

## C#

 `using` `System;``using` `System.Collections.Generic;``class` `GFG{` `// function for finding count of possible subsequence``static` `int` `countSubseq(``int` `[]arr, ``int` `n)``{``    ``int` `count = 0;` `    ``// creating a map to count the frequency of each element``     ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``,``int``>();` `    ``// store frequency of each element``     ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``if` `(mp.ContainsKey(arr[i])) ``            ``{``                ``var` `val = mp[arr[i]];``                ``mp.Remove(arr[i]);``                ``mp.Add(arr[i], val + 1); ``            ``} ``            ``else``            ``{``                ``mp.Add(arr[i], 1);``            ``}``        ``}` `    ``// iterate through the map``    ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `mp) {` `        ``// add all possible combination for key equal zero``        ``if` `(entry.Key == 0)``            ``count += (``int``)(Math.Pow(2, entry.Value - 1));` `        ``// add all (odd number of elements) possible``        ``// combination for key other than zero``        ``else``            ``count += (``int``)(Math.Pow(2, entry.Value - 1));``    ``}``    ``return` `count;``}` `// Driver function``public` `static` `void` `Main(String []args) ``    ``{``    ``int` `[]arr = { 2, 2, 2, 5, 6 };``    ``int` `n = arr.Length;``    ``Console.WriteLine(countSubseq(arr, n));``}``}` `// This code is contributed by shivanisinghss2110`

## Python3

 `# function for finding count of possible subsequence``def` `countSubseq(arr, n):``    ``count ``=` `0` `    ``# creating a map to count the frequency of each element``    ``mp ``=` `{}` `    ``# store frequency of each element``    ``for` `x ``in` `arr:``        ``if` `x ``in` `mp.keys():``            ``mp[x]``+``=``1``        ``else``:``            ``mp[x]``=``1` `    ``# iterate through the map``    ``for` `i ``in` `mp.keys():` `        ``# add all possible combination for key equal zero``        ``if` `(i ``=``=` `0``):``            ``count ``+``=` `pow``(``2``, mp[i]) ``-` `1` `        ``# add all (odd number of elements) possible``        ``# combination for key other than zero``        ``else``:``            ``count ``+``=` `pow``(``2``, mp[i] ``-` `1``)``    ``return` `count` `# Driver function``arr``=` `[``2``, ``2``, ``2``, ``5``, ``6` `]``n ``=` `len``(arr)``print``(countSubseq(arr, n))` `# This code is contributed by apurva raj`

## Javascript

 ``

Output:

`6`

Time complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up