Hedef

Bir fonksiyon veya program yazın bir tamsayı dizisini azalan sırayla ikili gösterimlerinde bulunan 1 sayısı ile sıralayın. İkincil sıralama koşulu gerekmez.

Örnek sıralama listesi

(16 bit tamsayılar kullanarak)

  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

Giriş

32 bit tam sayı dizisi.

Çıktı

Açıklandığı gibi aynı tamsayıların bir dizi.

puanlama

Bu, bir hafta içinde seçilecek en az bayt sayısı için golf kodudur.

J (11)

(\:+/"1@#:)

Bu liste alan bir fonksiyondur:

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

Bir isim vermek istiyorsanız, bir karakter daha ekler:

     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

Açıklama:

• \:: aşağı doğru sırala
• +/: toplamı
• "1: her satır
• #:: ikili temsil

JavaScript, 39

Güncelleme: Şimdi Ruby'den daha kısa.

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)

Açıklama:

q özyinelemeli bir işlevdir. Eğer x veya y 0 ise, döndürür x-y(x sıfır ise negatif sayı veya y sıfır ise pozitif sayı). Aksi takdirde, en düşük bit'i ( x&x-1) x ve y'den kaldırır ve tekrarlar.

Önceki sürüm (42)

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

Yakut 41

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

Ölçek:

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]

Piton 3 (44):

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

Common Lisp, 35

logcountbir sayıdaki 'on' bit sayısını döndürür. Bir liste için lbiz var:

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

Bağımsız bir işlev olarak ve bayt sayımını ne temel alacağım:

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

Python 3, 90 77 72 67 karakter.

Bizim çözümümüz komut satırından bir girdi alır ve sayıyı azalan düzende (67 karakter) veya artan (66) olarak yazdırır.

Azalan sipariş

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

@Daniero sayesinde, 1'in sayısında bir eksi kullanma önerisi için tersine çevirmek için bir dilim kullanmak yerine teşekkür ederiz ! Bu etkili bir şekilde 5 karakter kurtardı.

Sadece gönderim uğruna, artan sipariş sürümü (ilk yaptığımız) bir karakterden daha az alacaktı.

Artan düzen :

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

Sayesinde @Bakuriu için anahtar = lambda x ... öneri. D

JavaScript [76 bayt]

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

burada abir sayı giriş dizisidir.

Ölçek:

[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]&]&

Kullanımı:

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 sayılı belge}

k [15 Karakter]

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

örnek 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

Örnek 2 (tüm sayılar 2 ^ n -1'dir)

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

127 63 31 15 7 3

Mathematica 39

IntegerDigits[#,2] 10 taban sayısını 1 ve 0 lere dönüştürür.

Tr rakamları toplar.

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

Test durumu

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

{16375, 15342, 32425, 11746, 19944, 28436, 28943, 3944, 15752, 825, 21826 sayılı belge}

Java 8 - 87/113 81/111 60/80 60/74/48 karakterler

Bu tam bir java programı değildir, sadece bir fonksiyondur (kesin olması gereken bir yöntem).

Bunu varsayar java.util.Listve java.lang.Long.bitCountiçe aktarılır ve 60 karakterden oluşur:

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

Önceden içe aktarılmış içeriğe izin verilmiyorsa, burada 74 karakter var:

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

Olması gerekiyorsa daha fazla 7 karakter ekleyin static.

[4 yıl sonra] Ya da tercih ederseniz, 48 baytlık bir lambda (öneri için @KevinCruijssen teşekkürler) olabilir:

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

Python 2.x - 65 karakter (bayt)

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

Bu aslında 66 karakter, 65 işlevi görürsek (o zaman onu sunmak için lamer olan bir şeye ihtiyacınız olur).

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

Bash / CMD’de demo:

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' girişi

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

Olumsuz sayılar için çalışır.

C - 85 bayt (108 106 bayt)

GCC / Clang / mümkün __builtin_popcountolan her yerde taşınabilir sürüm (106 bayt):

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

Ultra yoğunlaştırılmış, taşınabilir olmayan, ancak işlevsel bir MSVC sürümü (85 bayt):

#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 */

• Bayt sayısına dahil edilen ilk newline nedeniyle #define, diğerleri gerekli değildir.

• Çağrılma işlevi s(array, length)özelliklere göre yapılır.

• sizeofPortatif versiyonda başka bir 7 karakter kaydetmek için kod yazabilir, diğer birkaç C cevap gibi. Hangisinin uzunluk-kullanılabilirlik oranı açısından en değerli olduğuna emin değilim, siz karar verin.

PowerShell v3, 61 58 53

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

Cmdlet için ScriptBlock Sort-Object, sayının ikili gösteriminde her 1 için 1 dizisini döndürür. Sort-ObjectListeyi, her sayı için döndürülen dizinin uzunluğuna göre sıralar.

Yürütmek için:

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

ECMAScript 6, 61

zGiriş olduğunu varsayar

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

Test verisi

[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]

Teşekkürler, kısa çözüm için diş fırçası.

R , 132 96 94 88 84 75 73 53 51 bayt

-20, J.Doe'nun uygulaması sayesinde -2

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

Orijinal yayınım:

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

Çevrimiçi deneyin!

Bu sonuca varmadan önce birkaç farklı yöntem denedim.

Matris Yöntemi: İki sütun matrisi oluşturulmuş, bir giriş vektörü ile bir sütun, ikili gösterimin toplamından biri, sonra ben ikili toplamı sıraladım.

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

Matris Olmayan: Gerçekleştirildi Matris fonksiyonunu atabilir ve bunun yerine bir ikili değer vektörü oluşturabilir, onları toplayabilir, sıralayabilir, sonra girdi vektörünü yeniden sıralamak için sıralı değerleri kullanabilirim.

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

Küçük değişiklikler

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

Daha Küçük Değişiklikler Her şeyi noktalı virgülle ayrılmış iki yerine bir kod satırına dönüştürme.

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

Toplama YöntemicolSums Oluşturulan ikili matrisin sütunlarını eklemek yerine, "bitmiş" işleminden sapplyönce sütundaki öğeleri ekledim sapply.

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

Rev için Azalan I gerçekten azalan kısaltmak istedim, ama bana R squawks ben kısaltmak çalışırsanız decreasingiçinde ordersipariş olarak istenen almak gerekliydi fonksiyonu, orderartan varsayılan, sonra hatırladım revbir vektör ters fonksiyonunu. EUREKA !!! Son çözümdeki son değişiklik 2 bayt daha tasarruf etmekti function.pryr::f

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

Haskell, 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)

Bunu çözmeyi düşündüğüm ilk yol bu, ama iddiaya girmenin daha iyi bir yolu var. Ayrıca, Haskell ithal etmenin bir yolunu bilen biri varsa, duymak isterim.

Örnek

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

Ungolfed versiyonu (açıklamalarla)

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)

Okunabilir kod (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]

Optimize edilmiş (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

Şaşırtıcı (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

Üçlü operatörler aşırı derecede uzun (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))

Çok uzun, oyuna devam et (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)

Final (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 (veya belki 24)

a girişi; tahrip edici bir şekilde sıralar:

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

fonksiyonel versiyon: yeni bir sıralı dizi döndürür:

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

24 karakterde daha kısa bir değişken ( adı veya işlevi argüman olarak geçen) bile var . Ama (iç çeker) en yüksek sırayı alır. Anladığım kadarıyla, bu istenmedi, bu yüzden bunu golf puanı olarak kabul etmiyorum:

a sortBySelector:#bitCount

PHP 5.4+ 131

Bu durumda neden PHP ile uğraştığımı bile bilmiyorum:

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

Kullanımı:

> 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 Mainframe sıralama ürünü) 288 (her kaynak satır 72 karakterdir, birinci konumda boş alana sahip olmalıdır)

 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)

Sadece eğlence için ve matematik yok.

Tamsayılarla bir dosya (bir "dizi" kullanan bir programdan çalıştırılabilir) alır. Sıralamadan önce, tam sayıları bitlere çevirir (16 karakterlik bir alanda). Daha sonra bitlerdeki 0'ları hiçbir şeye değiştirmez. SIRALI Değişen bitlerin sonucuna göre azalan. Sıralanan dosyayı yalnızca tam sayılarla oluşturur.

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

Düzenleme: azalan düzen bir karakter ekler.

Javascript 84

Diğer javascript cevaplarından esinlenmiş, ancak eval ve regex kullanmamış.

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

Postscript, 126

Sıralama yaptığımız değerlerin listesi önceden bilindiğinden ve çok sınırlı olduğu için (32), sıralama için yerleşik olmasa bile, 1..32 için eşleşen değerleri seçerek bu görev kolayca yapılabilir. (0 (32n) mı? Muhtemelen).

Prosedür, yığında diziyi bekler ve 'sıralanmış' diziyi döndürür.

/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

Veya, ritüel olarak beyaz boşluktan ve okunabilirlikten sıyrılmış:

/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

Sonra, eğer kaydedilmişse bits.psbu şekilde kullanılabilir:

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]

Etkin olarak bu Perl ile aynı olduğunu düşünüyorum (burada da henüz Perl yok):

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

Bununla birlikte , Postscript'in aksine, kolayca golf yapılabilir:

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

C - 124 111

Bir yöntem olarak uygulanır ve sıralama için standart kitaplığı kullanır. Diziye bir işaretçi ve boyut parametre olarak geçirilmelidir. Bu sadece 32-bit işaretçilere sahip sistemlerde çalışacaktır. 64 bit sistemlerde, işaretçi tanımlarını belirterek bazı karakterlerin harcanması gerekir.

Okunabilirlik için girinti

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

Örnek arama:

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

Genişletilmiş biçimde:

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

Görüldüğü gibi, bu dönüştürme çalışır argsa Stream<String>daha sonra, bir dönüştürücü, Stream<Integer>ile Integer::decode(daha kısa fonksiyon referans parseIntya da valueOf), ve sonra, ayırma Integer::bitCount, daha sonra bir dizi koyarak, ve bunu baskı.

Akışlar her şeyi kolaylaştırır.