Écrivez une ou plusieurs instructions qui compteront le nombre d'un dans un entier de seize bits non signé.

Par exemple, si l'entrée est 1337, alors le résultat est 6dû 1337au fait qu'un nombre binaire de seize bits est 0000010100111001, qui en contient six.

80386 Code machine, 4 octets

F3 0F B8 C1

qui prend l'entier cxet sort le nombre ax, et est équivalent à:

popcnt ax, cx     ; F3 0F B8 C1

Et voici une solution de 11 10 octets n'utilisant pas POPCNT:

31 C0 D1 E9 10 E0 85 C9 75 F8

ce qui équivaut à:

xor ax, ax        ; 31 C0   Set ax to 0
shr cx, 1         ; D1 E9   Shift cx to the right by 1 (cx >> 1)
adc al, ah        ; 10 E0   al += (ah = 0) + (cf = rightmost bit before shifting)
test cx, cx       ; 85 C9   Check if cx == 0
jnz $-6           ; 75 F8   Jump up to shr cx, 1 if not

Python 2, 17 octets

bin(s).count('1')

La fonction binintégrée renvoie l'entier converti en chaîne binaire. On compte ensuite les 1chiffres:

>>> s=1337
>>> bin(s)
'0b10100111001'
>>> bin(s).count('1')
6

J (5 caractères)

J n'a pas de types explicites. Cela fait la bonne chose pour tous les entiers.

+/@#:

• +/ la somme
• @ de
• #: la représentation de base deux

C, 21

for(n=0;x;n++)x&=x-1;

vous avez dit "écrire quelques instructions" (pas "une fonction") donc j'ai supposé que le nombre était fourni xet que le nombre de 1 était retourné n. Si je n'ai pas à l'initialiser, nje peux économiser 3 octets.

Il s'agit d'une adaptation de la célèbre expression x&x-1pour tester si quelque chose a une puissance de 2 (faux si c'est le cas, vrai si ce n'est pas le cas.)

Le voici en action sur le numéro 1337 de la question. Notez que la soustraction de 1 inverse le bit le moins significatif et tous les zéros vers la droite.

0000010100111001 & 0000010100111000 = 0000010100111000
0000010100111000 & 0000010100110111 = 0000010100110000
0000010100110000 & 0000010100101111 = 0000010100100000
0000010100100000 & 0000010100011111 = 0000010100000000
0000010100000000 & 0000010011111111 = 0000010000000000
0000010000000000 & 0000001111111111 = 0000000000000000

EDIT: pour être complet, voici l'algorithme naïf, qui est un octet de plus (et un peu plus lent.)

for(n=0;x;x/=2)n+=x&1;

Gelée , non compétitive

Cette réponse n'est pas concurrente, car la langue a été créée après la publication du défi.

2 octets:

BS

Jelly est un nouveau langage écrit par @Dennis, avec une syntaxe de type J.

         implicit: function of command-line arguments
B        Binary digits as list
 S       Sum

Essayez-le ici .

Pyth, 4 octets

sjQ2

Le programme prend le numéro dont le poids de hamming se trouve sur STDIN.

Julia, 29 27 19 octets

n->sum(digits(n,2))

Cela crée une fonction anonyme qui accepte un seul argument, n . Pour l'utiliser, affectez-le à quelque chose comme f=n->...et appelez-le comme f(1337).

La digits()fonction, lorsqu'elle est appelée avec 2 arguments, retourne un tableau des chiffres de l'entrée dans la base donnée. Renvoie donc digits(n, 2)les chiffres binaires de n. Prenez la somme du tableau et vous avez le nombre de ceux dans la représentation binaire de n.

CJam, 6 octets

ri2b:+

ri         "Read the input and convert it to integer";
  2b       "Convert the integer into base 2 format";
    :+     "Sum the digits of base 2 form";

Essayez-le en ligne ici

Joe , 4 octets

/+Ba

Il s'agit d'une fonction anonyme. Badonne la représentation binaire d'un nombre et la /+somme.

   (/+Ba)13
3
   (/+Ba)500
6

R, 24 octets

sum(intToBits(scan())>0)

scan() lit l'entrée de stdin.

intToBits()prend un entier et retourne un vecteur de type rawcontenant les zéros et ceux de la représentation binaire de l'entrée.

