Seu desafio é reduzir o código Brainfuck , de acordo com estas regras:
- Remova qualquer coisa que não seja uma
+-><[].,
. - Para qualquer grupo de consecutivo
+
ou-
caracteres, se a quantidade de+
s e-
s é o mesmo, removê-los. - Faça o mesmo que acima, mas com
>
e<
. - Remova as seqüências dos
+-><
caracteres se eles não fizerem nada. Por exemplo, você deve remover+>-<->+<
. (Esse pode ser o mais difícil e difícil de implementar.) Certifique-se de que não obtém nenhum falso positivo, como+>-<+>-<
, que não deve ser removido.
Casos de teste:
Entrada
++++++[->++++++<]>. prints a $
[-]< resets tape
>,[>,]<[.<] reverses NUL terminated input string
++-->><< does nothing
Saída
++++++[->++++++<]>.[-],[>,]<[.<]
Entrada
Should disappear: ++>>+<+++<->-->-<<->-<
Should disappear: +++>-<--->+<
Should stay: +++>-<+>---<
Saída
+++>-<+>---<
Você pode aceitar entrada e saída como desejar - stdin / stdout, uma função etc., mas a entrada pode não ser codificada.
Isso é código-golfe , então o código mais curto na contagem de caracteres vencerá.
++>>++<<--
deve sair>>++<<
, e isso não foi coberto. Por favor, adicione mais casos de teste.+++>-<+>---<
? Ele pode ser reduzido para evitar movimentos desnecessários do ponteiro, mas a saída esperada o mantém inalterado. Meu entendimento, baseado em olhar tanto para a pergunta quanto para as respostas, é que a maçaneta da porta é legal com a especificação sendo tomada livremente; devemos eliminar quaisquer+-><
sequências contíguas no-op , conforme explicitamente declaradas, e além disso é permitido realizar minificação extra como no seu exemplo++>>++<<--
, e também podemos fazer rearranjos, desde que não alterem a funcionalidade do código, por exemplo,>+<+
em+>+<
.+>-<->+<
. (Este pode ser o mais difícil e difícil de implementar.) Verifique se você não obteve nenhum falso positivo, como+>-<+>-<
, por exemplo, que não deve ser removido ". - isso é meio vago #Respostas:
REBEL - 104
Uso:
Entrada: Lê uma linha de stdin.
Saída: imprime uma linha no stdout.
Anomalias *:
_
faz com que outra linha seja lida e usada, em vez de não produzir nada.++++>----<
vez de+++>-<+>---<
. Mas tudo bem, certo? ;)>-<+
etc. são substituídos por+>-<
etc.Spoiler:
* Isto não é um erro, é um recurso!
fonte
Brainfuck, 579 bytes
Com formatação e alguns comentários:
Isso usa a mesma abordagem da solução de Keith Randall, minimizando todas as seqüências contíguas de maneira
+-<>
ideal por simulação. Por exemplo,+++>-<+>---<
torna++++>----<
->+<+<<+>+<->>>>
se e torna - se+<+>>+>
.Experimente online. (Se o valor absoluto de uma célula simulada chegar perto de 256, haverá problemas de estouro.)
A estrutura geral é
A fita é dividida em nós de 7 células; no início do loop interno, o layout da memória é
0 s 0 c 0 a b
onde
s
é um sinalizador booleano para a célula inicial,c
é o caractere atual,a
é a parte negativa do valor da célula simulada (mais um) eb
é a parte positiva do valor da célula simulada.Quando a sequência minificada está sendo impressa, o layout da memória é
d n e 0 0 a b
onde
d
é um sinalizador booleano para a direçãoa
eb
é como antes (mas se torna um / zero quando impresso)n
ee
é apenas diferente de zero para o nó final;n
está relacionado a quantas vezes o nó foi visto ee
é o valor do caractere que interrompeu o loop interno (mais um).Originalmente, considerei acompanhar mais informações por nó: nó mais à esquerda e mais à direita como sinalizadores booleanos e posição do nó em relação aos nós inicial e final. Mas podemos evitar isso observando as células vizinhas quando necessário e fazendo verificações à esquerda e à direita para encontrar o nó inicial.
Ao imprimir a sequência reduzida e decidir como mover o ponteiro simulado, podemos adotar uma abordagem geral: comece afastando-se do nó final (em uma direção arbitrária se os nós inicial e final forem iguais), vire à esquerda e à direita nós e pare com base no número de vezes que o nó final foi visto: 3 vezes se os nós inicial e final forem os mesmos; caso contrário, 2.
fonte
Python, 404 caracteres
Este código faz uma otimização perfeita de todas as subsequências de
+-<>
. Um pouco mais do que você pediu, mas lá está.Funciona simulando as
+-<>
operações na fitat
.s
é a posição inicial na fita ep
é a posição atual. Após a simulação, ele calcula a extensão[a,b]
que precisa ser operada e faz todo o +/- em uma passagem ideal.fonte
CoffeeScript -
403397Demonstração (perdoe o uso de bit.ly aqui, todo o URL quebraria a margem)
Versão não compactada (com código de depuração):
fonte
>+.-<
, produzindo a cadeia vazia em vez de deixá-la inalterada.