J (33)

Uno inferiore a 34!

+/,#:3 u: 

Pesante ispirato da questa risposta , ma un peso inferiore di uno.

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

J, peso 34

+/,#:a.i. 

Utilizzo: posizionare il stringa da misurare tra virgolette alla fine:

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

In alternativa, prendendo input dalla tastiera (peso 54):

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

Commenti

• Cè ‘ solo un modo per scrivere questo:)
• Non cè ‘ t … Ho trovato una soluzione che ha un peso di martellamento inferiore di uno.
• Non sto cercando di essere un buzzkill, ma le regole richiedono un programma non un frammento.

Python, 189

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

Commenti

• Lequivalente di Python 3, print(sum(bin(ord(A)).count('1')for A in input())), ha un punteggio di 180.
• @ dan04: utilizza virgolette doppie invece di singole per 176.

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 

Tipo di lo strumento giusto per il lavoro, ovviamente fa ancora schifo.

Commenti

• +1 per aver usato una delle mie lingue preferite di tutti i tempi. È ‘ è la prima lingua che ho imparato a programmare su un PC.

Unario 0

Sapevate tutti che sarebbe arrivato. Per prima cosa il programma BrainFuck:

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

Ho aggiunto nuove righe per renderlo “leggibile” ma ha un peso di Hamming di 4066. Funziona ottenendo ripetutamente il quoziente / resti di una stringa di input e somma di tutti i resti. Ovviamente se lo esegui da solo ottieni: 226 (4066% 256) (tecnicamente \ xe2) quindi chiaramente si governa da solo il vincitore.

Ora lo convertiamo in unario e otteniamo

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

Usiamo unimplementazione unaria con caratteri NULL \ x00 per “0” e boom, hamming weight di 0.

Domanda bonus : per quali caratteri ASCII c puoi eseguire questo programma su una stringa composta da N ripete e visualizza quel carattere. (Ad es. Una stringa di 32 spazi dà uno spazio).Quali valori di N funzionano (o un numero infinito di essi funzionerà o nessuno lo farà).

Commenti

• Non ‘ non sono sicuro di aver compreso questa soluzione. Il programma Brainfuck ha un enorme peso martellante. Unary accetta byte nulli come programma o sarebbe necessario reimplementare Unary? Se ‘ è il secondo, ‘ non è proprio una soluzione valida: chiunque potrebbe semplicemente dire ” Definisco un linguaggio di programmazione in cui ogni singolo byte di input restituisce {result} ” e vinco ogni sfida di golf del codice sul sito.
• Un null carattere Unario andrebbe bene. Tutto ciò di cui hai bisogno è un EOF per dire smetti di contare. Infatti qui ‘ cè un po di pseudo-C per leggere quel file: main(){ bignum Unarynum = 0; int c; while(EOF!=(c=readchar())){ Unarynum++; } return Unarynum; } Doesn ‘ Non importa quale sia il tuo carattere unario (purché non sia ‘ t EOF).
• Bene qui ‘ è un compilatore unario del C che funziona bene con caratteri nulli: ideone.com/MIvAg . Ovviamente il file richiesto per realizzare questo programma non si adatterebbe alluniverso, ma abbiamo la capacità di eseguirlo.
• Se puoi ‘ t effettivamente eseguirlo, ‘ non è proprio una soluzione.
• Come Carl Sagan una volta ha detto: ” Se desideri calcolare il peso di martellamento di una stringa, devi prima inventare 10 ^ 500 universi. ” (miliardi e miliardi, pari)

C, peso 322 263 256

Il peso di martellamento del peso di martellamento conta?

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

Usato principalmente per il golf standard tecniche.
Un singolo ciclo calcola il peso (spostandosi a destra e aggiungendo fino a zero) e scansiona la stringa (fa avanzare il puntatore quando viene raggiunto lo zero).
Supponendo che D sia inizializzato a 2 (parametro singolo).

Hamming weight specific optimizati ons:
1. ABDH, con peso 2 ciascuno, utilizzato per i nomi.
2. *++H preferito su H[1].

Commenti

• Hah, fino ad ora non sono riuscito a capire la tua prima frase.
• Puoi ridurre il punteggio a 230 restituendo il risultato come un numero unario : main(D,H,A)char*A,**H;{for(A=*++H;*A;A+=!(*A/=2))if(*A%2)printf("@");}
• @schnaader , Non ho mai saputo che @ fosse una cifra nel sistema unario. Pensavo usasse solo 0 .. 0. Ma se vuoi andare in questo modo, printf("@"+*a%2) è più breve.
• @ugoren: dipende dalla convenzione / definizione di unario. Per esempio. en.wikipedia.org/wiki/Unary_numeral_system utilizza segni di conteggio e dice ” Non è presente alcun simbolo esplicito che rappresenti lo zero in unario come in altre basi tradizionali “.
• @schnaader, OK, ma penso che ‘ s estende il requisito ” come numero ” troppo oltre.

Golfscript 84 72 58

{2base~}%{+}* 

(grazie a Howard e Peter Taylor per il loro aiuto)

Input: la stringa di input deve essere nello stack (passata come riga di comando o semplicemente posizionato sullo stack).

Nel caso in cui lo esegui dalla riga di comando, assicurati di utilizzare echo -n, altrimenti anche la nuova riga finale essere contato.

Risultato: stampa il valore del peso di martellamento nella console

Il programma può essere testato

qui .

Commenti

• Golfscript fa distinzione tra maiuscole e minuscole? In caso contrario, puoi salvare alcuni bit utilizzando BASE invece di base. Aggiornamento: appena selezionato, BASE non ‘ non funziona. Buona soluzione 🙂
• @Polynomial Lho provato dopo aver visto il tuo commento TEST / test 🙂 Ma non funziona ‘ t funziona.
• Puoi sbarazzarti di {...}2* applicando 2base~ in primo luogo. Ottiene un punteggio fino a 72.
• @ Howard, grazie per questo fantastico suggerimento! Lho ‘ applicato nella mia risposta.
• Il tuo meccanismo di test è sbagliato, perché ‘ hai dimenticato un importante limitazione della tua pagina Web GolfScript. Dovresti avere un ; prima della stringa che sostituisci con stdin, in modo che (; non sia necessario. Quindi losservazione di Howard ‘ arriva a 65.

Perl, 80 (22 caratteri)

Fatto e fatto:

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

O qui “è una versione alternativa con un peso di 77 (21 caratteri):

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

Non mi piace molto quella versione, però, perché il suo output omette la nuova riga finale.

Per calcolare il peso, presumo che sto contando i caratteri nel modo consueto (escluso perl -e / -E, ma inclusi altri caratteri di opzione). Se per qualche motivo le persone si lamentano di questo, allora il meglio che posso fare senza opzioni è 90 (26 caratteri):

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

Utilizzo di esempio:

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

Boom.

Pyth – 15

Dichiarazione di non responsabilità: questa risposta non è “idonea a vincere poiché Pyth è più giovane di questa sfida.

Utilizza .B per la rappresentazione binaria e conta il numero di "1" “s.

/.BQ\1 

Inserisce una stringa per salvare z rispetto a Q.

Provalo online qui .

Scala 231

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

Codice di autotest:

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

con modifica del test automatico.

Commenti

• ‘ pesa 495, non 231. Non puoi ‘ ottenere il peso 231 con 126 caratteri, che ‘ è una media inferiore a 2 e tutti i caratteri stampabili (eccetto @ e lo spazio, che doni ‘ da usare) hanno almeno un peso 2.
• @ugoren: ma ‘ sono solo 65 caratteri. Il programma viene stampato quasi due volte: una volta il codice per calcolare il peso di martellatura, e una seconda volta come input statico per calcolarlo per il programma. Ma la parte di calcolo manca del ” readLine () ” davanti, perché accetta linput letterale. Ho provato a chiarire la risposta stessa.

Java, weight 931 774 499 454

Penso che questa sia lunica risposta al momento con un peso superiore a circa 300.

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

Si aspetta linput come argomento della riga di comando.

GNU sed -r, 467 + 1

(+1 per luso di -r – o dovrebbe essere +4?)

Emette un valore unario per riga di origine; per convertire in un totale decimale, reindirizza loutput in | tr -d "\n" | wc -c. Conta tutti i caratteri ASCII stampabili (32-126), più lavanzamento riga (10).

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

È difficile evitare di elencare tutti i caratteri, ma possiamo ridurre questo osservando che le lettere minuscole hanno un peso di Hamming di uno in più rispetto alle lettere maiuscole corrispondenti. Preferiamo la nuova riga (punteggio 2) al punto e virgola (punteggio 5) come separatore di istruzioni; preferiamo @ (punteggio 1) o ! (punteggio 2) su / (punteggio 5) come delimitatore di pattern.

Nota – per ottenere i set di caratteri corretti, ho creato questa tabella da quella in man ascii, ordinata per peso. Basta aggiungere i punteggi a destra e sotto per ottenere il peso complessivo di ogni carattere:

 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 

Questo potrebbe rivelarsi utile ad altri.

Julia 262 268

La versione modificata utilizza la pratica funzione “count_ones” per un risparmio di 6 (262)

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

Vecchio versione che non utilizza la funzione di conteggio uno incorporata (268)

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

Utilizza largomento della riga di comando per linput.

CJam 52 o 48

Se linput non è già nello stack (52)

q:i2fbs:s:i:+ 

Se linput è nello stack (48)

:i2fbs:s:i:+ 

Ad esempio

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

Julia, HW 199

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

Con

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

o inserendo direttamente la stringa:

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 versione ungolfed (HW 411) ha questo aspetto:

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

E per il gusto di farlo, ecco una versione ottimizzata (Hamming Weight 231 ) dellopinione di Bakerg sul problema:

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

con

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

HPPPL (HP Prime Programming Language), 74

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

La calcolatrice grafica HP Prime ha una funzione hamdist () incorporata.Il peso di martellamento di ogni carattere è uguale alla distanza di percussione da 0.

ASC (stringa) crea un array di valori ASCII di ogni carattere in una stringa.

hamdist ( value, 0) calcola la distanza di percussione da 0 per ogni valore ASCII

sum () riassume tutti i valori.

Calcolo del peso di martellamento del proprio codice sorgente:

05AB1E , peso 17 (4 byte )

ÇbSO 

Provalo online o verifica altri casi di test .

Spiegazione:

 Ç # 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)  

Provalo online!

Anche se questo non è il codice del golf, la soluzione più breve sembra avere anche il minor peso di martellamento …