ゴール

関数またはプログラムを作成して、整数の配列をバイナリ表現に存在する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ビット整数の配列。

出力

説明どおりにソートされた同じ整数の配列。

得点

これは、1週間の時間内に選択される最小バイト数のコードゴルフです。

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

名前を付けたい場合は、1文字余分にかかります：

     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-1xと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'))

Common Lisp、35

logcount数値の「オン」ビットの数を返します。リストには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文字が効果的に節約されました。

投稿するためだけに、昇順バージョン（最初に作成したバージョン）は1文字少なくなります。

昇順：

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

key = lambda x…の提案をしてくれた@Bakuriuに感謝します。; 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 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年後]または、必要に応じて、48バイトのラムダ（提案に対して@KevinCruijssenに感謝）を使用できます。

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-Objectコマンドレットの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ジュゼッペにさらに感謝

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

私の元の投稿：

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

オンラインでお試しください！

この結果に至る前に、いくつかの異なる方法を試しました。

マトリックス法： 2列のマトリックスを作成し、1列に入力ベクトル、2進表現の合計の1つを作成してから、2進数の合計でソートしました。

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),]}

Non-Matrix：実現されて、行列関数を捨てて、代わりにバイナリ値のベクトルを作成し、それらを合計し、順序付けしてから、順序付けられた値を使用して入力ベクトルを並べ替えることができました。

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)]}

その他のマイナーな変更セミコロンで区切られた2行ではなく、1行のコードに全体を変換します。

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

SumメソッドでcolSums作成したバイナリマトリックスの列を追加する代わりに、「終了」するsapply前に列に要素を追加しましたsapply。

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

Revに減少することは本当に減少を短くしたかったのですdecreasingが、order関数を短くしようとするとRは私を驚かせます。これはorderデフォルトとして増加するデフォルトの順序を取得するために必要でしたがrev、ベクトルを逆にする関数を思い出しました。ユーレカ！！！最終ソリューションの最後の変更は、さらに2バイトを節約functionするpryr::fことでした

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
)

Scala、58

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

DFSORT（IBMメインフレームソート製品）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();}

編集：降順で文字が追加されます。

Javascript 84

他のJavaScriptの回答に触発されましたが、評価と正規表現はありません。

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));

Javascript（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、配列の中に入れ、それをプリントアウトし、。

ストリームはすべてを簡単にします。