ब्रेनएफ ** के, 396 391 बाइट्स
>+>>++++[-<++++++++>]->,----------[++++++++++.>>++++++++[-<++++<------>>]<.,----------]-<+[-<+]->>+[-<<<<<++++++++++.[-]>[-<+>>.<]<[->+<]>+>>>[[->+]->>+<<<+[-<+]->]>+[-<->[[->+]->+>>+<<<<+[-<+]->]<+>->+[->+]->>[->+<]>+>++++++++++>>-<<[-<-[>>]<]<->>>+[-<<<+>>>[-<->]<+++++++++>>>+]++++++++[-<++++<++++++>>]<<<[-<<<<+[-<+]-<+>>+[->+]->>>>+<]>.>.[-]<[-]<<<[->+<]<<+[-<+]>+]>>[-]<<<-<+[-<+]->>+]
मैं ऐसा करने के प्रलोभन का विरोध नहीं कर सका। कम से कम त्रिभुज नुकीले-नीचे की ओर होता है।
इनपुट न्यूक्लियर वर्णों की एक स्ट्रिंग के रूप में आता है, जिसके बाद एक नई लाइन होती है।
आउटपुट में हर लाइन पर एक एकल अनुगामी स्थान होगा।
उदाहरण:
$ bf sd.bf
010
0 1 0
1 1
2
$ bf sd.bf
123456
1 2 3 4 5 6
3 5 7 9 1
8 2 6 0
0 8 6
8 4
2
$ bf sd.bf
9245322
9 2 4 5 3 2 2
1 6 9 8 5 4
7 5 7 3 9
2 2 0 2
4 2 2
6 4
0
व्याख्या
चूंकि कोड को कार्यात्मक दृष्टिकोण से समझाना मुश्किल है, इसलिए हम इसे विभिन्न समय पर टेप की स्थिति के परिप्रेक्ष्य से देख सकते हैं। यहाँ मुख्य विचार यह है कि हम जिस त्रिभुज को आउटपुट करते हैं, उसे एक कसकर भरे (बीएफ, वैसे भी) सरणी के रूप में आरम्भ किया जाता है, जो लूप के प्रत्येक पुनरावृत्ति द्वारा आकार में सिकुड़ जाता है। एक और महत्वपूर्ण विचार यह है कि हम 255एक "प्लेसहोल्डर" को इंगित करने के लिए उपयोग करते हैं जिसे हम टेप पर खोज सकते हैं।
प्रारंभ
यह सबसे आसान कदम है। कार्यक्रम की शुरुआत में, हम निम्नलिखित कार्य करते हैं:
>+>>++++[-<++++++++>]->
यह टेप को निम्न स्थिति में ले जाता है (जहां >N<टेप पर पॉइंटर के स्थान को इंगित करता है)
[ 0 1 32 255 >0< 0 0 ...]
यहां पहला नंबर "बफर" स्थान है। हम इसे लंबे समय के आधार पर उपयोग नहीं करने जा रहे हैं, लेकिन यह थोड़ा संचालन को सरल बनाने और चारों ओर डेटा की प्रतिलिपि बनाने के लिए उपयोगी है।
दूसरी संख्या रिक्त स्थान की संख्या है जिसे हम पहली पंक्ति के बाद शुरू करते हुए, प्रत्येक पंक्ति के शुरू में आउटपुट करेंगे । पहली पंक्ति में कोई अग्रणी स्थान नहीं होगा।
तीसरा नंबर स्पेस कैरेक्टर है जिसे हम आउटपुट करते हैं।
चौथा नंबर एक प्लेसहोल्डर 255 है, जिससे हम अपेक्षाकृत आसानी से इस स्थिति में वापस आ सकते हैं।
इनपुट
इस स्थिति से, हम सभी पात्रों में पढ़ेंगे। इस चरण के अंत में, हम निम्नलिखित स्थिति में होने की उम्मीद करते हैं:
[ 0 1 32 255 a b c d e f ... >255< 0 0 ... ]
जहां a b c d e f ...संख्यात्मक वर्णों की स्ट्रिंग इंगित करती है जो इनपुट थी (न्यूलाइन नहीं)।
हम इसे निम्नलिखित के साथ पूरा करते हैं:
,----------[++++++++++.>>++++++++[-<++++<------>>]<.,----------]-
इसके लिए कुछ बारीकियां हैं। सबसे पहले, हम प्रत्येक चरित्र को आउटपुट करेंगे जैसे कि हम उन्हें प्राप्त करते हैं, और उसके बाद एक स्थान का उत्पादन करते हैं। दूसरे, हम टेप पर ASCII मान की प्रतिलिपि नहीं बनाना चाहते, हम वास्तविक संख्यात्मक अंक की प्रतिलिपि बनाना चाहते हैं। तीसरा, हम उस समय रुकना चाहते हैं जब हम एक नई लाइन मारते हैं और उस समय अपने आप को एक अच्छी जगह पर छोड़ देते हैं।
कहो हमारे इनपुट है 6723। फिर, पहला पढ़ने पर 6, हमारा टेप इस तरह दिखता है:
[ 0 1 32 255 >54< 0 0 ...]
हम जांचते हैं कि यह मान 10(ASCII की नई रेखा) के बराबर नहीं है ,----------[++++++++++। हम तब मूल्य का प्रिंट आउट लेते हैं और एक साथ 48 इनपुट मूल्य से घटाकर जारी रखते हैं और 32 को इसके आगे के मान में जोड़ते हैं ( >>++++++++[-<++++<------>>]<), यहाँ छोड़ रहे हैं:
[ 0 1 32 255 6 >32< 0 ...]
सूचना कैसे इस प्रक्रिया के दौरान हम यह मान सकते हैं कि हमारे इनपुट के अधिकार के लिए सभी अंक 0 होती है - इसका अर्थ यह है कि हम किसी भी पहले वाली स्थिति को बर्बाद कर के खतरे में नहीं कर रहे हैं अगर हम गणना करने के लिए सही करने के लिए मूल्यों का उपयोग 6 * 8और 4 * 8।
अब हम अपने द्वारा उत्पन्न अंतरिक्ष वर्ण को आउटपुट करते हैं, और हमारे द्वारा गणना किए गए स्थान को हटाते हुए एक नया इनपुट लेते हैं। आखिरकार, इनपुट को एक नई लाइन द्वारा समाप्त कर दिया जाएगा और लूप बाहर निकल जाएगा, 255जहां एक नई लाइन ( ,----------]-) होगी। यह दूसरा प्लेसहोल्डर चरित्र है जिसका उपयोग हम टेप को नेविगेट करने के लिए करेंगे। हमारे परिदृश्य में इस बिंदु पर, हमारा टेप बिल्कुल यही है:
[ 0 1 32 255 6 7 2 3 >255< 0 0 ... ]
गणना
जिस तरह से यह काम करता है वह यह है कि हमारे 255प्लेसहोल्डर्स के बीच अंकों की सूची लूप के प्रत्येक पुनरावृत्ति द्वारा सिकुड़ने वाली है। जब इसमें केवल 1 अंक बचा होता है, तो हम कर लेते हैं और इसे तुरंत रोक देना चाहिए (ध्यान दें कि, इस बिंदु पर, उस सूची का प्रत्येक अंक पहले ही आउटपुट हो चुका है, इसलिए हमें इसे फिर से आउटपुट करने के बारे में चिंता करने की आवश्यकता नहीं है)।
अब हम इस ट्रिक का उपयोग पहले 255प्लेसहोल्डर पर नेविगेट करने के लिए करते हैं <+[-<+]-:। यह प्रभावी रूप से बाईं ओर टेप को खोजता है 255, बीच में कुछ भी नहीं बदल रहा है। अब जब हमने पॉइंटर को स्थानांतरित कर दिया है, तो हम अपनी निकास स्थिति की जांच कर सकते हैं: यदि सूची में केवल एक अंक है, तो दाईं ओर सेल दो स्थान धारण करेगा 255। इस प्रकार, हम उसके खिलाफ जांच करते हैं और एक लूप शुरू करते हैं:>>+[-<<
हमारे लूप में पहला कदम एक नई पंक्ति का उत्पादन करना है। इसलिए हम पहली सेल (हमारे बफर सेल) में जाते हैं, इसमें 10 और आउटपुट जोड़ते हैं। अगला कदम सभी प्रमुख अंतरिक्ष पात्रों का उत्पादन करना है। उन्हें आउटपुट करने के बाद, हम अग्रणी स्थानों की संख्या के लिए हमारी गिनती बढ़ाते हैं। इन चरणों को निम्नलिखित द्वारा पूरा किया जाता है:
-<<<<<++++++++++.[-]>[-<+>>.<]<[->+<]>+>>>
जो हमें इस अवस्था में छोड़ देता है:
[ 0 2 32 255 >6< 7 2 3 255 0 0 0 0 0 0 ]
हमारा अगला कदम सूची में पहले मूल्य को दूसरे प्लेसहोल्डर को कॉपी करना है 255:
[[->+]->>+<<<+[-<+]->]
हम अनिवार्य रूप से हमारे प्लेसहोल्डर के बीच आगे और पीछे हटते हुए ऐसा करते हैं 255, हमें यहाँ छोड़ते हुए:
[ 0 2 32 255 >0< 7 2 3 255 0 6 0 0 ... ]
अब हम एक लूप शुरू करते हैं, बाकी सूची के माध्यम से पुनरावृत्ति करते हुए, जब हम टकराते हैं तो रुक जाते हैं 255:>+[-<
इस बिंदु पर, हमारी तत्काल बाईं ओर का अंक हमेशा 0. होता है, क्योंकि हम उनसे प्यार करते हैं, हम एक प्लेसहोल्डर 255को वहां पॉप करते हैं ताकि हम सूची में अपने स्थान पर वापस आ सकें। अगला चरण सूची के दूसरे स्थान को उन स्थानों पर ले जाना है, जहां हम पहले स्थान पर चले गए, दूसरे स्थान पर रहने वाले से पहले 255। इन चरणों को निम्नलिखित द्वारा पूरा किया जाता है:
->
[[->+]->+>>+<<<<+[-<+]->]
हमें यहाँ छोड़कर: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ]
अब, दोनों 6और 7एक स्थान जहां गणना हो सकता है के लिए ले जाया गया है। हमें दो प्रतियों की आवश्यकता है 7क्योंकि सूची में अगले नंबर को भी इसकी आवश्यकता होगी। 7के तुरंत बाद 255इस उद्देश्य में कार्य करता है, जबकि अन्य 7गणना के द्वारा भस्म हो जाएगा।
सबसे पहले, हम दो अंक जोड़ते हैं:
<+>->+[->+]->>
[->+<]>
हमें यहां छोड़कर:
[ 0 2 32 255 0 255 2 3 255 7 0 >13< 0 ]
चरणों का अगला संयोजन सबसे जटिल है। हमें यह देखने की आवश्यकता है कि क्या हम जिस संख्या को इंगित कर रहे हैं वह 10 से बड़ा है, और यदि यह है, तो हम घटाते हैं 10। वास्तव में, हम जो करते हैं, हम उससे 10 घटाते हैं और देखते हैं कि क्या वह 0घटाव के किसी भी बिंदु पर हिट करता है। यदि ऐसा होता है, तो हम 10बाद में वापस जोड़ते हैं । इसके अंत में, हमारे पास 10 का योग होना चाहिए।
Prepare a 10 to the right
+>++++++++++
Leave yet another 255 for a loop condition later
>>-<<
If the number is greater than 10 end up one space to the left
else one space to the right
[-<-[>>]<]<->
Check if the previous 255 is two spaces to the right and if it is
add 10 back to our sum--we've subtracted too much
>>+[-<<<+>>>[-<->]<+++++++++>>>+]
इस बिंदु पर, हमने लक्ष्य पूरा कर लिया है। हमारे पास राशि है modulo 10! इसके अलावा, संख्या 10 से अधिक थी या नहीं, हम यहाँ समाप्त करेंगे:
[ 0 2 32 255 0 255 2 3 255 7 0 3 0 0 >0< ]
हमारा अगला लक्ष्य इस नई राशि का उत्पादन करना है, इसे एक स्थान के साथ पालन करें, और इसे हमारी सूची में वापस इंजेक्ट करें। हम यह सब हमारी पिछली तकनीकों के साथ करते हैं 255-हॉटिंग और 48हमारी राशि को जोड़ने के लिए, इसलिए मैं इसे विस्तार से कवर नहीं करूंगा।
++++++++[-<++++<++++++>>]
<<<[-<<<<+[-<+]-<+>>+[->+]->>>>+<]
>.>.
और हम यहां हैं: [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ]
ध्यान दें कि हमने 255अपने नव-इंजेक्शन के बाद एक अतिरिक्त प्लेसहोल्डर कैसे रखा 3ताकि हम सूची में जगह न खोएं। इस बिंदु पर, हमारे पास हमारी राशि और उसका स्थान है, इसलिए हमें उस स्थिति को साफ करने और वापस लाने की आवश्यकता है जहां इस लूप का अगला पुनरावृत्ति काम करने वाला है। हमें अपने 51और 32कक्षों को खाली करने की आवश्यकता है , 7एक बार दाईं ओर ले जाएं, और हमारे सूची प्लेसहोल्डर पर नेविगेट करें ताकि हम शुरू कर सकें।
[-]<[-]<<<[->+<]<<+[-<+]
अब, हम यहाँ हैं: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
जो कि ठीक उसी जगह पर है जहाँ हम अपनी अगली यात्रा के लिए बनना चाहते हैं। तो 255 के लिए जाँच करें और आगे बढ़ें! ( >+])
जब हम लूप से दूर हो जाते हैं, तो हम एक पूरी नई सूची बनाने जा रहे हैं - पिछली सूची से रकम से बना। पहली बार, यह इस तरह दिखेगा:
[ 0 2 32 255 3 9 5 0 >0< ]
अब हम अपनी नई सूची में उस पूरी प्रक्रिया को दोहराना चाहते हैं, इसलिए हम 255बाईं ओर नीचे की ओर झुकते हैं और सब कुछ शुरू करते हैं! हमें थोड़ा सा सफाई करने की आवश्यकता है >>[-]<<, और फिर अपने प्लेसहोल्डर को साथ छोड़ दें <-। उसके बाद, हम बिलकुल उसी स्थान पर हैं, जैसा कि हम इनपुट के बाद थे, इसलिए हम एक ही चेक करने से दूर हो सकते हैं: <+[-<+]->>+और बूम! हमें अपना पूरा लूप मिल गया है! हमें बस समापन ब्रैकेट की आवश्यकता होती है, और जब यह समाप्त होता है तो हमने पहले ही सब कुछ आउटपुट कर दिया है, इसलिए हम कर रहे हैं ]:।
