1000 बार BrainFuck के साथ 'A' प्रिंट करें

Question

1000 बार 'A' प्रिंट करने के लिए सबसे अच्छा BrainFuck कोड (कोड आकार के संदर्भ में) क्या है?

मेरा दृष्टिकोण है:

• सेट 'ए' से पी [0]
• 255 'पी' को 255 'ए', 3 बार प्रदर्शित करने के लिए सेट करें
• 235 'ए' प्रदर्शित करने के लिए 235 से पी [1] पर सेट करें

यह प्रभावी नहीं है, लेकिन मैं एक साथ गुणा की तरह टो काउंटर्स का उपयोग करने का तरीका नहीं खोज सकता

क्या गुणन की तुलना में बेहतर दृष्टिकोण है?

एक अधिक सामान्य प्रश्न: क्या बड़ी संख्या में सबसे छोटे संभव कोड के साथ गुणा करने का नियम है?

Comments

यह शुरू करने के लिए एक अच्छी जगह है। कोड गोल्फ में आपका स्वागत है! :)

— फ्राईमईएग्गमैन

मुझे लगता है कि आप सिर्फ नेस्टेड लूप का उपयोग करना चाहते हैं, लेकिन मैं BF को अच्छी तरह से नहीं जानता। क्या आपने ब्रेनफक टिप्स देखी हैं ? इसके अलावा शायद ब्रेनफॉक स्थिरांक पर esolangs पृष्ठ यहाँ एक उपयोगी संसाधन होगा।

— जोनाथन एलन

मुझे लगता है कि आपको सबसे अच्छा BrainFuck कोड स्पष्ट करना चाहिए । क्या आप अधिकांश पठनीय, सबसे सुरुचिपूर्ण, कम से कम +वर्णों का उपयोग करके या केवल सर्वोच्च संक्षिप्तता की खोज में हैं?

— जोनाथन फ्रीच

@ जोनाथन एलन: हां, यह इस सवाल का उद्देश्य है: नेस्टेड लूप का उपयोग कैसे करें। यह ASM के पास एक आकर्षक भाषा है, लेकिन मैं कुछ पहलुओं को नहीं समझता

— नेल्सन जी।

क्या मैं BF पर इस संस्करण का उपयोग कर सकता हूं -> github.com/gergoerdi/brainfuck64

— Shaun Bebbers

Answer 1

वर्तमान में आप जिस विधि का उपयोग कर रहे हैं वह 39 बाइट्स है:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](नहीं मिल रहा है A) ( यह ऑनलाइन प्रयास करें! )

(लूप 3 बार, हर बार काउंटर को 255 पर सेट करें और कई बार प्रिंट करें, फिर 20 घटाएं, 1 घटाएं, और कई बार प्रिंट करें)

हालाँकि, यह 250 बार लूप करने के लिए बहुत छोटा है और हर बार 4 बार प्रिंट होता है (मेरे मूल लूप -4 लूप -250 प्रिंट -1 समाधान पर इस अनुकूलन के लिए धन्यवाद jimmy23013):

>------[<....>-] (16 बाइट्स)

यदि आपकी कोशिकाएँ अनबाउंड हैं (मैं मान रहा हूँ कि वे 8-बिट हैं अन्यथा आप शायद गोल्फ के लिए 255 का उपयोग करने की कोशिश नहीं करेंगे):

>>++++++++++[<++++++++++[<..........>-]>-] (42 बाइट्स)।

Comments

यह 8-बिट कोशिकाओं को लगता है, हालांकि ...

— जॉन ड्वोरक

@ जॉनडॉवरक: ओपी के बारे में सबसे प्रभावी समाधान के एक हिस्से के रूप में सवाल सेटिंग सेल 255 तक पहुंच सकता है। यह 8-बिट सेल रैपिंग का उपयोग करते हुए (एब) के एक बहुत स्पष्ट संकेत की तरह लगता है।

— randomdude999

@JohnDvorak क्या randomdude999 ने कहा, लेकिन मैंने 10x10x10 का उपयोग करते हुए एक विधि जोड़ दी, यदि कोशिकाएं अनबाउंड हैं।

— हाइपरएनुट्रीनो

250 गुना ....कम होगा।

— jimmy23013

@ jimmy23013 ... मुझे यकीन नहीं है कि मैंने ऐसा नहीं सोचा था कि अभी भी उस LOL को करने के लिए मेरे 10x10x10 समाधान को अनुकूलित किया गया है। धन्यवाद!

— हाइपरनेत्रिनो

Answer 2

47 बाइट्स (कोई कम नहीं)

मैंने यह समाधान केवल 47 बाइट्स में किया था। मैंने इसे दो अलग-अलग तरीकों से करने की कोशिश की, क्योंकि मैं सामान्य रूप से दो मूल्यों के बीच काउंटरों की बाजीगरी करके अंतरिक्ष को बचाने की कोशिश कर रहा था। यह मानता है कि A को p [4] में पहले से लोड किया गया है।

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

व्याख्या की

Place 5 into p[0]
+++++
Loop 5 times to put p[1]=20, p[2]=25
[>++++>+++++<<-]>
Loop 20 times
[>
Move pointer to p[2] and loop 25 times.
Also move p[2] to p[3]

[
Increment p[3] from 0, effectively moving the value from p[2] to p[3]
>+
Print p[4]
>.
Decrement p[2]
<<-]
Shift over to p[3]
>
[
Decrement p[3]
->
Print p[4]
.<
Increment p[2]
<+>]
Move back to p[1] and decrement
<<-
Repeat until p[1] is 0
]

Answer 3

'ए' के ​​लिए नंबर 65 पाने का सबसे छोटा तरीका है >+[+[<]>>+<+]>, और उसके बाद आप हाइपरन्यूट्रिनो >------[<....>-]को उसमें जोड़ सकते हैं । इसलिए पूर्ण कोड बन जाता है >+[+[<]>>+<+]>>------[<....>-](30 बाइट्स)

Comments

आप कैसे जानते हैं कि रास्ता सबसे छोटा है? यह निश्चित रूप से छोटा है, लेकिन क्या आप कुछ के लिए जानते हैं कि कोई भी एक छोटा नहीं मिलेगा?

— तदर्थ गार्फ हंटर

28:>+[+[<]>>+<+]------[>....<-]

— jimmy23013

@ SriotchilismO'Zaic हाँ, मेरा वास्तव में मतलब यह नहीं था कि यह सबसे छोटा लोल था

— धनु