Arrange given numbers to form the biggest number

Try it on GfG Practice

Given an array of non-negative integers arr[], the task is to arrange them in a manner such that after concatenating them in order, it results in the largest possible number. Since the result may be very large, return it as a string.

Examples:

Input: arr[] = [3, 30, 34, 5, 9]
Output: "9534330"
Explanation: The arrangement [9, 5, 34, 3, 30], gives the largest value "9534330".

Input: arr[] = [54, 546, 548, 60]
Output: "6054854654"
Explanation: The arrangement [60, 548, 546, 54], gives the largest value "6054854654".

Input: arr[] = [3, 4, 6, 5, 9]
Output: "96543"
Explanation: The arrangement [9, 6, 5, 4, 3], gives the largest value "96543".

Using Custom Comparator Sort - O(n*log(n)) Time and O(N) Auxiliary Space

Can we simply sort the numbers in descending order and concatenate them?
No, this approach is incorrect as we are concerned about the order of digits on concatenation of numbers, rather than their numeric values. For example: arr[] = [2, 3, 10], if we sort the array and concatenate the numbers, we will get result as "1032", whereas the correct result is "3210". Since we are concerned about the order or digits and not the numeric value, so first convert the numbers to strings.

Can we simply sort the array of strings in descending order and concatenate them?|
No, this approach will fail for test cases where the leading digits are same. For example, arr[] = ["20", "2", "3"], if we sort the strings and concatenate them, we will get "3202" as the maximum number but the actual maximum number is "3220".

The correct approach is to sort the numbers based on the lexicographical ordering of their concatenations. To achieve the correct order, we need to define a custom comparator for sorting. We compare two strings X and Y by comparing the concatenated results of XY and YX.

Detailed idea to use custom comparison function to sort the array:

• For two strings X and Y, compare the concatenated results XY (X followed by Y) and YX (Y followed by X).
• If XY is greater than YX, then X should come before Y in the final result.

// C++ program to arrange given numbers to form 
// the biggest number using custom comparator sort
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// Custom comparator to compare concatenated strings
bool myCompare(const string& s1, const string& s2) {
    return (s1 + s2) > (s2 + s1);
}

// Function to return the largest concatenated number
string findLargest(vector<int>& arr) {
  
    vector<string> numbers;
    for(int ele: arr) {
        numbers.push_back(to_string(ele));
    }
        
    // Sort the array using the custom comparator
    sort(numbers.begin(), numbers.end(), myCompare);

    // Handle the case where all numbers are zero.
  	// We are sorting is descending order, so zero 
  	// in front means complete array contains zero
    if (numbers[0] == "0") {
        return "0";
    }

    // Concatenate the sorted array
    string res = "";
    for (string& num : numbers) {
        res.append(num);
    }

    return res;
}

int main() {
    vector<int> arr = { 3, 30, 34, 5, 9 };
    cout << findLargest(arr) << endl; 
    return 0;
}

// Java program to arrange given numbers to form 
// the biggest number using custom comparator sort

import java.util.*;

class GfG {

    // Custom comparator to compare concatenated strings
    static boolean myCompare(String s1, String s2) {
        return (s1 + s2).compareTo(s2 + s1) > 0;
    }

    // Function to return the largest concatenated number
    static String findLargest(int[] arr) {

        // Convert the array of integers to an array of strings
        ArrayList<String> numbers = new ArrayList<>();
        for (int ele : arr) {
            numbers.add(Integer.toString(ele));
        }

        // Sort the array using the custom comparator
        Collections.sort(numbers, (s1, s2) -> myCompare(s1, s2) ? -1 : 1);

        // Handle the case where all numbers are zero.
        // We are sorting in descending order, so zero 
        // in front means complete array contains zero
        if (numbers.get(0).equals("0")) {
            return "0";
        }

        // Concatenate the sorted array
        StringBuilder res = new StringBuilder();
        for (String num : numbers) {
            res.append(num);
        }

        return res.toString();
    }

    public static void main(String[] args) {
        int[] arr = { 3, 30, 34, 5, 9 };
        System.out.println(findLargest(arr));
    }
}

# Python program to arrange given numbers to form 
# the biggest number using custom comparator sort

from functools import cmp_to_key

def my_compare(s1, s2):
    if s1 + s2 > s2 + s1:
        return -1  
    else:
        return 1

# Function to return the largest concatenated number
def findLargest(arr):
    numbers = [str(ele) for ele in arr]
    
    # Sort the array using the custom comparator
    numbers.sort(key=cmp_to_key(my_compare))

    # Handle the case where all numbers are zero.
    # We are sorting in descending order, so zero 
    # in front means complete array contains zero
    if numbers[0] == "0":
        return "0"

    # Concatenate the sorted array
    res = "".join(numbers)

    return res

if __name__ == "__main__":
    arr = [3, 30, 34, 5, 9]
    print(findLargest(arr))

// C# program to arrange given numbers to form 
// the biggest number using custom comparator sort

using System;

class GfG {
    
    // Custom comparator to compare concatenated strings
    public static bool MyCompare(string s1, string s2) {
        return (s1 + s2).CompareTo(s2 + s1) > 0;
    }

    // Function to return the largest concatenated number
    public static string FindLargest(int[] arr) {
        string[] numbers = new string[arr.Length];
        for (int i = 0; i < arr.Length; i++) {
            numbers[i] = arr[i].ToString();
        }

        // Sort the array using the custom comparator
        Array.Sort(numbers, (s1, s2) => MyCompare(s1, s2) ? -1 : 1);

        // Handle the case where all numbers are zero.
        // We are sorting in descending order, so zero 
        // in front means complete array contains zero
        if (numbers[0] == "0") {
            return "0";
        }

        // Concatenate the sorted array
        string res = "";
        foreach (string num in numbers) {
            res += num;
        }

        return res;
    }

    static void Main() {
        int[] arr = { 3, 30, 34, 5, 9 };
        Console.WriteLine(FindLargest(arr));
    }
}

// JavaScript program to arrange given numbers to form 
// the biggest number using custom comparator sort

// Custom comparator to compare concatenated strings
function myCompare(s1, s2) {
    return (s1 + s2) > (s2 + s1);
}

// Function to return the largest concatenated number
function findLargest(arr) {
    
    // Convert the array elements to strings
    let numbers = arr.map(String);

    // Sort the array using the custom comparator
    numbers.sort((s1, s2) => myCompare(s1, s2) ? -1 : 1);

    // Handle the case where all numbers are zero.
    // We are sorting in descending order, so zero 
    // in front means the complete array contains zero
    if (numbers[0] === "0") {
        return "0";
    }

    // Concatenate the sorted array
    return numbers.join('');
}

// Driver Code
let arr = [3, 30, 34, 5, 9];
console.log(findLargest(arr));

9534330