Split With Minimum Sum - Practice Coding Problems

Split With Minimum Sum - Problem

Imagine you have a positive integer and need to strategically split its digits into two separate numbers to achieve the minimum possible sum.

Given a positive integer num, your task is to split it into two non-negative integers num1 and num2 such that:

The concatenation of num1 and num2 uses exactly the same digits as the original num (a permutation)
Each digit from num appears in either num1 or num2, but the total count of each digit remains the same
Leading zeros are allowed in both num1 and num2

Your goal is to find the arrangement that produces the minimum possible sum of num1 + num2.

Example: For num = 4325, you could split it as 24 + 35 = 59, but a better split would be 23 + 45 = 68. Can you find an even better arrangement?

Input & Output

example_1.py — Basic Split

$ Input: num = 4325

› Output: 59

💡 Note: Split digits [4,3,2,5] → sort to [2,3,4,5] → alternate assignment gives num1=24, num2=35, sum=59

example_2.py — Two Digits

$ Input: num = 687

› Output: 75

💡 Note: Sort [6,8,7] to [6,7,8] → num1=68, num2=7 → sum=75. Alternative split 6|78=84 is larger.

example_3.py — Edge Case

$ Input: num = 10

› Output: 1

💡 Note: Sort [1,0] → num1=1, num2=0 → sum=1. The 0 forms a valid number by itself.

Visualization

Tap to expand

Understanding the Visualization

Lay Out Cards

Place all digit cards on the table: 4, 3, 2, 5

Sort by Value

Arrange cards from smallest to largest: 2, 3, 4, 5

Alternate Distribution

Deal alternately to two hands: Hand 1 gets 2,4 and Hand 2 gets 3,5

Form Numbers

Read each hand left-to-right: Hand 1 = 24, Hand 2 = 35

Calculate Total

Sum the values: 24 + 35 = 59 (minimum possible)

Key Takeaway

🎯 Key Insight: The greedy approach works because placing smaller digits in higher-value positions (leftmost) has the maximum impact on minimizing the sum. Alternating assignment keeps the two numbers roughly equal in length, preventing one number from dominating the sum.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting the digits takes O(n log n) time, where n is the number of digits

⚡ Linearithmic

Space Complexity

O(n)

Space to store the sorted digits and form the two numbers

⚡ Linearithmic Space

Constraints

10 ≤ num ≤ 10⁹
num does not contain leading zeros
The number has at least 2 digits

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 5

The optimal solution uses a greedy algorithm: sort all digits in ascending order, then alternately assign them to two numbers. This ensures smaller digits occupy more significant positions, minimizing the final sum. Time complexity is O(n log n) for sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Algorithm (Optimal)	O(n log n)	O(n)	Sort digits and alternately assign smallest digits to most significant positions
Brute Force (Try All Splits)	O(2^n)	O(n)	Generate all possible ways to split digits between two numbers and find minimum sum

Greedy Algorithm (Optimal) — Algorithm Steps

Extract all digits from the input number
Sort the digits in ascending order
Create two empty numbers (num1 and num2)
Alternately assign sorted digits to num1 and num2, starting with num1
Return the sum of the two formed numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Digits

Convert 4325 to [4,3,2,5]

Sort Ascending

Sort to get [2,3,4,5]

Alternate Assignment

Assign alternately: num1 gets 2,4 and num2 gets 3,5

Form Numbers

Build num1=24 and num2=35

Calculate Sum

Return 24 + 35 = 59

Code -

solution.c — C

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

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

int splitNum(int num) {
    char numStr[12];
    sprintf(numStr, "%d", num);
    int n = strlen(numStr);
    
    // Sort digits
    qsort(numStr, n, sizeof(char), compare);
    
    int num1 = 0, num2 = 0;
    
    // Alternately assign digits to minimize sum
    for (int i = 0; i < n; i++) {
        int digit = numStr[i] - '0';
        if (i % 2 == 0) {
            num1 = num1 * 10 + digit;
        } else {
            num2 = num2 * 10 + digit;
        }
    }
    
    return num1 + num2;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting the digits takes O(n log n) time, where n is the number of digits

⚡ Linearithmic

Space Complexity

O(n)

Space to store the sorted digits and form the two numbers

⚡ Linearithmic Space

Constraints

10 ≤ num ≤ 10⁹
num does not contain leading zeros
The number has at least 2 digits

21.1K Views

Medium Frequency

~12 min Avg. Time

842 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

Greedy Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler