Reconstruct Original Digits from English

Reconstruct Original Digits from English - Problem

Given a string s containing an out-of-order English representation of digits 0-9, return the digits in ascending order.

The string contains English words for digits like "zero", "one", "two", etc., but the letters are jumbled together. Your task is to figure out which digits are present and return them sorted.

Note: Each digit appears at most once in the input string.

Input & Output

Example 1 — Basic Mixed Digits

$ Input: s = "owtzero"

› Output: "02"

💡 Note: The string contains letters for "zero" (z,e,r,o) and "two" (t,w,o). Since we need ascending order, return "02".

Example 2 — Single Digit

$ Input: s = "fviefuro"

› Output: "45"

💡 Note: Contains "four" (f,o,u,r) and "five" (f,i,v,e). The shared 'f' appears twice. Result is "45".

Example 3 — Multiple Overlapping

$ Input: s = "nnei"

› Output: "9"

💡 Note: Contains "nine" (n,i,n,e). The string has n(2), e(1), i(1) which exactly matches the letters needed for 'nine'. Note that 'one' cannot be formed since there is no 'o' in the input.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
s contains an out-of-order representation of some digits 0-9
Each digit appears at most once

Visualization

Tap to expand

Asked in

G Google 23 f Facebook 18 M Microsoft 15

The key insight is recognizing that some digits have unique letters that appear nowhere else (z→zero, w→two, u→four, x→six, g→eight). Best approach uses frequency counting with strategic ordering to identify digits efficiently. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^10 × n) Space: O(1)

Try every possible combination of digits 0-9, convert each to English words, and check if the letter frequencies match the input string. This involves checking all 2^10 possible subsets.

Frequency Count with Unique Letters

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

Count letter frequencies and identify digits by their unique characters first (z→0, w→2, u→4, x→6, g→8), then identify remaining digits by process of elimination using the updated counts.

Optimized Pattern Recognition

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

Process digits in a carefully chosen order to avoid conflicts. Start with digits that have completely unique letters, then handle those that share letters but can be distinguished after removing the unique ones.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: Generate all possible combinations of digits 0-9
Step 2: For each combination, convert digits to English words
Step 3: Count letters and compare with input string
Step 4: Return the matching combination in ascending order

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Analysis

Count letter frequencies in the scrambled string

Generate Combinations

Try all possible digit subsets (2^10 = 1024 combinations)

Match & Return

Find combination that matches letter frequencies exactly

Code -

solution.c — C

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

char* solution(char* s) {
    int count[26] = {0};
    int digits[10] = {0};
    int len = strlen(s);
    
    // Count frequency of each character
    for (int i = 0; i < len; i++) {
        count[s[i] - 'a']++;
    }
    
    // Count digits using unique characters first
    // 0: 'z' is unique to "zero"
    digits[0] = count['z' - 'a'];
    
    // 2: 'w' is unique to "two"
    digits[2] = count['w' - 'a'];
    
    // 4: 'u' is unique to "four"
    digits[4] = count['u' - 'a'];
    
    // 6: 'x' is unique to "six"
    digits[6] = count['x' - 'a'];
    
    // 8: 'g' is unique to "eight"
    digits[8] = count['g' - 'a'];
    
    // 3: 'h' appears in "three" and "eight", so subtract "eight" count
    digits[3] = count['h' - 'a'] - digits[8];
    
    // 5: 'f' appears in "five" and "four", so subtract "four" count
    digits[5] = count['f' - 'a'] - digits[4];
    
    // 7: 's' appears in "seven" and "six", so subtract "six" count
    digits[7] = count['s' - 'a'] - digits[6];
    
    // 1: 'o' appears in "one", "zero", "two", "four"
    digits[1] = count['o' - 'a'] - digits[0] - digits[2] - digits[4];
    
    // 9: 'i' appears in "nine", "five", "six", "eight"
    digits[9] = count['i' - 'a'] - digits[5] - digits[6] - digits[8];
    
    // Build result string
    char* result = malloc(11 * sizeof(char));
    int pos = 0;
    
    for (int i = 0; i < 10; i++) {
        if (digits[i] > 0) {
            result[pos++] = '0' + i;
        }
    }
    
    result[pos] = '\0';
    return result;
}

int main() {
    char s[1000];
    if (scanf("%s", s) == 1) {
        char* result = solution(s);
        printf("%s\n", result);
        free(result);
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^10 × n)

2^10 combinations to try, each requiring O(n) letter counting

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for counting

✓ Linear Space

31.5K Views

Medium Frequency

~25 min Avg. Time

892 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler