Tạo một chương trình tính toán trọng số hãm của chuỗi. Người chiến thắng là chương trình có trọng lượng hamming thấp nhất.

Quy tắc:

• Trọng lượng Hamming cho một ký tự ASCII được định nghĩa là tổng số bit được đặt 1trong biểu diễn nhị phân của nó.
• Giả sử mã hóa đầu vào là ASCII 7 bit, được chuyển qua bất kỳ cơ chế đầu vào nào là bình thường đối với ngôn ngữ của bạn (ví dụ: stdin, args, v.v.)
• Xuất kết quả, dưới dạng số, thành thiết bị xuất chuẩn hoặc bất kỳ cơ chế đầu ra mặc định / bình thường nào mà ngôn ngữ của bạn sử dụng.
• Nó không cần phải nói, nhưng bạn phải có khả năng thực sự chạy chương trình, trong cuộc sống thực, để nó là một giải pháp hợp lệ.
• Người chiến thắng là giải pháp có mã có trọng lượng hamming thấp nhất.
• Xin lỗi, không có giải pháp trong khoảng trắng cho cái này! Ok, bạn có thể viết mã trong khoảng trắng bây giờ Tôi đã sắp xếp các quy tắc :)

Ví dụ về mỗi ký tự:

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

J (33)

Một thấp hơn 34!

+/,#:3 u:

Nhiều cảm hứng bởi câu trả lời này , nhưng trọng lượng Hamming của một giảm.

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

J, nặng 34

+/,#:a.i.

Cách sử dụng - đặt chuỗi cần đo trong dấu ngoặc kép ở cuối:

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

Ngoài ra, lấy đầu vào từ bàn phím (trọng lượng 54):

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

J , 39

+/,#:a.i:]

Đây là một hàm lấy một đối số. (Hoặc thay thế ]bằng chuỗi trực tiếp; như Gareth lưu ý, giúp giảm chi phí xuống 34.)

   + /, #: ai:] 'xin chào thế giới'
45
   + /, #: ai:] '+ /, #: ai:]'
39

Con trăn, 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

Loại công cụ phù hợp cho công việc, tất nhiên vẫn còn tệ.

Đại số 0

Tất cả các bạn đều biết nó đang đến. Đầu tiên là chương trình BrainFuck:

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

Tôi đã thêm các dòng mới để làm cho nó "có thể đọc được" nhưng nó có trọng số Hamming là 4066. Nó hoạt động bằng cách liên tục lấy thương số / phần còn lại của một chuỗi đầu vào và thêm tất cả các phần còn lại. Tất nhiên, nếu bạn tự chạy nó, bạn sẽ nhận được: 226 (4066% 256) (về mặt kỹ thuật \ xe2) để rõ ràng nó tự quy định người chiến thắng.

Bây giờ chúng tôi chuyển đổi nó thành Unary và nhận

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

Chúng tôi sử dụng triển khai đơn phương với các ký tự NULL \ x00 cho '0' và tăng vọt, cân bằng 0.

Câu hỏi thưởng : Đối với những ký tự ASCII cnào, bạn có thể chạy chương trình này trên một chuỗi bao gồm các Nlần lặp lại và để nó xuất ký tự đó. (EG một chuỗi 32 khoảng trắng cho một khoảng trắng). Giá trị nào của Ncông việc (có thể là vô số trong số chúng sẽ hoạt động hoặc không có giá trị nào).

C, trọng lượng 322 263 256

Có trọng lượng hamming của trọng lượng hamming?

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

Được sử dụng chủ yếu là kỹ thuật chơi golf tiêu chuẩn.
Một vòng lặp duy nhất tính toán trọng số (dịch chuyển sang phải và thêm cho đến 0) và quét chuỗi (tiến con trỏ khi đạt đến 0).
Giả sử Dđược khởi tạo thành 2 (tham số đơn).

Tối ưu hóa trọng lượng cụ thể của Hamming:
1. ABDH, với trọng lượng 2 mỗi cái, được sử dụng cho tên.
2. *++Hưa thích hơn H[1].

Golf 84 72 58

{2base~}%{+}*

(cảm ơn Howard và Peter Taylor vì sự giúp đỡ của họ)

Đầu vào: chuỗi đầu vào phải nằm trên ngăn xếp (được truyền dưới dạng đối số dòng lệnh hoặc đơn giản được đặt trên ngăn xếp).

Trong trường hợp bạn chạy nó từ dòng lệnh, hãy chắc chắn rằng bạn sử dụng echo -n, nếu không thì dòng mới cũng sẽ được tính.

Đầu ra: in giá trị trọng lượng hamming lên bàn điều khiển

Chương trình có thể được thử nghiệm ở đây .

Perl, 80 (22 ký tự)

Ngay và luôn:

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

Hoặc đây là phiên bản thay thế có trọng lượng 77 (21 ký tự):

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

Mặc dù vậy, tôi không thích phiên bản đó nhiều vì sản phẩm của nó bỏ qua dòng mới cuối cùng.

Để tính trọng lượng, tôi giả sử rằng tôi đang đếm các ký tự theo cách thông thường (không bao gồm perl -e/ -E, nhưng bao gồm các ký tự tùy chọn khác). Nếu vì lý do nào đó mọi người phàn nàn về điều này, thì điều tốt nhất tôi có thể làm mà không có tùy chọn là 90 (26 ký tự):

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

Sử dụng mẫu:

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

Bùng nổ.

Thứ 15 - 15

Tuyên bố miễn trừ trách nhiệm: Câu trả lời này không đủ điều kiện để giành chiến thắng vì Pyth trẻ hơn thử thách này.

Sử dụng .Bcho biểu diễn nhị phân và đếm số lượng "1".

/.BQ\1

Đưa đầu vào trong một chuỗi để tiết kiệm zso với Q.

Hãy thử trực tuyến tại đây .

Scala 231

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

Mã chọn lọc:

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

với sửa đổi selftesting.

Java, trọng lượng 931 774 499 454

Tôi nghĩ rằng đây là câu trả lời duy nhất tại thời điểm này với trọng lượng hơn 300.

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

Mong đợi đầu vào như là một đối số dòng lệnh.

GNU sed -r , 467 + 1

(+1 để sử dụng -r - hoặc nên là +4?)

Đầu ra dưới dạng giá trị đơn nguyên trên mỗi dòng nguồn; để chuyển đổi thành tổng số thập phân, chuyển hướng đầu ra thành | tr -d "\n" | wc -c. Đếm tất cả các ký tự ASCII có thể in (32-126), cộng với nguồn cấp dữ liệu (10).

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

Thật khó để tránh việc liệt kê tất cả các ký tự, nhưng chúng ta có thể giảm việc quan sát rằng các chữ cái viết thường có trọng số Hamming nhiều hơn một chữ cái viết hoa tương ứng. Chúng tôi thích dòng mới (điểm 2) hơn dấu chấm phẩy (điểm 5) làm dấu phân cách câu lệnh; chúng tôi thích @(điểm 1) hoặc! (điểm 2) hơn /(điểm 5) là dấu phân cách mẫu.

Lưu ý - để có được bộ ký tự phù hợp, tôi đã tạo bảng này từ bảng trong man ascii, được sắp xếp theo trọng lượng. Chỉ cần thêm điểm đúng và bên dưới để có trọng lượng tổng thể của từng nhân vật:

   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

Điều này có thể chứng minh hữu ích cho những người khác.

Julia 262 268

Phiên bản sửa đổi sử dụng chức năng 'Count_ones' tiện dụng để tiết kiệm 6 (262)

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

Phiên bản cũ không sử dụng chức năng đếm số tích hợp (268)

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

Sử dụng đối số dòng lệnh cho đầu vào.

CJam 52 hoặc 48

Nếu đầu vào chưa có trên ngăn xếp (52)

q:i2fbs:s:i:+

Nếu đầu vào là trên ngăn xếp (48)

:i2fbs:s:i:+

Ví dụ

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

Julia, CT 199

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

Với

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

hoặc bằng cách chèn trực tiếp chuỗi:

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

Phiên bản không được chỉnh sửa (HW 411) trông như thế này:

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

Và để giải trí, đây là một phiên bản tối ưu hóa (Hamming Trọng lượng 231 ) của bakerg đảm nhận vấn đề:

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

với

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

HPPPL (Ngôn ngữ lập trình HP Prime), 74

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

Máy tính vẽ đồ thị HP Prime có chức năng hamdist () tích hợp. Trọng lượng hamming của mỗi nhân vật giống như khoảng cách hãm từ 0.

ASC (chuỗi) tạo ra một mảng các giá trị ASCII của mỗi ký tự trong một chuỗi.

hamdist (value, 0) tính khoảng cách hãm từ 0 cho mỗi giá trị ASCII

tổng () tổng hợp tất cả các giá trị.

Tính trọng lượng hamming của mã nguồn của chính nó:

05AB1E , trọng lượng 17 (4 byte )

ÇbSO

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

Giải trình:

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

Hãy thử trực tuyến!

Mặc dù đây không phải là mã golf, nhưng giải pháp ngắn nhất cũng có trọng lượng nhỏ nhất ...