Imprima 'A' 1000 veces con BrainFuck

¿Cuál es el mejor código BrainFuck (en términos de tamaño del código) para imprimir 'A' 1000 veces?

Mi enfoque es:

establezca 'A' en p [0]
ajuste 255 a p [1] para mostrar 255 'A', 3 veces
ajuste 235 a p [1] para mostrar 235 'A'

Esto no es efectivo pero no puedo encontrar una manera de usar contadores de remolque simultáneamente como una multiplicación

¿Hay un mejor enfoque que una multiplicación?

Una pregunta más general: ¿hay una regla para hacer una multiplicación con un número grande con el código más pequeño posible?

code-golf tips brainfuck

— Nelson G.
fuente

Este es un buen lugar para comenzar. ¡Bienvenido a Code golf! :)

— FryAmTheEggman

Creo que solo quieres usar un bucle anidado, pero no conozco muy bien BF. ¿Has visto consejos Brainfuck ? También probablemente la página de esolangs en las constantes de Brainfuck sería un recurso útil aquí.

— Jonathan Allan

Creo que deberías aclarar el mejor código de BrainFuck . ¿Estás buscando el más legible, el más elegante, usando la menor cantidad de +caracteres o simplemente la mayor brevedad?

— Jonathan Frech

@ Jonathan Allan: Sí, ese es el propósito de esta pregunta: cómo usar un bucle anidado. Es un lenguaje fascinante, pero no entiendo algunos aspectos

— Nelson G.

¿Podría usar esta variante en BF -> github.com/gergoerdi/brainfuck64

— Shaun Bebbers

Respuestas:

El método que parece estar usando actualmente es de 39 bytes:

>>+++[<-[-<.>]>-]++++[<----->-]<-[-<.>](sin incluir obtener el A) (¡ Pruébelo en línea! )

(bucle 3 veces, cada vez configure el contador en 255 e imprima tantas veces, luego reste 20, reste 1 e imprima tantas veces)

Sin embargo, es mucho más corto hacer un bucle 250 veces e imprimir 4 veces cada vez (gracias a jimmy23013 por optimizar esto sobre mi solución original loop-4 loop-250 print-1):

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

Si sus celdas no tienen límites (supongo que son de 8 bits, de lo contrario, probablemente no intente usar 255 para jugar al golf):

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

— Hiperneutrino
fuente

Sin embargo, esto parece asumir celdas de 8 bits ...

— John Dvorak

@JohnDvorak: La pregunta mencionó establecer celdas en 255 como parte de la solución más efectiva que el OP podría pensar. Eso parece una indicación bastante clara de (ab) que usa el ajuste de celdas de 8 bits.

— randomdude999

@JohnDvorak Lo que randomdude999 dijo, pero agregué un método usando 10x10x10 en caso de que las celdas no estén acotadas.

— HyperNeutrino

250 veces ....sería más corto.

— jimmy23013

@ jimmy23013 ... no estoy seguro de cómo no pensé en eso, todavía optimicé mi solución 10x10x10 para hacer eso LOL. ¡Gracias!

— HyperNeutrino

47 bytes (sin desbordamientos)

Acabo de hacer esta solución en 47 bytes. Intenté hacerlo de una manera diferente a la que normalmente trataría de ahorrar espacio haciendo malabarismos con los contadores entre dos valores. Se supone que A está precargado en p [4].

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

Explicado

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
fuente

la forma más corta de obtener el número 65 para 'A' es >+[+[<]>>+<+]>, y luego simplemente agrega HyperNeutrino's >------[<....>-]al final de eso. entonces el código completo se convierte >+[+[<]>>+<+]>>------[<....>-](30 bytes)

— Sagitario
fuente

¿Cómo sabes que ese camino es el más corto? Ciertamente es más corto, pero ¿sabe con certeza que nadie encontrará uno más corto?

— Ad Hoc Garf Hunter

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

— jimmy23013

@ SriotchilismO'Zaic sí, realmente no quise decir que era el más corto jajaja

— Sagitario