Count the Number of Substrings With Dominant Ones

Count the Number of Substrings With Dominant Ones - Problem

String Enumeration Medium

You are given a binary string s containing only '0' and '1' characters. Your task is to find the number of substrings where the ones are dominant.

A substring has dominant ones if:

The number of ones ≥ (number of zeros)²
In mathematical terms: count_of_ones ≥ count_of_zeros²

Example: In substring "101", we have 2 ones and 1 zero. Since 2 ≥ 1², this substring has dominant ones.

Return the total count of all such substrings in the given binary string.

Input & Output

example_1.py — Basic Case

$ Input: s = "10110"

› Output: 9

💡 Note: Valid substrings: "1"(×3), "10", "101", "1011", "11", "110", "0" (when zeros²=0). Total count is 9 substrings with dominant ones.

example_2.py — All Ones

$ Input: s = "111"

› Output: 6

💡 Note: All possible substrings have dominant ones since there are no zeros: "1"(×3), "11"(×2), "111"(×1). Total: 3+2+1 = 6.

example_3.py — Many Zeros

$ Input: s = "00011"

› Output: 5

💡 Note: Valid substrings are single '1' characters and substrings ending with enough ones: "1"(×2), "01", "001", "011". Total: 5 valid substrings.

Visualization

Tap to expand

Understanding the Visualization

Formation Scanning

Examine each possible formation (substring) starting from every position

Force Counting

Use running tallies to efficiently track soldiers and empty positions as formation extends

Dominance Check

Verify if current soldier count ≥ (empty positions)² for tactical superiority

Strategic Termination

Stop extending when mathematical impossibility detected (optimization)

Key Takeaway

🎯 Key Insight: The dominance condition ones ≥ zeros² creates natural bounds that allow early termination optimizations, making the O(n²) solution practical even for larger inputs.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) for generating all substrings, but with O(1) dominance checking per substring due to running counts

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for running counters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 4 × 10⁴
s[i] is either '0' or '1'
String contains only binary characters

Asked in

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

The optimal solution uses running counts to check all substrings in O(n²) time. Key insight: maintain running counters for ones and zeros while extending substrings, enabling O(1) dominance checking per substring and early termination optimizations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all possible substrings and count ones/zeros for each
Optimized Single Pass (Optimal)	O(n²)	O(1)	Use running counts to avoid redundant substring character counting

Brute Force (Check All Substrings) — Algorithm Steps

Use outer loop to select starting position of substring
Use inner loop to extend substring to all possible ending positions
For each substring, count ones and zeros
Check if ones >= zeros² and increment result counter
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first position

Begin checking substrings starting from index 0

Extend substring

For each start position, extend to create all possible substrings

Count and check

Count ones/zeros and verify dominance condition

Move to next start

Repeat process for next starting position

Code -

solution.c — C

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

int dominantOnes(char* s) {
    int n = strlen(s);
    int count = 0;
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        int ones = 0;
        int zeros = 0;
        
        for (int j = i; j < n; j++) {
            // Add current character to counts
            if (s[j] == '1') {
                ones++;
            } else {
                zeros++;
            }
            
            // Check dominance condition
            if (ones >= zeros * zeros) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char s[100000];
    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("%d\n", dominantOnes(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating all substrings × O(n) for counting characters in each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters and variables

✓ Linear Space

Constraints

1 ≤ s.length ≤ 4 × 10⁴
s[i] is either '0' or '1'
String contains only binary characters

12.4K Views

Medium Frequency

~15 min Avg. Time

342 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 All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler