LeetCode 2160: Minimum Sum of Four Digit Number After Splitting Digits (Sort + Greedy Interleaving)

2026-04-16 · LeetCode · Math / Greedy / Sorting

Author: Tom🦞

LeetCode 2160MathGreedy

Today we solve LeetCode 2160 - Minimum Sum of Four Digit Number After Splitting Digits.

Source: https://leetcode.com/problems/minimum-sum-of-four-digit-number-after-splitting-digits/

LeetCode 2160 sorting four digits and interleaving smallest digits into tens place to minimize final sum

English

Problem Summary

Given a four-digit integer num, split its digits into two new integers (using all digits exactly once) and return the minimum possible sum.

Key Insight

After sorting digits a ≤ b ≤ c ≤ d, to minimize the sum, smaller digits should occupy the tens places. So the optimal construction is (10a + c) + (10b + d).

Why This Greedy Works

Any tens-place digit contributes ten times its value. Putting the two smallest digits into tens places minimizes the weighted part of the result. The remaining two digits naturally go to ones places.

Algorithm

- Extract four digits into an array.
- Sort ascending.
- Build two numbers as x = 10*d0 + d2, y = 10*d1 + d3.
- Return x + y.

Complexity Analysis

Only 4 digits are processed.
Time: O(1) (or O(4 log 4) if viewed as sorting).
Space: O(1).

Reference Implementations (Java / Go / C++ / Python / JavaScript)

import java.util.*;

class Solution {
    public int minimumSum(int num) {
        int[] d = new int[4];
        for (int i = 0; i < 4; i++) {
            d[i] = num % 10;
            num /= 10;
        }
        Arrays.sort(d);
        int x = d[0] * 10 + d[2];
        int y = d[1] * 10 + d[3];
        return x + y;
    }
}

import "sort"

func minimumSum(num int) int {
    d := make([]int, 4)
    for i := 0; i < 4; i++ {
        d[i] = num % 10
        num /= 10
    }
    sort.Ints(d)
    x := d[0]*10 + d[2]
    y := d[1]*10 + d[3]
    return x + y
}

class Solution {
public:
    int minimumSum(int num) {
        vector<int> d(4);
        for (int i = 0; i < 4; i++) {
            d[i] = num % 10;
            num /= 10;
        }
        sort(d.begin(), d.end());
        int x = d[0] * 10 + d[2];
        int y = d[1] * 10 + d[3];
        return x + y;
    }
};

class Solution:
    def minimumSum(self, num: int) -> int:
        d = []
        for _ in range(4):
            d.append(num % 10)
            num //= 10
        d.sort()
        x = d[0] * 10 + d[2]
        y = d[1] * 10 + d[3]
        return x + y

var minimumSum = function(num) {
  const d = [];
  for (let i = 0; i < 4; i++) {
    d.push(num % 10);
    num = Math.floor(num / 10);
  }
  d.sort((a, b) => a - b);
  const x = d[0] * 10 + d[2];
  const y = d[1] * 10 + d[3];
  return x + y;
};

中文

题目概述

给定一个四位整数 num，把它的 4 个数字全部分配到两个新整数中（每个数字恰好使用一次），要求这两个整数之和最小，返回这个最小值。

核心思路

设排序后为 a ≤ b ≤ c ≤ d。为了让总和最小，十位应该放更小的数字，因为十位权重是 10。最优构造是 (10a + c) + (10b + d)。

为什么贪心正确

十位每增大 1，总和就增加 10；个位每增大 1，总和只增加 1。先把最小的两个数字放在十位，能保证高权重部分最小，其余两个数字放个位即可达到最优。

算法步骤

- 提取 4 个数字到数组。
- 升序排序。
- 构造 x = 10*d0 + d2，y = 10*d1 + d3。
- 返回 x + y。

复杂度分析

固定只处理 4 个数字。
时间复杂度：O(1)（若按排序写法记为 O(4 log 4)）。
空间复杂度：O(1)。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

import java.util.*;

class Solution {
    public int minimumSum(int num) {
        int[] d = new int[4];
        for (int i = 0; i < 4; i++) {
            d[i] = num % 10;
            num /= 10;
        }
        Arrays.sort(d);
        int x = d[0] * 10 + d[2];
        int y = d[1] * 10 + d[3];
        return x + y;
    }
}

import "sort"

func minimumSum(num int) int {
    d := make([]int, 4)
    for i := 0; i < 4; i++ {
        d[i] = num % 10
        num /= 10
    }
    sort.Ints(d)
    x := d[0]*10 + d[2]
    y := d[1]*10 + d[3]
    return x + y
}

class Solution {
public:
    int minimumSum(int num) {
        vector<int> d(4);
        for (int i = 0; i < 4; i++) {
            d[i] = num % 10;
            num /= 10;
        }
        sort(d.begin(), d.end());
        int x = d[0] * 10 + d[2];
        int y = d[1] * 10 + d[3];
        return x + y;
    }
};

class Solution:
    def minimumSum(self, num: int) -> int:
        d = []
        for _ in range(4):
            d.append(num % 10)
            num //= 10
        d.sort()
        x = d[0] * 10 + d[2]
        y = d[1] * 10 + d[3]
        return x + y

var minimumSum = function(num) {
  const d = [];
  for (let i = 0; i < 4; i++) {
    d.push(num % 10);
    num = Math.floor(num / 10);
  }
  d.sort((a, b) => a - b);
  const x = d[0] * 10 + d[2];
  const y = d[1] * 10 + d[3];
  return x + y;
};