Objectif

Ecrivez une fonction ou un programme qui trie un tableau d'entiers dans l'ordre décroissant du nombre de 1 présents dans leur représentation binaire. Aucune condition de tri secondaire n'est nécessaire.

Exemple de liste triée

(en utilisant des entiers 16 bits)

  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

Contribution

Un tableau d'entiers 32 bits.

Sortie

Un tableau des mêmes entiers triés comme décrit.

Notation

Il s'agit du code golf pour le plus petit nombre d'octets à sélectionner en une semaine.

J (11)

(\:+/"1@#:)

C'est une fonction qui prend une liste:

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

Si vous voulez lui donner un nom, cela coûte un caractère supplémentaire:

     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

Explication:

• \:: trier vers le bas
• +/: somme de
• "1: chaque rangée de
• #:: représentation binaire

JavaScript, 39

Mise à jour: maintenant plus court que 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)

Explication:

q est une fonction récursive. Si x ou y sont 0, il retourne x-y(un nombre négatif si x est zéro ou un nombre positif si y est zéro). Sinon, il supprime le bit le plus bas ( x&x-1) de x et y et se répète.

Version précédente (42)

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

Rubis 41

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

Tester:

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

logcountrenvoie le nombre de bits sur un nombre. Pour une liste l, nous avons:

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

En tant que fonction autonome, et sur quoi je baserai l'octet:

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

Python 3, 90 77 72 67 caractères.

Notre solution prend une entrée de la ligne de commande et imprime le nombre par ordre décroissant (67 caractères) ou croissant (66).

Ordre décroissant

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

Merci à @daniero , pour la suggestion d'utiliser un moins dans le nombre de 1 pour l'inverser, au lieu d'utiliser une tranche pour inverser le tableau à la fin! Cela a effectivement sauvé 5 personnages.

Juste pour le poster, la version à ordre croissant (la première que nous avons créée) prendrait un caractère de moins.

Ordre croissant :

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

Merci à @Bakuriu pour la suggestion clé = lambda x… . ;RÉ

JavaScript [76 octets]

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

où aest un tableau d'entrée de nombres.

Tester:

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

Usage:

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 caractères]

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

Exemple 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

Exemple 2 (tous les nombres sont 2 ^ n -1)

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

127 63 31 15 7 3

Mathematica 39

IntegerDigits[#,2] convertit un numéro de base 10 en liste de 1 et de 0.

Tr résume les chiffres.

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

Cas de test

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 caractères

Ce n'est pas un programme Java complet, c'est juste une fonction (une méthode, pour être exact).

Il suppose cela java.util.Listet java.lang.Long.bitCountest importé et comporte 60 caractères:

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

Si aucun élément pré-importé n'est autorisé, le voici avec 74 caractères:

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

Ajoutez plus de 7 caractères si nécessaire static.

[4 ans plus tard] Ou si vous préférez, cela pourrait être un lambda (merci @KevinCruijssen pour la suggestion), avec 48 octets:

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

Python 2.x - 65 caractères (octets)

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

C'est en fait 66 caractères, 65 si nous en faisons une fonction (alors vous avez besoin de quelque chose pour l'appeler qui est plus facile à présenter).

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

Démo dans 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 ans

Entrée dans 'a'

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

Fonctionne pour les nombres non négatifs.

C - 85 octets (108 106 octets)

Version portable sur GCC / Clang / où qu'elle __builtin_popcountsoit disponible (106 octets):

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

Version MSVC uniquement ultra-condensée, non-portable, à peine fonctionnelle (85 octets):

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

• Première nouvelle ligne incluse dans le nombre d'octets en raison de la #define, les autres ne sont pas nécessaires.

• La fonction à appeler est s(array, length)conforme aux spécifications.

• Peut coder sizeofen dur dans la version portable pour enregistrer 7 autres caractères, comme le faisaient quelques autres réponses en C. Vous ne décidez pas lequel vaut le mieux en termes de rapport longueur / convivialité.

PowerShell v3, 61 58 53

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

Le ScriptBlock de la Sort-Objectcmdlet renvoie un tableau de 1 pour chaque 1 dans la représentation binaire du nombre. Sort-Objecttrie la liste en fonction de la longueur du tableau retourné pour chaque nombre.

Éxécuter:

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

ECMAScript 6, 61

Assume zest l'entrée

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

Données de test

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

Merci, brosse à dents pour la solution plus courte.

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

-20 grâce à la mise en œuvre de J.Doe -2 plus grâce à Giuseppe

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

Mon post original:

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

