Integer pairs having biwise AND equal to 0 - c++

Question

Two integers x and y form a magical pair, if the result of their Bitwise And equals 0.
Given an array of integers, find for every array element whether it forms a magical pair with some other array element or not.
Input
First line of the input contains a single integer T denoting the number of test cases.
The first line of each test case has an integer N denoting the number of elements in the given array.
The second line contains N single space-separated integers a1,a2,...an denoting the elements of the given array.
Output
For each test case ,print N space separated integers in a line.
If ai forms a magical pair with any other element of the given array , then ans'i should be equal to 1. Otherwise ans'i is 0.
Constraints
1<=N,Ai<=10^6
I tried brute force. For each element I checked if the bitwise AND of this number is zero or not with any other element present in the array. Obviously, it had a time complexity of O(N^2) and most of my test cases timed out
This problem is here: https://www.hackerearth.com/challenges/test/netapp-codenet-2017/algorithm/d2d1f6a92c6740278682e88ed42068a4/
Can anyone suggest me a better approach or algorithm so it passes the time limit?
Brute force code:
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int ans[n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i] & a[j] == 0)
ans[i] = 1;
for (int i = 0; i < n; i++)
cout << ans[i] << " ";

Answer 1

One way to do it would be to create a binary tree for all the numbers like a Trie.
For example, if you have array 3 6 2 9 10, binary array would look like
arr = 11, 110, 10, 1001, 1010, and the tree would like
root
/ \
0 1
\ / \
1 0 1
/ \ /
0 1 0
\ \
1 1
If we iterate through each element in binary array, the number(answer) matching the condition should have 0 for every set bit in the element and either 0 or 1 for unset bit in the element.
Now, we only need to traverse these bits into the tree. And if we are able to do it, then there exists at least one number satisfying the condition.
Time complexity O(N).
Reason:- There are n numbers. Each number is of 32 bit binary length. New node creation will take O(1). Therefore, O(32N) => O(N). Same time for inv_arr.
Note: Try converting the numbers into 32 bit binary numbers as it will cover all the numbers specified in the range. Otherwise it will result in a problem. Here 6 and 9 forms a magical pair, but 0110 in the inv_arr cannot be traversed and will result in no magical pair present as traversal of leftmost 0 cannot be done. If all numbers will be represented with same length binary, tree traversal will give correct answer.
Code
public class BinaryNode {
char c;
public BinaryNode left;
public BinaryNode right;
public BinaryNode(char c) {
this.c = c;
}
}
public class BinaryTree {
public BinaryNode root;
public BinaryTree(char c) {
root = new BinaryNode(c);
}
public void addToTree(String s) {
BinaryNode node = this.root;
int length = s.length();
for (int i = s.length()-1; i >= 0; i--) {
BinaryNode newNode;
if (s.charAt(i) == '0') {
newNode = addCharToTree(node.left, s.charAt(i));
node.left = newNode;
} else {
newNode = addCharToTree(node.right, s.charAt(i));
node.right = newNode;
}
node = newNode;
}
}
private BinaryNode addCharToTree(BinaryNode node, char c) {
if (node == null)
return new BinaryNode(c);
return node;
}
}
public class Solution {
private static void findMagicalPairs(List<Integer> list) {
// for creating 32 char long binary string list
List<String> binaryNumberList = list.stream()
.map(num -> Long.toBinaryString( Integer.toUnsignedLong(num) | 0x100000000L ).substring(1))
.collect(Collectors.toList());
// dummy character as root
BinaryTree binaryTree = new BinaryTree('c');
binaryNumberList.forEach(binaryTree::addToTree);
List<Boolean> booleanList = binaryNumberList.stream()
.map(s -> hasMagicalPair(s, binaryTree.root))
.collect(Collectors.toList());
}
private static boolean hasMagicalPair(String s, BinaryNode node) {
if (s == null || s.length() == 0)
return true;
if (node == null)
return false;
String substring = s.substring(0, s.length() - 1);
if (s.charAt(s.length()-1) == '1')
return hasMagicalPair(substring, node.left) ;
return hasMagicalPair(substring, node.left) || hasMagicalPair(substring, node.right);
}
}

Answer 2

First of all, sorry for the long answer :)
Problem: I think the problem with your brute force is that you are performing each checking twice (in both directions). Moreover, a lot of checkings are unnecessary.You can easily reduce the number of iterations by doing every checking only once (and only the necessary ones).
Key idea: You should not start the inner loop from 0.
Note: The first of the following sections only introduce the second, but the second section is the one that answers your question.
The whole code provided here is only meant to illustrate the stated ideas, nothing more.
1 - Find all possible magical pairs
Here we are trying to find all possible magical pairs in the given vector avoiding to check multiple times the same pair.
A solution could be:
std::vector<std::pair<int, int>> magical_pairs(const std::vector<int> & data)
{
std::vector<std::pair<int, int>> result;
for(size_t i = 0; i < data.size()-1; ++i) // Stop at second to last
{
for(size_t j = i+1; j < data.size(); ++j) // Start from i+1 and not 0
{
if((data[i] & data[j]) == 0)
result.push_back(std::make_pair(data[i], data[j]));
}
}
return result;
}
This way, you check all possible pairs only once.
According to me, if you want to get all possible magical pairs, you cannot reduce the complexity less than what it takes to check all possible pairs only once.But if someone has a better solution, I will be very interested to hear it (read it).
You can run an example this way:
std::vector<int> input_array {3, 12, -6, 27, 8, 18, -66, 47, 11}; // input example
for(const std::pair<int, int> & mp : magical_pairs(input_array))
std::cout << mp.first << " : " << mp.second << std::endl;
The results for this example:
3 : 12
3 : 8
12 : 18
8 : 18
2 - Check whether a number has a magical pair or not
Now that we know how to avoid to check already checked pairs, we will reuse the same principle to realize the function you want.
You want to check for every number in the array whether they have a magical pair in the array or not.In this case, we don't want to check all possible magical pairs, only one match is sufficient to determine if a number has a pair. Moreover, when we find a match, we can set two results at a time (one for each number of the pair).You can see that this way, we will be able to significantly reduce the number of iterations.
It leads us to proceed as follows:
Check every pair only once
Stop evaluation of a number at first match
Determine two results per match --> don't perform the search if already set
Knowing this, a solution could be:
std::vector<bool> has_magical_pair(const std::vector<int> & data)
{
std::vector<bool> result(data.size(), false);
for(size_t i = 0; i < data.size()-1; ++i) // From 0 to second to last
{
if(!result[i]) // search for a magical pair only if not already found
{
for(size_t j = i+1; j < data.size(); ++j) // From i+1 to last
{
if((data[i] & data[j]) == 0)
{
// Set two results at a time
result[i] = true;
result[j] = true;
break; // Exit the inner loop at first match
}
}
}
}
return result;
}
This way, you will be much more efficient than the brute force method.
You can run an example this way:
std::vector<int> input_array {3, 12, -6, 27, 8, 18, -66, 47, 11};
for(bool hmp : has_magical_pair(input_array))
std::cout << hmp << ", ";
std::cout << std::endl;
The results for this example:
1, 1, 0, 0, 1, 1, 0, 0, 0,
I think you will be able to adapt the code of this example to your use case quite easily.
I hope it can help you.

Answer 3

You have to save the operations you do first.
In the example you have 3 6 2 9 10
When you do it by brute force you first do
3 & 6
And after doing all the
3 & y
you repeat
6 & 3
. If you find how to avoid repeating this, you'll solve the problem.