J (33)

Um menor que 34!

+/,#:3 u: 

Fortemente inspirado por esta resposta , mas um peso de hamming inferior a um.

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

J, peso 34

+/,#:a.i. 

Uso – coloque o string a ser medida entre aspas no final:

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

Como alternativa, obtendo a entrada do teclado (peso 54):

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

Comentários

• Há ‘ s apenas uma maneira de escrever isso:)
• Não existe ‘ t … Eu encontrei uma solução que tem um peso de hamming menor.
• Não estou tentando ser um buzzkill, mas as regras pedem um programa, não um fragmento.

Python, 189

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

Comentários

• O equivalente Python 3, print(sum(bin(ord(A)).count('1')for A in input())), tem uma pontuação de 180.
• @ dan04: Use aspas duplas em vez de simples para 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 de a ferramenta certa para o trabalho, ainda é uma droga, é claro.

Comentários

• +1 por usar um dos meus idiomas favoritos de todos os tempos. É ‘ é a primeira linguagem que aprendi a codificar em um PC.

Unário 0

Todos vocês sabiam que isso aconteceria. Primeiro, o programa BrainFuck:

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

Eu adicionei novas linhas para torná-lo “legível”, mas tem um peso Hamming de 4066. Funciona obtendo repetidamente o quociente / restos de uma string de entrada e somando todos os restos. Obviamente, se você executá-lo sozinho, obterá: 226 (4066% 256) (tecnicamente \ xe2), então claramente ele se considera o vencedor.

Agora, convertemos para unário e obtemos

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

Usamos uma implementação unária com caracteres NULL \ x00 para “0” e boom, peso de hamming de 0.

Pergunta bônus : Para quais caracteres ASCII c você pode executar este programa em uma string que consiste em N repetições e exiba esse caractere. (Por exemplo, uma string de 32 espaços dá um espaço).Quais valores de N funcionam (um número infinito deles funcionará ou nenhum funcionará).

Comentários

• Eu ‘ não tenho certeza se entendi esta solução. O programa Brainfuck tem um peso enorme de presunto. O unário aceita bytes nulos como um programa ou você precisa reimplementar o unário? Se ‘ for o último, ‘ não é realmente uma solução válida – qualquer um poderia apenas dizer ” Eu defino uma linguagem de programação em que qualquer byte de entrada fornece {result} ” e ganho todos os desafios de golfe de código no site.
• Um valor nulo personagem Unário seria ótimo. Tudo que você precisa é um EOF para dizer pare de contar. Na verdade, aqui ‘ s algum pseudo-C para ler esse arquivo: main(){ bignum Unarynum = 0; int c; while(EOF!=(c=readchar())){ Unarynum++; } return Unarynum; } Doesn ‘ não importa o que você escolhe para ser seu personagem unário (contanto que não seja ‘ t EOF).
• Bem, aqui ‘ um compilador unário para C que funciona bem com caracteres nulos: ideone.com/MIvAg . É claro que o arquivo necessário para fazer este programa não caberia no universo, mas temos a capacidade de executá-lo.
• Se você puder ‘ t na verdade, executá-lo, ‘ não é realmente uma solução.
• Como Carl Sagan disse uma vez: ” Se você deseja calcular o peso de uma string, você deve primeiro inventar 10 ^ 500 universos. ” (bilhões e bilhões, até)

C, peso 322 263 256

O peso do hamming conta?

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

Usado principalmente no golfe padrão técnicas.
Um único loop calcula o peso (deslocando para a direita e adicionando até zero) e verifica a string (avança o ponteiro quando zero é alcançado).
Supondo que D seja inicializado em 2 (parâmetro único).

Otimização específica de peso de Hamming ons:
1. ABDH, com peso 2 cada, usado para nomes.
2. *++H preferencial a H[1].

Comentários

• Hah, eu não consegui entender sua primeira frase até agora.
• Você pode diminuir a pontuação para 230 exibindo o resultado como um número unário : main(D,H,A)char*A,**H;{for(A=*++H;*A;A+=!(*A/=2))if(*A%2)printf("@");}
• @schnaader , Eu nunca soube que @ era um dígito no sistema unário. Achei que ele só usasse 0 .. 0. Mas se você quiser ir por aqui, printf("@"+*a%2) é mais curto.
• @ugoren: Depende da convenção / definição de unário. Por exemplo. en.wikipedia.org/wiki/Unary_numeral_system usa marcas de contagem e diz ” Não há nenhum símbolo explícito representando zero em unário como em outras bases tradicionais “.
• @schnaader, OK, mas acho que ‘ está esticando o requisito ” como um número ” longe demais.

Golfscript 84 72 58

{2base~}%{+}* 

(agradecimentos a Howard e Peter Taylor por sua ajuda)

Entrada: a string de entrada deve estar na pilha (passada como linha de comando ou simplesmente colocado na pilha).

No caso de você executá-lo na linha de comando, certifique-se de usar echo -n, caso contrário, a nova linha final também ser contado.

Resultado: imprime o valor do peso do hamming no console

O programa pode ser testado

aqui .

Comentários

• O Golfscript diferencia maiúsculas de minúsculas? Caso contrário, você pode salvar alguns bits usando BASE em vez de base. Atualização: apenas verificado, BASE não ‘ não funciona. Boa solução 🙂
• @Polynomial Tentei isso depois de ver seu TEST / test comentário 🙂 Mas não funciona ‘ t funciona.
• Você pode se livrar de {...}2* aplicando 2base~ em primeiro lugar. A pontuação caiu para 72.
• @Howard, obrigado por esta ótima dica! Eu ‘ apliquei em minha resposta.
• Seu mecanismo de teste está errado, porque você ‘ se esqueceu de um limitação importante de sua página Web GolfScript. Você deve ter um ; antes da string que substituiu por stdin, de modo que (; seja desnecessário. Então, a observação de Howard ‘ reduz para 65.

Perl, 80 (22 caracteres)

Feito e pronto:

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

Ou aqui está uma versão alternativa com um peso de 77 (21 caracteres):

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

Não gosto tanto dessa versão, porque sua saída omite a nova linha final.

Para calcular o peso, estou presumindo que estou contando caracteres da maneira usual (excluindo o perl -e / -E, mas incluindo outros caracteres de opção). Se por algum motivo as pessoas reclamarem disso, o melhor que posso fazer sem opções é 90 (26 caracteres):

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

Exemplo de uso:

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

Boom.

Pyth – 15

Isenção de responsabilidade: esta resposta não é elegível para vencer, pois Pyth é mais jovem do que este desafio.

Usa .B para representação binária e conta o número de "1" “s.

/.BQ\1 

Aceita a entrada em uma string para salvar em z versus Q.

Experimente online aqui .

Scala 231

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

Código de autoteste:

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

com modificação de autoteste.

Comentários

• É ‘ peso 495, não 231. Você não pode ‘ obter peso 231 com 126 caracteres – que ‘ s uma média de menos de 2 e todos os caracteres imprimíveis (exceto @ e espaço, que você don ‘ use) tenha pelo menos peso 2.
• @ugoren: Mas ‘ s apenas 65 caracteres. O programa é impresso quase duas vezes: uma vez o código para calcular o peso do presunto e uma segunda vez como entrada estática para calculá-lo para o programa. Mas a parte do cálculo está faltando o ” readLine () ” na frente, porque leva a entrada literal. Tentei esclarecer a própria resposta.

Java, peso 931 774 499 454

Acho que esta é a única resposta no momento com peso acima de 300.

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

Espera entrada como um argumento de linha de comando.

GNU sed -r, 467 + 1

(+1 para uso de -r – ou deveria ser +4?)

Exibe como um valor unário por linha de origem; para converter em um total decimal, redirecione a saída para | tr -d "\n" | wc -c. Conta todos os caracteres ASCII imprimíveis (32-126), mais o avanço de linha (10).

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

É difícil evitar listar todos os caracteres, mas podemos reduzir isso observando que as letras minúsculas têm um peso Hamming de um a mais do que as letras maiúsculas correspondentes. Preferimos nova linha (pontuação 2) em vez de ponto e vírgula (pontuação 5) como separador de declarações; preferimos @ (pontuação 1) ou ! (pontuação 2) em / (pontuação 5) como delimitador de padrão.

Observação – para obter os conjuntos de caracteres certos, criei esta tabela a partir de man ascii, classificados por peso. Basta adicionar as pontuações corretas e abaixo para obter o peso geral de cada personagem:

 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 

Isso pode ser útil para outras pessoas.

Julia 262 268

A versão modificada usa a função útil “count_ones” para salvar 6 (262)

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

Antigo versão sem função incorporada de contagem única (268)

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

Usa argumento de linha de comando para entrada.

CJam 52 ou 48

Se a entrada ainda não estiver na pilha (52)

q:i2fbs:s:i:+ 

Se a entrada estiver na pilha (48)

:i2fbs:s:i:+ 

Por exemplo

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

Julia, HW 199

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

Com

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

ou inserindo diretamente a string:

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 

A versão sem golfe (HW 411) se parece com isto:

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

E para se divertir, aqui está uma versão otimizada (Peso Hamming 231 ) da opinião de Bakerg sobre o problema:

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

com

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

A calculadora gráfica HP Prime possui uma função hamdist () integrada.O peso hamming de cada caractere é igual à distância hamming de 0.

ASC (string) cria uma matriz dos valores ASCII de cada caractere em uma string.

hamdist ( valor, 0) calcula a distância Hamming de 0 para cada valor ASCII

sum () soma todos os valores.

Calculando o peso Hamming de seu próprio código-fonte:

05AB1E , peso 17 (4 bytes )

ÇbSO 

Experimente online ou verifique mais alguns casos de teste .

Explicação:

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

Experimente online!

Embora isso não seja um código de golfe, a solução mais curta também parece ter o menor peso de hamming …