Minimum Sum of Four Digit Number After Splitting Digits

Minimum Sum of Four Digit Number After Splitting Digits - Problem

You are given a positive integer num consisting of exactly four digits. Split num into two new integers new1 and new2 by using the digits found in num. Leading zeros are allowed in new1 and new2, and all the digits found in num must be used.

For example, given num = 2932, you have the following digits: two 2's, one 9 and one 3. Some of the possible pairs [new1, new2] are [22, 93], [23, 92], [223, 9] and [2, 329].

Return the minimum possible sum of new1 and new2.

Input & Output

Example 1 — Basic Case

$ Input: num = 2932

› Output: 52

💡 Note: We can split digits [2,9,3,2]. After sorting: [2,2,3,9]. Optimal split: 23 + 29 = 52

Example 2 — With Leading Zero

$ Input: num = 4009

› Output: 13

💡 Note: Digits are [4,0,0,9]. After sorting: [0,0,4,9]. Optimal split: 04 + 09 = 4 + 9 = 13

Example 3 — All Same Digits

$ Input: num = 1111

› Output: 22

💡 Note: All digits are 1. Any split gives the same result: 11 + 11 = 22

Constraints

1000 ≤ num ≤ 9999

Visualization

Tap to expand

Understanding the Visualization

Input

4-digit number: 2932

Process

Extract digits, sort, and split optimally

Output

Minimum possible sum: 52

Key Takeaway

🎯 Key Insight: Sort digits and place smallest ones in tens place to minimize the total sum

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to sort the digits and distribute them optimally - place the two smallest digits as tens place values and the two largest as ones place values. This minimizes the sum because tens place contributes 10x to the total. Best approach is Greedy Optimal Distribution with Time: O(1), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Optimal Distribution	O(1)	O(1)	Sort digits and distribute optimally to minimize sum
Generate All Possible Splits	O(1)	O(1)	Try every possible way to distribute 4 digits into two numbers

Greedy Optimal Distribution — Algorithm Steps

Extract and sort the 4 digits in ascending order
Place two smallest digits as the tens digits of both numbers
Place two largest digits as the ones digits of both numbers
Calculate and return the sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Digits

Sort 2,9,3,2 → 2,2,3,9

Optimal Split

Tens: 2,2 | Ones: 3,9 → 23 + 29

Minimum Sum

23 + 29 = 52

Code -

solution.c — C

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

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

int solution(int num) {
    // Extract digits
    int digits[4];
    int temp = num;
    for (int i = 0; i < 4; i++) {
        digits[i] = temp % 10;
        temp /= 10;
    }
    
    // Sort digits in ascending order
    qsort(digits, 4, sizeof(int), compare);
    
    // Optimal distribution: smallest digits as tens, largest as ones
    int num1 = digits[0] * 10 + digits[2];
    int num2 = digits[1] * 10 + digits[3];
    
    return num1 + num2;
}

int main() {
    int num;
    scanf("%d", &num);
    int result = solution(num);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed operations on exactly 4 digits

✓ Linear Growth

Space Complexity

O(1)

Only uses a fixed-size array for 4 digits

✓ Linear Space

44.9K Views

Medium Frequency

~8 min Avg. Time

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

Greedy Optimal Distribution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler