Number of Substrings With Only 1s - Practice Coding Problems

Number of Substrings With Only 1s - Problem

Math String Medium

You're given a binary string s containing only characters '0' and '1'. Your task is to count all possible substrings that consist entirely of '1's.

A substring is a contiguous sequence of characters within a string. For example, in the string "111", the substrings containing only '1's are: "1" (appears 3 times), "11" (appears 2 times), and "111" (appears 1 time), for a total of 6 substrings.

Since the result can be very large, return the answer modulo 10⁹ + 7.

Example: For s = "0110111", the groups of consecutive '1's are "11" and "111". The first group contributes 3 substrings, the second contributes 6 substrings, totaling 9.

Input & Output

example_1.py — Basic Case

$ Input: s = "0110111"

› Output: 9

💡 Note: The groups of consecutive 1's are "11" (length 2) and "111" (length 3). Group 1 contributes 2*(2+1)/2 = 3 substrings. Group 2 contributes 3*(3+1)/2 = 6 substrings. Total: 3 + 6 = 9.

example_2.py — All Ones

$ Input: s = "111"

› Output: 6

💡 Note: One group of length 3. Using formula: 3*(3+1)/2 = 6. The substrings are: "1" (appears 3 times), "11" (appears 2 times), "111" (appears 1 time).

example_3.py — No Ones

$ Input: s = "000"

› Output: 0

💡 Note: No substrings contain only 1's, so the answer is 0.

Visualization

Tap to expand

Understanding the Visualization

Scan the Necklace

Move through each bead, identifying groups of white pearls

Measure Each Group

Count the length of consecutive white pearl segments

Apply Magic Formula

For each group of length n, calculate n*(n+1)/2 possible segments

Sum All Groups

Add up the contributions from all groups to get the final answer

Key Takeaway

🎯 Key Insight: Instead of checking every possible substring, we can group consecutive '1's and use the mathematical formula n*(n+1)/2 to instantly calculate the number of valid substrings for each group. This transforms an O(n³) brute force solution into an elegant O(n) mathematical approach!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to check each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
Return the result modulo 10⁹ + 7

Asked in

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

The optimal solution uses a mathematical approach with O(n) time complexity. Instead of checking every substring, we identify consecutive groups of '1's and apply the formula n*(n+1)/2 for each group of length n. This elegant solution runs in a single pass and uses constant extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all possible substrings and count those containing only '1's
Mathematical Approach (Optimal)	O(n)	O(1)	Find consecutive groups of '1's and use formula n*(n+1)/2 for each group

Brute Force (Check All Substrings) — Algorithm Steps

Use outer loop to iterate through each starting position
Use inner loop to extend substring from current start position
For each substring, check if all characters are '1's
If yes, increment the counter
Return the final count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position i=0

Check all substrings starting at position 0

Extend Substring

For each start, extend the substring one character at a time

Validate

Check if current substring contains only '1's

Count

If valid, increment counter and continue

Code -

solution.c — C

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

int numSub(char* s) {
    const int MOD = 1000000007;
    int count = 0;
    int n = strlen(s);
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Check if substring contains only '1's
            int valid = 1;
            for (int k = i; k <= j; k++) {
                if (s[k] != '1') {
                    valid = 0;
                    break;
                }
            }
            if (valid) {
                count = (count + 1) % MOD;
            }
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to check each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
Return the result modulo 10⁹ + 7

28.4K Views

Medium Frequency

~15 min Avg. Time

890 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