Minimum Sum of Four Digit Number After Splitting Digits

Minimum Sum of Four Digit Number After Splitting Digits - Problem

Minimum Sum After Digit Redistribution

Imagine you have a 4-digit number and you need to redistribute its digits to create two new numbers that give you the smallest possible sum.

🎯 Your Mission: Given a positive integer num with exactly 4 digits, split all its digits to form two new integers new1 and new2. Your goal is to minimize new1 + new2.

📝 Rules:
• You must use all four digits from the original number
• Leading zeros are allowed (so digits can be distributed freely)
• Each new number must have at least one digit

💡 Example: For num = 2932
Available digits: [2, 9, 3, 2]
Possible splits: [22, 93], [23, 92], [29, 32], [2, 932], etc.
The optimal split minimizes the sum!

Input & Output

example_1.py — Basic Case

$ Input: num = 2932

› Output: 52

💡 Note: Digits are [2,9,3,2]. After sorting: [2,2,3,9]. Optimal split: new1 = 2*10 + 3 = 23, new2 = 2*10 + 9 = 29. Sum = 23 + 29 = 52.

example_2.py — All Same Digits

$ Input: num = 4009

› Output: 13

💡 Note: Digits are [4,0,0,9]. After sorting: [0,0,4,9]. Optimal split: new1 = 0*10 + 4 = 4, new2 = 0*10 + 9 = 9. Sum = 4 + 9 = 13.

example_3.py — Ascending Order

$ Input: num = 1234

› Output: 37

💡 Note: Digits are [1,2,3,4]. Already sorted. Optimal split: new1 = 1*10 + 3 = 13, new2 = 2*10 + 4 = 24. Sum = 13 + 24 = 37.

Visualization

Tap to expand

Understanding the Visualization

Sort Your Cards

Arrange the 4 digit cards in ascending order

Strategic Placement

Give the smallest cards the 'tens' position (higher weight)

Fill Remaining

Place larger cards in 'ones' positions

Calculate Score

Sum both hands for minimum total

Key Takeaway

🎯 Key Insight: Always put the smallest digits in the tens places to minimize both numbers simultaneously!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed 4 digits means constant number of combinations (about 2^4 = 16 ways)

✓ Linear Growth

Space Complexity

O(1)

Only storing digits and minimum sum, no additional data structures

✓ Linear Space

Constraints

1000 ≤ num ≤ 9999
num consists of exactly 4 digits
Leading zeros are allowed in the resulting numbers

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal greedy approach sorts the 4 digits and distributes them strategically: put the two smallest digits in tens places and the two largest in ones places. This minimizes both numbers simultaneously, giving us the minimum possible sum in O(1) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(1)	O(1)	Generate all possible ways to split 4 digits into two numbers
Greedy Approach (Optimal)	O(1)	O(1)	Sort digits and distribute optimally to minimize sum

Brute Force (Try All Combinations) — Algorithm Steps

Extract all 4 digits from the input number
Generate all possible ways to split digits into two non-empty groups
For each split, form two numbers and calculate their sum
Keep track of the minimum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Digits

Convert 2932 into individual digits [2,9,3,2]

Generate Splits

Try all combinations: {2,9}+{3,2}, {2,3}+{9,2}, etc.

Calculate Sums

For each split, form numbers and add them

Find Minimum

Track the smallest sum found

Code -

solution.c — C

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

int minimumSum(int num) {
    // Extract digits
    int digits[4];
    int temp = num;
    for (int i = 0; i < 4; i++) {
        digits[i] = temp % 10;
        temp /= 10;
    }
    
    int minSum = INT_MAX;
    
    // Try all ways to split digits
    for (int mask = 1; mask < 15; mask++) {
        int num1 = 0, num2 = 0;
        
        for (int i = 0; i < 4; i++) {
            if (mask & (1 << i)) {
                num1 = num1 * 10 + digits[i];
            } else {
                num2 = num2 * 10 + digits[i];
            }
        }
        
        if (num1 + num2 < minSum) {
            minSum = num1 + num2;
        }
    }
    
    return minSum;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed 4 digits means constant number of combinations (about 2^4 = 16 ways)

✓ Linear Growth

Space Complexity

O(1)

Only storing digits and minimum sum, no additional data structures

✓ Linear Space

Constraints

1000 ≤ num ≤ 9999
num consists of exactly 4 digits
Leading zeros are allowed in the resulting numbers

18.4K Views

Medium Frequency

~8 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler