Find Unique Binary String - Practice Coding Problems

Find Unique Binary String - Problem

Imagine you're a digital librarian tasked with finding a missing book ID in a binary numbering system! You have an array of n unique binary strings, each exactly n characters long, but there's one missing from the complete set.

Your mission: Find any binary string of length n that doesn't appear in the given array.

Example: If you have ["01", "10"] (2 strings of length 2), the missing strings could be "00" or "11" - return either one!

This is a fascinating problem that combines combinatorics with clever algorithmic thinking. With n positions and 2 choices per position, there are 2^n possible binary strings, but you're only given n of them - so there are always 2^n - n missing strings to choose from.

Input & Output

example_1.py — Basic Case

$ Input: ["01", "10"]

› Output: "00"

💡 Note: With strings "01" and "10", the missing strings are "00" and "11". We can return either one. Using the diagonal method: flip nums[0][0]='0' to '1', flip nums[1][1]='0' to '1', giving us "11".

example_2.py — Single Character

$ Input: ["0"]

› Output: "1"

💡 Note: With only "0" given, the missing string is "1". The diagonal method flips nums[0][0]='0' to get '1'.

example_3.py — Three Characters

$ Input: ["111", "011", "001"]

› Output: "101"

💡 Note: Using diagonal method: flip nums[0][0]='1' → '0', flip nums[1][1]='1' → '0', flip nums[2][2]='1' → '0', resulting in "000". Any missing string like "000", "010", "100", "101", or "110" would be valid.

Constraints

n == nums.length
1 ≤ n ≤ 16
nums[i].length == n
nums[i] is either '0' or '1'
All strings in nums are unique

Visualization

Tap to expand

Understanding the Visualization

Examine the Catalog

Look at your existing binary book IDs arranged in a grid

Apply Diagonal Magic

For each position i, flip the i-th digit of the i-th book ID

Generate Unique ID

The resulting ID is guaranteed to be different from all existing ones

Key Takeaway

🎯 Key Insight: The diagonal method is mathematically elegant and optimal - it constructs a unique string in O(n) time with minimal space, guaranteed to work by the genius of Cantor's diagonal argument!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses Cantor's diagonal argument - flip the i-th character of the i-th string to construct a guaranteed unique result in O(n) time. This elegant approach ensures our answer differs from every input string in at least one position.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Lookup (Optimal)	O(2^n * n)	O(n)	Store all strings in a hash set, then generate candidates until we find a missing one
Cantor's Diagonal Argument (Clever)	O(n)	O(1)	Use diagonal method to construct a string that differs from each input string in exactly one position

Hash Set Lookup (Optimal) — Algorithm Steps

Create a hash set from the input array for fast lookups
Generate binary strings systematically (0, 1, 2, ...)
For each generated string, check if it exists in the hash set
Return the first string not found in the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

Convert array ["01", "10"] to hash set for O(1) lookups

Generate Candidates

Try "00", "01", "10", "11" until finding one not in set

Fast Lookup

Each lookup in hash set takes O(1) time

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

int stringExists(char** nums, int numsSize, char* target) {
    for (int i = 0; i < numsSize; i++) {
        if (strcmp(nums[i], target) == 0) {
            return 1;
        }
    }
    return 0;
}

char* findDifferentBinaryString(char** nums, int numsSize) {
    int n = numsSize;
    char* result = (char*)malloc((n + 1) * sizeof(char));
    result[n] = '\0';
    
    // Try all possible binary strings starting from 0
    for (int i = 0; i < (int)pow(2, n); i++) {
        // Convert number to binary string
        for (int j = n - 1; j >= 0; j--) {
            result[n - 1 - j] = ((i >> j) & 1) + '0';
        }
        
        if (!stringExists(nums, numsSize, result)) {
            return result;
        }
    }
    
    return result;
}

int main() {
    char* nums[] = {"01", "10"};
    char* result = findDifferentBinaryString(nums, 2);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

Worst case generates up to 2^n strings, each taking O(n) time to create

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set stores n strings, each of length n

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~12 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Hash Set Lookup (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler