Tor

Schreiben Sie eine Funktion oder ein Programm, und sortieren Sie ein Array von Ganzzahlen in absteigender Reihenfolge nach der Anzahl der Einsen in ihrer Binärdarstellung. Es ist keine sekundäre Sortierbedingung erforderlich.

Beispiel sortierte Liste

(unter Verwendung von 16-Bit-Ganzzahlen)

  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

Eingang

Ein Array von 32-Bit-Ganzzahlen.

Ausgabe

Ein Array der gleichen Ganzzahlen, sortiert wie beschrieben.

Wertung

Dies ist Codegolf für die geringste Anzahl von Bytes, die in einer Woche ausgewählt werden können.

J (11)

(\:+/"1@#:)

Dies ist eine Funktion, die eine Liste annimmt:

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

Wenn Sie ihm einen Namen geben möchten, kostet dies ein zusätzliches Zeichen:

     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

Erläuterung:

• \:: nach unten sortieren
• +/: die Summe von
• "1: jede Reihe von
• #:: binäre Darstellung

JavaScript, 39

Update: Jetzt kürzer als 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)

Erläuterung:

q ist eine rekursive Funktion. Wenn x oder y 0 sind, wird zurückgegeben x-y(eine negative Zahl, wenn x Null ist, oder eine positive Zahl, wenn y Null ist). Andernfalls wird das niedrigste Bit entfernt (x&x-1 ) aus x und y entfernt und wiederholt.

Vorherige Version (42)

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

Rubin 41

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

Prüfung:

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

Gemeiner Lisp, 35

logcountGibt die Anzahl der Ein-Bits in einer Zahl zurück. Für eine Liste lhaben wir:

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

Als eigenständige Funktion und worauf ich die Byteanzahl stützen werde:

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

Python 3, 90 77 72 67 Zeichen.

Unsere Lösung verwendet eine Eingabe von der Befehlszeile und gibt die Nummer in absteigender Reihenfolge (67 Zeichen) oder aufsteigender Reihenfolge (66 Zeichen) aus.

Absteigende Reihenfolge

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

Vielen Dank an @daniero für den Vorschlag, ein Minus in der 1 zu verwenden, um es umzukehren, anstatt ein Slice zu verwenden, um das Array am Ende umzukehren! Dies sparte effektiv 5 Zeichen.

Nur um es zu veröffentlichen, würde die Version in aufsteigender Reihenfolge (die die erste war, die wir gemacht haben) ein Zeichen weniger haben.

Aufsteigende Reihenfolge :

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

Vielen Dank an @ Bakuriu für den Vorschlag key = lambda x… . ; D

JavaScript [76 Bytes]

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

wo aist ein Eingabearray von Zahlen.

Prüfung:

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

Verwendung:

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

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

Beispiel 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

Beispiel 2 (alle Zahlen sind 2 ^ n -1)

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

127 63 31 15 7 3

Mathematica 39

IntegerDigits[#,2] wandelt eine Zahl zur Basis 10 in eine Liste mit Einsen und Nullen um.

Tr summiert die Ziffern.

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

Testfall

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 Zeichen

Dies ist kein vollständiges Java-Programm, sondern nur eine Funktion (um genau zu sein eine Methode).

Es wird davon ausgegangen, dass java.util.Listund java.lang.Long.bitCountimportiert werden, und hat 60 Zeichen:

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

Wenn keine vorimportierten Sachen erlaubt sind, ist dies hier mit 74 Zeichen:

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

Fügen Sie weitere 7 Zeichen hinzu, falls dies erforderlich sein sollte static.

[4 Jahre später] Oder wenn Sie es vorziehen, könnte es ein Lambda sein (danke @KevinCruijssen für den Vorschlag), mit 48 Bytes:

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

Python 2.x - 65 Zeichen (Bytes)

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

Das sind tatsächlich 66 Zeichen, 65, wenn wir es zu einer Funktion machen (dann brauchen Sie etwas, um es zu nennen, das lamer ist, um es zu präsentieren).

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

Demo in 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

Eingabe in 'a'

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

Funktioniert für nicht negative Zahlen.

C - 85 Bytes (108 106 Bytes)

Portable Version auf GCC / Clang / wo __builtin_popcountimmer verfügbar (106 Bytes):

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

Ultrakondensierte, nicht tragbare, kaum funktionierende MSVC-Version (85 Byte):

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

• Die erste Zeile ist in der Byteanzahl enthalten #define, die anderen Zeilen sind nicht erforderlich.

• Die aufzurufende Funktion entspricht s(array, length)den Spezifikationen.

• Kann die sizeofin der portablen Version fest codieren , um weitere 7 Zeichen zu speichern, wie es einige andere C-Antworten taten. Ich bin mir nicht sicher, welches Modell in Bezug auf das Verhältnis von Länge und Nutzbarkeit am besten geeignet ist, entscheiden Sie.

PowerShell v3, 61 58 53

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

Der ScriptBlock für das Sort-ObjectCmdlet gibt für jede 1 in der binären Darstellung der Zahl ein Array mit Einsen zurück. Sort-Objectsortiert die Liste basierend auf der Länge des Arrays, das für jede Nummer zurückgegeben wird.

Ausführen:

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

ECMAScript 6, 61

Angenommen, zist die Eingabe

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

Testdaten

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

Danke, Zahnbürste für die kürzere Lösung.

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

-20 dank J.Does Implementierung -2 mehr dank Giuseppe

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

Mein ursprünglicher Beitrag:

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

Probieren Sie es online!

Ich habe verschiedene Methoden ausprobiert, bevor ich zu diesem Ergebnis kam.

Matrix-Methode: Erstellt eine zweispaltige Matrix, eine Spalte mit dem Eingabevektor, eine aus der Summe der Binärdarstellung, und sortiert dann nach der Summe der Binärdarstellungen.

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

Nicht-Matrix: Es wurde erkannt, dass ich die Matrixfunktion wegwerfen und stattdessen einen Vektor von Binärwerten erstellen, diese summieren, ordnen und dann die geordneten Werte verwenden könnte, um den Eingabevektor neu zu ordnen.

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

Kleinere Änderungen

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

Kleinere Änderungen Konvertieren des gesamten Objekts in eine Codezeile anstelle von zwei durch ein Semikolon getrennten.

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

Summenmethode Anstatt die Spalten mit der colSumsvon erstellten binären Matrix hinzuzufügen sapply, habe ich die Elemente in der Spalte vor sapply"Fertig" hinzugefügt .

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

Abnahme auf Umkehr Ich wollte eigentlich die Abnahme verkürzen, aber R quäkelt mich an, wenn ich versuche, decreasingdie orderFunktion zu verkürzen , was notwendig war, um die gewünschte Reihenfolge als orderStandard zu erreichen. Dann erinnerte ich mich an die revFunktion zum Umkehren eines Vektors. EUREKA !!! Die letzte Änderung in der endgültigen Lösung bestand functiondarin pryr::f, 2 weitere Bytes einzusparen

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)

