Binary String With Substrings Representing 1 To N

Binary String With Substrings Representing 1 To N - Problem

Binary String With Substrings Representing 1 To N

You are given a binary string s and a positive integer n. Your task is to determine whether the binary representation of all integers from 1 to n can be found as substrings within s.

For example, if n = 3, you need to check if the binary representations of 1 ("1"), 2 ("10"), and 3 ("11") all exist as contiguous substrings in s.

Goal: Return true if all binary representations from 1 to n are substrings of s, otherwise return false.

A substring is a contiguous sequence of characters within a string. This problem tests your understanding of string manipulation, binary representations, and efficient searching techniques.

Input & Output

example_1.py — Simple Case

$ Input: s = "0110", n = 3

› Output: true

💡 Note: We need binary representations: 1→"1", 2→"10", 3→"11". All can be found in "0110": "1" at index 1, "10" at index 0-1, "11" at index 1-2.

example_2.py — Missing Binary

$ Input: s = "0110", n = 4

› Output: false

💡 Note: We need: 1→"1", 2→"10", 3→"11", 4→"100". The binary "100" cannot be found as a substring in "0110".

example_3.py — Large n Edge Case

$ Input: s = "1", n = 1000000

› Output: false

💡 Note: With string length 1, it's impossible to contain binary representations of all numbers up to 1,000,000. Early termination optimization catches this.

Visualization

Tap to expand

Understanding the Visualization

List Required Evidence

Convert each number 1 to n into its binary 'fingerprint'

Search the Scene

Look for each binary fingerprint in the evidence string

Early Elimination

If n is too large, some fingerprints would be longer than the evidence itself

Case Conclusion

Return true only if ALL binary fingerprints are found

Key Takeaway

🎯 Key Insight: The exponential growth of binary representations allows for powerful early termination - if n requires binary strings longer than our evidence string, the case is impossible to solve!

Time & Space Complexity

Time Complexity

⏱️

O(min(n * m * log n, 1))

O(1) for large n due to early termination, otherwise same as brute force

⚡ Linearithmic

Space Complexity

O(log n)

Space for binary representation storage

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 1000
s[i] is either '0' or '1'
1 ≤ n ≤ 10⁹
Note: For very large n, the problem becomes impossible due to binary length constraints

Asked in

G Google 25 f Facebook 15 a Amazon 12 ⊞ Microsoft 8

The optimal approach combines substring searching with early termination optimization. For each number from 1 to n, convert to binary and check if it exists in the string. The key insight is that for very large n values, the binary representations become too long to fit in a reasonably sized string, allowing us to return false immediately. Time complexity is O(n * m * log n) for feasible cases, but O(1) for impossible cases due to early termination.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Binary)	O(n * m * log n)	O(log n)	Convert each number to binary and check if it exists as substring
Optimized with Early Termination	O(min(n * m * log n, 1))	O(log n)	Add optimization by recognizing when n is too large for the string length

Brute Force (Check Each Binary) — Algorithm Steps

Iterate through numbers from 1 to n
Convert each number to its binary representation
Check if this binary string exists as a substring in s
If any binary representation is not found, return false
If all are found, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Binary

Convert number 1 to binary: "1"

Search in String

Look for "1" in the given string

Continue Process

Repeat for numbers 2, 3, ..., n

Code -

solution.c — C

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

void toBinary(int n, char* binary) {
    int index = 0;
    if (n == 0) {
        binary[0] = '0';
        binary[1] = '\0';
        return;
    }
    
    char temp[32];
    int tempIndex = 0;
    
    while (n > 0) {
        temp[tempIndex++] = '0' + (n % 2);
        n /= 2;
    }
    
    for (int i = tempIndex - 1; i >= 0; i--) {
        binary[index++] = temp[i];
    }
    binary[index] = '\0';
}

int queryString(char* s, int n) {
    for (int i = 1; i <= n; i++) {
        char binaryRepr[32];
        toBinary(i, binaryRepr);
        if (strstr(s, binaryRepr) == NULL) {
            return 0;
        }
    }
    return 1;
}

int main() {
    char s[1001];
    int n;
    scanf("\"%1000[^\"]\" %d", s, &n);
    
    printf("%s\n", queryString(s, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * log n)

O(n) numbers to check, O(m) string length for substring search, O(log n) for binary conversion

⚡ Linearithmic

Space Complexity

O(log n)

Space needed to store the binary representation of the largest number

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 1000
s[i] is either '0' or '1'
1 ≤ n ≤ 10⁹
Note: For very large n, the problem becomes impossible due to binary length constraints

28.4K Views

Medium Frequency

~15 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 (Check Each Binary) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler