यह बहुत सरल है: आपका कार्यक्रम या फ़ंक्शन निम्नलिखित पाठ उत्पन्न करना चाहिए:

Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.

ठीक छाप

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं , जो आउटपुट को एक स्ट्रिंग के रूप में लौटाता है या इसे STDOUT (या निकटतम विकल्प) पर मुद्रित करता है। आप वैकल्पिक रूप से आउटपुट में एक एकल अनुगामी न्यूलाइन शामिल कर सकते हैं।

स्कोरिंग

आपके कोड में बाइट्स की संख्या आपके कोड में अद्वितीय बाइट्स की संख्या से गुणा होती है

सबसे कम स्कोर जीतता है।

उदाहरण के लिए, एक ब्रेनफैक या व्हॉट्सएप उत्तर का यहां बहुत बड़ा लाभ होगा, क्योंकि गुणक क्रमशः बहुत कम (8 और 3) होगा। हालांकि, आम तौर पर, उन भाषाओं में प्रोग्राम लिखने से बहुत अधिक कोड का उत्पादन होता है जो उस लाभ को नकार सकता है।

मानक कमियां जो अब मजाकिया नहीं हैं उन पर प्रतिबंध लगा दिया गया है ।

code-challenge string kolmogorov-complexity

— durron597
स्रोत

मुझे लगता है कि आवरण सटीक होना चाहिए?

— EnragedTanker

@ क्रेज़िड्यूड हाँ, यह उस बिंदु की तरह है

— ड्यूर्रोन 597

ठीक है। सिर्फ स्पष्ट करना। : p

— EnragedTanker

1

@CarpetPython सैंडबॉक्स में इस बारे में कुछ बहस हुई थी, और आखिरकार मैंने फैसला किया कि खेल के मैदान में ट्राय करने का कोई तरीका नहीं है। ध्यान दें कि व्हाट्सएप और अनिद्रा का वैसे भी उच्चतम स्कोर है!

— दुर्रोन 597

2

जैसा कि मैंने कहीं लिखा है, अगर हम मानते हैं कि कम यूनिक कैरेक्टर की भरपाई के लिए अधिक बाइट्स का उपयोग करना नंबरों को अलग-अलग आधारों में परिवर्तित करने के लिए समान व्यवहार करता है, तो bytecount~Log(X,unique)एक्स, इस समस्या के लिए कुछ निरंतर के साथ। इस प्रकार अद्वितीय ^ बाइटकाउंट ~ स्थिर। इस स्कोर (log2) की गणना करता है

python2_mbomb007 728, python2_carpetpython 744, ruby 756, Fish 825, Insomnia 1148, cjam 1277, whitespace 1484, brainfuck 3546

। तो ब्रेनफॉक जवाब को छोड़कर, यह अपेक्षाकृत स्थिर है ...

— ब्लोटोरेंज

7

अनिद्रा , 575 बाइट्स * 4 = 2300

dyedd=dyyyye=d=yd=dddde=ded=deey=eyy=de=edd=eydyee=yeyy=yey==ddyee=eydee=y=eyeedd=dde=yddd=eede=yedde=eeyd==yeyy=yyddy=eyy=dy=dddye=dyey=ede=yddd=dde=de=yyye=yyye=ddyyy=dyy=yeyddy=eyyyde=eed=ddd=yd=edyyd=eeydd=yedd=eye=eee=eeyy=yyyedde=d=eyyyedy=d=yddyye==dyyede=ddd=eydd=yd=ddde==eeeeyy=yeyd=deyy=yyy=ydy=dy=dd=e=ey=dddddy=yeey=ey=eed=ddd=eedy=ddddde=ydeyy=edd=ydy=ddy=yeedd=ydde=dde=edyye=ded=yeed=dddddde=eedy=eyde=ydy=ydydd=eyydd=dd=dddd=ddyye=ydeey=ed=eeeye=y=ydydde=eyyd=eyee=dy=edeyed=dyed==eyyddey=dd=yddd=yddd=de=ddedy=eyydd=eeedy==eyyydeee=d=d=eydd=yey=dyy==yyyedy=

4 वर्णों का उपयोग करता है dye=।

समाधान 1 बी (अप्रकाशित): 783 बाइट्स * 3 = 2349

eeeeyeeyy=eeyy=yeyye=yyyeeyye=eeeye=yeyey=eyeyyy=eyy=eeyeye=yeyeyyy=yyeeye=yeyy=yey==yyeyeyeye=eyyey=y=yyyyyy=y=eyyeyyyyyyye=eeye=yyeeyye=eyeyeyyy==yeyy=yeyyyeyye=yyyeeyy==eeyyeee==eeyye=yyyyeyyeyyye=yyyyyyy=yeye=eyyyyy=eeye=eeyeeeeey=eyeye=eeee=yeyyye=eyyyyye=y=eeeyyy=eyyeyee=yyy=eyye=yeyeeee=yyeyeyyyy=eeyy=yyyyy=eyyyy=yyeeyye=e=eyyyyy=eyey==eyeyy=yyyyyeyeyeye=ye=yyyyyy==eeeeyy=yeye=yeyyey=yyy=eyyyeeeye==yeeyyeyy=e==yeeeyyyeyy=yeey=ey=eee=eyeyy=yyeeee=yeeyyyyy=yee=yeyyy=yeeeeyy=eyeeeeeye=eeeyy=yyeeeeyyye=yey=yyyyeeyye=yyyyyyy=yeee=eeeeyyeye=eyeeye=eeyyeyyy=eeyee=yyyyyeeyy=eee=eeyyeyyyyy=eeey=eyyeeyy=eyyeyyy=eeeeyeee=eeeye=y=yyyeyy=yyeeee=yyeyey=ey=eyyyyyeyyy=yeye==yeeyyyeyy=yeye=yyyyeeyy=eeeyyeeyyy=yeeyeyyy=eeyye=eee=eyyye==eyeyeyyyyy=e=eeyeeye=yeey=eyeyy=eyeye=ey=eyyeye=

केवल 3 वर्णों का उपयोग करता है ey=।

समाधान 1: 826 बाइट्स * 3 = 2478

yoyoy~oyoyo~oyooyy~ooyyoyy~ooyyyyoy~~yoyyo~ooyoooyooo~yoyyo~oyoyoyyy~yyo~oyyoo~~ooooy~oyyyyy~oyoyoo~~oyyyoooyy~~oyoyooyyy~yyooo~yoyo~yoyyyyo~yooyo~y~yyoyyyooyy~oyyooy~ooyoy~oyyooy~ooyyo~yoyyoo~o~ooyo~yooyyoo~yoyoy~ooyyyyooo~oyoyyo~yyoyyyoo~yyo~yyooyyo~yoyyoooy~~yoyyyooyoyy~oyoyyy~yoooyyoy~yooyy~yooyyo~yyooyyoo~oyoyo~oyyy~oyyo~oyyoyo~oyyyoo~oyoyyoo~yooyo~ooooo~~yoyyoyyoyoo~yoyyooo~y~ooooy~yyyoy~ooooyyoyyoy~oyyoo~oyyoyo~yoyyyooy~oyooo~yoyyoyy~yyyyyo~oyooy~oyoyy~yoyyyoy~ooyoy~yoyyoooy~~oyyyo~ooooooy~yooyoyyoyo~yooyyo~oooyyo~yoyooyyo~oyyy~o~yooooy~oyoyyooooy~~yoyyooyyo~oy~yyyoyyyyy~yoyyyoy~yooo~oooy~oooooyyoyyyo~yoyyo~y~oooyyyoyoo~yyooooyoyy~y~oooyyyoy~~yoy~oyyoyoyyy~yoyyyyy~oyooo~yyyyooo~yooyyoy~yooyo~yoyyyo~yyoyyyo~o~ooooooyoy~oyoyyoy~yyoooo~ooooyy~oyoyoy~ooyyo~yyoooyo~yyyyyo~oyyo~yooyyooyyoy~~ooyyyyoyyy~ooyyo~yyooo~

केवल 3 वर्णों का उपयोग करता है yo~:। इसे उत्पन्न करने के लिए एक प्रोग्राम का उपयोग किया जाता है।

वर्तमान में, सभी प्रोग्राम केवल निर्देश 0, 1, 2, 6 का उपयोग करते हैं। दूसरे शब्दों में, वे एक ही बाइट में बिट्स में हेरफेर करते हैं और परिणाम का प्रिंट आउट लेते हैं।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत

19

CJam, 266 281 456 बाइट्स * 14 12 7 अद्वितीय = 3724 3372 3192

इसे ऑनलाइन आज़माएं।

14301201124204202034420112034224204431020210101232301021240204310431312122132100240400222324402030223103420431324402222132223233141443401210314023001122320404112224314302132421403301243334313000011124244441400003310332301330220022110121411122100040310110020040121444302100143202204330334033211334242120304123121024200421121232100303121022431044444423243331440434010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

व्याख्या

मैंने जिस रणनीति का उपयोग किया है वह स्ट्रिंग में प्रत्येक चरित्र को आधार -123 अंक के रूप में मानना है और इसे प्रोग्राम में एक दशमलव संख्या के रूप में एनकोड करना है। कार्यक्रम फिर उस संख्या को आधार 123 में बदल देता है और प्रत्येक आधार -123 अंक को एक वर्ण में वापस मैप करता है। क्योंकि यह समझाना कठिन है कि कार्यक्रम अपनी वर्तमान स्थिति में क्यों है, मैं इसके प्रत्येक संस्करण की व्याख्या करूँगा।

