CrLf

JavaScript 136ms：

var largestNumber = function(nums) {
	return [].join.call(arguments)
	.split(',')
	.sort(function(a,b){
		return b+a > (a+b) ? 1 : -1
	})
	.join('').replace(/^0+(.)/,'$1')
}
复制代码

不懂那些更快的是怎么实现的，好想看一看...

CrLf

回复 4# 523066680


    JavaScript 组有人是 120ms，比我快多了，实在想不出来他把时间省在哪里了
    回头我也用c玩一个

CrLf

回复 2# 523066680


    看完夜场谍影重重，回家撸了C语言

221 / 221 test cases passed.
Status: Accepted
Runtime: 0 ms

还不下跪

CrLf

JavaScript 124ms：

var largestNumber = function(nums) {
    var arr = [];
    [].forEach.call(arguments,function(a){a.map?[].push.apply(arr,a):arr.push(a)})
	return arr
    	.sort(function(a,b){
    		return ''+b+a > ''+a+b ? 1 : -1
    	})
    	.join('').replace(/^0+(.)/,'$1')
}
复制代码

C语言 0ms：

char* largestNumber(int* nums, int numsSize) {
	struct struct_num{
		int digit;
		int number;
	};

	struct struct_num *group[10][100], *pg, *pg2;
	int group_count[10]={0,0,0,0,0,0,0,0,0,0};
	int i,j,k;
	int number,index,digit;
	char output[10000]="0";
	char *p=output;

	const char itoa_map[11]="0123456789";

	for(i=numsSize;i--;){
		number = nums[i];

		for(digit=10;number>=digit;digit*=10){}
		index = number/(digit/10);

		pg=(struct struct_num *)malloc(sizeof(struct struct_num));

		group[index][group_count[index]++]=pg;
		(pg)->number = number;
		(pg)->digit = digit;
	}

	for(i=10;i--;){
		for(j=group_count[i];j-->0;){
			pg = group[i][j];

			for(k=j;k-->0;){
				pg2 = group[i][k];
				if(
					((long long) pg->number * pg2->digit+pg2->number)< ((long long) pg2->number * pg->digit + pg->number)
				){
					* (long long*) pg ^= * (long long*) pg2;
					* (long long*) pg2 ^= * (long long*) pg;
					* (long long*) pg ^= * (long long*) pg2;
				}
			}
		}
		for(j=group_count[i];j--;){
			pg = group[i][j];
			number = pg->number;
			digit = pg->digit / 10;
			while(digit >= 1){
				*p++ = itoa_map[number / digit % 10];
				digit /= 10;
			}
			free(pg);
		}
	}
	if(output[0]=='0')return "0";

	*p='\0';

	return output;
}
复制代码

CrLf

回复 13# xxpinqz


    说实话，不是很喜欢谍影重重5这种全程高能的肌肉片

CrLf

好像还可以继续优化，可惜没有微秒和纳秒，比较不出来

CrLf

回复 19# happy886rr


    感觉排序方式不是最重要的，个人经验，结构优化的收益远比冒泡和快速排序之间的效率差异大得多：

1、用结构体 struct_num 保存数字和进位，排序时用 (long long) 数值比较大小，等到输出时再转为字符串
2、分设 10 个数组 hash 表，用于保存由 0-9 开头的数字组成的数组，这样只需要对 1-9 各组单独排序即可
3、函数自实现/内联，就题解题，节省函数调用开销
复制代码

CrLf

回复 24# aa77dd@163.com


    要看稳定值，我看到120毫秒那个档很集中，绝不是偶然，一定有什么我还没想到的办法

CrLf

JS 修改后耗时约为 109ms

var largestNumber = function(nums) {
    return nums
        .sort((a,b) => ''+b+a > ''+a+b ? 1 : -1)
        .join('')
        .replace(/^0+(?=.)/,'')
}
复制代码

尽量用 ES6 的语法来写的版本看起来也很萌...

var largestNumber = function(nums) {
    let arr = [];
    for(let a of nums)arr.unshift(`${a}`)
    let retArr = arr.sort((a,b) => b+a > a+b ? 1 : -1)
    return retArr[0]==='0' ? '0' : retArr.join('')
}
复制代码