Number of Wonderful Substrings

Number of Wonderful Substrings - Problem

A wonderful string is a string where at most one letter appears an odd number of times.

For example, "ccjjc" and "abab" are wonderful, but "ab" is not.

Given a string word that consists of the first ten lowercase English letters ('a' through 'j'), return the number of wonderful non-empty substrings in word. If the same substring appears multiple times in word, then count each occurrence separately.

A substring is a contiguous sequence of characters in a string.

Input & Output

Example 1 — Basic Wonderful String

$ Input: word = "aba"

› Output: 4

💡 Note: Four wonderful substrings: "a" (index 0), "b" (index 1), "a" (index 2), and "aba" (indices 0-2). All single characters are wonderful, and "aba" has 'a' appearing 2 times (even) and 'b' appearing 1 time (odd) - at most one odd count.

Example 2 — All Single Characters

$ Input: word = "aabb"

› Output: 9

💡 Note: Single character substrings: "a", "a", "b", "b" (4 total). Two character substrings: "aa", "ab", "bb" (3 total). Three character: "aab", "abb" (2 total). Four character: "aabb" (1 total). Total: 4+3+2+0 = 9 wonderful substrings.

Example 3 — No Wonderful Multi-Character Substrings

$ Input: word = "he"

› Output: 2

💡 Note: Only the single character substrings "h" and "e" are wonderful. The substring "he" has both characters appearing once (2 odd counts > 1), so it's not wonderful.

Constraints

1 ≤ word.length ≤ 10⁵
word consists of lowercase English letters from 'a' to 'j'

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 a Amazon 22

The key insight is to use bit manipulation to efficiently track character frequency parity. Each bit in a mask represents whether a character appears an odd number of times. Two substrings with the same mask or masks differing by exactly one bit form wonderful substrings. Best approach uses hash map with bitmasks: Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Check All Substrings

⏱️ Time: O(n³) Space: O(1)

For each possible substring, count the frequency of each character and verify that at most one character appears an odd number of times. This requires checking all O(n²) possible substrings.

Optimal Bit Manipulation with Hash Map

⏱️ Time: O(n) Space: O(n)

Represent the odd/even state of each character using a bitmask. Two substrings with the same mask or masks differing by exactly one bit form wonderful substrings. Use a hash map to count occurrences of each mask state.

Prefix Sum with Frequency Tracking

⏱️ Time: O(n²) Space: O(1)

Instead of recalculating frequencies for each substring, maintain running frequency counts as we extend substrings. For each starting position, extend the substring character by character while updating frequencies.

Brute Force - Check All Substrings — Algorithm Steps

Generate all possible substrings
For each substring, count character frequencies
Check if at most one character has odd frequency
Count valid wonderful substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible contiguous substrings

Count Frequencies

For each substring, count how many times each character appears

Check Wonderful

Verify at most one character has odd frequency

Code -

solution.c — C

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

long long solution(char* word) {
    int n = strlen(word);
    long long count = 0;
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Count frequency of each character in substring
            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 l = 0; l < 10; l++) {
                if (freq[l] % 2 == 1) {
                    oddCount++;
                }
            }
            
            if (oddCount <= 1) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char word[100001];
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;  // Remove newline
    
    long long result = solution(word);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Two nested loops generate O(n²) substrings, each requiring O(n) time to count frequencies

✓ Linear Growth

Space Complexity

O(1)

Only using fixed-size frequency array for 10 characters

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

856 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

Brute Force - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler