Longer Contiguous Segments of Ones than Zeros

Longer Contiguous Segments of Ones than Zeros - Problem

String Easy

Given a binary string s, determine whether the longest contiguous segment of 1's is strictly longer than the longest contiguous segment of 0's.

A contiguous segment is a sequence of consecutive identical characters. For example:

In "110100010", the longest segment of 1's has length 2 ("11")
The longest segment of 0's has length 3 ("000")
Since 2 < 3, we return false

Special cases:

If there are no 0's in the string, the longest segment of 0's is considered to have length 0
If there are no 1's in the string, the longest segment of 1's is considered to have length 0

Return true if the longest segment of 1's is strictly longer than the longest segment of 0's, otherwise return false.

Input & Output

example_1.py — Basic Case

$ Input: s = "1101"

› Output: true

💡 Note: The longest segment of 1's is "11" with length 2. The longest segment of 0's is "0" with length 1. Since 2 > 1, return true.

example_2.py — Longer Zeros

$ Input: s = "110100010"

› Output: false

💡 Note: The longest segment of 1's is "11" with length 2. The longest segment of 0's is "000" with length 3. Since 2 < 3, return false.

example_3.py — Only Ones

$ Input: s = "111"

› Output: true

💡 Note: The longest segment of 1's is "111" with length 3. There are no 0's, so the longest segment of 0's has length 0. Since 3 > 0, return true.

Visualization

Tap to expand

Understanding the Visualization

Initialize Tracking

Set up counters for current segment length and maximum lengths seen so far

Scan Characters

Move through each character, extending current segment or starting a new one

Update Records

When a segment ends, check if it beats the current record for that character type

Final Comparison

Compare the longest 1's segment with longest 0's segment to get the answer

Key Takeaway

🎯 Key Insight: By tracking segment lengths in a single pass, we can efficiently determine the winner without needing to store or re-examine any part of the string, achieving optimal O(n) time and O(1) space complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, examining each character exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant number of variables regardless of input size

✓ Linear Space

Constraints

1 ≤ s.length ≤ 500
s consists only of characters '0' and '1'

Asked in

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

The optimal approach uses a single pass through the string with O(n) time and O(1) space complexity. We track the current segment length and update maximum lengths whenever we encounter a character different from the previous one. This efficiently identifies the longest contiguous segments of both 1's and 0's in one traversal.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Optimal Solution	O(n)	O(1)	Single pass through string tracking current and maximum segment lengths
Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to find longest segments

One-Pass Optimal Solution — Algorithm Steps

Initialize variables to track current segment length and maximum lengths
Iterate through each character in the string
If current character matches previous, increment current segment length
If current character differs, update maximum for previous character and reset current length
After loop, update maximum one final time for the last segment
Compare maximum lengths and return result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up variables to track current and maximum segment lengths

Scan Forward

Move through string, extending current segment or starting new one

Update Maximums

When segment ends, check if it's the longest seen so far

Final Update

Handle the last segment after loop ends

Code -

solution.c — C

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

bool checkZeroOnes(char* s) {
    int len = strlen(s);
    if (len == 0) return false;
    
    int maxOnes = 0;
    int maxZeros = 0;
    int currentLength = 1;
    
    // Single pass through the string
    for (int i = 1; i < len; i++) {
        if (s[i] == s[i-1]) {
            // Continue current segment
            currentLength++;
        } else {
            // Segment ended, update maximum
            if (s[i-1] == '1') {
                if (currentLength > maxOnes) {
                    maxOnes = currentLength;
                }
            } else {
                if (currentLength > maxZeros) {
                    maxZeros = currentLength;
                }
            }
            currentLength = 1;
        }
    }
    
    // Handle the last segment
    if (s[len-1] == '1') {
        if (currentLength > maxOnes) {
            maxOnes = currentLength;
        }
    } else {
        if (currentLength > maxZeros) {
            maxZeros = currentLength;
        }
    }
    
    return maxOnes > maxZeros;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = 0;
        memmove(s, s+1, strlen(s));
    }
    printf("%s\n", checkZeroOnes(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, examining each character exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant number of variables regardless of input size

✓ Linear Space

Constraints

1 ≤ s.length ≤ 500
s consists only of characters '0' and '1'

28.5K Views

Medium Frequency

~15 min Avg. Time

850 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

One-Pass Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler