Stampa "A" 1000 volte con BrainFuck

Qual è il miglior codice BrainFuck (in termini di dimensioni del codice) per stampare 'A' 1000 volte?

Il mio approccio è:

imposta 'A' su p [0]
impostare 255 su p [1] per visualizzare 255 'A', 3 volte
impostare 235 su p [1] per visualizzare 235 'A'

Questo non è efficace ma non riesco a trovare un modo per utilizzare contemporaneamente i contatori di rimorchi come una moltiplicazione

Esiste un approccio migliore di una moltiplicazione?

Una domanda più generale: esiste una regola per effettuare una moltiplicazione con un numero elevato con il codice più piccolo possibile?

code-golf tips brainfuck

— Nelson G.
fonte

Questo è un buon punto di partenza. Benvenuto in Code golf! :)

— FryAmTheEggman,

Penso che tu voglia usare solo un loop nidificato, ma non conosco molto bene BF. Hai visto i suggerimenti di Brainfuck ? Anche probabilmente la pagina degli esolang sulle costanti di Brainfuck sarebbe una risorsa utile qui.

— Jonathan Allan,

Penso che dovresti chiarire il miglior codice BrainFuck . Sei alla ricerca del più leggibile, più elegante, usando il minor numero di +caratteri o semplicemente la massima brevità?

— Jonathan Frech,

@Jonathan Allan: Sì, questo è lo scopo di questa domanda: come utilizzare un ciclo nidificato. È un linguaggio affascinante vicino ASM ma non capisco alcuni aspetti

— Nelson G.

Potrei usare questa variante su BF -> github.com/gergoerdi/brainfuck64

— Shaun Bebbers

Risposte:

Il metodo che attualmente stai utilizzando è di 39 byte:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](escluso il recupero del A) ( Provalo online! )

(ripetere 3 volte, impostare ogni volta il contatore su 255 e stamparlo più volte, quindi sottrarre 20, sottrarre 1 e stamparlo più volte)

Tuttavia, è molto più breve eseguire il ciclo 250 volte e stampare 4 volte ogni volta (grazie a jimmy23013 per averlo ottimizzato sulla mia soluzione originale loop-4 loop-250 print-1):

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

Se le tue cellule non hanno limiti (suppongo siano a 8 bit, altrimenti probabilmente non proveresti a usare 255 per giocare a golf):

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

— HyperNeutrino
fonte

questo sembra assumere celle a 8 bit, però ...

— John Dvorak,

@JohnDvorak: La domanda menzionava l'impostazione delle celle su 255 come parte della soluzione più efficace a cui l'OP poteva pensare. Sembra un'indicazione abbastanza chiara di (ab) utilizzando il wrapping delle celle a 8 bit.

— randomdude999,

@JohnDvorak Cosa ha detto randomdude999, ma ho aggiunto un metodo usando 10x10x10 nel caso in cui le celle siano illimitate.

— HyperNeutrino,

250 volte ....sarebbe più breve.

— jimmy23013,

@ jimmy23013 ... non sono sicuro di come non abbia pensato a una soluzione 10x10x10 ancora ottimizzata per farlo LOL. Grazie!

— HyperNeutrino,

47 byte (nessun underflow)

Ho appena fatto questa soluzione in 47 byte. Ho provato a farlo in un modo diverso da quello che normalmente proverei a risparmiare spazio manipolando i contatori tra due valori. Presuppone che A sia precaricato in p [4].

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

spiegato

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
fonte

il modo più breve per ottenere il numero 65 per "A" è >+[+[<]>>+<+]>, quindi aggiungi HyperNeutrino >------[<....>-]alla fine. così il codice completo diventa >+[+[<]>>+<+]>>------[<....>-](30 byte)

— Sagittario
fonte

Come fai a sapere che il modo più breve? È certamente più breve, ma sai per certo che nessuno ne troverà uno più corto?

— Ad Hoc Garf Hunter l'

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

— jimmy23013

@ SriotchilismO'Zaic sì, non intendevo davvero che fosse il lol più corto

— Sagittario