Count Substrings That Satisfy K-Constraint I

Count Substrings That Satisfy K-Constraint I - Problem

You're given a binary string s (containing only '0's and '1's) and an integer k. Your task is to find how many substrings of s satisfy the k-constraint.

A substring satisfies the k-constraint if at least one of these conditions is true:

The number of '0's in the substring is at most k
The number of '1's in the substring is at most k

Example: If s = "10101" and k = 1, the substring "101" has 2 zeros and 1 one. Since the number of ones (1) ≤ k (1), it satisfies the constraint!

Return the total count of all valid substrings.

Input & Output

example_1.py — Basic Case

$ Input: s = "10101", k = 1

› Output: 12

💡 Note: The valid substrings are: "1" (1 one), "10" (1 zero, 1 one), "101" (1 zero), "0" (1 zero), "01" (1 zero, 1 one), "010" (2 zeros, 1 one - ones≤k), "1" (1 one), "10" (1 zero, 1 one), "101" (1 zero), "0" (1 zero), "01" (1 zero, 1 one), "1" (1 one). Total: 12 substrings.

example_2.py — All Valid

$ Input: s = "1001", k = 2

› Output: 10

💡 Note: With k=2, most substrings are valid since we allow up to 2 of each character. All 10 possible substrings satisfy the k-constraint: "1", "10", "100", "1001", "0", "00", "001", "0", "01", "1".

example_3.py — Edge Case

$ Input: s = "111", k = 1

› Output: 6

💡 Note: All substrings contain only 1's, so they all satisfy 'ones ≤ k' condition. The 6 substrings are: "1" (×3), "11" (×2), "111" (×1). Total: 3+2+1 = 6.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
0 ≤ k ≤ s.length
Each substring must be contiguous

Visualization

Tap to expand

Understanding the Visualization

Set Up Window

Start with an empty window at the beginning of the string

Expand Window

Keep adding items to the right side of the window

Check Validity

Window is valid if zeros ≤ k OR ones ≤ k (at least one condition)

Shrink If Needed

If both zeros > k AND ones > k, remove items from the left

Count Substrings

For current right position, count all valid substrings ending here

Key Takeaway

🎯 Key Insight: Instead of checking every substring individually (O(n³)), we use a sliding window to find the furthest valid starting position for each ending position, then count all valid substrings in O(1) time per position, achieving optimal O(n) complexity.

Asked in

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

The optimal solution uses a sliding window approach with two pointers. For each position, we maintain the furthest valid starting point and count all substrings ending at the current position. This achieves O(n) time complexity compared to the brute force O(n³) approach, making it efficient for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Two Pointers)	O(n)	O(1)	Use sliding window technique to efficiently count valid substrings
Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all possible substrings and check each one against the k-constraint

Sliding Window (Two Pointers) — Algorithm Steps

Initialize left pointer, counts for zeros and ones, and result counter
For each right pointer position, add the current character to our counts
While the current window violates k-constraint (both counts > k), shrink from left
Count all valid substrings ending at current right position: (right - left + 1)
Move right pointer and repeat until end of string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Start with left=0, right=0, and zero counters

Expand Window

Move right pointer and update character counts

Check Constraint

If both counts > k, shrink window from left

Count Substrings

Add (right - left + 1) to result for current position

Code -

solution.c — C

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

int countKConstraintSubstrings(char* s, int k) {
    int n = strlen(s);
    int left = 0;
    int zeros = 0, ones = 0;
    int result = 0;
    
    for (int right = 0; right < n; right++) {
        // Add current character to window
        if (s[right] == '0') {
            zeros++;
        } else {
            ones++;
        }
        
        // Shrink window while constraint is violated
        while (zeros > k && ones > k) {
            if (s[left] == '0') {
                zeros--;
            } else {
                ones--;
            }
            left++;
        }
        
        // All substrings ending at 'right' and starting from 'left' to 'right' are valid
        result += right - left + 1;
    }
    
    return result;
}

int main() {
    char s[1001];
    int k;
    fgets(s, sizeof(s), stdin);
    scanf("%d", &k);
    
    // Remove newline and quotes if present
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = 0;
    }
    
    printf("%d\n", countKConstraintSubstrings(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is visited at most twice (once by right pointer, once by left pointer)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track pointers and counts

✓ Linear Space

28.5K 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

Constraints

Visualization

Related Problems

Common Approaches

Sliding Window (Two Pointers) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler