Related Articles

# Find the missing element in an array of integers represented in binary format

• Difficulty Level : Hard
• Last Updated : 11 Sep, 2018

Given N strings which represents all integers from 0 to N in binary format except any one. The task is to find the missing number. Input consists of an array of strings where array elements are represented in binary format.

Examples:

Input: arr[] = {“0000”, “0001”, “0010”, “0100”}
Output: 3

Input: arr[] = {“0000”, “0001”, “0010”, “0011”, “0100”, “0110”, “0111”, “1000”}
Output: 5

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

• An imbalance of 1’s and 0’s in the least significant bits of the numbers can be observed in the N integers given. Since one number is missing either a 0 or 1 from the LSB is missing. If the number which is missing has LSB = 0 then count(1) will be greater than equal to count(0). If LSB of missing number is 1 then count(1) is less than count(0).
• From the step 1 one can easily determine the LSB of missing number.
• Once determined, discard all the numbers having LSB different from that of the missing number, i.e., if the missing number has LSB = 0, then discard all the numbers with LSB = 1 and vice versa.
• Continue the process from step 1 all over again and recur for the next LSB.
• Continue with the above process till all the bits are traversed.

Below is the impplementation of the above approach:

 `// C++ program to find the missing integer``// in N numbers when N bits are given``#include ``using` `namespace` `std;`` ` `class` `BitInteger {``private``:``    ``bool``* bits;`` ` `public``:``    ``static` `const` `int` `INTEGER_SIZE = 32;`` ` `    ``BitInteger()``    ``{``        ``bits = ``new` `bool``[INTEGER_SIZE];``    ``}`` ` `    ``// Constructor to convert an integer``    ``// variable into binary format``    ``BitInteger(``int` `value)``    ``{``        ``bits = ``new` `bool``[INTEGER_SIZE];`` ` `        ``for` `(``int` `j = 0; j < INTEGER_SIZE; j++) {`` ` `            ``// The if statement will shift the``            ``// original value j times.``            ``// So that appropriate (INTEGER_SIZE - 1 -j)th``            ``// bits will be either 0/1.``            ``//  (INTEGER_SIZE - 1 -j)th bit for all``            ``// j = 0 to INTEGER_SIZE-1 corresponds``            ``// to  LSB to MSB respectively.``            ``if` `(((value >> j) & 1) == 1)``                ``bits[INTEGER_SIZE - 1 - j] = ``true``;``            ``else``                ``bits[INTEGER_SIZE - 1 - j] = ``false``;``        ``}``    ``}``    ``// Constructor to convert a``    ``// string into binary format.``    ``BitInteger(string str)``    ``{``        ``int` `len = str.length();``        ``int` `x = INTEGER_SIZE - len;``        ``bits = ``new` `bool``[INTEGER_SIZE];`` ` `        ``// If len = 4. Then x = 32 - 4 = 28.``        ``// Hence iterate from``        ``// bit 28 to bit 32 and just``        ``// replicate the input string.``        ``int` `i = 0;`` ` `        ``for` `(``int` `j = x; j <= INTEGER_SIZE && i < len; j++, i++) {``            ``if` `(str[i] == ``'1'``)``                ``bits[j] = ``true``;``            ``else``                ``bits[j] = ``false``;``        ``}``    ``}`` ` `    ``// this function fetches the kth bit``    ``int` `fetch(``int` `k)``    ``{``        ``if` `(bits[k])``            ``return` `1;`` ` `        ``return` `0;``    ``}`` ` `    ``// this function will set a value``    ``// of bit indicated by k to given bitValue``    ``void` `set(``int` `k, ``int` `bitValue)``    ``{``        ``if` `(bitValue == 0)``            ``bits[k] = ``false``;``        ``else``            ``bits[k] = ``true``;``    ``}`` ` `    ``// convert binary representation to integer``    ``int` `toInt()``    ``{``        ``int` `n = 0;``        ``for` `(``int` `i = 0; i < INTEGER_SIZE; i++) {``            ``n = n << 1;``            ``if` `(bits[i])``                ``n = n | 1;``        ``}``        ``return` `n;``    ``}``};`` ` `// Function to find the missing number``int` `findMissingFunc(list& myList, ``int` `column)``{``    ``// This means that we have processed``    ``// the entire 32 bit binary number.``    ``if` `(column < 0)``        ``return` `0;`` ` `    ``list oddIndices;``    ``list evenIndices;`` ` `    ``for` `(BitInteger t : myList) {`` ` `        ``// Initially column = LSB. So``        ``// if LSB of the given number is 0,``        ``// then the number is even and``        ``// hence we add it to evenIndices list.``        ``// else if LSB = 0 then add it to oddIndices list.``        ``if` `(t.fetch(column) == 0)``            ``evenIndices.push_back(t);``        ``else``            ``oddIndices.push_back(t);``    ``}`` ` `    ``// Step 1 and Step 2 of the algorithm.``    ``// Here we determine the LSB bit of missing number.`` ` `    ``if` `(oddIndices.size() >= evenIndices.size())`` ` `        ``// LSB of the missing number is 0.``        ``// Hence it is an even number.``        ``// Step 3 and 4 of the algorithm``        ``// (discarding all odd numbers)``        ``return` `(findMissingFunc(evenIndices, column - 1)) << 1 | 0;`` ` `    ``else``        ``// LSB of the missing number is 1.``        ``// Hence it is an odd number.``        ``// Step 3 and 4 of the algorithm``        ``// (discarding all even numbers)``        ``return` `(findMissingFunc(oddIndices, column - 1)) << 1 | 1;``}`` ` `// Function to return the missing integer``int` `findMissing(list& myList)``{``    ``// Initial call is with given array and LSB.``    ``return` `findMissingFunc(myList, BitInteger::INTEGER_SIZE - 1);``}`` ` `// Driver Code.``int` `main()``{`` ` `    ``// a corresponds to the input array which``    ``// is a list of binary numbers``    ``list a = { BitInteger(``"0000"``), BitInteger(``"0001"``),``                           ``BitInteger(``"0010"``), BitInteger(``"0100"``),``                           ``BitInteger(``"0101"``) };``    ``int` `missing1 = findMissing(a);``    ``cout << missing1 << ``"\n"``;`` ` `    ``return` `0;``}`
Output:
```3
```

Time Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up