Problema de loop Brainf * ck

19

Tenho um problema para um cyber clube que solicita que você imprima:

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

Usando Brainf ** k em 29 bytes ou menos sem usar o caractere ','.

Eu tenho um código de trabalho:

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

No entanto, meu loop é muito longo, enviando-me 16 bytes acima do limite.

Existe uma maneira mais eficiente de definir a segunda e a terceira célula para 58 e 90 para que eu possa executar meu segundo loop? Ou existe uma maneira melhor de fazer isso tudo junto que eu simplesmente não estou vendo?

code-golf tips brainfuck Nick Rod
fonte
11
Quanto à sua pergunta, embora ela salve apenas quatro bytes, na verdade é melhor gerar 59 e 90 e alterar -.para .-, descartando >.<.
Martin Ender
Eu tenho +[--->++<]>++++[.-]para 19 bytes, mas ele imprime os caracteres de controlo, bem ...
Timtech
@MartinEnder Sim, desculpe-me por isso, vi seu comentário no outro post e encontrei esse grupo que parecia muito mais apropriado, vou excluir o do SO, pois ele não gerou muitas respostas.
Nick Rod
2
Sinceramente, estou curioso sobre o que é esse "clube cibernético", porque garoto, eles devem ter bons jogadores de golfe!
Sp3000 28/08/16

Respostas:

23

27 24 bytes

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

Passei um dia inteiro basicamente escrevendo um forçador bruto e vendo os resultados chegarem. Agora posso voltar a fazer algum trabalho real ... Outro dia de forçar bruto mais tarde ...

Experimente online!

O componente ++[<++[++<]>>>+]inicializa a fita para

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

o que é perfeito para o que precisamos!

Sp3000
fonte
8
Magia. (∩｀-´) ⊃━ ☆ ﾟ. * ･｡ ﾟ
primo
@primo Para ser justo eu não tenho idéia o que está acontecendo estrutura-wise no primeiro semestre, e eu acho que o fato de que você é capaz de chegar com seus próprios algoritmos / técnicas é incrível :)
SP3000
Fita no final de cada loop: codepad.org/ZoJUlQ8M . Não é de todo intuitivo que ele termine com os valores que possui, ou mesmo de forma alguma;);
primo
11
Uma alternativa 24:+[[>++<<]>->+>+]<[-<-.>]
primo
15

30 bytes

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

Experimente online!

85 e 171 são bastante fáceis de gerar no cérebro (inversos modulares de 3 e -3 ). 85 está bem próximo de 90 e 171 está bem próximo de 177 ( 59 · 3 ), que é usado aqui. Com um pouco de hackery, sou capaz de produzir 88 e 176 .

Ainda um byte abaixo do alvo, no entanto.

Outras sugestões

Em geral, é mais curto para iterar sobre uma lista, multiplicando por uma constante, e não o contrário. Isto é especialmente verdade para 3 ou mais valores. Por exemplo, isto:

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

pode ser escrito como:

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

Havia apenas dois valores internos, portanto, não há muita melhoria neste caso. De fato, apenas a refatoração é um byte mais curto:

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

Multiplicando 30 por 2 e 3 , em vez de 10 por 6 e 9 . Com a sugestão de Martin Büttner, isso já está reduzido a 38 bytes, sem muita alteração no original:

+++++[>++++++[>++>+++<<-]<-]>>-[>.-<-]
primo
fonte
Eu nunca teria pensado em multiplicar o 58 e iterar por um número maior, isso é muito mais eficiente.
Nick Rod
4

34 bytes

Você economizou 11 bytes, mas ainda assim 5 bytes ...

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

Já passei horas, espero que alguém possa melhorar isso.

Timtech
fonte