Smallest Value of the Rearranged Number - Problem

Math Sorting Medium

You are given an integer num. Rearrange the digits of num such that its value is minimized and it does not contain any leading zeros.

Return the rearranged number with minimal value.

Note: The sign of the number does not change after rearranging the digits.

Input & Output

Example 1 — Positive Number with Zero

$ Input: num = 4320

› Output: 2034

💡 Note: Sort digits [4,3,2,0] → [0,2,3,4]. Since 0 is first, swap with first non-zero (2) → [2,0,3,4] = 2034

Example 2 — Negative Number

$ Input: num = -4320

› Output: -2034

💡 Note: Same rearrangement as positive case, but keep negative sign: -2034

Example 3 — Single Digit

$ Input: num = 0

› Output: 0

💡 Note: Single digit 0 remains 0

Constraints

-2³¹ ≤ num ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 18 G Google 15

The key insight is to sort digits in ascending order to minimize value, then handle leading zeros by swapping the first non-zero digit to the front. Best approach is sort-first with Time: O(n log n), Space: O(n).

Common Approaches

✓ Generate All Permutations

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

Extract all digits, generate every possible permutation, filter out those with leading zeros, and return the minimum. This explores all possibilities but is extremely inefficient.

Sort and Handle Leading Zeros

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

Convert the number to digits, sort them in ascending order to get the smallest arrangement, then handle the leading zero case by finding the first non-zero digit and swapping it to the front.

Generate All Permutations — Algorithm Steps

Extract digits from the number
Generate all permutations of digits
Filter out arrangements with leading zeros
Find and return the minimum value

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Digits

Convert number to individual digit array

Generate Permutations

Create all possible arrangements of digits

Filter & Find Minimum

Remove leading zero cases and find smallest valid number

Code -

solution.c — C

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

long long minResult = LLONG_MAX;

void swap(char* a, char* b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

void permute(char* digits, int start, int len) {
    if (start == len - 1) {
        if (digits[0] == '0') return;
        long long val = atoll(digits);
        if (val < minResult) {
            minResult = val;
        }
        return;
    }
    
    for (int i = start; i < len; i++) {
        swap(&digits[start], &digits[i]);
        permute(digits, start + 1, len);
        swap(&digits[start], &digits[i]);
    }
}

long long solution(long long num) {
    if (num == 0) return 0;
    
    int isNegative = num < 0;
    if (isNegative) num = -num;
    
    char digits[20];
    sprintf(digits, "%lld", num);
    int len = strlen(digits);
    
    minResult = LLONG_MAX;
    permute(digits, 0, len);
    
    return isNegative ? -minResult : minResult;
}

int main() {
    long long num;
    scanf("%lld", &num);
    printf("%lld\n", solution(num));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Generating all permutations of n digits takes n! time

⚠ Quadratic Growth

Space Complexity

O(n!)

Storing all permutations requires factorial space

⚠ Quadratic Space

28.5K Views

Medium Frequency

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

Smallest Value of the Rearranged Number - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler