Unique Substrings With Equal Digit Frequency

Unique Substrings With Equal Digit Frequency - Problem

Medium

Given a string s consisting only of digits (0-9), find the number of unique substrings where every digit that appears has the same frequency.

A substring is valid if all digits present in it appear exactly the same number of times. For example:

"112233" is valid because digits 1, 2, and 3 each appear exactly 2 times
"1123" is invalid because digit 1 appears 2 times while digits 2 and 3 appear 1 time each
"111" is valid because only digit 1 appears and it appears 3 times

Your task is to count all such unique valid substrings in the given string.

Input & Output

example_1.py — Basic Case

$ Input: s = "112233"

› Output: 4

💡 Note: Valid substrings are: "11" (digit 1 appears 2 times), "22" (digit 2 appears 2 times), "33" (digit 3 appears 2 times), and "112233" (digits 1,2,3 each appear 2 times). Total: 4 unique substrings.

example_2.py — Mixed Frequencies

$ Input: s = "1123"

› Output: 4

💡 Note: Valid substrings are: "1" (single digit), "1" (another single digit - but same as first, so only counted once), "2" (single digit), "3" (single digit). The full string "1123" is invalid because digit 1 appears 2 times while 2 and 3 appear 1 time each.

example_3.py — Single Digit

$ Input: s = "111"

› Output: 3

💡 Note: Valid substrings are: "1" (appears once), "11" (digit 1 appears twice), "111" (digit 1 appears three times). All are valid because only one unique digit is present in each.

Constraints

1 ≤ s.length ≤ 1000
s consists only of digits (0-9)
Each digit appears at most 1000 times in the string

Visualization

Tap to expand

Understanding the Visualization

Build the Score

Create a prefix sum 'score' tracking cumulative playtime for each instrument

Analyze Sections

For any musical phrase, subtract scores to get exact playtime per instrument

Check Harmony

Verify all playing instruments have equal duration

Collect Valid Phrases

Store unique harmonious sections

Key Takeaway

🎯 Key Insight: Prefix sums transform an expensive O(n) frequency counting operation into an elegant O(1) lookup, making our symphony analysis both efficient and beautiful!

Asked in

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

The optimal approach uses prefix sums to efficiently calculate digit frequencies in any substring in O(1) time. By building a cumulative count array for each digit (0-9), we can determine if all digits in a substring have equal frequency by checking the difference between prefix sums. This reduces the time complexity from O(n³) to O(n²) while maintaining clear, readable code.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(n²)	Generate all possible substrings and check each one for equal digit frequencies
Prefix Sum Optimization (Optimal)	O(n²)	O(n)	Use prefix sums to calculate digit frequencies in any substring in O(1) time

Brute Force (Check All Substrings) — Algorithm Steps

Iterate through each possible starting position i
For each starting position, iterate through each possible ending position j
Extract substring from i to j
Count frequency of each digit (0-9) in the substring
Check if all non-zero frequencies are equal
If valid, add substring to a set to ensure uniqueness
Return the size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Substrings

Start with first position, generate all substrings beginning there

Check Each Substring

Count digit frequencies in current substring

Validate Frequencies

Verify all present digits have same frequency

Store Valid Ones

Add valid substrings to set for uniqueness

Code -

solution.c — C

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

bool hasEqualFreq(char* s, int len) {
    int freq[10] = {0};
    for (int i = 0; i < len; i++) {
        freq[s[i] - '0']++;
    }
    
    int firstNonZero = -1;
    for (int i = 0; i < 10; i++) {
        if (freq[i] > 0) {
            if (firstNonZero == -1) {
                firstNonZero = freq[i];
            } else if (freq[i] != firstNonZero) {
                return false;
            }
        }
    }
    
    return true;
}

int numUniqueSubstrings(char* s) {
    int n = strlen(s);
    char substrings[1000][1000];
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (hasEqualFreq(s + i, j - i)) {
                strncpy(substrings[count], s + i, j - i);
                substrings[count][j - i] = '\0';
                
                bool duplicate = false;
                for (int k = 0; k < count; k++) {
                    if (strcmp(substrings[k], substrings[count]) == 0) {
                        duplicate = true;
                        break;
                    }
                }
                
                if (!duplicate) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    char* start = s;
    char* end = s + strlen(s) - 1;
    while (*start == '"' || *start == ' ' || *start == '\n') start++;
    while (*end == '"' || *end == ' ' || *end == '\n') end--;
    *(end + 1) = '\0';
    
    printf("%d\n", numUniqueSubstrings(start));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to check each substring's digit frequencies

⚠ Quadratic Growth

Space Complexity

O(n²)

O(n²) space to store all unique valid substrings in the worst case

⚠ Quadratic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

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