Mã BrainFuck tốt nhất (về kích thước mã) để in 'A' 1000 lần là gì?

Cách tiếp cận của tôi là:

• đặt 'A' thành p [0]
• đặt 255 thành p [1] để hiển thị 255 'A', 3 lần
• đặt 235 thành p [1] để hiển thị 235 'A'

Điều này không hiệu quả nhưng tôi không thể tìm ra cách sử dụng đồng thời kéo quầy như phép nhân

Có một cách tiếp cận tốt hơn một phép nhân?

Một câu hỏi tổng quát hơn: có quy tắc nào để nhân một số lớn với mã nhỏ nhất có thể không?

Phương thức mà bạn dường như hiện đang sử dụng là 39 byte:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](không bao gồm nhận A) ( Dùng thử trực tuyến! )

(lặp 3 lần, mỗi lần đặt bộ đếm thành 255 và in nhiều lần, sau đó trừ 20, trừ 1 và in nhiều lần)

Tuy nhiên, việc lặp lại 250 lần ngắn hơn và in 4 lần mỗi lần (cảm ơn jimmy23013 vì đã tối ưu hóa điều này qua giải pháp loop-4 loop-250 print-1 ban đầu của tôi):

>------[<....>-] (16 byte)

Nếu các ô của bạn không bị ràng buộc (Tôi giả sử chúng là 8 bit nếu không bạn có thể không thử sử dụng 255 để chơi gôn):

>>++++++++++[<++++++++++[<..........>-]>-] (42 byte).

47 byte (không có dòng chảy)

Tôi chỉ làm giải pháp này trong 47 byte. Tôi đã thử làm nó theo một cách khác với bình thường tôi sẽ cố gắng tiết kiệm không gian bằng cách tung hứng giữa các giá trị. Nó giả định rằng A được tải sẵn vào p [4].

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

Giải thích

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
]

cách ngắn nhất để có được số 65 cho 'A' là >+[+[<]>>+<+]>, và sau đó bạn chỉ cần thêm HyperNeutrino >------[<....>-]vào cuối số đó. vì vậy mã đầy đủ trở thành >+[+[<]>>+<+]>>------[<....>-](30 byte)