Reconstruct Original Digits from English - Practice Coding Problems

Reconstruct Original Digits from English - Problem

You're given a jumbled string containing the English words for digits 0-9, but all mixed up! Your task is to figure out which digits were originally present and return them in ascending order.

For example, if you see "owzttnfour", this contains the letters for "two" and "four", so you should return "24".

The Challenge: Some letters appear in multiple digit words (like 'o' in both "zero" and "four"), so you need to be clever about how you count them!

Goal: Reconstruct the original digits from the scrambled English representation and return them sorted in ascending order as a string.

Input & Output

example_1.py — Basic Case

$ Input: s = "owzttnfour"

› Output: "24"

💡 Note: The string contains letters for "two" and "four". Since we return digits in ascending order, the answer is "24".

example_2.py — Multiple Digits

$ Input: s = "fviefuro"

› Output: "45"

💡 Note: The string contains letters for "four" and "five". Sorted in ascending order gives us "45".

example_3.py — Single Digit

$ Input: s = "nnei"

› Output: "9"

💡 Note: The string contains letters for "nine" only, so the answer is "9".

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is a lowercase English letter
s is guaranteed to be a valid representation of some digits 0-9

Visualization

Tap to expand

Understanding the Visualization

Gather Evidence

Count how many times each letter appears in the scrambled text

Find Smoking Guns

Look for unique letters: 'z' only appears in 'zero', 'w' only in 'two', etc.

Solve Easy Cases

Count digits with unique letters first - these are guaranteed wins

Deduce Harder Cases

Use the remaining letters to figure out the trickier digits

Present Evidence

Arrange your findings in ascending order to present the solution

Key Takeaway

🎯 Key Insight: Look for unique letters first (z, w, u, x, g), then systematically deduce remaining digits. This transforms a complex combinatorial problem into a simple counting and deduction exercise!

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 31 Apple 24

The optimal solution uses a smart deduction strategy with hash tables. Key insight: some digits have unique letters (z→0, w→2, u→4, x→6, g→8). Count these first, then deduce remaining digits by subtracting known counts. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Smart Hash Table (Optimal)	O(n)	O(1)	Count letters first, then cleverly deduce digits using unique letter patterns
Brute Force (Try All Combinations)	O(10^n)	O(n)	Try all possible combinations of digits 0-9 and check which combination matches the input

Smart Hash Table (Optimal) — Algorithm Steps

Count frequency of each letter in the input string
Identify digits with unique letters: 0(z), 2(w), 4(u), 6(x), 8(g)
Count these digits and subtract their letters from the frequency map
Identify next determinable digits: 3(h), 5(f), 7(s)
Count remaining digits: 1(o), 9(i)
Build result string with digits in ascending order

Visualization

Tap to expand

Step-by-Step Walkthrough

Count All Letters

Build frequency map of all characters in input

Find Unique Letters

Identify digits with letters that appear only in that digit

Deduce Step by Step

Use unique letters first, then work through partially unique ones

Subtract Counted

Remove letters of found digits from remaining counts

Build Result

Construct answer string with digits in ascending order

Code -

solution.c — C

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

char* reconstructDigits(char* s) {
    // Count frequency of each letter
    int count[26] = {0};
    for (int i = 0; s[i]; i++) {
        count[s[i] - 'a']++;
    }
    
    // Count each digit
    int digits[10] = {0};
    
    // Digits with unique letters first
    digits[0] = count['z' - 'a'];  // zero
    digits[2] = count['w' - 'a'];  // two
    digits[4] = count['u' - 'a'];  // four
    digits[6] = count['x' - 'a'];  // six
    digits[8] = count['g' - 'a'];  // eight
    
    // Next determinable digits
    digits[3] = count['h' - 'a'] - digits[8];  // three
    digits[5] = count['f' - 'a'] - digits[4];  // five
    digits[7] = count['s' - 'a'] - digits[6];  // seven
    
    // Remaining digits
    digits[1] = count['o' - 'a'] - digits[0] - digits[2] - digits[4];  // one
    digits[9] = count['i' - 'a'] - digits[5] - digits[6] - digits[8];  // nine
    
    // Build result
    char* result = malloc(strlen(s) + 1);
    int pos = 0;
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < digits[i]; j++) {
            result[pos++] = '0' + i;
        }
    }
    result[pos] = '\0';
    
    return result;
}

int main() {
    char s[1000];
    scanf("%s", s);
    printf("%s\n", reconstructDigits(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count letters, then constant time operations to deduce each digit

✓ Linear Growth

Space Complexity

O(1)

Only need frequency array of 26 letters and digit counts array of 10 digits

✓ Linear Space

43.2K Views

Medium-High Frequency

~18 min Avg. Time

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

Smart Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler