Créez un programme qui calcule le poids de hamming d'une chaîne. Winner est le programme avec le poids le plus faible.

Règles:

• Le poids de Hamming pour un caractère ASCII est défini comme le nombre total de bits définis 1dans sa représentation binaire.
• Supposons que le codage d'entrée est ASCII 7 bits, transmis via le mécanisme d'entrée normal pour votre langue (par exemple stdin, args, etc.)
• Exportez le résultat, sous forme de nombre, vers stdout ou tout autre mécanisme de sortie par défaut / normal utilisé par votre langue.
• Cela devrait aller de soi, mais vous devez être en mesure d' exécuter le programme, dans la vraie vie, pour qu'il soit une solution valide.
• Winner est la solution dont le code a le poids le plus faible.
• Désolé, aucune solution en blanc pour celui-ci! Ok, vous pouvez coder en espace maintenant j'ai trié les règles :)

Exemples par caractère:

char |  binary  | weight
-----+----------+-------
a    | 01100001 | 3
x    | 01111000 | 4
?    | 00111111 | 6
\x00 | 00000000 | 0
\x7F | 01111111 | 7

J (33)

Un de moins de 34!

+/,#:3 u:

Fortement inspiré par cette réponse , mais un poids inférieur à un.

   +/,#:3 u:'+/,#:3 u:'
33

J, poids 34

+/,#:a.i.

Utilisation - placez la chaîne à mesurer entre guillemets à la fin:

   +/,#:a.i.'+/,#:a.i.'
34

Alternativement, en prenant l'entrée du clavier (poids 54):

   +/,#:a.i.1!:1[1
hello
21

J , 39

+/,#:a.i:]

Il s'agit d'une fonction prenant un argument. (Ou remplacez- ]le directement par la chaîne; comme le note Gareth, cela réduit le coût à 34.)

   + /, #: ai:] 'bonjour le monde'
45
   + /, #: ai:] '+ /, #: ai:]'
39

Python, 189

print sum(bin(ord(A)).count("1")for A in raw_input())

QBasic, 322 311 286 264

H$=COMMAND$
FOR A=1 TO LEN(H$)
B=ASC(MID$(H$,A,1))
WHILE B>0
D=D+B MOD 2
B=B\2
WEND
NEXT
?D

Le bon outil pour le travail, ça craint toujours bien sûr.

Unaire 0

Vous saviez tous que ça allait arriver. Tout d'abord le programme BrainFuck:

,[[>++[>>+>+<<<-]>>>
[<<<+>>>-]>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>
[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-]
[-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>
[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<
[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<<<
[>>+<[>>+>+<<<-]>>>[<<<+>>>-]>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>
[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]> 
[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<
[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<<<]>>>
[>+>+<<-]>>[<<+>>-][-]+<[>[-]<<[<<->>-]<<[>>+<<-]>>>[-]]>[<<<+<[-]>>>>
[-]]<<[->>>>+<<<<]<[-<<+>>]<<],]>>>>>>>.

J'ai ajouté des nouvelles lignes pour le rendre "lisible" mais il a un poids de Hamming de 4066. Il fonctionne en obtenant à plusieurs reprises le quotient / les restes d'une chaîne d'entrée et en additionnant tous les restes. Bien sûr, si vous l'exécutez sur lui-même, vous obtenez: 226 (4066% 256) (techniquement \ xe2) si clairement qu'il se déclare vainqueur.

Maintenant, nous le convertissons en Unary et obtenons

000 ... 9*google^5.9 0's ... 000

Nous utilisons une implémentation unaire avec des caractères NULL \ x00 pour '0' et boom, ce qui entrave le poids de 0.

Question bonus : pour quels caractères ASCII cpouvez-vous exécuter ce programme sur une chaîne composée de Nrépétitions et le faire sortir ce caractère. (EG une chaîne de 32 espaces donne un espace). Quelles valeurs du Ntravail (soit un nombre infini d'entre elles fonctionnera, soit aucune ne fonctionnera).

C, poids 322 263 256

Le poids du hamming est-il important?

main(D,H,A)char*A,**H;{for(A=*++H;*A;A+=!(*A/=2))D+=*A%2;printf("%d",D-2);}

Utilisé principalement des techniques de golf standard.
Une seule boucle calcule le poids (décalage vers la droite et ajout jusqu'à zéro) et analyse la chaîne (avance le pointeur lorsque le zéro est atteint).
En supposant Dest initialisé à 2 (paramètre unique).

Optimisations spécifiques au poids de Hamming:
1. ABDH, avec un poids de 2 chacun, utilisé pour les noms.
2. *++Hpréféré à H[1].

Golfscript 84 72 58

{2base~}%{+}*

(merci à Howard et Peter Taylor pour leur aide)

Entrée: la chaîne d'entrée doit être sur la pile (passée comme argument de ligne de commande, ou simplement placée sur la pile).

Si vous l'exécutez à partir de la ligne de commande, assurez-vous de l'utiliser echo -n, sinon la nouvelle ligne de fin sera également comptée.

Sortie: imprime la valeur du poids de freinage sur la console

Le programme peut être testé ici .

Perl, 80 (22 caractères)

Fait et fait:

perl -0777nE 'say unpack"%32B*"'

Ou voici une version alternative avec un poids de 77 (21 caractères):

perl -0777pE '$_=unpack"%32B*"'

Je n'aime pas autant cette version, car sa sortie omet la dernière ligne.

Pour calculer le poids, je suppose que je compte les caractères de la manière habituelle (à l'exclusion du perl -e/ -E, mais en incluant d'autres caractères d'option). Si, pour une raison quelconque, les gens se plaignent de cela, le mieux que je puisse faire sans options est de 90 (26 caractères):

$/=$,,say unpack"%32B*",<>

Exemple d'utilisation:

$ perl -0777nE 'say unpack"%32b*"' rickroll.txt
7071

Boom.

Pyth - 15

Avertissement: Cette réponse n'est pas éligible pour gagner car Pyth est plus jeune que ce défi.

Utilise .Bla représentation binaire et compte le nombre de "1".

/.BQ\1

Prend l'entrée dans une chaîne pour enregistrer par zrapport à Q.

Essayez-le en ligne ici .

Scala 231

readLine().map(_.toInt.toBinaryString).flatten.map(_.toInt-48)sum

Code d'autotest:

"""readLine().map(_.toInt.toBinaryString).flatten.map(_.toInt-48)sum""".map(_.toInt.toBinaryString).flatten.map(_.toInt-48)sum

avec modification d'auto-test.

Java, poids 931 774 499 454

Je pense que c'est la seule réponse pour le moment avec un poids supérieur à 300 environ.

class H{public static void main(String[]A){System.out.print(new java.math.BigInteger(A[0].getBytes()).bitCount());}}

Attend l'entrée comme argument de ligne de commande.

GNOU sed -r , 467 + 1

(+1 pour l'utilisation de -r- ou cela devrait-il être +4?)

Sorties sous forme de valeur unaire par ligne source; pour convertir en un total décimal, redirigez la sortie vers | tr -d "\n" | wc -c. Compte tous les caractères ASCII imprimables (32-126), plus le saut de ligne (10).

s@[a-z]@\U& @g
s@[?{}~]@      @g
s@[][/7;=>OW|^]@     @g
s@[-'+.3569:<GKMNSUVYZ\\]@    @g
s@[#%&)*,CEFIJL1248ORTX]@   @g
s@$|[!"$(ABDH0P`]@  @g
y! @!11!

Il est difficile d'éviter de lister tous les caractères, mais nous pouvons réduire cela en observant que les lettres minuscules ont un poids de Hamming supérieur à celui des lettres majuscules correspondantes. Nous préférons la nouvelle ligne (score 2) au point-virgule (score 5) comme séparateur d'instructions; nous préférons @(score 1) ou !(score 2) à/ (score 5) comme délimiteur de modèle.

Remarque - pour obtenir les bons jeux de caractères, j'ai créé ce tableau à partir de celui de man ascii, trié par poids. Ajoutez simplement les scores à droite et en dessous pour obtenir le poids global de chaque personnage:

   2 4   3 5 6   7 
   ---  ------   - 
0:   @   0 P `   p |0

1: ! A   1 Q a   q | 
2: " B   2 R b   r |1
4: $ D   4 T d   t | 
8: ( H   8 X h   x | 

3: # C   3 S c   s | 
5: % E   5 U e   u | 
6: & F   6 V f   v |2
9: ) I   9 Y i   y | 
A: * J   : Z j   z | 
C: , L   < \ l   | | 

7: ´ G   7 W g   w | 
B: + K   ; [ k   { |3
D: - M   = ] m   } | 
E: . N   > ^ n   ~ | 

F: / O   ? _ o     |4
   ---  ------   -  
    1      2     3

Cela pourrait s'avérer utile à d'autres.

Julia 262 268

La version modifiée utilise la fonction pratique 'count_ones' pour une économie de 6 (262)

show(mapreduce(x->count_ones(x),+,map(x->int(x),collect(ARGS[1]))))

Ancienne version sans fonction de comptage intégrée (268)

show(mapreduce(x->int(x)-48,+,mapreduce(x->bits(x),*,collect(ARGS[1]))))

Utilise l'argument de ligne de commande pour l'entrée.

CJam 52 ou 48

Si l'entrée n'est pas déjà sur la pile (52)

q:i2fbs:s:i:+

Si l'entrée est sur la pile (48)

:i2fbs:s:i:+

Par exemple

"Hello World":i2fbs:s:i:+

Julia, HW 199

H=mapreduce;H(B->B=='1',+,H(P->bits(P),*,collect(A[:])))

Avec

A="H=mapreduce;H(B->B=='1',+,H(P->bits(P),*,collect(A[:])))"

ou en insérant directement la chaîne:

julia> H=mapreduce;H(B->B=='1',+,H(P->bits(P),*,collect("H=mapreduce;H(B->B=='1',+,H(P->bits(P),*,collect(A[:])))")))
199

La version non golfée (HW 411) ressemble à ceci:

bitstring=mapreduce(x->bits(x),*,collect(teststring[:]))
mapreduce(checkbit->checkbit=='1',+,bitstring)

Et pour le plaisir, voici une version optimisée (Hamming Weight 231 ) du point de vue de Bakerg sur le problème:

A=mapreduce;show(A(B->int(B)-48,+,A(B->bits(B),*,collect(H[:]))))

avec

H="A=mapreduce;show(A(B->int(B)-48,+,A(B->bits(B),*,collect(H[:]))))"

HPPPL (langage de programmation HP Prime), 74

sum(hamdist(ASC(a),0))

La calculatrice graphique HP Prime a une fonction hamdist () intégrée. Le poids de hamming de chaque personnage est le même que la distance de hamming de 0.

ASC (chaîne) crée un tableau des valeurs ASCII de chaque caractère d'une chaîne.

hamdist (valeur, 0) calcule la distance de hamming à partir de 0 pour chaque valeur ASCII

sum () résume toutes les valeurs.

Calcul du poids du hamming de son propre code source:

05AB1E , poids 17 (4 octets )

ÇbSO

Essayez-le en ligne ou vérifiez d'autres cas de test .

Explication:

Ç       # Convert the characters in the (implicit) input to their ASCII decimal values
        #  i.e. "Test" → [84,101,115,116]
 b      # Convert those values to binary
        #  i.e. [84,101,115,116] → ["1010100","1100101","1110011","1110100"]
  S     # Split it into a list of 0s and 1s (implicitly flattens)
        #  i.e. ["1010100","1100101","1110011","1110100"]
        #   → [1,0,1,0,1,0,0,1,1,0,0,1,0,1,1,1,1,0,0,1,1,1,1,1,0,1,0,0]
   O    # Sum those (and output implicitly)
        #  i.e. [1,0,1,0,1,0,0,1,1,0,0,1,0,1,1,1,1,0,0,1,1,1,1,1,0,1,0,0] → 16

Perl 6 , 102

+*.ords>>.base(2).comb(~1)

Essayez-le en ligne!

Bien que ce ne soit pas du golf de code, la solution la plus courte semble également avoir le plus petit poids de hamming ...