Dies ist der erste Weg, den ich mir überlegt habe, aber ich wette, es gibt einen besseren Weg, dies zu tun. Wenn jemand eine Möglichkeit zum Golfen von Haskell-Importen kennt, wäre ich sehr interessiert, das zu hören.

Beispiel

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

Ungolfed version (mit erklärungen)

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)

Kaffeeskript (94)

Lesbarer Code (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]

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

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

Ternäre Operatoren sind zu lang (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))

Noch zu lange, hör auf zu wirken (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)

Finale (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 (oder vielleicht 24)

Eingabe in a; destruktiv sortiert in einem:

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

funktionale Version: gibt ein neues sortiertes Array zurück:

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

Es gibt sogar eine kürzere Variante (Übergabe des Namens oder der Funktion als Argument) in 24 Zeichen. Aber (seufz) es wird zuletzt am höchsten sortiert. Soweit ich verstanden habe, wurde dies nicht verlangt, daher nehme ich das nicht als Golf-Score:

a sortBySelector:#bitCount

PHP 5.4+ 131

Ich weiß nicht einmal, warum ich mich mit PHP beschäftige, in diesem Fall:

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

Verwendung:

> 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-Sortierprodukt) 288 (jede Quellzeile besteht aus 72 Zeichen und muss an Position 1 ein Leerzeichen enthalten.)

 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)

Nur zum Spaß und ohne Mathematik.

Nimmt eine Datei (kann von einem Programm ausgeführt werden, das ein "Array" verwendet) mit den ganzen Zahlen. Vor dem Sortieren werden die Ganzzahlen in Bits (in einem 16-stelligen Feld) übersetzt. Dann ändert sich die 0 in den Bits zu nichts. SORT Absteigend vom Ergebnis der geänderten Bits. Erstellt die sortierte Datei nur mit den ganzen Zahlen.

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

Bearbeiten: absteigende Reihenfolge fügt ein Zeichen hinzu.

Javascript 84

Inspiriert von anderen Javascript-Antworten, aber ohne eval und 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));

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

Nachschrift, 126

Da die Liste der Werte, nach denen wir sortieren, im Voraus bekannt und sehr begrenzt ist (32), kann diese Aufgabe auch dann problemlos durchgeführt werden, wenn keine Sortierfunktion integriert ist, indem übereinstimmende Werte für 1..32 ausgewählt werden. (Ist es O (32n)? Wahrscheinlich).

Die Prozedur erwartet das Array auf dem Stack und gibt das sortierte Array zurück.

/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

Oder rituell von Leerzeichen und Lesbarkeit befreit:

/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

Wenn es gespeichert ist, bits.pskann es folgendermaßen verwendet werden:

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]

Ich denke, es ist effektiv dasselbe wie dieses Perl (es gibt hier auch noch kein Perl):

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

Obwohl , dass , im Gegensatz zu Postscript, kann leicht golfed werden:

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

C - 124 111

Implementiert als Methode und unter Verwendung der Standardbibliothek für die Sortierung. Ein Zeiger auf das Array und die Größe sollten als Parameter übergeben werden. Dies funktioniert nur auf Systemen mit 32-Bit-Zeigern. Auf 64-Bit-Systemen müssen einige Zeichen für die Angabe von Zeigerdefinitionen verwendet werden.

Einzug für die Lesbarkeit

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

Beispielanruf:

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

In erweiterter Form:

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

Wie Sie sehen können, funktioniert dies, indem Sie das argsin ein Stream<String>konvertieren und dann Stream<Integer>mit der Integer::decodeFunktionsreferenz in ein konvertieren (kürzer alsparseInt oder)valueOf ) und anschließend nach sortierenInteger::bitCount , dann in ein Array einfügen und es ausdrucken.

Streams machen alles einfacher.