Brainfuck - दशमलव प्रारूप आउटपुट

ब्रेनफैक पर कार्यान्वयन के लिए पहला कार्य के रूप में, मैंने दशमलव प्रारूप में टेप पर लिखे 4-बाइट नंबर को प्रिंट करने के लिए एक उचित सरल व्यायाम लेने का फैसला किया। यह कार्य दिलचस्प निकला, खासकर जब आप समझते हैं कि कोड को डुप्लिकेट करने के लिए (और उपयोग करें कि संख्या बिल्कुल 4 बाइट्स है) मैं जितना संभव हो उतना कम उपयोग करना चाहता था, और छोरों का अधिक उपयोग करना चाहता था।



यह तुरंत स्पष्ट हो गया कि दो अलग-अलग दृष्टिकोण हैं - या तो मूल संख्या को 10 से शेष के साथ विभाजित करने का प्रयास करें, और परिणामी शेष से अंक बनाएं, या एक दशमलव संख्या को 2 से गुणा करके और यदि आवश्यक हो तो एक जोड़ दें। दूसरे विकल्प के साथ खेलने के बाद, और पता चला कि बिट्स गलत क्रम में आते हैं, मैं पहले विकल्प पर लौट आया।







दो समस्याएं थीं - पहला: अग्रणी शून्य से बचने के लिए, दूसरा: 10. "संख्या" के शेष भाग के साथ विभाजन को लिखने के लिए 10. दूसरा कार्य, जाहिर है, 2560 से कम दो-बाइट संख्या को विभाजित करने के लिए नीचे आता है ... लेकिन हम सीधे कार्यक्रम में जाएंगे।



पहला इनपुट। सिद्धांत रूप में, इसकी आवश्यकता नहीं है (धारणा से, संख्या पहले से ही टेप पर दर्ज की गई है), लेकिन हमें किसी तरह इसे डिबग करना होगा



,>,>,>, <<<



स्रोत डेटा के अनुसार चक्र का उपयोग करने में सक्षम होने के लिए, हम अतिरिक्त मार्कअप पेश करते हैं



<+>

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

[- >> + <<] <

[-> + <]

+ >> + >> +



इकाइयाँ मूल संख्या के बाइट और बाईं बाइट के बाईं ओर के बीच होती हैं। गाड़ी सबसे सही इकाई (दो कम बाइट्स के बीच) पर है। हम मुख्य चक्र शुरू करते हैं। अब से, स्रोत डेटा की लंबाई कहीं भी उपयोग नहीं की जाती है।



सबसे पहले, संख्या की शुरुआत का पता लगाएं



[[<<] >>



अब हम प्रत्येक अंक को 4 कोशिकाओं द्वारा बाईं ओर स्थानांतरित करेंगे, और मुक्त स्थान में, पिछली शेष संख्या और नए अंक को 10 से विभाजित करें।



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

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

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



यहां हम इस तथ्य का उपयोग करते हैं कि (* * 256 + b) / 10 = ((* * 255 + b) + a) / 10, और कहा कि <10।



भागफल और शेष पाए जाने के बाद, यह जांचना आवश्यक है कि अग्रणी शून्य निकला है या नहीं। यदि यह पता चला, तो हमने पाया और अगले बाइट्स के बीच "1" चिह्न नहीं लगाया है।



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

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

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



जब संख्या समाप्त हो जाती है, तो शेष शेष राशि एक नई संख्या होती है। इसे आउटपुट लाइन पर दें।



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



और हम इस कदम पर पाए गए निजी के अंकों को 3 बाइट्स द्वारा दाईं ओर स्थानांतरित करते हैं (ताकि वे आउटपुट लाइन से सही दूरी पर हों)



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



यदि यह पता चला कि कोई निजी नहीं है, तो चक्र समाप्त हो गया है - और आप लाइन प्रदर्शित कर सकते हैं



> [।>] +++++++++++++++-----।



वह सब है।



यह किसी भी तरह से बोझिल हो गया - शायद, मुझे अभी भी कई अवसर नहीं दिख रहे हैं।



शायद दोहरीकरण विकल्प बेहतर होगा - लेकिन उसके लिए, मूल अंकों को विभाजित नहीं किया जाना चाहिए, और 2 से गुणा किया जाना चाहिए, और कैरी बिट के साथ काम करना चाहिए। मुझे कोशिश करनी होगी। लेकिन यह विकल्प तभी काम करेगा जब "बाइट" राज्यों की संख्या दो की शक्ति हो (यह तथ्य उपरोक्त कोड में उपयोग नहीं किया गया है, यह कार्यक्रम 10 से अधिक राज्यों की संख्या के साथ काम करेगा)।