创建一个程序来计算字符串的汉明权重。获胜者是汉明重量最低的程序。

规则：

• ASCII字符的汉明加权定义为以1二进制表示形式设置的总位数。
• 假设输入编码为7位ASCII，并通过您语言所正常使用的任何输入机制（例如stdin，args等）进行传递
• 将结果以数字形式输出到stdout或您的语言使用的任何默认/正常输出机制。
• 它应该不用说，但是您必须能够在现实生活中实际运行该程序，才能使其成为有效的解决方案。
• 优胜者是其代码的汉明权重最低的解决方案。
• 抱歉，此空格中没有解决方案！好的，现在我已经整理了规则，您可以在空格中进行编码了：）

每个字符的示例：

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

J（33）

比34低一！

+/,#:3 u:

这个答案极大地启发了我，但汉姆的权重降低了一个。

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

J，体重34

+/,#:a.i.

用法-将要测量的字符串放在引号的结尾：

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

或者，从键盘（权重54）获取输入：

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

Ĵ，39

+/,#:a.i:]

这是一个带有一个参数的函数。（或]直接替换为字符串；正如Gareth所指出的那样，这使成本降低到了34。）

   + /，＃：ai：]'hello world'
45
   + /，＃：ai：]'+ /，＃：ai：]'
39

巨蟒（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

那种对工作的工具，还是很烂，当然。

一元0

你们都知道它要来了。首先是BrainFuck程序：

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

我添加了换行符以使其“可读”，但汉明权重为4066。它通过反复获取输入字符串的商/余数并将所有余数加起来来工作。当然，您应该自己运行它，您会得到：226（4066％256）（从技术上讲是\ xe2），所以它很明显会自己决定赢家。

现在我们将其转换为一元，并得到

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

我们使用一元实现，对于'0'和臂杆，使用NULL字符\ x00，汉明权重为0。

额外的问题：c您可以针对由什么字符组成的字符串在字符串上运行此程序，N并输出该字符。（例如，一串32个空格给出一个空格）。什么N工作价值（无限数量的价值将起作用，或者无价值）。

C，重量322 263 256

汉明重量的汉明重量是否计数？

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

主要使用标准的高尔夫技术。
一个循环计算权重（向右移动并加到零）并扫描字符串（到达零时前进指针）。
假设D初始化为2（单个参数）。

汉明权重优化：
1. ABDH，每个权重2，用于命名。
2. *++H优先于H[1]。

高尔夫脚本84 72 58

{2base~}%{+}*

（感谢霍华德和彼得·泰勒的帮助）

输入：输入字符串必须在堆栈上（作为命令行参数传递，或简单地放在堆栈上）。

如果您从命令行运行它，请确保使用echo -n，否则尾随的换行符也将被计入。

输出：将汉明重量值打印到控制台

该程序可以在这里进行测试。

Perl，80（22个字符）

完成并完成：

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

或者这是重量为77（21个字符）的备用版本：

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

不过，我不太喜欢该版本，因为它的输出省略了最后的换行符。

为了计算权重，我假设我以通常的方式计算字符（不包括perl -e/ -E，但包括其他选项字符）。如果由于某些原因人们对此有所抱怨，那么我最好的选择就是90（26个字符）：

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

用法示例：

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

繁荣。

腐霉病-15

免责声明：由于Pyth比这个挑战还年轻，因此此答案不符合要求。

用途.B为二进制表示的计数的数目"1"的。

/.BQ\1

以字符串形式输入以保存z与Q。

在这里在线尝试。

斯卡拉231

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

自检代码：

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

经过自我测试的修改。

Java中，体重931 774 499 454

我认为这是目前唯一的答案，体重超过300。

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

期望将输入作为命令行参数。

GNU sed -r，467 + 1

（使用-r- +1，还是应该+4？）

每行源输出为一元值；要转换为十进制总数，请将输出重定向到| tr -d "\n" | wc -c。计算所有可打印的ASCII字符（32-126），加上换行符（10）。

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

很难避免列出所有字符，但是我们可以减少这种观察，因为小写字母的汉明权重比相应的大写字母大一。与语句（分5）相比，我们更喜欢用换行（分2）作为语句分隔符；我们将@（得分1）或!（得分2）优先于/（得分5）作为模式定界符。

注意-为了获得正确的字符集，我从中的表创建了该表man ascii，按权重排序。只需在右边和下面添加分数即可获得每个角色的整体分量：

   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

这可能对其他人有用。

朱莉娅262268

修改后的版本使用方便的“ count_ones”功能可节省6（262）

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

不使用内置单计数功能的旧版本（268）

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

使用命令行参数进行输入。

果酱52或48

如果输入尚未在堆栈上（52）

q:i2fbs:s:i:+

如果输入在堆栈上（48）

:i2fbs:s:i:+

例如

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

朱莉娅（HW 199）

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

用

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

或直接插入字符串：

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

非高尔夫版本（HW 411）如下所示：

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

有趣的是，这是贝克对问题的优化版本（Hamming Weight 231）：

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

与

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

HPPPL（HP Prime编程语言），74

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

HP Prime图形计算器具有内置的hamdist（）函数。每个字符的汉明权重与从0开始的汉明距离相同。

ASC（string）创建字符串中每个字符的ASCII值的数组。

hamdist（value，0）为每个ASCII值从0计算汉明距离

sum（）汇总所有值。

计算其自身源代码的汉明权重：

05AB1E，权重17（4 字节）

ÇbSO

在线尝试或验证更多测试用例。

说明：

Ç       # 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 6、102

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

在线尝试！

虽然这不是代码高尔夫球，但最短的解决方案似乎也具有最小的汉明重量。