Essayez-le en ligne!

J'ai essayé plusieurs méthodes différentes avant d'arriver à ce résultat.

Méthode matricielle: Création d'une matrice à deux colonnes, une colonne avec le vecteur d'entrée, une de la somme de la représentation binaire, puis j'ai trié sur la somme de binaire.

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: Réalisé, je pouvais jeter la fonction de matrice et créer un vecteur de valeurs binaires, les additionner, les ordonner, puis utiliser les valeurs ordonnées pour réorganiser le vecteur d'entrée.

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

Des changements mineurs

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

Autres modifications mineures Conversion de la totalité d'un élément en une ligne de code au lieu de deux séparées par un point-virgule.

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

Méthode Sum Au lieu d'ajouter les colonnes avec colSumsla matrice binaire créée par sapply, j'ai ajouté les éléments de la colonne avant sapply"terminé".

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

Diminution de la valeur de revenant Je voulais vraiment raccourcir décroissant, mais R me reproche si j'essaie de raccourcir decreasingla orderfonction, ce qui était nécessaire pour que l'ordre souhaité orderaugmente par défaut, puis je me souvenais de la revfonction permettant d'inverser un vecteur. EUREKA !!! La dernière modification de la solution finale était functionde pryr::fsauver 2 autres octets

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)

C'est la première façon dont j'ai pensé résoudre ce problème, mais je parie qu'il existe un meilleur moyen de le faire. De plus, si quelqu'un connaissait un moyen de golfer les importations Haskell, je serais très intéressé de l'entendre.

Exemple

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

Version non-golfée (avec explications)

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)

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

Optimisé (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

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

Les opérateurs ternaires sont excessivement longs (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))

Trop long encore, arrêtez de lancer (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 (ou peut-être 24)

entrée dans un; trie de manière destructive dans un:

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

version fonctionnelle: renvoie un nouveau tableau trié:

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

il existe même une variante plus courte (en passant le nom ou la fonction en argument) dans 24 caractères. Mais (soupir), cela triera en dernier. Si j'ai bien compris, cela n'a pas été demandé, je ne prends donc pas cela pour un score de golf:

a sortBySelector:#bitCount

PHP 5.4+ 131

Je ne sais même pas pourquoi je m'embête avec PHP, dans ce cas:

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

Usage:

> 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 (produit de tri IBM Mainframe) 288 (chaque ligne source compte 72 caractères et doit comporter un espace en position un)

 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)

Juste pour le plaisir, et pas de mathématiques.

Prend un fichier (peut être exécuté depuis un programme utilisant un "tableau") avec les entiers. Avant le tri, il convertit les nombres entiers en bits (dans un champ de 16 caractères). Puis change les zéro dans les bits à rien. SORT Décroissant sur le résultat des bits modifiés. Crée le fichier trié avec uniquement les entiers.

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

Edit: ordre décroissant ajoute un caractère.

Javascript 84

Inspiré par d'autres réponses javascript, mais sans eval ni 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})

Postscript, 126

Étant donné que la liste des valeurs par lesquelles nous effectuons le tri est connue à l’avance et très limitée (32), cette tâche peut être effectuée facilement, même en l’absence de fonction de tri intégrée, en sélectionnant les valeurs correspondantes pour 1..32. (Est-ce O (32n)? Probablement).

La procédure attend un tableau sur la pile et retourne un tableau 'trié'.

/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

Ou, rituellement dépourvu d'espace blanc et de lisibilité:

/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

Ensuite, s’il est sauvegardé, bits.psil peut être utilisé comme ceci:

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]

Je pense que c'est effectivement le même que ce Perl (il n'y a pas encore de Perl ici aussi):

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

Bien que cela , contrairement à Postscript, puisse être facilement joué au golf:

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

C - 124 111

Implémenté en tant que méthode et en utilisant la bibliothèque standard pour le tri. Un pointeur sur le tableau et la taille doivent être passés en tant que paramètres. Cela ne fonctionnera que sur des systèmes avec des pointeurs 32 bits. Sur les systèmes 64 bits, certains caractères doivent être utilisés pour spécifier les définitions de pointeur.

Indentation pour la lisibilité

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

Exemple d'appel:

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

Sous forme développée:

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

Comme vous pouvez le constater, cela fonctionne en convertissant le argsen a Stream<String>, puis en un Stream<Integer>avec la Integer::decoderéférence de fonction (plus court que parseIntou valueOf), puis en triant Integer::bitCount, en le plaçant dans un tableau et en l'imprimant.

Les flux rendent tout plus facile.