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

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

Problema de loop Brainf * ck

27 24 bytes

30 bytes

34 bytes