[Question]
  [
Create a program that computes the [hamming weight](http://en.wikipedia.org/wiki/Hamming_weight) of a string. Winner is the program with the lowest hamming weight.
Rules:
* Hamming weight for an ASCII character is defined as the total number of bits set to `1` in its binary representation.
* Assume input encoding is 7-bit ASCII, passed through whatever input mechanism is normal for your language (e.g. stdin, args, etc.)
* Output the result, as a number, to stdout or whatever default/normal output mechanism your language uses.
* It should go without saying, but you have to be able to *actually run the program, in real life,* for it to be a valid solution.
* Winner is the solution whose code has the lowest hamming weight.
* Sorry, no solutions in [whitespace](http://en.wikipedia.org/wiki/Whitespace_%28programming_language%29) for this one! Ok, you can code in whitespace now I've sorted out the rules :)
Per-character examples:
```
char |  binary  | weight
-----+----------+-------
a    | 01100001 | 3
x    | 01111000 | 4
?    | 00111111 | 6
\x00 | 00000000 | 0
\x7F | 01111111 | 7
```
  
[Answer]
## J, weight 34
```
+/,#:a.i.
```
Usage - place the string to be measured in quotes at the end:
```
   +/,#:a.i.'+/,#:a.i.'
34
```
Alternatively, taking input from the keyboard (weight 54):
```
   +/,#:a.i.1!:1[1
hello
21
```
[Answer]
# J (33)
One lower than 34!
```
+/,#:3 u:
```
Heavily *inspired* by [this answer](https://codegolf.stackexchange.com/a/6243/18638), but a hamming weight of one lower.
```
   +/,#:3 u:'+/,#:3 u:'
33
```
[Answer]
## [J](http://jsoftware.com), 39
```
+/,#:a.i:]
```
This is a function taking one argument. (Or replace `]` with the string directly; as Gareth notes, that brings the cost down to 34.)
```
   +/,#:a.i:] 'hello world'
45
   +/,#:a.i:] '+/,#:a.i:]'
39
```
[Answer]
## Python, 189
```
print sum(bin(ord(A)).count("1")for A in raw_input())
```
[Answer]
## 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
```
*Kind of* the right tool for the job, still sucks of course.
[Answer]
## Unary 0
You all knew it was coming. First the BrainFuck program:
```
,[[>++[>>+>+<<<-]>>>
[<<<+>>>-]>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>
[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-]
[-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>[<<<<<<->>>->>>
[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<
[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<<<
[>>+<[>>+>+<<<-]>>>[<<<+>>>-]>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>
[<<<<<<+>>>>>>-]<<<[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]> 
[-]>[<<<<<<->>>->>>[-]<<<<<<[>>>>+>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<
[>>+>+<<<-]>>>[<<<+>>>-][-]<<[>>[-]<[>[-]+<[-]]<[-]]>[-]>]<<<<<<]>>>
[>+>+<<-]>>[<<+>>-][-]+<[>[-]<<[<<->>-]<<[>>+<<-]>>>[-]]>[<<<+<[-]>>>>
[-]]<<[->>>>+<<<<]<[-<<+>>]<<],]>>>>>>>.
```
I added newlines to make it "readable" but it has a Hamming weight of 4066. It works by repeatedly getting the quotient/remainders of an input string and adding up all the remainders. Of course should you run it on itself you get: 226 (4066 % 256) (technically \xe2) so clearly it rules itself the winner.
Now we convert it to Unary and get
```
000 ... 9*google^5.9 0's ... 000
```
We use a unary implementation with NULL characters \x00 for '0' and boom, hamming weight of 0.
**Bonus question**:
For what ASCII characters `c` can you run this program on a string consisting on `N` repitions and have it output that character. (E.G. a string of 32 spaces gives a space). What values of `N` work (either an infinite number of them will work, or none will).
[Answer]
## C, weight 322 263 256
Does the hamming weight of the hamming weight count?
```
main(D,H,A)char*A,**H;{for(A=*++H;*A;A+=!(*A/=2))D+=*A%2;printf("%d",D-2);}
```
Used mostly standard golfing techniques.  
A single loop calculates weight (shifting right and adding until zero) and scans the string (advances pointer when zero reached).  
Assuming `D` is initialized to 2 (single parameter).  
Hamming weight specific optimizations:  
1. `ABDH`, with weight 2 each, used for names.  
2. `*++H` preferred over `H[1]`.
[Answer]
### Golfscript ~~84~~ ~~72~~ 58
```
{2base~}%{+}*
```
*(thanks to Howard and Peter Taylor for their help)*
*Input:* the input string has to be on the stack (passed as command line argument, or simply placed on the stack).
In case you run it from the command line, make sure you use `echo -n`, otherwise the trailing newline will also be counted.
*Output:* prints the hamming weight value to the console
The program can be tested [here](http://golfscript.apphb.com/?c=OydoZWxsbyB3b3JsZCcKCnsyYmFzZX59JXsrfSo=).
[Answer]
## Perl, 80 (22 chars)
Done and done:
```
perl -0777nE 'say unpack"%32B*"'
```
Or here's an alternate version with a weight of 77 (21 chars):
```
perl -0777pE '$_=unpack"%32B*"'
```
I don't like that version as much, though, because its output omits the final newline.
To calculate the weight, I'm assuming that I'm counting characters in the usual way (excluding the `perl -e`/`-E`, but including other option characters). If for some reason people complain about this, then the best I can do without options is 90 (26 chars):
```
$/=$,,say unpack"%32B*",<>
```
Sample usage:
```
$ perl -0777nE 'say unpack"%32b*"' rickroll.txt
7071
```
Boom.
[Answer]
# Pyth - 15
**Disclaimer: This answer isn't eligible to win since Pyth is younger than this challenge.**
Uses `.B` for binary representation and counts the number of `"1"`'s.
```
/.BQ\1
```
Takes input in a string to save on `z` versus `Q`.
[Try it online here](http://pyth.herokuapp.com/?code=%2F.BQ%5C1&input=%22%2F.BQ%5C1%22&debug=1).
[Answer]
### Scala 231
```
readLine().map(_.toInt.toBinaryString).flatten.map(_.toInt-48)sum
```
Selftesting code:
```
"""readLine().map(_.toInt.toBinaryString).flatten.map(_.toInt-48)sum""".map(_.toInt.toBinaryString).flatten.map(_.toInt-48)sum
```
with selftesting modification.
[Answer]
# Java, weight ~~931~~ ~~774~~ ~~499~~ 454
I think this is the only answer at the moment with a weight over about 300.
```
class H{public static void main(String[]A){System.out.print(new java.math.BigInteger(A[0].getBytes()).bitCount());}}
```
Expects input as a command line argument.
[Answer]
# GNU `sed -r`, 467 + 1
(+1 for use of `-r` - or should that be +4?)
Outputs as a unary value per source line; to convert to a decimal total, redirect output into `| tr -d "\n" | wc -c`. Counts all printable ASCII characters (32-126), plus linefeed (10).
```
s@[a-z]@\U& @g
s@[?{}~]@      @g
s@[][/7;=>OW|^]@     @g
s@[-'+.3569:<GKMNSUVYZ\\]@    @g
s@[#%&)*,CEFIJL1248ORTX]@   @g
s@$|[!"$(ABDH0P`]@  @g
y! @!11!
```
It's hard to avoid listing all characters, but we can reduce this observing that lowercase letters have a Hamming weight of one more than the corresponding uppercase letters. We prefer newline (score 2) over semicolon (score 5) as a statement separator; we prefer `@` (score 1) or `!` (score 2) over `/` (score 5) as pattern delimiter.
Note - to get the right sets of characters, I created this table from the one in `man ascii`, sorted by weight. Just add the scores right and below to get the overall weight of each character:
```
   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
```
This might prove useful to others.
[Answer]
# Julia 262 268
Modified version uses handy 'count\_ones' function for a saving of 6 (262)
```
show(mapreduce(x->count_ones(x),+,map(x->int(x),collect(ARGS[1]))))
```
Old version using no built in one-counting function (268)
```
show(mapreduce(x->int(x)-48,+,mapreduce(x->bits(x),*,collect(ARGS[1]))))
```
Uses command line argument for input.
[Answer]
# CJam 52 or 48
If input is not already on the stack (52)
```
q:i2fbs:s:i:+
```
If input is on stack (48)
```
:i2fbs:s:i:+
```
For example
```
"Hello World":i2fbs:s:i:+
```
[Answer]
# Julia, HW 199
```
H=mapreduce;H(B->B=='1',+,H(P->bits(P),*,collect(A[:])))
```
With
```
A="H=mapreduce;H(B->B=='1',+,H(P->bits(P),*,collect(A[:])))"
```
or by directly inserting the 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
```
The ungolfed version (HW 411) looks like this:
```
bitstring=mapreduce(x->bits(x),*,collect(teststring[:]))
mapreduce(checkbit->checkbit=='1',+,bitstring)
```
And for the fun of it, here is an optimized version (Hamming Weight **231**) of bakerg’s take on the problem:
```
A=mapreduce;show(A(B->int(B)-48,+,A(B->bits(B),*,collect(H[:]))))
```
with
```
H="A=mapreduce;show(A(B->int(B)-48,+,A(B->bits(B),*,collect(H[:]))))"
```
[Answer]
# HPPPL (HP Prime Programming Language), 74
```
sum(hamdist(ASC(a),0))
```
The HP Prime graphing calculator has a built-in hamdist() function. The hamming weight of each character is the same as the hamming distance from 0.
ASC(string) creates an array of the ASCII values of each character in a string.
hamdist(value,0) computes the hamming distance from 0 for each ASCII value
sum() sums up all values.
Calculating the hamming weight of its own source code:
[![Hamming Weight HPPPL](https://i.stack.imgur.com/4aSY2.png)](https://i.stack.imgur.com/4aSY2.png)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), weight 17 (4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage))
```
ÇbSO
```
[Try it online](https://tio.run/##yy9OTMpM/f//cHtSsP///yGpxSUA) or [verify some more test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn3l/8PtScH@/3X@J3JVcNlzlaQWl3CFuAaHcIWAWAZc@XVcYBUA).
**Explanation:**
```
Ç       # 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
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 102
```
+*.ords>>.base(2).comb(~1)
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwX1tLL78opdjOTi8psThVw0hTLzk/N0mjzlDzvzVXcWKlQpqGOm416prWXFxp@UUK6onqOuoVQGyvrmOgl5xRpKNgUGHuBmIpVHMpKOippekBTeOq/Q8A "Perl 6 – Try It Online")
While this isn't code golf, the shortest solution also seems to have the smallest hamming weight...
]