कम हमिंग वजन के साथ हैमिंग वजन की गणना करें

19

एक प्रोग्राम बनाएं जो एक स्ट्रिंग के हैमिंग वजन की गणना करता है । विजेता सबसे कम हैमिंग वजन वाला कार्यक्रम है।

नियम:

  • एक ASCII चरित्र के लिए हैमिंग वजन 1को उसके द्विआधारी प्रतिनिधित्व में निर्धारित बिट्स की कुल संख्या के रूप में परिभाषित किया गया है ।
  • मान लें कि इनपुट एन्कोडिंग 7-बिट एएससीआईआई है, जो आपकी भाषा के लिए इनपुट तंत्र सामान्य है (जैसे स्टड, आर्ग्स, आदि) के माध्यम से पारित किया गया।
  • परिणाम को एक संख्या के रूप में, स्टडआउट या आपकी भाषा का उपयोग करने के लिए डिफ़ॉल्ट / सामान्य आउटपुट तंत्र के रूप में आउटपुट करें।
  • यह बिना कहे जाना चाहिए, लेकिन आपको वास्तव में कार्यक्रम को चलाने के लिए, वास्तविक जीवन में सक्षम होना चाहिए , इसके लिए एक वैध समाधान होना चाहिए।
  • विजेता एक ऐसा समाधान है जिसके कोड में सबसे कम वजन वाला वजन होता है।
  • क्षमा करें, इसके लिए व्हॉट्सएप में कोई समाधान नहीं है ! ठीक है, आप व्हॉट्सएप में कोड कर सकते हैं अब मैंने नियमों को सुलझा लिया है :)

प्रति चरित्र उदाहरण:

char |  binary  | weight
-----+----------+-------
a    | 01100001 | 3
x    | 01111000 | 4
?    | 00111111 | 6
\x00 | 00000000 | 0
\x7F | 01111111 | 7
code-golf  binary  number-theory 
— बहुपद
स्रोत
यदि हम 0x20संदर्भ के रूप में ASCII 32 लेते हैं , hello worldतो 11 के बजाय 10 का गुनगुना वजन नहीं है?
— क्रिस्टियन लुपस्कू
hello world11 का वजन क्यों है ? केवल 10 वर्ण एक स्थान से भिन्न हैं। इसके अलावा - रिक्त स्थान को छोड़कर एक प्रोग्राम का हैमिंग वजन सिर्फ इसकी लंबाई है। सामान्य कोड गोल्फ से इतना अलग नहीं है।
— ugoren
क्षमा करें, मैंने इसे पूरी तरह से खराब कर दिया। विकिपीडिया का हैमिंग वेट लेख बल्कि भ्रामक है, और मैं पूरी तरह से नियमों को मानता हूं। अब फिर से लिखना। अद्यतन: ठीक है, ASCII स्ट्रिंग में 1 पर सेट बिट्स की संख्या के रूप में इसे परिभाषित करने के लिए फिर से लिखा गया है, स्क्रू-अप के लिए क्षमा करें।
— बहुपत्नी
@ कम मूल्य वाले ASCII वर्णों के साथ एक समाधान में कम भार वाला वजन होता है।
— बहुपत्नी
1
नाउ इट आल मेक्स सेंस। उपयोग अपरकेस, के सावधान ~और o।
— ugoren

जवाबों:

8

जे, वजन ३४

+/,#:a.i.

उपयोग - स्ट्रिंग को अंत में उद्धरण में मापा जाए:

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

वैकल्पिक रूप से, कीबोर्ड से इनपुट लेना (वजन 54):

   +/,#:a.i.1!:1[1
hello
21
— गैरेथ
स्रोत
इसे लिखने का केवल एक ही तरीका है :)
— युगीन
वहाँ नहीं है ... मैं एक समाधान है कि एक कम वजन का एक वजन है पाया।
— atı
बज़किल बनने की कोशिश नहीं कर रहे हैं, लेकिन नियम एक कार्यक्रम के लिए पूछते हैं , एक टुकड़ा नहीं।
— फ़ूजएक्सएक्स
5

जे , ३ ९

+/,#:a.i:]

यह एक तर्क लेने वाला कार्य है। (या ]सीधे स्ट्रिंग के साथ बदलें ; गैरेथ नोट्स के रूप में, जो लागत को 34 तक लाता है।)

   + /, #: ai:] 'हैलो वर्ल्ड'
45
   + /, #: ai:] '+ /, #: ai:]'
39
— ephemient
स्रोत
बड़े मन वाले ऐसा सोचते हैं। :-)
— गारेथ
5

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

काम के लिए सही उपकरण की तरह , अभी भी निश्चित रूप से बेकार है।

— काउंटरक्लॉक को चालू करना बंद कर दिया
स्रोत
1
मेरे समय की मेरी पसंदीदा भाषाओं में से एक का उपयोग करने के लिए +1। यह पहली भाषा है जिसे मैंने पीसी पर कोड करना सीखा।
— बहुपद
5

अनार्य ०

आप सभी को पता था कि यह आ रहा है। पहला ब्रेनफैक कार्यक्रम:

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

मैंने इसे "पठनीय" बनाने के लिए नई कड़ियाँ जोड़ीं, लेकिन इसका वजन 4066 है। यह बार-बार इनपुट स्ट्रिंग के भागफल / अवशेषों को प्राप्त करने और सभी अवशेषों को जोड़कर काम करता है। निश्चित रूप से आपको इसे अपने आप पर चलाना चाहिए: 226 (4066% 256) (तकनीकी रूप से \ xe2) तो स्पष्ट रूप से यह खुद विजेता का नियम है।

अब हम इसे Unary में बदलते हैं और प्राप्त करते हैं

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

हम '0' और बूम, 0 के वजन के लिए बूम के साथ NULL अक्षर \ x00 के साथ एक यूनिरी कार्यान्वयन का उपयोग करते हैं।

बोनस प्रश्न : एएससीआईआई के किस अक्षर के लिए cआप इस प्रोग्राम को एक स्ट्रिंग पर चला सकते हैं जिसमें Nरेपिशन शामिल है और यह उस चरित्र को आउटपुट करता है। (उदा। 32 स्थानों की एक स्ट्रिंग एक स्थान देती है)। Nकाम के मूल्य (या तो उनमें से अनंत संख्या में काम करेंगे, या कोई भी नहीं)।

— walpen
स्रोत
1
मुझे यकीन नहीं है कि मैं इस समाधान को समझता हूं। ब्रेनफक कार्यक्रम में बहुत बड़ा वजन होता है। क्या यूनरी एक कार्यक्रम के रूप में अशक्त बाइट्स को स्वीकार करता है, या आपको यूनेरी को फिर से लागू करने की आवश्यकता होगी? यदि यह बाद का है, तो यह वास्तव में एक वैध समाधान नहीं है - कोई भी कह सकता है "मैं एक प्रोग्रामिंग भाषा को परिभाषित करता हूं जहां कोई भी एकल इनपुट बाइट {परिणाम}" देता है, और साइट पर हर कोड गोल्फ चुनौती जीतता है।
— बहुपद
1
एक अशक्त चरित्र यूनरी ठीक होगा। गिनती बंद करने के लिए आपको बस एक ईओएफ चाहिए। वास्तव में यहाँ उस फ़ाइल को पढ़ने के लिए कुछ छद्म-सी है: main(){ bignum Unarynum = 0; int c; while(EOF!=(c=readchar())){ Unarynum++; } return Unarynum; }आप अपने Unary char (जब तक यह EOF नहीं है) को चुनने के लिए क्या मायने रखता है।
— Walpen
1
अच्छी तरह से यहाँ सी संकलक के लिए एक है कि अशक्त पात्रों के साथ ठीक काम करता है: ideone.com/MIvAg । बेशक इस कार्यक्रम को बनाने के लिए आवश्यक फ़ाइल ब्रह्मांड में फिट नहीं होगी, लेकिन हमारे पास इसे चलाने की क्षमता है।
— walpen
3
यदि आप वास्तव में इसे नहीं चला सकते हैं, तो यह वास्तव में एक समाधान नहीं है।
— बहुपत्नी
4
जैसा कि कार्ल सागन ने एक बार कहा था: "यदि आप एक स्ट्रिंग के हैमिंग वजन की गणना करना चाहते हैं, तो आपको पहले 10 ^ 500 ब्रह्मांडों का आविष्कार करना होगा।" (अरबों और अरबों, यहां तक ​​कि)
— Walpen
4

सी, वजन 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]।

— ugoren
स्रोत
हाह, मैं अब तक आपके पहले वाक्य को समझने में पूरी तरह से विफल रहा।
— ब्रेडबॉक्स
आप एक के रूप में परिणाम outputting द्वारा 230 स्कोर नीचे प्राप्त कर सकते हैं एकल : संख्याmain(D,H,A)char*A,**H;{for(A=*++H;*A;A+=!(*A/=2))if(*A%2)printf("@");}
— schnaader
@schnaader, मुझे कभी नहीं पता @था कि एक प्रणाली में एक अंक था। मैंने सोचा कि यह केवल का उपयोग करता है 0.. 0। लेकिन अगर आप इसे जाना चाहते हैं, तो रास्ता printf("@"+*a%2)छोटा है।
— ugoren
@ यूगोरेन: एकमत के सम्मेलन / परिभाषा पर निर्भर करता है। उदाहरण के लिए en.wikipedia.org/wiki/Unary_numeral_system टैली मार्क्स का उपयोग करता है और कहता है कि "कोई स्पष्ट प्रतीक नहीं है जो एकात्मक में शून्य का प्रतिनिधित्व करता है जैसा कि अन्य पारंपरिक आधारों में है"।
— श्नाडर
@schnaader, ठीक है, लेकिन मुझे लगता है कि यह आवश्यकता को "एक संख्या के रूप में" बहुत दूर खींच रहा है।
— बदसूरत
4

गोल्फस्क्रिप्ट 84 72 58

{2base~}%{+}*

(उनकी मदद के लिए हॉवर्ड और पीटर टेलर का धन्यवाद)

इनपुट: इनपुट स्ट्रिंग को स्टैक पर होना चाहिए (कमांड लाइन तर्क के रूप में पारित किया गया, या बस स्टैक पर रखा गया)।

यदि आप इसे कमांड लाइन से चलाते हैं, तो सुनिश्चित करें कि आप इसका उपयोग करते हैं echo -n, अन्यथा अनुगामी न्यूलाइन भी गिना जाएगा।

आउटपुट: कंसोल के लिए हैमिंग वेट वैल्यू प्रिंट करता है

यहां कार्यक्रम का परीक्षण किया जा सकता है ।

— क्रिस्टियन लुपस्कू
स्रोत
1
क्या गोल्फस्क्रिप्ट केस-संवेदी है? यदि नहीं, तो आप BASEइसके बजाय का उपयोग करके कुछ बिट्स बचा सकते हैं base। अद्यतन: बस जाँच की, BASEकाम नहीं करता है। अच्छा समाधान :)
— बहुपद
@Polynomial मैंने कोशिश की अपने को देखने के बाद कि TEST/ testटिप्पणी :) लेकिन यह काम नहीं करता है।
— क्रिस्टियन ल्यूपस्कू
आप पहली बार में {...}2*आवेदन करके छुटकारा पा सकते हैं 2base~। 72 तक नीचे जाता है।
— हॉवर्ड
@ इस महान टिप के लिए धन्यवाद! मैंने इसे अपने उत्तर में लागू कर दिया है।
— क्रिस्टियन लुपस्कू
आपका परीक्षण तंत्र गलत है, क्योंकि आप अपने वेब गोल्फस्क्रिप्ट पेज की एक महत्वपूर्ण सीमा भूल गए हैं। आपके पास ;स्ट्रिंग से पहले होना चाहिए जिसे आप स्टड के लिए स्थानापन्न करते हैं, ताकि (;अनावश्यक हो। तब हावर्ड का अवलोकन 65 तक हो जाता है।
— पीटर टेलर
2

पर्ल, 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

बूम।

— रोटी का डिब्बा
स्रोत
2

अजगर - 15

अस्वीकरण: यह जवाब जीतने के योग्य नहीं है क्योंकि पायथ इस चुनौती से छोटी है।

.Bबाइनरी प्रतिनिधित्व के लिए उपयोग करता है और संख्या की गणना करता है "1"।

/.BQ\1

zबनाम पर सहेजने के लिए एक स्ट्रिंग में इनपुट लेता है Q।

इसे यहाँ ऑनलाइन आज़माएँ ।

— Maltysen
स्रोत
1

स्काला 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

सेल्फाइटिंग संशोधन के साथ।

— अज्ञात उपयोगकर्ता
स्रोत
यह वजन 495 है, 231 नहीं है। आप 126 चरों के साथ वजन 231 नहीं प्राप्त कर सकते हैं - यह औसत 2 से कम है, और सभी प्रिंट करने योग्य आकर्षण (सिवाय @और अंतरिक्ष, जो आप उपयोग नहीं करते हैं) का वजन 2 है कम से कम।
— ugoren
1
@ यूगोरेन: लेकिन यह केवल 65 वर्ण है। कार्यक्रम को लगभग दो बार मुद्रित किया जाता है: एक बार हैमिंग वजन की गणना करने के लिए कोड, और कार्यक्रम के लिए गणना करने के लिए स्थिर इनपुट के रूप में दूसरी बार। लेकिन गणना वाला भाग "रीडलाइन ()" को याद कर रहा है, क्योंकि यह शाब्दिक इनपुट लेता है। मैंने स्वयं उत्तर स्पष्ट करने का प्रयास किया।
— उपयोगकर्ता अज्ञात
1

जावा, वजन 931 774 499 454

मुझे लगता है कि इस समय लगभग 300 से अधिक वजन वाला एकमात्र उत्तर है।

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

कमांड लाइन तर्क के रूप में इनपुट की अपेक्षा करता है।

— SuperJedi224
स्रोत
1

जीएनयू sed -r, 467 + 1

(+1 के उपयोग के लिए -r- या कि +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

यह दूसरों के लिए उपयोगी साबित हो सकता है।

— टोबी स्पाईट
स्रोत
0

जूलिया 262 268

6 (262) की बचत के लिए संशोधित संस्करण काम 'count_ones' फ़ंक्शन का उपयोग करता है

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

इनपुट के लिए कमांड लाइन तर्क का उपयोग करता है।

— bakerg
स्रोत
0

CJam 52 या 48

यदि इनपुट पहले से ही स्टैक पर नहीं है (52)

q:i2fbs:s:i:+

यदि इनपुट स्टैक पर है (48)

:i2fbs:s:i:+

उदाहरण के लिए

"Hello World":i2fbs:s:i:+
— bakerg
स्रोत
0

जूलिया, एचडब्ल्यू 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)

और इसके मज़े के लिए, यहाँ समस्या पर बेकरी के लेने का एक अनुकूलित संस्करण (हैमिंग वेट 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[:]))))"
— एमएल
स्रोत
0

एचपीपीपीएल (एचपी प्राइम प्रोग्रामिंग लैंग्वेज), 74

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

एचपी प्राइम ग्राफिंग कैलकुलेटर में एक अंतर्निहित हैमिस्ट () फ़ंक्शन है। प्रत्येक वर्ण का हैमिंग वजन 0 से हैमिंग दूरी के समान है।

ASC (स्ट्रिंग) एक स्ट्रिंग में प्रत्येक वर्ण के ASCII मूल्यों की एक सरणी बनाता है।

हम्डिस्ट (मान, 0) प्रत्येक ASCII मान के लिए 0 से हैमिंग दूरी की गणना करता है

sum () सभी मानों को पूरा करता है।

अपने स्वयं के स्रोत कोड के बढ़ते वजन की गणना:

हैमिंग वजन एचपीपीपीएल

— एमएल
स्रोत
0

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
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.