Check If a String Contains All Binary Codes of Size K

Check If a String Contains All Binary Codes of Size K - Problem

Imagine you're a cryptographer working with binary codes! Given a binary string s and an integer k, you need to determine if every possible binary code of length k appears as a substring within s.

For example, if k = 2, there are exactly 4 possible binary codes: "00", "01", "10", and "11". Your task is to check if all of these appear somewhere in the given string s.

Goal: Return true if every binary code of length k is a substring of s, otherwise return false.

Input & Output

example_1.py — Basic case with k=2

$ Input: s = "00110110", k = 2

› Output: true

💡 Note: The 4 possible binary codes of length 2 are: "00", "01", "10", and "11". All of these appear as substrings in "00110110": "00" at index 0, "01" at index 1, "11" at index 2, and "10" at index 5.

example_2.py — Missing code case

$ Input: s = "0110", k = 1

› Output: true

💡 Note: The 2 possible binary codes of length 1 are: "0" and "1". Both appear in "0110": "0" at indices 0 and 3, "1" at indices 1 and 2.

example_3.py — Insufficient length

$ Input: s = "0110", k = 2

› Output: false

💡 Note: The 4 possible binary codes of length 2 are: "00", "01", "10", "11". In string "0110" we can find: "01", "11", "10", but "00" is missing.

Visualization

Tap to expand

Understanding the Visualization

Setup

Place sliding window of size k at the start of string

Extract

Extract the k-length substring and add to hash set

Slide

Move window one position right and repeat

Check

Stop when we have 2^k unique codes or reach end

Key Takeaway

🎯 Key Insight: We only need to collect 2^k unique substrings, and the sliding window approach with hash set allows us to do this optimally in one pass with early termination.

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

Single pass through string of length n, with k time to process each substring

✓ Linear Growth

Space Complexity

O(2^k × k)

Hash set stores at most 2^k strings, each of length k

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁵
s[i] is either '0' or '1'
1 ≤ k ≤ 20
The string s consists only of binary digits

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 25

The optimal solution uses a sliding window technique with a hash set to collect all unique k-length substrings in a single pass. The key insight is that we need exactly 2^k unique substrings, and we can stop early once we've found them all. This achieves O(n × k) time complexity with early termination optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Codes)	O(n × 2^k × k)	O(k)	Generate all possible k-length binary codes and check if each exists in the string
One-Pass Hash Set (Optimal)	O(n × k)	O(2^k × k)	Use sliding window to collect all k-length substrings in one pass

Brute Force (Generate All Codes) — Algorithm Steps

Generate all 2^k possible binary codes of length k
For each generated code, search if it exists as a substring in s
If any code is missing, return false
If all codes are found, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Code

Generate binary code: 00

Search String

Search for '00' in string

Next Code

Generate next code: 01

Continue

Repeat for all 2^k codes

Code -

solution.c — C

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

bool hasAllCodes(char* s, int k) {
    int len = strlen(s);
    if (len < k) {
        return false;
    }
    
    int totalCodes = 1 << k; // 2^k
    
    for (int i = 0; i < totalCodes; i++) {
        char binaryCode[k + 1];
        // Convert number to binary string
        for (int j = 0; j < k; j++) {
            binaryCode[k - 1 - j] = ((i >> j) & 1) ? '1' : '0';
        }
        binaryCode[k] = '\0';
        
        // Check if this code exists in s
        if (strstr(s, binaryCode) == NULL) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char s[100000];
    int k;
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    scanf("%d", &k);
    printf("%s\n", hasAllCodes(s, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^k × k)

We generate 2^k codes, and for each code we search through string of length n, with k characters to compare

✓ Linear Growth

Space Complexity

O(k)

Only need space to store the current binary code being checked

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁵
s[i] is either '0' or '1'
1 ≤ k ≤ 20
The string s consists only of binary digits

25.8K Views

Medium Frequency

~18 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Codes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler