目标

编写函数或程序，将整数数组按其二进制表示形式中存在的1的数量降序排列。不需要二级排序条件。

示例排序列表

（使用16位整数）

  Dec                Bin        1's
16375   0011111111110111        13
15342   0011101111101110        11
32425   0111111010101001        10
11746   0010110111100010         8
28436   0000110111110100         8
19944   0100110111101000         8
28943   0000011100011111         8
 3944   0000011111101000         7
15752   0011110110001000         7
  825   0000000011111001         6
21826   0101010101000010         6

输入值

一个32位整数数组。

输出量

按描述排序的相同整数的数组。

计分

这是在一周内要选择的最少字节数的代码高尔夫球。

J（11）

(\:+/"1@#:)

这是一个带有列表的函数：

     (\:+/"1@#:) 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944
16375 15342 32425 28943 11746 28436 19944 3944 15752 825 21826

如果要给它起个名字，它会额外增加一个字符：

     f=:\:+/"1@#:
     f 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944
16375 15342 32425 28943 11746 28436 19944 3944 15752 825 21826

说明：

• \:：向下排序
• +/：的总和
• "1：每行
• #:：二进制表示

JavaScript，39

更新：现在比Ruby短。

x.sort(q=(x,y)=>!x|-!y||q(x&x-1,y&y-1))

40

x.sort(q=(x,y)=>x&&y?q(x&x-1,y&y-1):x-y)

说明：

q是一个递归函数。如果x或y为0，则返回x-y（如果x为零，则为负数；如果y为零，则为正数）。否则，它将x&x-1从x和y中删除最低位（）并重复。

先前版本（42）

x.sort(q=(x,y)=>x^y&&!x-!y+q(x&x-1,y&y-1))

红宝石41

f=->a{a.sort_by{|n|-n.to_s(2).count(?1)}}

测试：

a = [28943, 825, 11746, 16375, 32425, 19944, 21826, 15752, 15342, 3944, 28436];
f[a]
=> [16375, 15342, 32425, 11746, 28436, 28943, 19944, 15752, 3944, 21826, 825]

Python 3（44）：

def f(l):l.sort(lambda n:-bin(n).count('1'))

常见的Lisp，35岁

logcount返回数字中的“ on”位数。对于列表l，我们有：

(sort l '> :key 'logcount)

CL-USER> (sort (list 16375 15342 32425 11746 28436 19944 28943 3944 15752 825 21826) '> :key 'logcount)
;=> (16375 15342 32425 11746 28436 19944 28943 3944 15752 825 21826)

作为独立功能，我将基于字节计数：

(lambda(l)(sort l'> :key'logcount))

Python 3， 90 77 72 67个字符。

我们的解决方案从命令行获取输入，并以降序（67个字符）或升序（66）来打印数字。

降序

print(sorted(input().split(),key=lambda x:-bin(int(x)).count("1"))) # 67

感谢@daniero，建议使用1的减号来反转它，而不是使用切片来反转数组！这有效地节省了5个字符。

仅仅为了发布它，升序版本（这是我们制作的第一个）将少一个字符。

升序：

print(sorted(input().split(),key=lambda x:bin(int(x)).count("1"))) # 66

感谢@Bakuriu提供key = lambda x…的建议。; D

JavaScript [76字节]

a.sort(function(x,y){r='..toString(2).split(1).length';return eval(y+r+-x+r)})

其中a是数字的输入数组。

测试：

[28943,825,11746,16375,32425,19944,21826,15752,15342,3944,28436].sort(function(x, y) {
    r = '..toString(2).split(1).length';
    return eval(y + r + -x + r);
});

[16375, 15342, 32425, 19944, 11746, 28943, 28436, 15752, 3944, 21826, 825]

Mathematica 30

SortBy[#,-DigitCount[#,2,1]&]&

用法：

SortBy[#,-DigitCount[#,2,1]&]&@
                           {19944,11746,15342,21826,825,28943,32425,16375,28436,3944,15752}

{16375、15342、32425、11746、19944、28436、28943、3944、15752、825、21826}

k [15个字符]

{x@|<+/'0b\:'x}

例子1

{x@|<+/'0b\:'x}19944, 11746, 15342, 21826, 825, 28943, 32425, 16375, 28436, 3944, 15752

16375 15342 32425 28436 28943 11746 19944 15752 3944 825 21826

示例2（所有数字均为2 ^ n -1）

{x@|<{+/0b\:x}'x}3 7 15 31 63 127

127 63 31 15 7 3

Mathematica 39

IntegerDigits[#,2] 将以10为底的数字转换为1和0的列表。

Tr 对数字求和。

f@n_:=SortBy[n,-Tr@IntegerDigits[#,2]&]

测试用例

f[{19944, 11746, 15342, 21826, 825, 28943, 32425, 16375, 28436, 3944, 15752}]

{16375、15342、32425、11746、19944、28436、28943、3944、15752、825、21826}

Java 8-87/ 113 81/111 60/80 60/74/48个字符

这不是一个完整的Java程序，它只是一个函数（准确地说是一个方法）。

它假定java.util.List和java.lang.Long.bitCount被导入，并具有60个字符：

void s(List<Long>a){a.sort((x,y)->bitCount(x)-bitCount(y));}

如果不允许任何预导入的内容，则为74个字符：

void s(java.util.List<Long>a){a.sort((x,y)->x.bitCount(x)-x.bitCount(y));}

如果需要，则再添加7个字符static。

[4年后]或者，如果您愿意，也可以是lambda（感谢@KevinCruijssen的建议），具有48个字节：

a->{a.sort((x,y)->x.bitCount(x)-x.bitCount(y));}

Python 2.x-65个字符（字节）

print sorted(input(),key=lambda x:-sum(int(d)for d in bin(x)[2:]))

实际上是66个字符，如果我们将其设为一个函数，则为65个（然后您需要调用它来呈现某些内容）。

f=lambda a:sorted(a,key=lambda x:-sum(int(d)for d in bin(x)[2:]))

Bash / CMD中的演示：

echo [16, 10, 7, 255, 65536, 5] | python -c "print sorted(input(),key=lambda x:-sum(int(d)for d in bin(x)[2:]))"

Matlab，34岁

输入“ a”

[~,i]=sort(-sum(dec2bin(a)'));a(i)

适用于非负数。

C-85字节（108 106字节）

GCC / Clang / __builtin_popcount随处可用的便携式版本（106字节）：

#define p-__builtin_popcount(
c(int*a,int*b){return p*b)-p*a);}
void s(int*n,int l){qsort(n,l,sizeof l,c);}

超压缩，不可移植，几乎没有功能的仅MSVC版本（85字节）：

#define p __popcnt
c(int*a,int*b){return p(*b)-p(*a);}
s(int*n,int l){qsort(n,l,4,c);}         /* or 8 as needed */

• 由于，第一个换行符包含在字节计数中#define，其他的则不需要。

• 调用功能s(array, length)符合规范。

• 可以sizeof像其他C答案一样在便携式版本中硬编码以保存另外7个字符。我不确定就长度-可用性比率而言，哪一个最有价值。

PowerShell的V3，61 58 53

$args|sort{while($_){if($_-band1){1};$_=$_-shr1}}-des

Sort-Objectcmdlet 的ScriptBlock为数字的二进制表示形式，对于每个1返回1的数组。Sort-Object根据为每个数字返回的数组的长度对列表进行排序。

执行：

script.ps1 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944

ECMAScript 6，61

假设z是输入

z.sort((a,b)=>{c=d=e=0;while(++c<32)d+=a>>c&1,e+=b>>c&1},e-d)

测试数据

[28943,825,11746,16375,32425,19944,21826,15752,15342,3944,28436].sort(
    (a,b)=>{
        c=d=e=0;
        while(++c<32)
            d+=a>>c&1,e+=b>>c&1
    },e-d
)

[16375, 15342, 32425, 11746, 19944, 28436, 28943, 15752, 3944, 21826, 825]

谢谢，牙刷为您提供了更短的解决方案。

R，132 96 94 88 84 75 73 53 51字节

-20多亏了J.Doe的实现--2多亏了Giuseppe

function(x)x[order(colSums(sapply(x,intToBits)<1))]

我的原始帖子：

pryr::f(rev(x[order(sapply(x,function(y)sum(as.double(intToBits(y)))))]))

在线尝试！

在得出此结果之前，我尝试了几种不同的方法。

矩阵方法：创建了两列矩阵，其中一列具有输入向量，其中一个是二进制表示的和，然后我对二进制和进行了排序。

function(x){m=matrix(c(x,colSums(sapply(x,function(y){as.integer(intToBits(y))}))),nc=2,nr=length(x));m[order(m[,2],decreasing=T),]}

非矩阵：意识到，我可以抛弃矩阵函数，而是创建一个二进制值的向量，对它们求和，对它们进行排序，然后使用排序后的值对输入向量进行重新排序。

function(x){m=colSums(sapply(x,function(y){as.integer(intToBits(y))}));x[order(m,decreasing=T)]}

小变化

function(x){m=colSums(sapply(x,function(y)as.double(intToBits(y))));x[order(m,decreasing=T)]}

较小的更改将整个内容转换为一行代码，而不是用分号分隔两行。

function(x)x[order(colSums(sapply(x,function(y)as.double(intToBits(y)))),decreasing=T)]

数总和法而不是用加列colSums由创建的二元矩阵的sapply，我之前加列元素sapply“完了。”

function(x)x[order(sapply(x,function(y)sum(as.double(intToBits(y)))),decreasing=T)]

下降到启我真的想缩短减少，但在我[R叫声，如果我尽量缩短decreasing在order功能，这是必要的，以获得所需的顺序作为order违约增加，然后我想起了rev功能逆转的向量。EUREKA ！！！最终解决方案中的最后一个更改是function要pryr::f多保存2个字节

function(x)rev(x[order(sapply(x,function(y)sum(as.double(intToBits(y)))))])

哈斯克尔123C

import Data.List
import Data.Ord
b 0=[]
b n=mod n 2:b(div n 2)
c n=(n,(sum.b)n)
q x=map fst$sortBy(comparing snd)(map c x)

这是我想解决此问题的第一种方法，但我敢打赌，有更好的方法可以解决此问题。另外，如果有人知道Haskell进口高尔夫的方式，我会很感兴趣。

例

*Main> q [4,2,15,5,3]
[4,2,5,3,15]
*Main> q [7,0,2]
[0,2,7]

非高尔夫版本（带说明）

import Data.List
import Data.Ord

-- Converts an integer into a list of its bits
binary 0 = []
binary n = mod n 2 : binary (div n 2)

-- Creates a tuple where the first element is the number and the second element
-- is the sum of its bits.
createTuple n = (n, (sum.binary) n)

-- 1) Turns the list x into tuples
-- 2) Sorts the list of tuples by its second element (bit sum)
-- 3) Pulls the original number out of each tuple
question x = map fst $ sortBy (comparing snd) (map createTuple x)

CoffeeScript（94）

可读代码（212）：

sort_by_ones_count = (numbers) ->
  numbers.sort (a, b) ->
    a1 = a.toString(2).match(/1/g).length
    b1 = b.toString(2).match(/1/g).length
    if a1 == b1
      0
    else if a1 > b1
      1
    else
      -1

console.log sort_by_ones_count [825, 3944, 11746, 15342, 15752, 16375, 19944, 21826, 28436, 28943, 32425]

优化（213）：

count_ones = (number) -> number.toString(2).match(/1/g).length
sort_by_ones_count = (numbers) -> numbers.sort (a, b) ->
  a1 = count_ones(a)
  b1 = count_ones(b)
  if a1 == b1 then 0 else if a1 > b1 then 1 else -1

混淆（147）：

c = (n) -> n.toString(2).match(/1/g).length
s = (n) -> n.sort (a, b) ->
  a1 = c(a)
  b1 = c(b)
  if a1 == b1 then 0 else if a1 > b1 then 1 else -1

三元运算符过长（129）：

c = (n) -> n.toString(2).match(/1/g).length
s = (n) -> n.sort (a, b) ->
  a1 = c(a)
  b1 = c(b)
  (0+(a1!=b1))*(-1)**(0+(a1>=b1))

太久了，请停止投放（121）：

c = (n) -> n.toString(2).match(/1/g).length
s = (n) -> n.sort (a, b) ->
  a1 = c(a)
  b1 = c(b)
  (-1)**(a1>=b1)*(a1!=b1)

决赛（94）：

c=(n)->n.toString(2).match(/1/g).length
s=(n)->n.sort((a, b)->(-1)**(c(a)>=c(b))*(c(a)!=c(b)))

Smalltalk（Smalltalk / X），36（或24）

输入 破坏性地分类为：

a sort:[:a :b|a bitCount>b bitCount]

功能版本：返回一个新的排序数组：

a sorted:[:a :b|a bitCount>b bitCount]

甚至还有一个更短的变体（将名称或函数作为参数传递）为24个字符。但是（叹气）它将排在最后。据我了解，这不是必需的，所以我不认为这是高尔夫成绩：

a sortBySelector:#bitCount

PHP 5.4+ 131

在这种情况下，我什至不知道为什么要打扰PHP：

<?unset($argv[0]);usort($argv,function($a,$b){return strcmp(strtr(decbin($b),[0=>'']),strtr(decbin($a),[0=>'']));});print_r($argv);

用法：

> php -f sortbybinaryones.php 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944
Array
(
    [0] => 16375
    [1] => 15342
    [2] => 32425
    [3] => 28436
    [4] => 19944
    [5] => 11746
    [6] => 28943
    [7] => 3944
    [8] => 15752
    [9] => 825
    [10] => 21826
)

斯卡拉，58岁

def c(l:List[Int])=l.sortBy(-_.toBinaryString.count(_>48))

DFSORT（IBM Mainframe分类产品）288（每行源代码为72个字符，位置1处必须有空格）

 INREC IFTHEN=(WHEN=INIT,BUILD=(1,2,1,2,TRAN=BIT)), 
       IFTHEN=(WHEN=INIT,FINDREP=(STARTPOS=3,INOUT=(C'0',C'')))
 SORT FIELDS=(3,16,CH,D) 
 OUTREC BUILD=(1,2)

只是为了好玩，没有数学。

取一个带有整数的文件（可以从使用“数组”的程序中执行）。在排序之前，它将整数转换为位（在16个字符的字段中）。然后将位中的0更改为空。SORT降序更改的结果。仅使用整数创建排序文件。

C

void main()
{
 int a[]={7,6,15,16};
 int b,i,n=0;
 for(i=0;i<4;i++)
 {  for(b=0,n=0;b<=sizeof(int);b++)
      (a[i]&(1<<b))?n++:n;   
    a[i]=n;
 }
 for (i = 1; i < 4; i++) 
  {   int tmp = a[i];
      for (n = i; n >= 1 && tmp < a[n-1]; n--)
         a[n] = a[n-1];
      a[n] = tmp;
  }    
}

C＃，88 89

int[] b(int[] a){return a.OrderBy(i=>-Convert.ToString(i,2).Count(c=>c=='1')).ToArray();}

编辑：降序添加一个字符。

Java脚本 84

受其他javascript答案启发，但没有eval和regex。

var r=(x)=>(+x).toString(2).split('').reduce((p,c)=>p+ +c)
[28943,825,11746,16375,32425,19944,21826,15752,15342,3944,28436].sort((x,y)=>r(x)-r(y));

Java语言（82）

a.sort(function(b,c){q=0;while(b|c){b%2?c%2?0:q++:c%2?q--:0;b>>=1;c>>=1}return q})

后记126

因为我们进行排序的值列表是事先已知的并且非常有限（32），所以即使没有内置的排序方法，也可以通过选择1..32的匹配值来轻松完成此任务。（是O（32n）吗？可能）。

过程期望将数组放在堆栈上并返回“排序”数组。

/sort_by_bit_count {
    [ exch
    32 -1 1 {
        1 index
        {
            dup 2 32 string cvrs
            0 exch
            {48 sub add} forall
            2 index eq 
            {3 1 roll} {pop} ifelse
        } forall
        pop
    } for
    pop ]
} def

或者，在仪式上剥夺了空白和可读性：

/s{[exch 32 -1 1{1 index{dup 2 32 string cvrs 0 exch{48 sub add}forall 2 index eq{3 1 roll}{pop}ifelse}forall pop}for pop]}def

然后，如果保存到bits.ps它，可以这样使用：

gs -q -dBATCH bits.ps -c '[(%stdin)(r)file 1000 string readline pop cvx exec] s =='
825 3944 11746 15342 15752 16375 19944 21826 28436 28943 32425
[16375 15342 32425 11746 19944 28436 28943 3944 15752 825 21826]

我认为它实际上与该Perl相同（这里也没有Perl）：

sub f{map{$i=$_;grep{$i==(()=(sprintf'%b',$_)=~/1/g)}@_}reverse 1..32}

虽然说，不像后记，可以很容易地golfed：

sub f{sort{j($b)-j($a)}@_}sub j{$_=sprintf'%b',@_;()=/1/g}

C- 124 111

作为一种方法实现，并使用标准库进行排序。指向数组和大小的指针应作为参数传递。这仅适用于具有32位指针的系统。在64位系统上，必须花费一些字符来指定指针定义。

缩进以提高可读性

c(int*a,int*b){
    int d,e,i;
    for(d=e=i=0;i-32;){
        d+=*a>>i&1;e+=*b>>i++&1;
    }
    return d>e?-1:d<e;
}
o(r,s){qsort(r,s,4,c);}

样品电话：

main() {
    static int a[] ={1, 2, 3, 4, 5, 6, 7, 8, 9};
    o(a, 9);
}

Java 8：144

static void main(String[]a){System.out.print(Stream.of(a).mapToInt(Integer::decode).sorted(Comparable.comparing(Integer::bitCount)).toArray());}

展开形式：

static void main(String[] args){
    System.out.print(
        Stream.of(args).mapToInt(Integer::decode)
              .sorted(Comparable.comparing(Integer::bitCount))
              .toArray()
        );
}

如您所见，这可以通过将转换args为Stream<String>，然后转换为来实现Stream<Integer>使用Integer::decode函数引用（比parseInt或短，valueOf），然后按Integer::bitCount，然后将其放入数组中并打印出来来实现。

流使一切变得容易。