Number of Wonderful Substrings - Practice Coding Problems

Number of Wonderful Substrings - Problem

A wonderful string is a string where at most one letter appears an odd number of times. This means all letters can appear an even number of times, or exactly one letter can appear an odd number of times while all others appear an even number of times.

Examples of wonderful strings:

"ccjjc" - 'c' appears 3 times (odd), 'j' appears 2 times (even)
"abab" - 'a' appears 2 times (even), 'b' appears 2 times (even)
"a" - 'a' appears 1 time (odd)

Not wonderful: "ab" - both 'a' and 'b' appear 1 time (two letters with odd counts)

Given a string word consisting of the first ten lowercase English letters ('a' through 'j'), return the number of wonderful non-empty substrings in the word. Each occurrence of a substring is counted separately, even if the substring appears multiple times.

Input & Output

example_1.py — Basic Case

$ Input: word = "aba"

› Output: 4

💡 Note: The wonderful substrings are: "a" (position 0), "b" (position 1), "a" (position 2), and "aba" (entire string). Note that "ab" and "ba" are not wonderful since both have two characters with odd counts.

example_2.py — All Even Counts

$ Input: word = "aabb"

› Output: 9

💡 Note: All possible substrings where at most one character appears an odd number of times: "a", "a", "b", "b" (single chars), "aa", "bb" (pairs), "aab", "abb" (three chars), "aabb" (full string).

example_3.py — Single Character

$ Input: word = "he"

› Output: 2

💡 Note: The wonderful substrings are "h" and "e". The substring "he" is not wonderful because both 'h' and 'e' appear an odd number of times (once each).

Visualization

Tap to expand

Understanding the Visualization

Initialize State

Start with all switches OFF (bitmask = 0)

Process Characters

For each character, flip its corresponding switch

Check Compatibility

Look for previous states that match or differ by one switch

Count Results

Add compatible pairs to the total count

Key Takeaway

🎯 Key Insight: By representing character parity as bits and using XOR operations, we can efficiently track state changes and find compatible substring pairs in O(n) time!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, constant time hash map operations

✓ Linear Growth

Space Complexity

O(min(n, 2^10))

Hash map stores at most n+1 bitmasks, but only 2^10=1024 possible bitmasks

⚡ Linearithmic Space

Constraints

1 ≤ word.length ≤ 10⁵
word consists of only the first ten lowercase English letters ('a' through 'j')
A substring is a contiguous sequence of characters within the string

Asked in

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

The optimal solution uses bit manipulation with a hash map to achieve O(n) time complexity. Each bit in a bitmask represents whether a character appears an odd number of times. Two positions form a wonderful substring if their bitmasks are identical (all even) or differ by exactly one bit (one character odd).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all substrings and count character frequencies for each
Bit Manipulation + Hash Map (Optimal)	O(n)	O(min(n, 2^10))	Use bitmask to represent character parity and prefix sum technique

Brute Force (Check All Substrings) — Algorithm Steps

Iterate through all possible starting positions i
For each i, iterate through all possible ending positions j
Count character frequencies in substring[i:j+1]
Check if at most one character has odd frequency
If wonderful, increment counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings using nested loops

Count Characters

For each substring, count frequency of each character

Check Wonderful

Verify at most one character has odd frequency

Code -

solution.c — C

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

long long wonderfulSubstrings(char* word) {
    int n = strlen(word);
    long long count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Count frequency of each character (a-j)
            int freq[10] = {0};
            for (int k = i; k <= j; k++) {
                freq[word[k] - 'a']++;
            }
            
            // Check if at most one character has odd frequency
            int oddCount = 0;
            for (int k = 0; k < 10; k++) {
                if (freq[k] % 2 == 1) oddCount++;
            }
            
            if (oddCount <= 1) {
                count++;
            }
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to count frequencies for each

⚠ Quadratic Growth

Space Complexity

O(1)

Only need constant space to store character counts (at most 10 characters)

✓ Linear Space

Constraints

1 ≤ word.length ≤ 10⁵
word consists of only the first ten lowercase English letters ('a' through 'j')
A substring is a contiguous sequence of characters within the string

42.8K Views

Medium-High Frequency

~25 min Avg. Time

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