यहाँ कार्यक्रम का अंत पहले संस्करण में कैसा दिखता है:

...2068438725 123b:c

यह संभव सबसे सरल तरीके से रणनीति को लागू करता है। बेस 10 में सामान्य रूप से एन्कोडेड संख्या को वापस बेस 123 में बदल दिया जाता है और प्रत्येक बेस 123 अंक को एक वर्ण में वापस मैप किया जाता है। लेकिन यह 4 अद्वितीय गैर-अंकीय वर्णों का उपयोग करता है, और उनमें से किसी एक से छुटकारा पाने में सक्षम होने के कारण कम सीधा कोड का उपयोग करने के कारण आकार हिट के लायक होगा।

सबसे पहले, मुझे एहसास हुआ कि मैं bऔर :ASCII चरित्र मूल्यों को एक चरित्र (पहले से मौजूद cऑपरेटर के साथ) में वापस बदल दिया और उन्हें ~ऑपरेटर के साथ मूल्यांकन करके उन्हें रनटाइम पर बनाकर ऑपरेटरों से छुटकारा पा सकता हूं । यह :ऑपरेटर के साथ ऐसा करने के लिए थोड़ा मुश्किल हो गया , क्योंकि इसे निम्नलिखित cऑपरेटर के साथ एक साथ पार्स किया जाना है । मैंने इसे चरित्रों का निर्माण करके और फिर चरित्र :का cनिर्माण और मूल्यांकन करके हल किया है +, जो पूर्व दो पात्रों को स्ट्रिंग में समेटता है, जो :cतब ठीक से मूल्यांकन किया जा सकता है।

दूसरा, मुझे एहसास हुआ कि जिस ~ऑपरेटर को मैंने पेश किया था, उसके पास एक नया ओवरलोडेड वेरिएंट था: जब एक नंबर दिया जाता है, तो वह बिटवाइज़ सप्लीमेंट तैयार करता है। एक नंबर के बाद एक पंक्ति में दो बार इस का उपयोग करके, मैं बिना परिणामी कम्प्यूटेशनल प्रभाव के साथ स्रोत में एक टोकन ब्रेक का परिचय दे सकता था, जिससे मुझे अलग-अलग संख्याओं के साथ उपयोग किए जाने वाले रिक्त स्थान को बदलने की अनुमति मिली ~~।

अंतिम परिणाम अंत में कोड के 15 और बाइट्स हैं, लेकिन यह लागत 14. में से 2 अद्वितीय वर्णों को समाप्त करने के लाभ से बहुत अधिक है। यहां दूसरे संस्करण के अंत के साथ पहले संस्करण के अंत की तुलना है:

...2068438725  123[ b  ][   :c    ]
...2068438725~~123~~98c~58c99c43c~~

मेरे द्वारा उपयोग किए जा रहे 2 से कम संचालकों का उपयोग करना असंभव होगा, लेकिन मुझे अभी भी कम अद्वितीय चरित्र चाहिए थे। इसलिए अगला कदम अंकों को खत्म करना था। संख्या की एन्कोडिंग को बदलकर ताकि प्रत्येक दशमलव अंक वास्तव में आधार -5 अंक था, मैं संभवतः 6-9 अंकों को समाप्त कर सकता हूं। प्रोगाम के अंत से कुछ भी खत्म करने से पहले, यह इस तरह दिखता था:

...4010014400 10b5b123b:c

जैसा कि पहले उल्लेख किया गया है, अंतरिक्ष को खत्म करना आसान है। लेकिन b, :है, और cइतना आसान होगा नहीं, के रूप में अपने चरित्र के कोड हैं 98, 58, और 99क्रमशः,। इन सभी में उन्मूलन के लिए चिह्नित अंक थे, इसलिए मुझे उन सभी को प्राप्त करने के तरीके खोजने थे। और केवल 5-9 वाले चरित्र मानों के साथ उपयोगी उपयोगी सांख्यिक परिशोधन, वृद्धि, गुणा और जोड़ थे।

के लिए 98, मैंने शुरू में उपयोग किया था 100~~40c~40c~, जो 100दो बार घटता है । लेकिन तब मुझे एहसास हुआ कि मैं ~ऑपरेटर का एक और उपयोग कर सकता हूं , क्योंकि बिटवाइज़ पूरक मुझे नकारात्मक संख्या प्राप्त करने देता है, जब जोड़ा जाता है, तो मुझे घटाव का अनुकरण करने दें। इसलिए मैंने तब इस्तेमाल किया 100~~1~43c~, जो जोड़ता है 100और -22 बाइट्स छोटा होता है। के लिए 58, मैंने उपयोग किया 44~~14~~43c~, जो जोड़ता है 44और 14। और के लिए 99, मैंने इस्तेमाल किया 100~~40c~, जो कम हो जाता है 100।

अंतिम परिणाम बहुत बड़ा और अनुमानित है, लेकिन काफी बड़ी संख्या और प्रसंस्करण कोड की लागत 12. 5 में से 5 अद्वितीय वर्णों को समाप्त करने के बड़े लाभ से थोड़ा आगे निकल गए थे। यहां कार्यक्रम की अंतिम समाप्ति से पहले तुलना और बाद में तुलना की गई है eliminations:

...4010014400  10[      b      ][  5  ][     b     ]123[      b      ][            :c            ]
...4010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

— Runer112
स्रोत

ठीक है, अब मैं प्रभावित हूँ। आधार 6 अंक, आधार 7 अंक आदि आधार 5 की तुलना कैसे करते हैं?

— डुर्रोन 597

@ durron597 वे वास्तव में संगणना किसी भी आसान, ऑपरेटरों के चरित्र कोड के रूप में मैं जरूरत नहीं बनाते हैं ( 98, 58, और 99) अभी भी सीमा से बाहर हैं। और आधार को बढ़ाने से कार्यक्रम का कुल आकार 8-10% कम हो जाता है, जो कि एक नया अनूठा चरित्र होने से प्राप्त 10-15% स्कोर के लिए पर्याप्त नहीं है। bऑपरेटर को फिर से शामिल करने लायक नहीं है।

— रनर ११२

एक संख्या x लें, और इसे आधार b में बदलें। इसकी लंबाई होगी floor(log_b(x)+1), और इसमें bअलग-अलग चिन्ह होंगे। तो स्कोर है b*floor(log_b(x)+1)। x एक बड़ी संख्या है, और यदि आप इसे b के लिए प्लॉट करते हैं, तो आप पाएंगे कि b = 3 पर न्यूनतम बहुत अधिक है। यानी, जब आप उच्च आधार (लॉग) का उपयोग करते हैं, तो लंबाई थोड़ी कम हो जाती है, लेकिन चारसेट का आकार रैखिक रूप से बढ़ जाता है, इसलिए यह इसके लायक नहीं है। एक साधारण

— व्हाट्सएप

@blutorange आपको व्हॉट्सएप प्रोग्राम को रखना चाहिए। 4134 दूसरे स्थान के लिए पर्याप्त है

— डुर्रोन 597

16

व्हॉट्सएप, 1157 937 बाइट्स * 3 अद्वितीय = 3471 2811

लोकप्रिय (?) अनुरोध से, मैं अपना व्हाट्सएप समाधान पोस्ट कर रहा हूं।

आवश्यक कोड को कम करने के लिए, मैंने पूरे स्ट्रिंग को एक बाइनरी नंबर (प्रत्येक बाइट के लिए 7 बिट) के रूप में हार्डकोड किया। एक साधारण लूप पात्रों को निकालता है और उन्हें प्रिंट करता है।

Filebin.ca पर स्रोत कोड।

नोट: विनिर्देशों को मनमाने ढंग से बड़े पूर्णांक के लिए अनुमति दी जाती है , लेकिन आधिकारिक पृष्ठ पर हास्केल दुभाषिया 20 बिट्स तक सीमित है। उदाहरण के लिए, github / hostilefork / whitespaces पर यह रूबी दुभाषिया।

व्हाट्सएप प्रोग्राम बनाने के लिए माणिक स्क्रिप्ट (l = WHITESPACE, t = TAB, u = NEWLINE, सब कुछ // अनदेखा करने के बाद, एक फाइल पर लिखते हैं prog.h):

str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.'

def b2ws(bin)
    bin.chars.map{|x|x=='0' ? "l" : "t"}.join
end
def d2ws(dec,pad=0)
    b2ws(dec.to_s(2).rjust(pad,'0'))
end

bin = str.reverse.chars.map do |x|
    "  " + d2ws(x.getbyte(0),7) + " // char <#{x=="\n" ? "LF" : x}>"
end
data = "lll // pushes string as one large number\n#{bin.join("\n")}\nu"

File.open('prog.h','w') do |fout|
    fout << data << "\n"
    fout << <<-eos

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu
    eos
end

चित्रण के लिए, मानव-पठनीय रूप में व्हॉट्सएप कार्यक्रम। इसे एक वास्तविक व्हाट्सएप प्रोग्राम में बदलने के लिए एक सरल स्क्रिप्ट के लिए नीचे देखें।

lll // pushes string as one large number
  ltltttl // char <.>
  ttltltt // char <k>
  ttltttt // char <o>
  ttltttt // char <o>
  ttlttll // char <l>
  ltlllll // char < >
  ttllllt // char <a>
  ltlllll // char < >
  ttlltlt // char <e>
  ttlttlt // char <m>
  ltlllll // char < >
  ttllttt // char <g>
  ttltttl // char <n>
  ttltllt // char <i>
  tttlttl // char <v>
  ttltllt // char <i>
  ttllttt // char <g>
  ltlllll // char < >
  ltllltl // char <">
  ltlttll // char <,>
  tlllttt // char <G>
  tlltttt // char <O>
  tllltll // char <D>
  ltlllll // char < >
  tlttllt // char <Y>
  tlttltl // char <Z>
  tlllllt // char <A>
  tllttll // char <L>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltlllll // char < >
  tltlltl // char <R>
  tllltlt // char <E>
  tltlttl // char <V>
  tlltttt // char <O>
  ltlllll // char < >
  tltlltt // char <S>
  tltllll // char <P>
  tllttlt // char <M>
  tltltlt // char <U>
  tlltltl // char <J>
  ltlllll // char < >
  tlttlll // char <X>
  tlltttt // char <O>
  tlllttl // char <F>
  ltlllll // char < >
  tlltttl // char <N>
  tltlttt // char <W>
  tlltttt // char <O>
  tltlltl // char <R>
  tlllltl // char <B>
  ltlllll // char < >
  tlltltt // char <K>
  tlllltt // char <C>
  tlltllt // char <I>
  tltltlt // char <U>
  tltlllt // char <Q>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltllltl // char <">
  ltlllll // char < >
  ltttltl // char <:>
  ltltllt // char <)>
  ttlltlt // char <e>
  ttllltt // char <c>
  ttllllt // char <a>
  ttlltlt // char <e>
  tttllll // char <p>
  ltlllll // char < >
  ttttllt // char <y>
  ttlttlt // char <m>
  ltlllll // char < >
  tttlltl // char <r>
  ttltttt // char <o>
  ttllttl // char <f>
  ltlllll // char < >
  ttttllt // char <y>
  ttlltll // char <d>
  tttlttt // char <w>
  ttltttt // char <o>
  tttlltl // char <r>
  ltlllll // char < >
  ttltttt // char <o>
  ttltttt // char <o>
  tttltll // char <t>
  ltlllll // char < >
  tttltll // char <t>
  tttlltt // char <s>
  tttltlt // char <u>
  ttltltl // char <j>
  ltltlll // char <(>
  ltlllll // char < >
  ttlltll // char <d>
  ttlltlt // char <e>
  tttltll // char <t>
  ttltttt // char <o>
  tttltlt // char <u>
  tttlllt // char <q>
  ltlllll // char < >
  ttttllt // char <y>
  ttlttll // char <l>
  tttlltt // char <s>
  tttltlt // char <u>
  ttltttt // char <o>
  ttltllt // char <i>
  ttttlll // char <x>
  ttltttt // char <o>
  ttltttl // char <n>
  ttllltl // char <b>
  ttltttt // char <o>
  ltlllll // char < >
  ttltlll // char <h>
  tttltll // char <t>
  ttlltlt // char <e>
  ttllltl // char <b>
  ttllllt // char <a>
  ttttltl // char <z>
  ttltllt // char <i>
  ttlttll // char <l>
  tllltlt // char <E>
u

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu

मूल रूप से, आउटपुट के लिए स्ट्रिंग एक लंबा पूर्णांक है, और आपको इसके स्कोर को कम करने की आवश्यकता है।

एक संख्या x लें, और इसे आधार b में बदलें। इसकी लंबाई होगी floor(log_b(x)+1), और इसमें bअलग-अलग चिन्ह होंगे। तो स्कोर है b*floor(log_b(x)+1)। xएक बड़ी संख्या है, और यदि आप इसे बी के लिए प्लॉट करते हैं, तो आप पाएंगे कि न्यूनतम बहुत कम है b=3(और b=2लगभग उतना ही अच्छा है)। यानी, जब आप उच्च आधारों (लॉग) का उपयोग करते हैं, तो लंबाई थोड़ी कम हो जाती है, लेकिन चारसेट का आकार रैखिक रूप से बढ़ जाता है, इसलिए यह इसके लायक नहीं है।

इस प्रकार मैंने केवल 0/1 के साथ एक भाषा की तलाश की, लेकिन मुझे कोई नहीं मिला, और फिर मुझे याद आया कि वहां व्हाट्सएप था और उसने कोशिश की थी। व्हॉट्सएप में, आप 0 और 1 के सीधे के साथ बाइनरी नंबर दर्ज कर सकते हैं।

पुराना कोड, बदतर स्कोर लेकिन अधिक दिलचस्प

फाइलबीन पर पुराना कोड ।

प्रोग्राम बनाने के लिए मैंने जो माणिक स्क्रिप्ट का इस्तेमाल किया (l = WHITESPACE, t = TAB, u = NEWLINE, //जिसे नजरअंदाज करने के बाद सब कुछ एक फाइल पर लिखता है prog.h):

str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.' + "\n"

def shift(x)
    (x-97)%128
end

EOS = "lttltl" #26
STACK = []

bin = str.reverse.chars.map do |x|
    byte = shift(x.getbyte(0))
    rf = STACK.index(byte)
    STACK.unshift(byte)

    y = byte.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
    ph = "lll#{y}u" # pushing directly
    if rf
        bn = rf.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
        cp = "ltll#{bn}u" # copying from stack
    end

    if STACK.size>0 && STACK[0]==STACK[1]
        "lul // dup #{x.inspect}"
    elsif cp && cp.size < ph.size
        "#{cp} // copy <#{x.inspect}> (from #{rf})"
    else
        "#{ph} // push <#{x.inspect}> (#{shift(x.getbyte(0))})"
    end
end

File.open('prog.h','w') do |fout|
    fout << "ll#{EOS}u // push EOS" << "\n"
    fout << bin.join("\n") << "\n"
    fout << <<-eos
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  ll#{EOS}u // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu
    eos
end

चित्रण के लिए, मानव-पठनीय रूप में व्हॉट्सएप कार्यक्रम। इसे एक वास्तविक व्हाट्सएप प्रोग्राम में बदलने के लिए एक सरल स्क्रिप्ट के लिए नीचे देखें।

lllttltlu // push EOS
llltltlltu // push <"\n"> (41)
llltllttltu // push <"."> (77)
llltltlu // push <"k"> (10)
llltttlu // push <"o"> (14)
lul // dup "o"
llltlttu // push <"l"> (11)
lllttttttu // push <" "> (63)
llllu // push <"a"> (0)
ltlltu // copy <" "> (from 1)
llltllu // push <"e"> (4)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
lllttlu // push <"g"> (6)
lllttltu // push <"n"> (13)
llltlllu // push <"i"> (8)
llltltltu // push <"v"> (21)
ltlltu // copy <"i"> (from 1)
lllttlu // push <"g"> (6)
ltllttlu // copy <" "> (from 6)
llltllllltu // push <"\""> (65)
llltlltlttu // push <","> (75)
lllttllttlu // push <"G"> (102)
lllttltttlu // push <"O"> (110)
lllttlllttu // push <"D"> (99)
ltlltltu // copy <" "> (from 5)
lllttttlllu // push <"Y"> (120)
lllttttlltu // push <"Z"> (121)
lllttlllllu // push <"A"> (96)
lllttltlttu // push <"L"> (107)
ltlltllu // copy <" "> (from 4)
lllttlltllu // push <"E"> (100)
lllttlltttu // push <"H"> (103)
llltttllttu // push <"T"> (115)
ltllttu // copy <" "> (from 3)
llltttllltu // push <"R"> (113)
ltlltllu // copy <"E"> (from 4)
llltttltltu // push <"V"> (117)
ltlltttlu // copy <"O"> (from 14)
ltlltllu // copy <" "> (from 4)
llltttlltlu // push <"S"> (114)
lllttlttttu // push <"P"> (111)
lllttlttllu // push <"M"> (108)
llltttltllu // push <"U"> (116)
lllttltlltu // push <"J"> (105)
ltlltltu // copy <" "> (from 5)
llltttltttu // push <"X"> (119)
ltlltlllu // copy <"O"> (from 8)
lllttlltltu // push <"F"> (101)
ltllttu // copy <" "> (from 3)
lllttlttltu // push <"N"> (109)
llltttlttlu // push <"W"> (118)
ltlltllu // copy <"O"> (from 4)
ltlltllltu // copy <"R"> (from 17)
lllttlllltu // push <"B"> (97)
ltlltltu // copy <" "> (from 5)
lllttltltlu // push <"K"> (106)
lllttllltlu // push <"C"> (98)
lllttltlllu // push <"I"> (104)
ltllttttu // copy <"U"> (from 15)
llltttllllu // push <"Q"> (112)
ltlltltu // copy <" "> (from 5)
ltllttlltu // copy <"E"> (from 25)
ltllttttlu // copy <"H"> (from 30)
ltllttttlu // copy <"T"> (from 30)
llltllllltu // push <"\""> (65)
ltlltllu // copy <" "> (from 4)
llltlttlltu // push <":"> (89)
llltlltlllu // push <")"> (72)
llltllu // push <"e"> (4)
llltlu // push <"c"> (2)
llllu // push <"a"> (0)
llltllu // push <"e"> (4)
lllttttu // push <"p"> (15)
ltlltttu // copy <" "> (from 7)
lllttlllu // push <"y"> (24)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
llltllltu // push <"r"> (17)
llltttlu // push <"o"> (14)
llltltu // push <"f"> (5)
ltllttu // copy <" "> (from 3)
ltllttlu // copy <"y"> (from 6)
lllttu // push <"d"> (3)
llltlttlu // push <"w"> (22)
llltttlu // push <"o"> (14)
ltlltttu // copy <"r"> (from 7)
ltlltltu // copy <" "> (from 5)
ltlltlu // copy <"o"> (from 2)
lul // dup "o"
llltllttu // push <"t"> (19)
ltllttu // copy <" "> (from 3)
ltlltu // copy <"t"> (from 1)
llltlltlu // push <"s"> (18)
llltltllu // push <"u"> (20)
llltlltu // push <"j"> (9)
llltllltttu // push <"("> (71)
ltlltltu // copy <" "> (from 5)
lllttu // push <"d"> (3)
llltllu // push <"e"> (4)
ltlltttu // copy <"t"> (from 7)
llltttlu // push <"o"> (14)
ltlltttu // copy <"u"> (from 7)
llltllllu // push <"q"> (16)
ltllttlu // copy <" "> (from 6)
lllttlllu // push <"y"> (24)
llltlttu // push <"l"> (11)
llltlltlu // push <"s"> (18)
ltlltltu // copy <"u"> (from 5)
llltttlu // push <"o"> (14)
llltlllu // push <"i"> (8)
llltltttu // push <"x"> (23)
ltlltlu // copy <"o"> (from 2)
lllttltu // push <"n"> (13)
llltu // push <"b"> (1)
ltlltlu // copy <"o"> (from 2)
ltlltlttu // copy <" "> (from 11)
llltttu // push <"h"> (7)
llltllttu // push <"t"> (19)
llltllu // push <"e"> (4)
llltu // push <"b"> (1)
llllu // push <"a"> (0)
lllttlltu // push <"z"> (25)
llltlllu // push <"i"> (8)
llltlttu // push <"l"> (11)
lllttlltllu // push <"E"> (100)
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  lllttltlu // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu

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

lulडुप्लिकेट चरित्र होने पर स्टैक को क्लोन करने के लिए उपयोग करें
ltlस्टैक के एन-वें प्रविष्टि को क्लोन करने के लिए उपयोग करें यदि सीधे चार्ट को धकेलने की तुलना में कम है
97 (मॉड 128) द्वारा सभी बाइट्स को नीचे शिफ्ट करें, बाइनरी संख्या को छोटा बनाता है

मेरे मानव पढ़ने योग्य व्हाट्सएप कोड को वास्तविक व्हाट्सएप प्रोग्राम में बदलने के लिए एक सरल रूबी स्क्रिप्ट (एक फ़ाइल पढ़ें prog.hऔर एक फाइल पर लिखता है prog.ws):

WHITESPACE = "l"
NEWLINE = "u"
TAB = "t"

File.open('prog.ws','w') do |fout|
    code = ""
    fin = File.read('prog.h')
    fin.each_line do |line|
        line.gsub!(/\/\/.*/,'')
        line.scan(/#{NEWLINE}|#{WHITESPACE}|#{TAB}/i) do |x|

            code << case x.downcase
            when NEWLINE.downcase
                "\n"
            when WHITESPACE.downcase
                " "
            when TAB.downcase
                "\t"
            else
                ""
            end
        end
    end
    fout << code
end

— blutorange
स्रोत

अनुगामी newline वैकल्पिक है, आप इसे मुद्रित नहीं करके कुछ वर्ण सहेज सकते हैं।

— डुर्रोन 597 13

धन्यवाद, इसे बदल दिया। मूल रूप से, मैंने इसे शामिल किया क्योंकि हास्केल दुभाषिया कुछ डिबग आउटपुट को जोड़ता है, लेकिन रूबी के साथ, यह साफ दिखता है।

— ब्लटोरांगे

7

रूबी 144 बाइट्स * 39 यूनीक = 5616

puts"Elizabeth obnoxiously quoted (just too rowdy for my peace): \"#{'the quick brown fox jumps over the lazy dog,'.upcase}\" giving me a look."

कभी-कभी सबसे सरल सबसे अच्छा है।

— MegaTom
स्रोत

आप डेटा में किसी भी सरलीकरण का उपयोग नहीं करते हैं। Cjam और व्हाट्सएप के उदाहरणों में कुछ स्पष्टीकरणों के साथ प्रभावशाली स्कोर मिला। यहां तक कि एक समझदार भाषा में सुव्यवस्थित कोड का उपयोग करने के लिए बोनस के साथ, यह बहुत अधिक जमीन है !!! हो सकता है कि आप लंबाई + अद्वितीय स्कोरिंग प्रतियोगिता में फिर से प्रवेश कर सकें ।

— जोस_एक्स

6

ब्रेनफक, 1264 बाइट्स * 7 अद्वितीय = 8848

हाँ, यह एक भयानक स्कोर है।

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

— mbomb007
स्रोत

मैंने पाया कि कम अद्वितीय वर्णों का उपयोग करना संभव है, लेकिन लंबाई १० 5 ९ ५, समय ५ = ५३

— to५

आप इसे केवल +.यकीन के साथ कर सकते हैं कि यह कोई भी छोटा हो।

— कैप्टंसीग

केवल का उपयोग करना +और .मुझे 15018 * 2 = मिलता है 30,036।

— कैप्टनक्रिग

6

> <> (मछली) - 578 बाइट्स * 8 अद्वितीय = 4624

14121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p

मेरा स्कोर उतना प्रतिस्पर्धी नहीं है जितना मैं उम्मीद कर रहा था, लेकिन मुझे लगा कि यह समाधान अभी भी काफी दिलचस्प है।

व्याख्या

कोड का पहला खंड अंक 0-4 का एक लंबा तार है जो स्ट्रिंग में प्रत्येक वर्ण के लिए 3 अंकों का आधार 5 प्रतिनिधित्व करता है। शेष कोड pमछली में ऑपरेटर का लाभ उठाता है जो आपको कार्यक्रम के स्रोत कोड को संपादित करने की अनुमति देता है जबकि कार्यक्रम चल रहा है। उस ऑपरेटर का उपयोग करके, मैं आधार 5 वर्णों को आधार 10 में बदलने और उन्हें आउटपुट करने के लिए आवश्यक मछली कोड उत्पन्न करने में सक्षम था, और फिर दुभाषिया के अंत तक पहुंचने से पहले उस कोड को फ़ाइल की शुरुआत में स्रोत कोड में वापस डाल दिया। लाइन के चारों ओर और लिपटे। जब दुभाषिया लाइन के अंत तक पहुँचता है, तो कोड इस तरह दिखने के लिए संशोधित किया गया है:

v4121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p
>55**$5*++ol?!;

जब कोड चारों ओर से घूमता है और vऑपरेटर से टकराता है तो वह दूसरी पंक्ति में चला जाता है, >ऑपरेटर से टकराता है और लूप से आगे बढ़ता है, हर बार बेस 5 एन्कोडिंग को एक बेस 10 एससीआई मान में परिवर्तित करता है और फिर उस मूल्य को आउटपुट करता है। जब स्टैक पर कोई अधिक मान नहीं होते हैं, तो ?ऑपरेटर इसे छोड़ देगा ;और प्रोग्राम समाप्त हो जाएगा।

— tallestpurpl
स्रोत

5

7 , 273 बाइट्स × 7 यूनिक बाइट्स = 1911, नॉनकंपेटिंग (भाषा पोस्टडेट्स चैलेंज)

501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

अद्वितीय वर्णों को नीचे रखें

ठीक छाप

स्कोरिंग

अनिद्रा , 575 बाइट्स * 4 = 2300

समाधान 1 बी (अप्रकाशित): 783 बाइट्स * 3 = 2349

समाधान 1: 826 बाइट्स * 3 = 2478

CJam, 266 281 456 बाइट्स * 14 12 7 अद्वितीय = 3724 3372 3192

व्याख्या

व्हॉट्सएप, 1157 937 बाइट्स * 3 अद्वितीय = 3471 2811

पुराना कोड, बदतर स्कोर लेकिन अधिक दिलचस्प

रूबी 144 बाइट्स * 39 यूनीक = 5616

ब्रेनफक, 1264 बाइट्स * 7 अद्वितीय = 8848

> <> (मछली) - 578 बाइट्स * 8 अद्वितीय = 4624

व्याख्या

7 , 273 बाइट्स × 7 यूनिक बाइट्स = 1911, नॉनकंपेटिंग (भाषा पोस्टडेट्स चैलेंज)

पायथन 2, 163 147 145 143 बाइट्स * 35 36 35 अद्वितीय = 5705 5292 5220 5005

संपादन:

पायथन 2, 14508 11700 11088 10164 9486 9746 7860 145 बाइट्स * 36 अद्वितीय = 5220

> <> (मछली) - 138 बाइट्स * 65 अद्वितीय = 8970

05AB1E , 380 बाइट्स * 11 चार्ट = 4180 स्कोर

पर्ल 6, 139 बाइट्स * 36 अद्वितीय = 5004

जावा 8, 141 बाइट्स * 64 अद्वितीय अक्षर = 9,024

पर्ल 5 , 137 बाइट्स * 35 अद्वितीय = 4795

Tcl , 345 बाइट्स, 345 x 13 = 4485

Tcl , 337 बाइट्स, 337 x 15 = 5055

Tcl , 329 बाइट्स, 329 x 16 = 5264

Tcl , 333 बाइट्स, 333 x 16 = 5328

Tcl , 148 बाइट्स, 148 x 37 = 5476

Tcl , 277 बाइट्स, 277 x 21 = 5817

Tcl , 371 बाइट्स, 371 x 16 = 5936

Tcl , 401 बाइट्स, 401 x 16 = 6416

Tcl , 403 बाइट्स, 403 x 16 = 6448

Tcl , 433 बाइट्स, 433 x 15 = 6495

Tcl , 473 बाइट्स, 473 x 14 = 6622

Tcl , 133 बाइट्स, 133 x 60 = 7980