19

Tengo un problema para un club cibernético que le pide que imprima:

ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!

Usando Brainf ** k en 29 bytes o menos sin usar el carácter ','.

Tengo un código de trabajo:

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

Sin embargo, mi ciclo es demasiado largo, enviándome 16 bytes por encima del límite.

¿Hay una manera más eficiente de configurar la segunda y tercera celda en 58 y 90 para que pueda ejecutar mi segundo ciclo? ¿O hay una mejor manera de hacer esto todos juntos que simplemente no estoy viendo?

code-golf tips brainfuck

— Nick Rod
fuente

1

En cuanto a su pregunta, aunque solo ahorra cuatro bytes, en realidad es mejor generar 59 y 90 y cambiar el -.a .-, soltando el >.<.

— Martin Ender

Tengo +[--->++<]>++++[.-]para 19 bytes pero se imprime los caracteres de control, así ...

— Timtech

@MartinEnder Sí, lo siento, vi tu comentario en la otra publicación y encontré este grupo que parecía mucho más apropiado, eliminaré el que está en SO ya que no generó muchas respuestas.

— Nick Rod

2

Sinceramente, tengo curiosidad por saber qué es este "club cibernético", porque ¡deben tener algunos buenos golfistas!

— Sp3000

23

27 24 bytes

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

~~Pasé un día entero básicamente escribiendo un forzador bruto y viendo los resultados. Ahora puedo volver a hacer un trabajo real ...~~ Otro día de forzamiento bruto más tarde ...

Pruébalo en línea!

El componente ++[<++[++<]>>>+]inicializa la cinta a

[130, 0, 0, 0, 91, 59, 0]
                       ^

¡lo cual es perfecto para lo que necesitamos!

— Sp3000
fuente

8

Hechicería (∩｀-´) ⊃━ ☆ ﾟ. * ･｡ﾟ

— primo

@primo Para ser justos, no tengo idea de lo que está sucediendo en cuanto a estructura en la primera mitad, y creo que el hecho de que puedas crear tus propios algoritmos / técnicas es increíble :)

— Sp3000

Cinta al final de cada ciclo: codepad.org/ZoJUlQ8M . No es del todo intuitivo que terminaría en los valores que lo hace, o incluso en absoluto;)

— primo

1

Una alternativa 24:+[[>++<<]>->+>+]<[-<-.>]

— primo

15

30 bytes

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

Pruébalo en línea!

85 y 171 son bastante fáciles de generar en brainfuck (inversos modulares de 3 y -3 ). 85 está bastante cerca de 90 , y 171 está bastante cerca de 177 ( 59 · 3 ), que se usa aquí. Con un poco de piratería, puedo producir 88 y 176 en su lugar.

Sin embargo, aún queda un byte por debajo del objetivo.

Otras sugerencias

En general, es más corto iterar sobre una lista, multiplicando por una constante, en lugar de lo contrario. Esto es especialmente cierto para 3 o más valores. Por ejemplo, esto:

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

Se puede escribir como:

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

Solo había dos valores internos, por lo que no es una gran mejora en este caso. De hecho, solo refactorizar es un byte más corto:

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

Multiplicar 30 por 2 y 3 , en lugar de 10 por 6 y 9 . Con la sugerencia de Martin Büttner, esto ya se ha reducido a 38 bytes, sin muchos cambios al original:

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

— primo
fuente

Nunca hubiera pensado multiplicar el 58 e iterar por un número mayor, eso es mucho más eficiente.

— Nick Rod

4

34 bytes

Le guardó 11 bytes, pero aún 5 bytes demasiado tiempo ...

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

Ya he pasado horas, espero que alguien pueda mejorar esto.

— Timtech
fuente

Brainf * ck Problema de bucle

27 24 bytes

30 bytes

34 bytes