intToBits(scan())>0renvoie un vecteur logique où chaque élément est TRUEsi l'élément vectoriel binaire correspondant est un 1 (puisque tous les éléments sont 0 ou 1 et 1> 0), sinon FALSE.

Dans R, vous pouvez additionner un vecteur logique pour obtenir le nombre d' TRUEéléments, donc la somme du vecteur de logique comme ci-dessus nous donne ce que nous voulons.

Notez que sum()ne peut pas gérer l' rawentrée directement, d'où la solution de contournement à l'aide de logiques.

Rubis, 18 octets

n.to_s(2).count'1'

Forth, 48 49 octets

: c ?dup if dup 1- and recurse 1+ then ;
0 1337 c

Si une fonction réelle est nécessaire, la deuxième ligne devient

: c 0 swap c ;

et vous l'appelez par "1337 c". Les mots de contrôle relativement verbeux de Forth rendent cela difficile (en fait, ils en rendent beaucoup).

Modifier: ma version précédente ne gérait pas correctement les nombres négatifs.

Mathematica, 22 18 octets

Merci à alephalpha de me l'avoir rappelé DigitCount.

DigitCount[#,2,1]&

ES6 (34 22 21 octets):

Il s'agit d'une simple fonction récursive qui peut être raccourcie un peu plus. Cela prend simplement un peu et s'exécute à nouveau:

B=n=>n&&(1&n)+B(n>>1)

Essayez-le sur http://www.es6fiddle.net/imt5ilve/ (vous en avez besoin à varcause de 'use strict';).

Je ne peux pas croire que j'ai battu des poissons !!!

Le vieux:

n=>n.toString(2).split(1).length-1

ES5 (39 octets):

Les deux fonctions peuvent être facilement adaptées à ES5:

function B(n){return n?(1&n)+B(n>>1):0}

//ungolfed:

function B(number)
{
    if( number > 0 )
    {
        //arguments.callee points to the function itself
        return (number & 1) + arguments.callee( number >> 1 );
    }
    else
    {
        return 0;
    }
}

Le vieux:

function(n){return n.toString(2).split(1).length-1}

@ user1455003 m'a donné une très bonne idée, qui a "déclenché" la plus petite:

function B(n,x){for(x=0;n;n>>=1)x+=n&1;return x}

Je l'ai adapté à ES6 et l'ai rendu récursif pour raccourcir beaucoup!

> <> (Poisson) , 24 octets + 2 = 26

0$11.>~n;
2,:?!^:2%:{+}-

Le programme ne fait que répéter le mod 2, soustrait et divise jusqu'à ce que le nombre d'entrée devienne zéro, puis imprime la somme des mod 2.

Test avec le -vdrapeau, par exemple

py -3 fish.py ones.fish -v 1337

PHP (38 octets):

Cela utilise la même approche que ma réponse ES6

<?=count(split(1,decbin($_GET[n])))-1;

Il s'agit d'un code complet, il vous suffit de le mettre dans un fichier et d'y accéder via le navigateur, avec le paramètre n=<number>.

PHP <4,2 (32 octets):

C'est un peu plus court:

<?=count(split(1,decbin($n)))-1;

Cela ne fonctionne que de manière fiable sur PHP <4.2 car la directive a register_globalsété définie Offpar défaut de PHP4.2 à PHP5.4 (qui a été supprimée d'ici là).

Si vous créez un php.inifichier avec register_globals=On, cela fonctionnera.

Pour utiliser le code, accédez au fichier à l'aide d'un navigateur, avec POST ou GET.

Suggestion de @ViniciusMonteiro (38/45 octets):

Il a donné 2 très bonnes suggestions qui ont une utilisation très intéressante de la fonction array_sum:

38 octets:

<?=array_sum(str_split(decbin(1337)));

45 octets:

<?=array_sum(preg_split('//', decbin(1337)));

C'est une très bonne idée et peut être raccourcie un peu plus, pour une longueur de 36 octets:

<?=array_sum(split(1,decbin(1337)));

C #, 45 octets

Convert.ToString((ushort)15,2).Sum(b=>b-48);

https://dotnetfiddle.net/kJDgOY

Japt, 3 octets (non compétitif)

¢¬x

Essayez-le ici.

cire d'abeille ,31 27 octets

Réponse non concurrente. La cire d'abeille est plus récente que ce défi.

Cette solution utilise la façon de Brian Kherigan de compter les bits définis sur le site Web «Bit Twiddling Hacks».

il passe simplement par une boucle, incrémentant le nombre de bits, tout en itérant number=number&(number-1)jusqu'à number = 0. La solution ne passe par la boucle que si des bits sont définis.

Je pourrais raser 4 octets en réorganisant quelques instructions. Le code source et l'explication ont été mis à jour:

pT_
>"p~0+M~p
d~0~@P@&<
{@<

Explication:

pT_            generate IP, input Integer, redirect
>"             if top lstack value > 0 jump next instruction,
               otherwise continue at next instruction
  p            redirect if top lstack value=0 (see below)
   ~           flip top and 2nd lstack values
    0+         set top lstack value to 0, set top=top+2nd
      M        decrement top lstack value
       ~       flip top and 2nd lstack values
        p      redirect to lower left
        <      redirect to left
       &       top=top&2nd
      @        flip top and 3rd lstack values
    @P         increment top lstack value, flip top and 3rd values
 ~0~           flip top and 2nd values, set top=0, flip top and 2nd again
d              redirect to upper left
>"p~0+M.....   loop back

  p            if top lstack = 0 at " instruction (see above), redirect
  0            set lstack top to zero (irrelevant instruction)
  <            redirect to the left
 @             flip top and 3rd lstack values
{              output top lstack value as integer (bitcount)

Clonez mon référentiel GitHub contenant l'interpréteur de cire d'abeille, les spécifications de langue et des exemples.

Java, 17 octets

Travaux pour byte, short, charet int. Utiliser comme lambda.

Integer::bitCount

Testez ici

Sans utiliser les intégrés:

42 octets

s->{int c=0;for(;s!=0;c++)s&=s-1;return c}

Testez ici

Clip , 6

2 façons:

cb2nx1

Il s'agit d'une traduction simple de l'exigence: le nombre de ceux dans la représentation de base-2 du nombre.

r+`b2n

Une autre méthode, qui prend la somme des chiffres de la représentation en base 2.

Octave, 18

sum(dec2bin(s)-48)

Exemple:

octave:1> s=1337
s =  1337
octave:2> sum(dec2bin(s)-48)
ans =  6

GML (Game Maker Language), 21 octets

for(n=0;x;n/=2)n+=x&1

C # 39 octets

Convert.ToString(X,2).Count(C=>C=='1');

Perl, 21

$r=grep$v&1<<$_,0..15

PowerShell (51 octets)

"$([char[]][convert]::ToString($s,2)|%{"+$_"})"|iex

Explication:
[convert]::ToString($s,2)produit une représentation de chaîne binaire à partir de $s.
[char[]]le jette comme un tableau de caractères et nous permet d'énumérer chaque caractère.
|%{"+$_"}ajoute à chaque caractère un signe +
"$()"appelle implicitement .ToString()la sous-expression résultante
|iexadditionne la chaîne canalisée (c.-à-d. "+1 +0 +1 +1 +0 +1 +0 +0" = 4)

Clojure, 42 octets

#(count(filter #{\1}(Long/toString % 2)))

Lire de droite à gauche, convertir en une chaîne binaire, convertir en une séquence de caractères, filtrer sur 1s et compter combien vous en avez.

MODIFIÉ Avec l'aide de Sieg

Haskell 42 caractères

t 0=[]
t n=t(quot n 2)++[rem n 2]
f=sum.t

déclare l' f :: Integer -> Integer
utilisation de la fonction à partir de l'interpréteur interactif f <number>ou ajoute la ligne main=print$f <number>à la fin du fichier.

Matlab, 13 octets

de2bicrée un vecteur de zéros et de uns représentant le nombre binaire, et sumrenvoie simplement la somme de toutes les entrées.

sum(de2bi(n))

𝔼𝕊𝕄𝕚𝕟, 4 caractères / 11 octets (non concurrentiel)

⨭⟦ïⓑ

Try it here (Firefox only).

Explication

Convertit l'entrée en binaire, se divise le long des caractères et obtient la somme du tableau résultant.