We use cookies (including Google cookies) to personalize ads and analyze traffic. By continuing to use our site, you accept our Privacy Policy.

SimplyLeet
TagsDisclaimersPrivacyTermsContactAbout Us

Smallest Value of the Rearranged Number

Difficulty: Medium

Problem Description

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 that the sign of the number does not change after rearranging the digits.

Key Insights

  • The digits of the number can be rearranged to form various combinations.
  • If the number is positive, the smallest arrangement must not start with a zero.
  • If the number is negative, the largest arrangement (in terms of value) must be formed.
  • Sorting the digits is a natural approach to find the smallest or largest arrangement.
  • Handling leading zeros is critical for positive numbers.

Space and Time Complexity

Time Complexity: O(n log n), where n is the number of digits in the input number due to sorting. Space Complexity: O(n), for storing the digits of the number.

Solution

To solve the problem, we will:

  1. Convert the integer to a string to extract its digits.
  2. Separate the digits into positive and negative cases.
  3. For positive numbers, sort the digits in ascending order, ensuring that the first digit is not zero (if possible).
  4. For negative numbers, sort the digits in descending order to maximize the value.
  5. Finally, construct the rearranged number and return it.

Code Solutions

def smallest_rearranged_number(num):
    is_negative = num < 0
    digits = sorted(str(abs(num)))

    if is_negative:
        # For negative numbers, sort in descending order
        return -int(''.join(digits[::-1]))
    else:
        # For positive numbers, sort in ascending order
        if digits[0] == '0':
            # Find the first non-zero digit to swap with the first position
            for i in range(1, len(digits)):
                if digits[i] != '0':
                    # Swap
                    digits[0], digits[i] = digits[i], digits[0]
                    break
        return int(''.join(digits))

# Example usage
print(smallest_rearranged_number(310))   # Output: 103
print(smallest_rearranged_number(-7605))  # Output: -7650
← Back to All Questions