Check if Binary String Has at Most One Segment of Ones

Check if Binary String Has at Most One Segment of Ones - Problem

String Easy

Given a binary string s without leading zeros, determine if the string contains at most one contiguous segment of ones.

A contiguous segment means consecutive '1' characters that are not separated by any '0' characters. For example:

"1111" has one segment of ones
"101" has two segments of ones
"1100" has one segment of ones

Return true if the string has at most one contiguous segment of ones, otherwise return false.

Key insight: Since there are no leading zeros, if there are multiple segments of ones, we must encounter the pattern "01" somewhere in the string (a '0' followed by a '1').

Input & Output

example_1.py — Basic case with one segment

$ Input: s = "1111"

› Output: true

💡 Note: The string contains only consecutive '1's forming exactly one contiguous segment.

example_2.py — Multiple segments

$ Input: s = "101"

› Output: false

💡 Note: The string has two separate segments of '1's: one at position 0 and another at position 2, separated by '0' at position 1.

example_3.py — One segment followed by zeros

$ Input: s = "1100"

› Output: true

💡 Note: The string has one contiguous segment of '1's at the beginning, followed by '0's. This counts as having at most one segment.

Constraints

1 ≤ s.length ≤ 100
s[i] is either '0' or '1'
s does not contain leading zeros (first character is always '1')

Visualization

Tap to expand

Understanding the Visualization

Understand the Pattern

Since no leading zeros exist, string must start with '1'

Identify Key Insight

Multiple segments require reconnecting: 111...000...111

Look for Evidence

Any '01' substring proves multiple segments exist

Early Termination

Return false immediately when '01' is found

Key Takeaway

🎯 Key Insight: Since there are no leading zeros, any '01' pattern proves multiple segments exist - making this an O(n) pattern matching problem rather than a segment counting problem.

Asked in

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

The optimal solution leverages a key insight: since there are no leading zeros, finding any '01' pattern in the string guarantees multiple segments exist. This allows us to solve the problem in O(n) time with a simple pattern search instead of counting segments explicitly.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Pattern Check (Optimal)	O(n)	O(1)	Check for '01' pattern in a single pass - if found, multiple segments exist
Brute Force (Count All Segments)	O(n)	O(1)	Iterate through string and count all contiguous segments of ones

One-Pass Pattern Check (Optimal) — Algorithm Steps

Iterate through the string from index 0 to n-2
Check if current character is '0' and next character is '1'
If we find '01' pattern, return false immediately
If we complete the scan without finding '01', return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Key Insight

Multiple segments mean '01' pattern exists

Single Scan

Check each adjacent pair of characters

Pattern Found

Return false immediately on finding '01'

No Pattern

Return true if scan completes without '01'

Code -

solution.c — C

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

bool hasAtMostOneSegment(char* s) {
    // Check for "01" pattern
    return strstr(s, "01") == NULL;
}

// Alternative implementation with explicit loop
bool hasAtMostOneSegmentLoop(char* s) {
    int len = strlen(s);
    for (int i = 0; i < len - 1; i++) {
        if (s[i] == '0' && s[i + 1] == '1') {
            return false;
        }
    }
    return true;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        for (int i = 1; i < len-1; i++) {
            s[i-1] = s[i];
        }
        s[len-2] = '\0';
    }
    printf("%s\n", hasAtMostOneSegment(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, with potential for early termination

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for loop variables

✓ Linear Space

28.4K Views

Medium Frequency

~8 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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Pattern Check (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler