สร้างโปรแกรมที่คำนวณน้ำหนักการขัดขวางของสตริง ผู้ชนะคือโปรแกรมที่มีน้ำหนักแฮมมิ่งต่ำสุด

กฎ:

• การรับน้ำหนักของตัวอักษร 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

J , 39

+/,#:a.i:]

นี่คือฟังก์ชั่นรับหนึ่งอาร์กิวเมนต์ (หรือแทนที่]ด้วยสตริงโดยตรงเช่นเดียวกับกาเร็ ธ โน้ตซึ่งจะทำให้ราคาลดลงถึง 34)

   + /, #: ai:] 'สวัสดีชาวโลก'
45
   + /, #: ai:] '+ /, #: ai:]'
39

Python, 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 แรก:

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

ฉันเพิ่มบรรทัดใหม่เพื่อให้ "อ่านได้" แต่มีน้ำหนักของ Hamming ที่ 4066 มันทำงานโดยการรับผลหาร / เศษของสตริงป้อนข้อมูลซ้ำ ๆ และเพิ่มส่วนที่เหลือทั้งหมด แน่นอนคุณควรรันด้วยตัวเองคุณจะได้รับ: 226 (4066% 256) (ทางเทคนิค \ xe2) ดังนั้นชัดเจนว่ามันเป็นกฎของผู้ชนะ

ตอนนี้เราแปลงเป็น Unary และรับ

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

เราใช้การติดตั้งที่ไม่เป็นเอกภาพกับอักขระ NULL \ x00 สำหรับ '0' และบูมลดน้ำหนักเป็น 0

คำถามโบนัส : สำหรับอักขระ ASCII cใดที่คุณสามารถเรียกใช้โปรแกรมนี้บนสตริงที่ประกอบด้วยNrepitions และให้มันส่งออกอักขระนั้น (EG สตริง 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 (พารามิเตอร์เดียว)

การปรับน้ำหนักเฉพาะ Hamming ให้เหมาะสม:
1. ABDHโดยใช้น้ำหนัก 2 ตัวสำหรับชื่อ
2. ต้องการมากกว่า*++HH[1]

Golfscript 84 72 58

{2base~}%{+}*

(ขอบคุณ Howard และ Peter Taylor สำหรับความช่วยเหลือของพวกเขา)

อินพุต:สตริงอินพุตต้องอยู่บนสแต็ก (ส่งผ่านเป็นอาร์กิวเมนต์บรรทัดคำสั่งหรือวางไว้บนสแต็ก)

ในกรณีที่คุณเรียกใช้จากบรรทัดคำสั่งตรวจสอบให้แน่ใจว่าคุณใช้echo -nมิฉะนั้นบรรทัดใหม่ต่อท้ายจะถูกนับด้วย

เอาท์พุท:พิมพ์ค่าน้ำหนัก hamming ไปยังคอนโซล

โปรแกรมที่สามารถทดสอบได้ที่นี่

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

ความเจริญ

Pyth - 15

คำเตือน: คำตอบนี้ไม่มีสิทธิ์ที่จะชนะเนื่องจาก Pyth อายุน้อยกว่าความท้าทายนี้

ใช้.Bสำหรับการแสดงไบนารีและนับจำนวนของ"1"'s

/.BQ\1

จะเข้าในสายที่จะบันทึกในเมื่อเทียบกับzQ

ลองมันออนไลน์ได้ที่นี่

สกาล่า 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

ด้วยการดัดแปลง selftesting

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

(+1 สำหรับการใช้-r- หรือควรเป็น +4 หรือไม่)

เอาต์พุตเป็นค่า unary ต่อบรรทัดซอร์ส | 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!

เป็นการยากที่จะหลีกเลี่ยงการแสดงรายการอักขระทั้งหมด แต่เราสามารถลดการสังเกตนี้ได้ว่าตัวอักษรตัวเล็กมีน้ำหนัก Hamming มากกว่าหนึ่งตัวอักษรตัวพิมพ์ใหญ่ที่สอดคล้องกัน เราต้องการบรรทัดใหม่ (คะแนน 2) มากกว่าอัฒภาค (คะแนน 5) เป็นตัวคั่นคำสั่ง เราชอบ@(คะแนน 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

สิ่งนี้อาจเป็นประโยชน์ต่อผู้อื่น

Julia 262 268

เวอร์ชั่นที่แก้ไขใช้ฟังก์ชั่น '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]))))

ใช้อาร์กิวเมนต์บรรทัดคำสั่งสำหรับอินพุต

CJam 52 หรือ 48

ถ้าอินพุตไม่ได้อยู่ในสแต็ก (52)

q:i2fbs:s:i:+

ถ้าอินพุตอยู่บนสแต็ก (48)

:i2fbs:s:i:+

ตัวอย่างเช่น

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

Julia, 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 ) ของ bakerg ในการแก้ปัญหา:

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 (สตริง) สร้างอาร์เรย์ของค่า ASCII ของอักขระแต่ละตัวในสตริง

hamdist (ค่า 0) คำนวณระยะการแฮ็มจาก 0 สำหรับแต่ละค่า ASCII

sum () สรุปค่าทั้งหมด

การคำนวณน้ำหนัก hamming ของซอร์สโค้ดของตนเอง:

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 , 102

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

ลองออนไลน์!

ในขณะที่นี่ไม่ใช่โค้ดกอล์ฟวิธีแก้ปัญหาที่สั้นที่สุดก็ดูเหมือนจะมีน้ำหนักแฮมที่เล็กที่สุด ...