Smallest Value of the Rearranged Number - Practice Coding Problems

Smallest Value of the Rearranged Number - Problem

Math Sorting Medium

You are given an integer num. Your task is to rearrange the digits of this number to create the smallest possible value while ensuring there are no leading zeros.

The challenge is to find the optimal arrangement of digits that minimizes the numerical value. For example, if you have the number 310, you could arrange it as 013, 103, 130, 301, or 310. However, 013 has a leading zero, so the smallest valid arrangement is 103.

Important: The sign of the number remains unchanged after rearranging the digits. If the input is negative, the output should also be negative.

Goal: Return the rearranged number with the minimal absolute value, preserving the original sign.

Input & Output

example_1.py — Basic Positive Number

$ Input: num = 310

› Output: 103

💡 Note: The digits are 3, 1, 0. Arranging them in ascending order gives 013, but this has a leading zero. So we place the smallest non-zero digit (1) first, followed by the rest in ascending order: 103.

example_2.py — Negative Number

$ Input: num = -7605

› Output: -7650

💡 Note: For negative numbers, we want to minimize the absolute value by making it as large as possible. The digits are 7, 6, 0, 5. Arranging in descending order gives 7650, so the result is -7650.

example_3.py — All Zeros

$ Input: num = -000

› Output: 0

💡 Note: Special case: when the number is 0 (or consists only of zeros), the result is simply 0.

Constraints

-10¹⁵ ≤ num ≤ 10¹⁵
No leading zeros allowed in the result
The sign of the number must be preserved

Visualization

Tap to expand

Understanding the Visualization

Separate Sign

Handle positive and negative numbers differently

Sort Digits

Arrange digits in ascending (positive) or descending (negative) order

Handle Leading Zeros

For positive numbers, move smallest non-zero digit to front

Construct Result

Build the final number and apply the original sign

Key Takeaway

🎯 Key Insight: The optimal strategy is to sort digits and handle positive/negative cases differently - ascending order for positive (with leading zero fix) and descending for negative numbers.

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 f Meta 18

The optimal approach uses sorting to arrange digits efficiently. For positive numbers, sort digits in ascending order but place the smallest non-zero digit first to avoid leading zeros. For negative numbers, sort digits in descending order to minimize the absolute value. This achieves O(n log n) time complexity, much better than the O(n!) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Optimal Arrangement	O(n log n)	O(n)	Sort digits and strategically place them to minimize value
Brute Force (Generate All Permutations)	O(n!)	O(n!)	Generate all possible permutations and find the smallest valid one

Sorting + Optimal Arrangement — Algorithm Steps

Handle special case: if number is 0, return 0
Separate the sign and work with absolute value
Convert number to individual digits and sort them
For positive numbers: find smallest non-zero digit for first position
Place remaining digits in ascending order
For negative numbers: arrange digits in descending order
Apply the original sign to the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Digits

Sort digits of 4320: [0,2,3,4]

Handle Leading Zero

Find smallest non-zero digit (2) and move to front

Arrange Remaining

Place remaining digits in ascending order: 2034

Apply Sign

Apply original sign if number was negative

Code -

solution.c — C

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

int compareAsc(const void *a, const void *b) {
    return (*(char*)a - *(char*)b);
}

int compareDesc(const void *a, const void *b) {
    return (*(char*)b - *(char*)a);
}

long long smallestNumber(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);
    
    if (isNegative) {
        // For negative numbers, sort in descending order
        qsort(digits, len, sizeof(char), compareDesc);
        return -atoll(digits);
    } else {
        // Sort in ascending order
        qsort(digits, len, sizeof(char), compareAsc);
        
        // Handle leading zeros
        if (digits[0] == '0') {
            for (int i = 1; i < len; i++) {
                if (digits[i] != '0') {
                    char temp = digits[0];
                    digits[0] = digits[i];
                    digits[i] = temp;
                    break;
                }
            }
        }
        
        return atoll(digits);
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the digits, where n is the number of digits

⚡ Linearithmic

Space Complexity

O(n)

Need to store the digits in an array for sorting and manipulation

⚡ Linearithmic Space

28.3K Views

Medium Frequency

~15 min Avg. Time

845 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

Sorting + Optimal Arrangement — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler