Todos nós conhecemos, ou pelo menos ouvimos falar, de uma foda cerebral , uma das línguas esotéricas mais famosas e influentes. Enquanto hoje em dia a maioria das implementações usa uma fita infinita, o compilador original de Urban Müller tinha uma fita de 30000 células. Um fato pouco conhecido * é que na verdade existe um valor especial no final da fita, algo que quase nunca é interagido em um programa típico de foda cerebral.

Embora você possa imprimir esse valor com 29999 se >a ., brainfuck é conhecido por suas soluções curtas e concisas, então seu objetivo é imprimir esse valor com o número mínimo de caracteres.

^*ficção

Regras:

• Uma atualização das instruções do cérebro:
  • +/ -: Aumenta / diminui a célula atual, agrupando de 255 a 0 quando 255 é incrementado e vice-versa
  • </ >: Mova o ponteiro para a esquerda / direita na fita
  • .: Imprime o valor da célula atual.
  • [: Pule para o correspondente ]se o valor na célula for 0
  • ]: Pule para o correspondente [se o valor na célula não for 0
• Nesse caso ,(Get input) não faz nada, pois o compilador original deixa a célula inalterada no EOF, e esse programa não deve receber entrada.
• A fita é inicialmente preenchida com todos os 0s, exceto a célula 30000, que contém um valor desconhecido
• O ponteiro começa na célula 1 e deve terminar na célula 30000, depois de impressa.
• As células à esquerda de 1 e à direita de 30000 têm um comportamento indefinido, portanto, as soluções não devem visitar essas células.
• Observe que o valor em 30000 é pode ser um 0, portanto, simplesmente fazer um loop até atingir uma célula diferente de zero não funcionará.
• Você deve imprimir apenas o valor na célula 30000
• A solução mais curta vence!
  • O desempatador é o programa mais eficiente (é executado em menos etapas), seguido pelo tempo de envio mais rápido.

Dica: O Esolanging Fruit sugere usar https://copy.sh/brainfuck para testar seu código. As especificações são as descritas neste desafio, e você pode selecionar a abortopção para que seu programa seja interrompido se ficar fora dos limites.

54 bytes

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

119 x 252 = 29988. Loop aninhado direto.

Eu usei essa ferramenta para verificar se o ponteiro para em 29999.

50 bytes

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

Experimente aqui!

A primeira seção ( >+[>+[<]>->+]>-<<) configura a fita como

0*12 121' 0 110

A próxima seção ( [>>-------[[>]+[<]>-]<<-]) itera 121 vezes, acrescentando 249 1s ao final da fita a cada vez. Se você for rápido em matemática, poderá perceber que 121 * 249 resulta em 30129 1s, mas a primeira iteração tem os 110 restantes para lidar e acrescenta ( 110-7) 103 1s à fita, o que significa que existem apenas 29983 1s. A fita final se parece com:

0*12 0' 0 0 1*29983 0 ???

E uma final >>>[>]>.para imprimir o valor.

Alguns outros algoritmos de nota:

• 252 * 119 = 29988 (também 50 bytes)
• 163 * 184 = 29992 (56 bytes)
• 204 * 147 = 29988 (60 bytes)
• 153 * 196 = 29988 (56 bytes)
• 191 * 157 = 29987 (57 bytes)
• 254 * 118 = 29972 (56 bytes)
  • Este é o que eu considero o próximo mais próximo de bater 50, já que os bytes extras estão basicamente apenas viajando a distância extra. Se eu pudesse encontrar um algoritmo que gere 118 e viaje além de 14 células, isso poderia ser superado.

81

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

Isso se move em 150 células 200 vezes.

Isso é muito mais longo do que eu gostaria que fosse, e há um sério obstáculo ao golfe:

Não sei mais por que trabalho.

Isso está repleto de compensações para os que não pagam até o ponto em que alguns deles provavelmente poderiam ser cancelados. Eu adicionei e excluí vários segmentos tanto que não lembro mais por que coloquei certas coisas onde estão (por exemplo, por que a primeira parte inicializa as células da fita em 199 e 151 em vez de 200 e 150?).

De qualquer maneira, aqui está minha versão comentada dessa monstruosidade, na esperança de que eu (ou outra pessoa) os ache úteis:

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

0 0 0 199' 155

[
  n' k 0
  >[
    n k' j
    ->+[[->+<]<]>
    0' n k－1 j＋1 OR
    n 0 0' j＋1
    >>
  ]
  0*k n 0 0 k 0'
  <[-<<+>>]<<<-
  0*k n－1' k
]
>-------[[->+<]>-]>.