लम्बा लम्बा कार्यक्रम बनाओ

Question

पेंग्वेज एक दिमागी बोली है जो स्रोत प्रतिबंध संबंधी चुनौतियों को तोड़ने के लिए कुख्यात है। ऐसा इसलिए है क्योंकि पेंग्विज को केवल उसके स्रोत की लंबाई की परवाह है, सामग्री की नहीं।

सबसे पहले, कार्यक्रम की लंबाई की गणना की जाती है। फिर, कहा जाता है कि लंबाई को बाइनरी में बदल दिया गया है और 3. के कई को बाइनरी से बाएं-पैडेड किया गया है। परिणामस्वरूप बाइनरी स्ट्रिंग को 3 बिट्स के टुकड़ों में विभाजित किया गया है, जिनमें से प्रत्येक को ब्रेनफैक कमांड में अनुवादित किया गया है:

000 -> +
001 -> -
010 -> >
011 -> <
100 -> .
101 -> ,
110 -> [
111 -> ]

अंत में कार्यक्रम को ब्रेनफैक के रूप में चलाया जाता है ^{1 के} ।

यहाँ से चुनौती काफी सरल है, एक ऐसा लेंग्वेज प्रोग्राम लिखें जिसमें कोई इनपुट न हो और जो एक बाइट बार-बार पूर्णांक $n$ से मिलकर आउटपुट उत्पन्न करता है , जहाँ $n$ आपके प्रोग्राम की लंबाई से कड़ाई से अधिक हो।

उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

यहां ब्रेनफक से पेंगुइन की गणना करने के लिए एक हैकी कार्यक्रम है

---

^{1: इस चुनौती के लिए हम रैपिंग सेल और एक नॉन-रैपिंग टेप का उपयोग करेंगे।}

Comments

+[.]क्या मैं जीत गया? : पी

— क्विंटेक

शायद आउटपुट की लंबाई पर स्कोर करना अधिक दिलचस्प हो सकता है?

— जो किंग

@JoKing यह एक अच्छा विचार है। दुर्भाग्य से इसके लिए थोड़ी देर लगती है।

— पोस्ट रॉक गार्फ हंटर

इसके अलावा, यह टैग की गई क्वीन क्यों है?

— इग्नोरेंस

+]$2^{3n}$

Answer 1

8437495638205698686671 बाइट्स

यह ब्रेनफक प्रोग्राम में अनुवाद करता है:

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

$231584178474632390847141970017375815706539969331281128078915168015826259279614$

यह फ़ंक्शन द्वारा गणना की जाती है

f(n)=2*f(n-1)+n
f(0)=0

255 के इनपुट के साथ।

स्पष्टीकरण:

-[         Loop 255 times
  >>[>]    Move to the end of a series of positive cells (initially empty)
  +        Add one cell to the end
  [-       Loop over each cell 
    >[>]+  Add one cell to the end
    .      Print a SOH byte
    [<]+   Restore current cell
  <]       Move to next cell
<-]        Decrement counter

Answer 2

9093903938998324939360576240306155985031832511498888836321985855167849863863065731015823 बाइट्स

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

जो बिल्कुल प्रिंट करता है

298333629248008269731638612618517353495058861384016275770860733328251135402804732197446995616017112134460464130233444058136509123809012106419446593183683387659250431692751255099808162970657410517657862174602556590616568690423540284801267472920128909691902547970614008613488242333460665145840144517097342073878746293059960326132795671583153307437896728515625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

$250^{255}$

इस ब्रेनफक जवाब में क्रेडिट @hvd को जाता है , इसलिए उसे सुनिश्चित करना सुनिश्चित करें!

स्पष्टीकरण:

मैं अपनी खुद की एक व्याख्या लिखने जा रहा था, लेकिन एहसास हुआ कि @hvd का स्पष्टीकरण पहले से ही बिंदु पर है, इसलिए मैं इसे यहां उद्धृत करूंगा:

>>>>>> काम करने की जगह को छोड़ने के लिए आवश्यक है।

-255 पैदा करता है ( 0 से - 1 = 255 जब हमारे पास रैपिंग सेल होता है )।

[[->>>+<<<]------>>>-] यह मान 250 की 255 प्रतियों में बदल जाता है, ऐसा दिखने वाला टेप देता है:

0 0 0 0 0 0 250 0 0 250 0 0 ... 250 0 0 [0]

<<<[<<<]+ डेटा पॉइंटर को वापस ले जाता है और प्रारंभिक डेटा को पूरा करता है:

0 0 0 [1] 0 0 250 0 0 250 0 0 ...

इसके बाद लूप आता है: [+...-] शुरू में 1 से 2 सेट करता है, जो लूप के अंत में 1 पर वापस सेट हो जाता है। लूप समाप्त हो जाता है जब लूप शरीर पहले से ही 2 से 1 सेट करता है।

अब, संख्या 2 250 250 250 ... 250 एक काउंटर का प्रतिनिधित्व करती है, बेस 250 में, प्रत्येक संख्या उस अंक की तुलना में अधिक होती है, जिसका वह प्रतिनिधित्व करता है।

• [>>>]<<<सही करने के लिए सभी तरह से चलता है। चूंकि प्रत्येक अंक एक गैर-शून्य संख्या द्वारा दर्शाया जाता है, यह तुच्छ है।

• ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-काउंटर को 1. घटाता है। अंतिम अंक से शुरू होता है: अंक घट जाता है। यदि यह सकारात्मक रहता है, तो हम कर रहे हैं। यदि यह शून्य हो जाता है, तो इसे 250 पर सेट करें, और पहले अंक के साथ जारी रखें।

• [<<<].>>>पॉइंटर को लेफ्ट-डिजिट से पहले वापस ले जाता है, और NUL बाइट प्रिंट करने के लिए यह एक अच्छा पल है। फिर बायीं ओर सबसे अधिक अंक के लिए फिर से स्थिति, यह देखने के लिए कि क्या हम कर रहे हैं।

सत्यता की पुष्टि करने के लिए प्रारंभिक बदलने के लिए, -करने के लिए +करने के लिए प्रिंट 250 ¹ , NUL बाइट्स ++के लिए 250 ² , आदि

Answer 3

19326644346528796447 बाइट्स

ब्रेनफक कोड:

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

प्रिंटों

57896044618658097711785492504343953926634992332820282019728792003956564819967

अशक्त बाइट्स।

यह इस तरह काम करता है:

mem[i]=255;
do
    while(--mem[i]){
        mem[i+1]=mem[i+2]=mem[i];
        mem[i]=1;
        i+=2;
    }
while(mem[--i]);

काफी सीधी पुनरावृत्ति।