# Generating the maximum number possible from an array

I have the following code in Scala as a solution to the problem:

Find the maximum number possible from the given Seq of Integers while keeping the individual numbers intact

e.g.

Seq(2,5,9,4) should result in 9542

Seq(4, 98, 10, 110, 91) should result in 9891411010

Note that in case of numbers with more than one digit, the entire number should remain together.

Solution in Scala:

import scala.util.Sorting
object MatheMagic {
def getLargestPossibleNumber(numArray: Seq[Int]) = {
numArray.sorted[Int](IntOrdering).mkString.toLong
}
object IntOrdering extends Ordering[Int] {
def compare(x: Int, y: Int) = {
-(x.toString.concat(y.toString).toInt compare y.toString.concat(x.toString).toInt)
}
}
}


Sample invocation:

MatheMagic.getLargestPossibleNumber(Seq(4, 98, 10, 110, 91))

• LGTM, though I'm not sure how I would actually prove that the algorithm always gives the correct answer. Oct 27, 2015 at 15:41
• @SethTisue I would compare it to bruteforce on some randomly generated testcases Oct 27, 2015 at 17:48
• Actually, I'm pretty sure that an induction proof would work just fine. Haven't done one in ages though. Oct 29, 2015 at 22:44

Your algorithm is good, but the implementation is a bit wasteful:

• In IntOrdering.compare, x and y are converted to String twice, and then converted to Int
• It's especially bad since the numbers in the sequence may pass through compare multiple times in different pairs, and get converted to String even more times
• You could reduce the casts:
• Convert all numbers to String once in the beginning
• Compare as strings. The algorithm will work with alphabetical comparison too
• Convert to Long once at the end
• Creating a custom Ordering seems a bit overkill

This one-liner will do the job:

nums.map(_.toString).sortWith(
(a, b) => (a concat b).compareTo(b concat a) > 0).mkString.toLong