Number of Substrings Containing All Three Characters

Number of Substrings Containing All Three Characters - Problem

Imagine you're analyzing DNA sequences! You have a string s composed exclusively of three nucleotide bases: a, b, and c. Your task is to find how many contiguous subsequences (substrings) contain at least one occurrence of each of these three characters.

For example, if your DNA sequence is "abcabc", you need to count all substrings that have at least one 'a', one 'b', and one 'c'. The substring "abc" qualifies, as does "abca", "abcab", and the entire string "abcabc".

Goal: Return the total count of such valid substrings.

Input & Output

example_1.py — Basic Case

$ Input: s = "abcabc"

› Output: 10

💡 Note: The substrings containing at least one occurrence of 'a', 'b', and 'c' are: "abc", "abca", "abcab", "abcabc", "bca", "bcab", "bcabc", "cab", "cabc", "abc" (the second occurrence). Total count = 10.

example_2.py — Minimum Valid Case

$ Input: s = "aaacb"

› Output: 3

💡 Note: The valid substrings are: "aaacb", "aacb", "acb". These are the only substrings that contain at least one of each character 'a', 'b', and 'c'.

example_3.py — No Valid Substrings

$ Input: s = "abc"

› Output: 1

💡 Note: Only one substring "abc" contains all three characters. This is the minimum possible valid case.

Visualization

Tap to expand

Understanding the Visualization

Track Base Positions

As you scan the DNA sequence, remember where you last encountered each base

Calculate Valid Segments

At any position, segments ending here are valid if they start from position 0 up to the minimum last-seen position

Count Efficiently

Add min(last_positions) + 1 to your total count for each position

Single Pass Complete

One scan through the sequence gives you the complete answer

Key Takeaway

🎯 Key Insight: Instead of checking every possible substring, track the last positions of each required character. The number of valid substrings ending at any position is simply the minimum of these positions plus one!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant time operations at each step

✓ Linear Growth

Space Complexity

O(1)

Only storing three position variables regardless of input size

✓ Linear Space

Constraints

3 ≤ s.length ≤ 5 × 10⁴
s consists only of 'a', 'b', and 'c' characters
The string contains at least one character of each type for non-zero results

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18 Apple 15

The optimal solution uses a sliding window approach with position tracking. Instead of checking every substring individually, we maintain the last seen positions of characters 'a', 'b', and 'c'. For each position, the number of valid substrings ending at that position equals min(last_a, last_b, last_c) + 1, achieving O(n) time complexity with constant space.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Position Tracking (Optimal)	O(n)	O(1)	Track last seen positions of a, b, c and calculate valid substrings ending at current position
Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it contains all three characters

Sliding Window with Position Tracking (Optimal) — Algorithm Steps

Initialize variables to track last seen positions of 'a', 'b', 'c' as -1
Iterate through the string, updating the position of current character
At each position, if all three characters have been seen, calculate valid substrings
Valid substrings ending at current position = min(last_a, last_b, last_c) + 1
Add this count to the total result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize position tracking

Set last_a, last_b, last_c to -1

Update positions as we scan

Update position of current character

Calculate valid substrings

When all characters seen, add min(positions) + 1 to count

Continue scanning

Repeat for each character in string

Code -

solution.c — C

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

int min3(int a, int b, int c) {
    int min_val = a;
    if (b < min_val) min_val = b;
    if (c < min_val) min_val = c;
    return min_val;
}

int numberOfSubstrings(char* s) {
    int lastPos[3] = {-1, -1, -1}; // for 'a', 'b', 'c'
    int count = 0;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        char c = s[i];
        lastPos[c - 'a'] = i;
        
        if (lastPos[0] != -1 && lastPos[1] != -1 && lastPos[2] != -1) {
            count += min3(lastPos[0], lastPos[1], lastPos[2]) + 1;
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant time operations at each step

✓ Linear Growth

Space Complexity

O(1)

Only storing three position variables regardless of input size

✓ Linear Space

Constraints

3 ≤ s.length ≤ 5 × 10⁴
s consists only of 'a', 'b', and 'c' characters
The string contains at least one character of each type for non-zero results

48.2K Views

High Frequency

~15 min Avg. Time

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

Sliding Window with Position Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler