Unique Substrings With Equal Digit Frequency

Unique Substrings With Equal Digit Frequency - Problem

\ Medium

You are given a string s that consists only of digits (0-9). Your task is to find the number of unique substrings where every digit that appears in the substring appears the same number of times.

Examples of valid substrings:

In substring "112233", digits 1, 2, and 3 each appear exactly 2 times - this is valid
In substring "111", only digit 1 appears and it appears 3 times - this is valid
In substring "1", only digit 1 appears once - this is valid

Examples of invalid substrings:

In substring "1123", digit 1 appears 2 times while digits 2 and 3 appear 1 time each - this is invalid
In substring "12223", digit 2 appears 3 times while digits 1 and 3 appear 1 time each - this is invalid

Return the number of unique substrings that satisfy this condition.

Input & Output

Example 1 — Basic Case

$ Input: s = "1123"

› Output: 4

💡 Note: Valid substrings are: "1" (appears twice as different substrings but same string), "11" (digit 1 appears 2 times), "2" (digit 2 appears 1 time), "3" (digit 3 appears 1 time). Unique count is 4.

Example 2 — All Same Digits

$ Input: s = "111"

› Output: 3

💡 Note: Valid substrings are: "1", "11", "111". All contain only digit 1 with consistent frequency within each substring.

Example 3 — Single Digit

$ Input: s = "5"

› Output: 1

💡 Note: Only one substring "5" which trivially has equal frequency (digit 5 appears once).

Constraints

1 ≤ s.length ≤ 1000
s consists only of digits (0-9)

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is using prefix sums to calculate digit frequencies for any substring in O(1) time. The optimal approach uses prefix arrays to track cumulative counts, enabling efficient validation of the equal frequency condition. Best approach: Prefix Sum. Time: O(n²), Space: O(n²)

Common Approaches

✓ Brute Force - Check All Substrings

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

For each possible substring, count the frequency of each digit and verify that all present digits have the same count. Use a set to store valid substrings to ensure uniqueness.

Prefix Sum Optimization

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

Pre-calculate cumulative counts of each digit up to each position. For any substring from index i to j, we can find digit frequencies using prefix[j+1] - prefix[i] in constant time.

Brute Force - Check All Substrings — Algorithm Steps

Step 1: Generate all possible substrings using nested loops
Step 2: For each substring, count frequency of each digit 0-9
Step 3: Check if all non-zero frequencies are equal
Step 4: Add valid substrings to set and return set size

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings using nested loops

Count Frequencies

For each substring, count how often each digit appears

Validate

Check if all present digits have equal frequency

Code -

solution.c — C

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

bool isValid(const char* s, int start, int end) {
    int freq[10] = {0};
    
    // Count frequencies
    for (int i = start; i <= end; i++) {
        freq[s[i] - '0']++;
    }
    
    // Find first non-zero frequency
    int expectedFreq = -1;
    for (int i = 0; i < 10; i++) {
        if (freq[i] > 0) {
            if (expectedFreq == -1) {
                expectedFreq = freq[i];
            } else if (freq[i] != expectedFreq) {
                return false;
            }
        }
    }
    
    return true;
}

int solution(const char* s) {
    int n = strlen(s);
    char validSubstrings[10000][1001];
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            if (isValid(s, i, j)) {
                char substring[1001];
                int len = j - i + 1;
                strncpy(substring, s + i, len);
                substring[len] = '\0';
                
                // Check if already exists
                bool exists = false;
                for (int k = 0; k < count; k++) {
                    if (strcmp(validSubstrings[k], substring) == 0) {
                        exists = true;
                        break;
                    }
                }
                
                if (!exists) {
                    strcpy(validSubstrings[count], substring);
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to check each substring

⚠ Quadratic Growth

Space Complexity

O(n³)

Set can store up to O(n²) substrings, each of length O(n)

⚠ Quadratic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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