Sort the Jumbled Numbers - Practice Coding Problems

Sort the Jumbled Numbers - Problem

Array Sorting Medium

Imagine you have a secret code system where each digit 0-9 is mapped to a different digit. You're given an array of numbers and need to sort them based on how they would appear when decoded using this mapping system.

You are given:

A mapping array where mapping[i] = j means digit i should be replaced with digit j
An array nums containing integers to be sorted

Your task: Return the array nums sorted in ascending order based on their mapped values, but keep the original numbers in the result.

Example: If mapping = [8,9,4,0,2,1,3,5,7,6] and nums = [991,338,38]:

991 → 669 (9→6, 9→6, 1→9)
338 → 007 = 7 (3→0, 3→0, 8→7)
38 → 07 = 7 (3→0, 8→7)

Since both 338 and 38 map to 7, they maintain their relative order. Final result: [338, 38, 991]

Input & Output

example_1.py — Basic Sorting

$ Input: mapping = [8,9,4,0,2,1,3,5,7,6], nums = [991,338,38]

› Output: [338, 38, 991]

💡 Note: 991 maps to 669 (9→6,9→6,1→9), 338 maps to 007=7 (3→0,3→0,8→7), 38 maps to 07=7 (3→0,8→7). Since 7 < 669, both 338 and 38 come before 991. Since 338 and 38 both map to 7, they maintain relative order.

example_2.py — All Same Mapping

$ Input: mapping = [0,1,2,3,4,5,6,7,8,9], nums = [789,456,123]

› Output: [123, 456, 789]

💡 Note: Identity mapping means numbers stay the same: 789→789, 456→456, 123→123. Sorting gives [123, 456, 789].

example_3.py — Edge Case with Zero

$ Input: mapping = [1,0,2,3,4,5,6,7,8,9], nums = [0,10,1]

› Output: [1, 0, 10]

💡 Note: 0 maps to 1, 10 maps to 01=1, 1 maps to 0. Sorted by mapped values: 1(→0), 0(→1), 10(→1). Since 0 and 10 both map to 1, they keep relative order.

Constraints

mapping.length == 10
0 ≤ mapping[i] ≤ 9
All values in mapping[i] are unique
1 ≤ nums.length ≤ 3 × 10⁴
0 ≤ nums[i] < 10⁹

Visualization

Tap to expand

Understanding the Visualization

Cipher Setup

Create the decoding key: mapping[i] tells us what digit i becomes

Decode Messages

Transform each intercepted number using the cipher, digit by digit

Create Intelligence Report

Pair each original message with its decoded value and intercept order

Chronological Sorting

Sort by decoded values, maintaining original order for ties

Mission Complete

Return the original messages in their proper chronological sequence

Key Takeaway

🎯 Key Insight: By separating the decoding (mapping) phase from the sorting phase, we eliminate redundant calculations and achieve optimal O(n*m + n log n) time complexity while maintaining stable sort order.

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses pre-computation to map each number exactly once, then applies stable sorting based on mapped values. Key insight: separate the mapping phase from sorting to avoid redundant calculations, and preserve relative order for numbers with identical mapped values using the original index as a tiebreaker.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Direct Comparison)	O(n * m * log n)	O(1)	Decode each number multiple times during sorting comparisons
Pre-compute Mapped Values	O(n * m + n log n)	O(n)	First pass maps all numbers, second pass sorts using precomputed values

Brute Force (Direct Comparison) — Algorithm Steps

Create a helper function to map a single number using the mapping array
Use a custom comparator that calls the mapping function for both numbers being compared
Apply stable sort using this comparator to maintain relative order
Return the sorted array with original numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with nums = [991, 338, 38] and mapping = [8,9,4,0,2,1,3,5,7,6]

First Comparison

Compare 991 vs 338: Map 991→669, Map 338→7, 669 > 7

Second Comparison

Compare 991 vs 38: Map 991→669, Map 38→7, 669 > 7

Third Comparison

Compare 338 vs 38: Map 338→7, Map 38→7, equal so maintain order

Final Result

Sorted array: [338, 38, 991] based on mapped values [7, 7, 669]

Code -

solution.c — C

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

static int* globalMapping;

int getMappedValue(int num) {
    if (num == 0) {
        return globalMapping[0];
    }
    
    int mapped = 0;
    int multiplier = 1;
    
    while (num > 0) {
        int digit = num % 10;
        mapped = globalMapping[digit] * multiplier + mapped;
        multiplier *= 10;
        num /= 10;
    }
    
    return mapped;
}

int compare(const void* a, const void* b) {
    int numA = *(int*)a;
    int numB = *(int*)b;
    
    int mappedA = getMappedValue(numA);
    int mappedB = getMappedValue(numB);
    
    if (mappedA < mappedB) return -1;
    if (mappedA > mappedB) return 1;
    return 0;
}

int* sortJumbled(int* mapping, int mappingSize, int* nums, int numsSize, int* returnSize) {
    globalMapping = mapping;
    *returnSize = numsSize;
    
    int* result = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        result[i] = nums[i];
    }
    
    qsort(result, numsSize, sizeof(int), compare);
    
    return result;
}

int main() {
    int mapping[] = {8,9,4,0,2,1,3,5,7,6};
    int nums[] = {991,338,38};
    int returnSize;
    
    int* result = sortJumbled(mapping, 10, nums, 3, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n"); // 338 38 991
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * log n)

n is array length, m is average number of digits per number. Each comparison requires O(m) time to map digits, and we do O(n log n) comparisons

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables, not counting the space needed for sorting

✓ Linear Space

52.4K Views

Medium Frequency

~15 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

Brute Force (Direct Comparison) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler