अद्वितीय आउटपुट के साथ ब्रेनफ *** सबप्रोग्राम

Question

आपको एक 100-बाइट लंबा ब्रेनफक (BF) प्रोग्राम लिखना चाहिए।

एक चरित्र को हर संभव तरीके से हटा दिया जाएगा जिसके परिणामस्वरूप 100 नए (99-बाइट लंबे) कार्यक्रम होंगे। कार्यक्रम के लिए उदाहरण के लिए ++.>.5 subprograms हैं +.>., +.>., ++>., ++..और ++.>।

आपका स्कोर 100 प्रोग्राम उत्पन्न करने वाले अनूठे आउटपुट की संख्या होगी। उच्च स्कोर बेहतर है।

विवरण

• पहले वर्णों को आउटपुट करने के बाद आपके कार्यक्रम समाप्त हो जाएंगे।
• अमान्य या गैर-समाप्ति कार्यक्रम और खाली आउटपुट उत्पन्न करने वाले कार्यक्रमों को स्कोर की ओर नहीं गिना जाता है।
• BF सेल 8 बिट रैपिंग वाले होते हैं। (255 + 1 = 0, 0-1 = 255)
• आपके प्रोग्राम को कोई इनपुट नहीं दिया गया है। यदि आप ,कोड का उपयोग करते हैं तो यह वर्तमान सेल को सेट करता है 0।
• प्रारंभिक स्थिति के बाईं ओर कोई कोशिका नहीं हैं। जैसे <.कि अमान्य है, लेकिन .<मान्य है क्योंकि निष्पादन समाप्त हो गया है .। टेप दूसरी दिशा में अनबाउंड है।
• असंतुलित कोष्ठक ( [और ]) के साथ कार्यक्रम अमान्य हैं।
• आपका मूल कार्यक्रम 100 बाइट्स से छोटा हो सकता है क्योंकि स्कोर को बदले बिना इसे 100 बाइट तक विस्तारित करना आसान है।
• आपके मूल कार्यक्रम को मान्य BF कोड नहीं होना चाहिए।

आप अपने जवाब के स्कोर को निर्धारित करने के लिए इस python3 प्रोग्राम (ideone लिंक) का उपयोग कर सकते हैं । (लंबे समय तक चलने वाले कार्यक्रमों के लिए आपको maxstepचर को संशोधित करने की आवश्यकता हो सकती है ।)

उदाहरण

(सादगी के लिए यह कार्यक्रम 100 बाइट्स से छोटा है।)

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

Score: 3

Explanation:

Subprogram     => Output

+,+[-]+><.-,-. => 1
+,+[-]+><.-,-. => 1
+++[-]+><.-,-. => 1
++,[-]+><.-,-. => 1
++,+-]+><.-,-. => None
++,+[]+><.-,-. => None
++,+[-+><.-,-. => None
++,+[-]><.-,-. => 0
++,+[-]+<.-,-. => None
++,+[-]+>.-,-. => 0
++,+[-]+><-,-. => 255
++,+[-]+><.,-. => 1
++,+[-]+><.--. => 1
++,+[-]+><.-,. => 1
++,+[-]+><.-,- => 1

Unique outputs are [0, 1, 255]    
Score is 3 for ++,+[-]+><.-,-. (length = 15)

टाई के मामले में विजेता कम कोड वाला होता है। (आपका कार्यक्रम विवरण अनुभाग में बताए अनुसार 100 बाइट्स से कम हो सकता है।) यदि कोड समान लंबाई के हैं तो विजेता पहले वाला पोस्टर है।

बोनस पहेली: बिना बोल्ड प्रतिबंध के आप स्कोर 100 के साथ एक कार्यक्रम पा सकते हैं?

Comments

मैंने बोनस पहेली हल की; इसका उत्तर (सेंसर) है।

— AJMansfield

@AJMansfield क्या आप अपनी टिप्पणी संपादित कर सकते हैं ताकि अन्य लोग भी पहेली के बारे में सोच सकें? उदाहरण के लिए pastebin.com लिंक पर अपने समाधान को बदलें जिसमें उत्तर होता है।

— रैंडमरा

हम्म। मैंने इस प्रश्न के लिए एक जेनेटिक ऑप्टिमाइज़र लिखा था जो मौजूदा उत्तरों में सूक्ष्म सुधार लाने की कोशिश करेगा, लेकिन यह अभी तक बहुत सफल नहीं है। वे क्रमशः 79 और 43 पर अटक रहे हैं। आह अच्छी तरह से - यह एक शॉट के लायक था!

— 3

Answer 1

स्कोर: 35 41 69 78 79 83

(नई पंक्ति निकालें)

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

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

मुझे यकीन नहीं है कि यह क्यों काम करता है ...

स्कोर: 79

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

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

यह 2 * मेम [i] * i को योग करने के लिए माना जाता था और उन सेल (+ कॉन्स्ट) की संख्या जोड़ते हैं, जहां पते दाईं ओर से बाईं ओर गिने जाते हैं। गुणक 2 और कोशिकाओं की संख्या को हटाने और अलग समता होने + कर सकते हैं।

यह वास्तव में 69 अंक संस्करण में उस तरह काम किया। लेकिन नवीनतम संस्करण ने इसे तोड़ दिया और संयोग से कुछ और मिला। यह राशि की गणना करता है (मेम [i] * i + i + 1) और हटाने + और> लगभग वही करता है, योग के अलावा (i) जिसमें कोशिकाओं की संख्या का अंतर होता है, जो विभिन्न आउटपुट की संख्या भी है या तो हटाने के लिए + और>।

बोनस के लिए:

+। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +। +।

Comments

नोट: यदि आप प्रदान किए गए स्कोरर प्रोग्राम के साथ इसका परीक्षण करते हैं, तो कुछ उपप्रोग्रामों को लंबे समय तक चलाने के लिए maxstepमान (इन def evaluate(r,maxstep=20000):) को बढ़ाना सुनिश्चित करें ।

— रैंडम

स्कोर वास्तव में करने के लिए बढ़ाया जा सकता है 79की जगह ->+>+> ...के साथ->,>+> ...

— BrainSteel

@BrainSteel मैंने अभी इसे नो-ऑप में बदल दिया है।

— jimmy23013

Answer 2

स्कोर: 37 43

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

संपादित करें: अब मेरा कार्यक्रम कुछ वर्ग कोष्ठक की अनुमति देता है। इसके साथ कोई पुरस्कार जीतने के लिए नहीं जा रहा है, लेकिन यही मुझे कुछ भारित RNG बनाने के लिए मिलता है जो मेरे लिए व्यस्त काम करते हैं।

यह मैंने C में लिखे एक प्रोग्राम द्वारा उत्पन्न किया था।

Nहटाए गए हर वें चरित्र के लिए, यहाँ आउटपुट हैं:

N = 0 => 158
N = 1 => 158
N = 2 => 158
N = 3 => 187
N = 4 => 129
N = 5 => 100
N = 6 => 158
N = 7 => 13
N = 8 => 1
N = 9 => 211
N = 10 => 129
N = 11 => 1
N = 12 => 57
N = 13 => 255
N = 14 => Mismatched Braces
N = 15 => 59
N = 16 => 11
N = 17 => 11
N = 18 => 11
N = 19 => 117
N = 20 => 11
N = 21 => 117
N = 22 => 166
N = 23 => Mismatched Braces
N = 24 => 206
N = 25 => 206
N = 26 => 206
N = 27 => 147
N = 28 => 147
N = 29 => 158
N = 30 => 148
N = 31 => 188
N = 32 => 51
N = 33 => 17
N = 34 => 84
N = 35 => 84
N = 36 => 84
N = 37 => 158
N = 38 => 158
N = 39 => 94
N = 40 => 46
N = 41 => 94
N = 42 => 94
N = 43 => 94
N = 44 => 17
N = 45 => 196
N = 46 => Mismatched Braces
N = 47 => 149
N = 48 => No Termination
N = 49 => No Termination
N = 50 => Mismatched Braces
N = 51 => Mismatched Braces
N = 52 => 45
N = 53 => 77
N = 54 => 45
N = 55 => 77
N = 56 => 50
N = 57 => 209
N = 58 => 50
N = 59 => 251
N = 60 => 249
N = 61 => 99
N = 62 => 99
N = 63 => 117
N = 64 => 89
N = 65 => 207
N = 66 => 89
N = 67 => 115
N = 68 => 115
N = 69 => 115
N = 70 => 95
N = 71 => Mismatched Braces
N = 72 => Mismatched Braces
N = 73 => 104
N = 74 => Mismatched Braces
N = 75 => No Termination
N = 76 => No Termination
N = 77 => No Termination
N = 78 => No Termination
N = 79 => Left Overflow
N = 80 => 3
N = 81 => 2
N = 82 => No Termination
N = 83 => Mismatched Braces
N = 84 => No Termination
N = 85 => 133
N = 86 => 133
N = 87 => 0
N = 88 => Mismatched Braces
N = 89 => 158
N = 90 => 0
N = 91 => 4
N = 92 => Mismatched Braces
N = 93 => 0
N = 94 => 158
N = 95 => Mismatched Braces
N = 96 => 0
N = 97 => 157
N = 98 => 159
N = 99 => None

कुल 37 अद्वितीय आउटपुट हैं, जो (संख्यात्मक क्रम में) हैं:

0, 1, 2, 3, 4, 11, 13, 17, 45, 46, 50, 51, 57, 59, 77, 84, 89, 94, 95, 99,
100, 104, 115, 117, 129, 133, 147, 148, 149, 157, 158, 159, 166, 187, 188, 
196, 206, 207, 209, 211, 249, 251, 255

मैं 90% 100% निश्चित हूं कि यह समाधान इष्टतम नहीं है , लेकिन यह साबित करना कि अत्यधिक मुश्किल हो सकता है । कुछ चीजें हैं जो स्पष्ट हैं। कोई होने .अंतिम वर्ण तक प्रतीकों लगता है जाने का रास्ता होने के लिए , और वर्ग कोष्ठक ( []) के बजाय बेकार होने लगते हैं । मैंने यहां थोड़ी सोच-विचार किया, जिसे मैं रेखांकित करना चाहता हूं:

आज्ञा देना Lकोड की लंबाई बाइट्स में (चुनौती में 100), और nउप कार्यक्रमों के अनूठे आउटपुट की संख्या हो।

के लिए L=3, वहाँ प्रपत्र के कई इष्टतम समाधान कर रहे हैं +-., जहां n=2(इस मामले में, आउटपुट 1 और 255 के लिए कर रहे हैं +.और -.के लिए सबसे अच्छा अनुपात क्रमश।) यह कहते हैं L = 3पर n/L = 66.67%। ध्यान दें कि इस अनुपात को कम से कम नहीं पीटा जा सकता है L<10।

L=10समाधान के लिए , यह सरल है कि यह bruteforce के लिए पर्याप्त है। यहाँ सभी बेहतरीन समाधान हैं n = 6:

++>-->+<+. => 6
++>-->+<+. => 6
+++>->+<+. => 6
--->->+<+. => 6
++>---><+. => 6
+++>--><+. => 6
-->++>-<-. => 6
+++>+>-<-. => 6
--->+>-<-. => 6
-->+++><-. => 6
--->++><-. => 6

जिसका अनुपात प्राप् त होता है n/L = 60%।

जैसा कि L->infinity, यह स्पष्ट है कि अनुपात 0 के पास होना चाहिए, क्योंकि संभावित अनंत के लिए केवल 255 संभावित आउटपुट होते हैं L।

हालांकि, यह अनुपात समान रूप से कम नहीं होता है। के लिए एक समाधान का निर्माण करना संभव नहीं है n=6, L=9, इसलिए इसके लिए सबसे अच्छा संभव अनुपात L=9है 5/9 = 55.56% < 60%।

यह सवाल है, कैसे जल्दी , और किस मामले में, अनुपात उतरता है? के लिए L = 100, और कम से 10^9 checks/second, यह ब्रह्मांड के जीवनकाल से अधिक समय परिमाण के कई आदेश लेना सर्वोत्कृष्ट समाधान bruteforce होगा। क्या इस बारे में जाने का एक सुंदर तरीका है? मैं बहुत ज्यादा संदेह यह करने के लिए नीचे है कि 37%के लिए L = 100।

अनुपात वास्तव में बढ़ता है, तक L=100। पुष्टि करने के लिए अन्य उत्तर देखें।

मुझे आपके उपरोक्त के मूल्यांकन सुनने में अच्छा लगेगा। मैं बिल्कुल गलत हो सकता था, आखिरकार।