Largest number formed from an array (understanding a solution) - arrays

Question

Write a function that, given a list of non-negative integers, arranges them such that they form the largest possible number. For example, given [0, 1, 2, 3], the largest formed number is 3210.
Logic I understand:
We compare two numbers XY (Y appended at the end of X) and YX (X appended at the end of Y). If XY is larger, then X should come before Y in output, else Y should come before. For example, let X and Y be 542 and 60. To compare X and Y, we compare 54260 and 60542. Since 60542 is greater than 54260, we put Y first. I can also write code for this.
What surprises me is this solution:
#include <stdio.h>
#include<stdlib.h>
int swap(const void *c, const void *d) {
int n1 = *(int*)c;
int n2 = *(int*)d;
int a = pow(10, floor(log10(n2)) + 1) * n1 + n2;
int b = pow(10, floor(log10(n1)) + 1) * n2 + n1;
if (n1 == 0) return 1;
if (a < b) return 1;
return 0;
}
int main() {
int t = 0, tc = 0;
scanf("%d", &t);
for(tc = 1; tc <= t; tc++) {
int n;
scanf("%d",&n);
int arr[n];
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
qsort(arr, n, sizeof(int), swap);
for (int i = 0; i < n; i++)
printf("%d", arr[i]);
printf("\n");
}
return 0;
}
To my surprise, it passes all the test cases. Can anyone explain to me this logic?

Answer 1

This does exactly what you described:
int a = pow(10, floor(log10(n2)) + 1) * n1 + n2;
int b = pow(10, floor(log10(n1)) + 1) * n2 + n1;
If we're passed in X and Y, then a is XY, and b is YX.
If you're concatenating 2 and 34, you need to multiply 2 by 100 (to get 200) and then add 34 (to get 234). Where did the 100 come from? It's 10 to the power of the number of digits in 34. To get the number of digits, we compute the base-10 logarithm of 34 and round it up.
So:
log10(34) ~= 1.5
floor(log10(34)) == 1
floor(log10(34)) + 1 == 2
10^2 = 100, so now we know what to multiply the first number by before adding the second.
The second line does the same thing with the variables in the opposite order (computing YX concatenated).
Finally, we return 1 if a < b and 0 otherwise. This makes it a working comparator for a sort function:
if (a < b) return 1;
EDIT
I'm not sure what this line is doing:
if (n1 == 0) return 1;
I think it may be protecting us from the result of log10(0). (I'm not sure what that returns... the mathematical result is negative infinity.)
Basically, the result of this in the comparator is "Put n2 first if n1 is 0," which is always right. (I'm just not 100% sure why it's needed.)

Answer 2

Let's say that an array arr[] is the solution to your problem, i.e. its elements are arranged in such a way as to produce the max result M. Therefore, swapping arbitrary array elements i and j cannot yield a result that would be greater than M.
Consider comparing arbitrary indexes i and j in your comparator function swap, and digits surrounding them:
XXXXXXXX IIIIII XXXXXXXXXXXXXXXX JJJJJJ XXXXXXXXX
-------- ------ ---------------- ------ ---------
arr[...] arr[i] arr[...] arr[j] arr[...]
Note that if IIIIII block sorts before JJJJJJ block, it would continue sorting ahead of it regardless of the content of the X blocks. Therefore, comparing individual elements of arr in isolation produces an optimal solution when the entire array is sorted using this comparison.
Your comparator implementation performs this logic using "decimal shifting": if you want to add digits of x behind digits of y, you need to decimal-shift y by the number of digits in the x. The number of digits in the x can be determined as log10(x); decimal shifting left by k positions is achieved by multiplying y by 10k.
Note: This line
if (n1 == 0) return 1;
should be at the top, before you call decimal logarithm. There should also be another line
if (n2 == 0) return 0;
to ensure that we do not pass zero to log10.

Answer 3

What has been done in the code is,
Take input the array
Sort it descending order
Output it
The input & output part is easy to understand.
Now the sorting is done using qsort which accepts a compare function. In the code though the function is named swap, it is actually a compare function - which returns 1 when the first element is greater then the second one. Otherwise returns 0. Like is 54 > 45? and is 45>54?
Now, why a descending sort gives the deserved output? Let's see an example:
54 > 45 , This means if the big number is a left position the number is greater. A descending sort keeps the greater number left.

Answer 4

You already have some very good explanations of why the code you posted works. However, it should be noted that this method suffers from overflow whenever the decimal shifted version of any number exceeds the max representable int. If we assume a 32-bit int then this has 10 digits (2147483647), so comparing relatively small numbers such as 32412 and 12345 will cause problems.
As an alternative we can compare the numbers directly using a recursive function. Let the two numbers be n1 and n2, with d1 and d2 digits respectively. Our comparison function needs to handle three cases:
If d1 == d2we compare n1 and n2 directly, e.g. 345 and 463
If d1 < d2 we compare n1 to the d1 high-order digits of n2, e.g. for 37 and 398 we compare 37 and 39. If these are equal, we recursively compare n1 with the d2-d1 low-order digits of n2. So for 37 and 378 we'd compare 37 and 8.
If d1 > d2 we can swap n1 and n2 and compare as per case 2, though we then have to reverse the order of the result.
Here's some code to illustrate.
int swap(const void *c, const void *d)
{
int n1 = *(int*)c;
int n2 = *(int*)d;
int d1 = numDigits(n1);
int d2 = numDigits(n2);
return compare0(n1, d1, n2, d2);
}
int compare0(int n1, int d1, int n2, int d2)
{
if (d1 == d2)
return n2 - n1;
else if (d1 < d2)
return compare1(n1, d1, n2, d2);
else
return -compare1(n2, d2, n1, d1);
}
int compare1(int n1, int d1, int n2, int d2)
{
int pd = (int) pow(10, d2 - d1);
int nh2 = n2 / pd;
if (n1 == nh2)
return compare0(n1, d1, n2 % pd, d2 - d1);
else
return nh2 - n1;
}
int numDigits(int n)
{
return (n == 0) ? 1 : 1 + (int) log10(n);
}