รหัส BrainFuck ที่ดีที่สุด (ในแง่ของขนาดรหัส) ในการพิมพ์ 'A' 1,000 ครั้งคือเท่าไหร่

แนวทางของฉันคือ

• ตั้ง 'A' เป็น p [0]
• ตั้งค่า 255 เป็น p [1] เพื่อแสดง 255 'A', 3 ครั้ง
• ตั้งค่า 235 เป็น p [1] เพื่อแสดง 235 'A'

มันไม่ได้มีประสิทธิภาพ แต่ฉันไม่สามารถหาวิธีใช้ตัวนับพ่วงพร้อมกันเช่นการคูณ

มีวิธีที่ดีกว่าการคูณหรือไม่

คำถามทั่วไปเพิ่มเติม: มีกฎในการคูณด้วยจำนวนมากด้วยรหัสที่เล็กที่สุดหรือไม่

วิธีที่คุณใช้อยู่ในปัจจุบันคือ 39 ไบต์:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](ไม่รวมการรับA) ( ลองออนไลน์! )

(วน 3 ครั้งในแต่ละครั้งตั้งค่าตัวนับเป็น 255 และพิมพ์หลาย ๆ ครั้งจากนั้นลบ 20, ลบ 1 และพิมพ์หลายครั้ง)

อย่างไรก็ตามมันสั้นกว่ามากที่จะวนซ้ำ 250 ครั้งและพิมพ์ 4 ครั้งในแต่ละครั้ง (ขอบคุณ jimmy23013 สำหรับการปรับให้เหมาะสมกับลูป -4 ลูป -250-print-1 solution เดิมของฉัน):

>------[<....>-] (16 ไบต์)

หากเซลล์ของคุณไม่ได้ จำกัด (ฉันสมมติว่ามันเป็น 8 บิตมิฉะนั้นคุณอาจจะไม่ลองใช้ 255 เพื่อเล่นกอล์ฟ):

>>++++++++++[<++++++++++[<..........>-]>-] (42 ไบต์)

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
]

วิธีที่สั้นที่สุดในการรับหมายเลข 65 สำหรับ 'A' คือ>+[+[<]>>+<+]>จากนั้นคุณเพียงเพิ่ม HyperNeutrino's >------[<....>-]ไปยังจุดสิ้นสุด ดังนั้นรหัสเต็มกลายเป็น>+[+[<]>>+<+]>>------[<....>-](30 ไบต์)