Substrings of Size Three with Distinct Characters

Substrings of Size Three with Distinct Characters - Problem

Find All Good Substrings

Imagine you're analyzing text patterns to find "good" character sequences. A string is considered good when all its characters are unique - no repeating letters allowed!

Your mission: Given a string s, count how many good substrings of exactly length 3 exist within it.

Key Points:

🎯 We only care about substrings with exactly 3 characters
✨ All 3 characters must be different (like "abc", "xyz", "cat")
🔄 Count every occurrence, even if the same substring appears multiple times
📝 A substring is a contiguous sequence of characters

Example: In "xyzzaz", we have substrings "xyz" (good ✓), "yzz" (bad ✗), "zza" (bad ✗), "zaz" (good ✓). Answer: 2

Input & Output

example_1.py — Simple case

$ Input: s = "xyzzaz"

› Output: 2

💡 Note: The good substrings are "xyz" (positions 0-2) and "zaz" (positions 3-5). "yzz" and "zza" contain repeated characters so they don't count.

example_2.py — All good substrings

$ Input: s = "abcd"

› Output: 2

💡 Note: We have two possible 3-character substrings: "abc" (all different) and "bcd" (all different). Both are good, so the answer is 2.

example_3.py — Edge case

$ Input: s = "aab"

› Output: 0

💡 Note: The only 3-character substring is "aab" which has repeated 'a' characters, so it's not good. The answer is 0.

Constraints

1 ≤ s.length ≤ 100
s consists of lowercase English letters only
Note: We only count substrings of exactly length 3

Visualization

Tap to expand

Understanding the Visualization

Position the Frame

Place your 3-item window frame at the start of the street

Inspect Items

Check if all 3 visible items are different - if yes, count it!

Slide Forward

Move the frame one position right and repeat the inspection

Key Takeaway

🎯 Key Insight: Instead of examining every item in each window from scratch, we only need to check if the 3 current items are all different - a simple constant-time comparison!

Asked in

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

The optimal solution uses a sliding window approach with direct character comparison. Since we only need to check 3 characters at a time, we can simply compare a != b && b != c && a != c for each window position. This gives us O(n) time complexity with O(1) space, making it highly efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to efficiently track character uniqueness
Brute Force (Check Every Substring)	O(n)	O(1)	Check each possible 3-character substring individually

Sliding Window (Optimal) — Algorithm Steps

Initialize a sliding window of the first 3 characters
Check if the current window has all unique characters
Slide the window: remove the leftmost character, add the new rightmost character
For each new window position, check uniqueness in constant time
Continue until we've processed all possible windows

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize window

Start with first 3 characters

Check uniqueness

Compare the 3 characters directly

Slide window

Move window one position right

Code -

solution.c — C

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

int countGoodSubstrings(char* s) {
    int len = strlen(s);
    if (len < 3) return 0;
    
    int count = 0;
    
    // Check each 3-character window
    for (int i = 0; i <= len - 3; i++) {
        // Get the 3 characters in current window
        char a = s[i], b = s[i+1], c = s[i+2];
        
        // Check if all three are different
        if (a != b && b != c && a != c) {
            count++;
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant time operations for each character

✓ Linear Growth

Space Complexity

O(1)

Only storing at most 3 characters at any time, regardless of input size

✓ Linear Space

23.5K Views

Medium Frequency

~12 min Avg. Time

847 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler