Drukuj „A” 1000 razy dzięki BrainFuck

Jaki jest najlepszy kod BrainFuck (pod względem wielkości kodu), aby wydrukować „A” 1000 razy?

Moje podejście to:

ustaw „A” na p [0]
ustaw 255 na p [1], aby wyświetlić 255 'A', 3 razy
ustaw 235 na p [1], aby wyświetlić 235 „A”

To nie jest skuteczne, ale nie mogę znaleźć sposobu na jednoczesne używanie liczników holowania, jak na mnożeniu

Czy istnieje lepsze podejście niż pomnożenie?

Bardziej ogólne pytanie: czy istnieje zasada mnożenia przez dużą liczbę najmniejszym możliwym kodem?

code-golf tips brainfuck

— Nelson G.
źródło

To dobre miejsce na początek. Witamy w Code golf! :)

— FryAmTheEggman

Myślę, że chcesz po prostu użyć zagnieżdżonej pętli, ale nie znam BF zbyt dobrze. Czy widziałeś wskazówki Brainfuck ? Również prawdopodobnie strona esolangs na temat stałych Brainfuck byłaby tu przydatnym zasobem.

— Jonathan Allan

Myślę, że powinieneś wyjaśnić najlepszy kod BrainFuck . Czy szukasz najbardziej czytelnych, najbardziej eleganckich, wykorzystujących najmniej +znaków lub po prostu najwyższą zwięzłość?

— Jonathan Frech

@Jonathan Allan: Tak, taki jest cel tego pytania: jak używać zagnieżdżonej pętli. To fascynujący język bliski ASM, ale nie rozumiem niektórych aspektów

— Nelson G.

Czy mogę użyć tego wariantu na BF -> github.com/gergoerdi/brainfuck64

— Shaun Bebbers

Odpowiedzi:

Metoda, której obecnie używasz, to 39 bajtów:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](nie w tym uzyskanie A) ( Wypróbuj online! )

(zapętl 3 razy, za każdym razem ustaw licznik na 255 i wydrukuj tyle razy, a następnie odejmij 20, odejmij 1 i wydrukuj tyle razy)

Jednak znacznie krótsza jest pętla 250 razy i drukowanie 4 razy za każdym razem (dzięki jimmy23013 za optymalizację tego w porównaniu z moim oryginalnym rozwiązaniem loop-4 loop-250 print-1):

>------[<....>-] (16 bajtów)

Jeśli twoje komórki są niezwiązane (zakładam, że są 8-bitowe, inaczej prawdopodobnie nie spróbowałbyś użyć 255 do gry w golfa):

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

— HyperNeutrino
źródło

wydaje się, że zakłada to 8-bitowe komórki ...

— John Dvorak

@JohnDvorak: Pytanie dotyczyło ustawienia komórek na 255 jako część najbardziej skutecznego rozwiązania, o jakim OP mógłby myśleć. To wydaje się dość wyraźnym wskazaniem (ab) przy użyciu 8-bitowego zawijania komórek.

— randomdude999

@JohnDvorak Co powiedział randomdude999, ale dodałem metodę przy użyciu 10x10x10 na wypadek, gdyby komórki były niezwiązane.

— HyperNeutrino

250 razy ....byłoby krótsze.

— jimmy23013

@ jimmy23013 ... nie jestem pewien, jak o tym nie pomyślałem, a mimo to zoptymalizowałem moje rozwiązanie 10x10x10 do tego LOL. dzięki!

— HyperNeutrino

47 bajtów (bez niedomiarów)

Właśnie zrobiłem to rozwiązanie w 47 bajtach. Próbowałem to zrobić w inny sposób niż normalnie próbowałem zaoszczędzić miejsce, żonglując licznikami między dwiema wartościami. Zakłada się, że A jest wstępnie załadowany do p [4].

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

Wyjaśniono

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
]

— Josh Bacon
źródło

najkrótszym sposobem na uzyskanie liczby 65 dla „A” jest >+[+[<]>>+<+]>, a następnie dodajesz HyperNeutrino >------[<....>-]na końcu tego. więc pełny kod staje się >+[+[<]>>+<+]>>------[<....>-](30 bajtów)

— Strzelec
źródło

Skąd wiesz, że ta droga jest najkrótsza? Z pewnością jest krótszy, ale czy na pewno wiesz, że nikt go nie znajdzie?

— Ad Hoc Garf Hunter

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

— jimmy23013,

@ SriotchilismO'Zaic yeah Tak naprawdę nie miałem na myśli, że to najkrótszy lol

— Strzelec