Minimum sum of two numbers formed from digits of an array

Try it on GfG Practice

Given an array of digits (values are from 0 to 9), find the minimum possible sum of two numbers formed from digits of the array. All digits of given array must be used to form the two numbers.

Examples: 

Input: arr[] = [6, 8, 4, 5, 2, 3]
Output: 604
Explanation: The minimum sum is formed by numbers 358 and 246

Input: arr[] = [5, 3, 0, 7, 4]
Output: 82
Explanation: The minimum sum is formed by numbers 35 and 047

Min Heap-based Greedy Approach - O(n * log n) and O(n) space

To minimize the sum of two numbers formed by the digits of the array, we divide the digits into two halves and assign half of them to each number, ensuring the leading digits are smaller. We use a Min Heap to efficiently retrieve the two smallest elements at a time, appending them alternately to the two numbers. This process continues until all elements are exhausted.

#include <bits/stdc++.h>
using namespace std;

int minSum(vector<int> &arr) {
    
    // Create min heap
    priority_queue<int, vector<int>, greater<int>> pq(arr.begin(), arr.end());
    string num1, num2;

    while (!pq.empty()) {
        num1 += to_string(pq.top()); pq.pop();
        if (!pq.empty()) {
            num2 += to_string(pq.top()); pq.pop();
        }
    }
    return stoi(num1) + stoi(num2);
}

int main() {
    vector<int> arr = {5, 3, 0, 7, 4};
    cout << minSum(arr);
}

// Importing necessary libraries
import java.util.PriorityQueue;

public class MinSum {
    public static int minSum(int[] arr) {
        
        // Using a priority queue to simulate a min-heap
        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
        for (int num : arr) {
            minHeap.add(num);
        }

        StringBuilder num1 = new StringBuilder();
        StringBuilder num2 = new StringBuilder();

        while (!minHeap.isEmpty()) {
            num1.append(minHeap.poll());
            if (!minHeap.isEmpty()) {
                num2.append(minHeap.poll());
            }
        }

        return Integer.parseInt(num1.toString()) + Integer.parseInt(num2.toString());
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 0, 7, 4};
        System.out.println(minSum(arr));
    }
}

import heapq

def min_sum(arr):
    heapq.heapify(arr)
    num1, num2 = [], []

    while arr:
        num1.append(str(heapq.heappop(arr)))
        if arr:
            num2.append(str(heapq.heappop(arr)))

    return int("".join(num1)) + int("".join(num2))

arr = [5, 3, 0, 7, 4]
print(min_sum(arr))

// Importing necessary libraries
using System;
using System.Collections.Generic;

public class MinSum {
    public static int MinSum(int[] arr) {
        
        // Using a priority queue to simulate a min-heap
        PriorityQueue<int, int> minHeap = new PriorityQueue<int, int>();
        foreach (int num in arr) {
            minHeap.Enqueue(num, num);
        }

        string num1 = "";
        string num2 = "";

        while (minHeap.Count > 0) {
            num1 += minHeap.Dequeue();
            if (minHeap.Count > 0) {
                num2 += minHeap.Dequeue();
            }
        }

        return int.Parse(num1) + int.Parse(num2);
    }

    public static void Main(string[] args) {
        int[] arr = {5, 3, 0, 7, 4};
        Console.WriteLine(MinSum(arr));
    }
}

// Import the heap module (not needed in JavaScript)
function minSum(arr) {
    
    // Convert the array into a min-heap
    arr.sort((a, b) => a - b);
    let num1 = [];
    let num2 = [];

    while (arr.length > 0) {
        num1.push(arr.shift()); // Pop the smallest element
        if (arr.length > 0) {
            num2.push(arr.shift()); // Pop the next smallest element
        }
    }

    return parseInt(num1.join('')) + parseInt(num2.join(''));
}

const arr = [5, 3, 0, 7, 4];
console.log(minSum(arr));

82

More Efficient Approaches :

Please refer Minimum sum of two numbers formed from digits of an array for another O(n Log n) approach and a O(n) approach