Brain-Flak (um cruzamento entre Brainf ** ke Flak-Overstow) é uma linguagem esotérica baseada em pilha. Desde que este desafio foi lançado, o idioma evoluiu e foi atualizado, mas essa primeira revisão do idioma é conhecida como "clássico de quebra-cabeças".
Você deve escrever um programa ou função que use uma sequência de códigos clássicos do Brain-Flak e avaliá-los. Também será necessária uma lista (possivelmente vazia) de números inteiros. Existem entradas para o programa clássico Brain-Flak.
O idioma
Brain-Flak tem duas pilhas, conhecidas como 'esquerda' e 'direita'. A pilha ativa começa à esquerda. Se uma pilha vazia for exibida ou visualizada, ela retornará 0. Não há variáveis. Quando o programa é iniciado, cada entrada é enviada para a pilha ativa em ordem (para que a última entrada fique no topo da pilha).
Os únicos caracteres válidos em um programa Brain-Flak são ()[]{}<>
e sempre devem ser equilibrados . Se houver caracteres inválidos ou os colchetes forem incomparáveis, você terá um comportamento indefinido. Tudo é válido.
Existem dois tipos de funções: Nilads e Mônadas . Um nilad é uma função que recebe 0 argumentos. Aqui estão todas as niladas:
()
+1.[]
-1.{}
Pop a pilha ativa.<>
Alterne a pilha ativa.
Eles são concatenados juntos quando são avaliados. Portanto, se tivéssemos um '3' no topo da pilha ativa, este trecho:
()(){}
avaliaria para 1 + 1 + active.pop()
qual avaliaria 5. <>
avalia para 0.
As mônadas têm um argumento, um pedaço do código Brain-Flak. Aqui estão todas as mônadas:
(n)
Pressione 'n' na pilha ativa.[n]
Imprima 'n' como um int e uma nova linha.{foo}
Enquanto active.peek ()! = 0, faça foo. Avalia para 0¹.<foo>
Execute foo, mas avalie-o como 0.
Essas funções também retornarão o valor dentro delas, portanto
(()()())
Vai empurrar 3 e
[()()()]
Irá imprimir 3, mas
[(()()())]
Imprimirá e empurrará 3.
Quando o programa termina de executar, cada valor deixado na pilha ativa é impresso como um número inteiro, com uma nova linha entre. Valores na outra pilha são ignorados.
Regras:
Seu programa deve suportar números no intervalo (-128, 127) e um tamanho de pilha de pelo menos 255. Se você oferecer suporte a maiores, ótimo.
Subfluxo / estouro é indefinido.
IO de amostra:
O programa vazio:
Entrada: Nenhuma
Saída: Nenhuma
Adição. Fonte:
({}{})
Entrada:
2, 3
Resultado:
5
Subtração. Fonte:
({}<>){({}[])<>({}[])<>}<>
Entrada:
2, 3
Resultado:
-1
Multiplicação. Fonte:
({}<>)<>({}[]){({}[])<>(({}))<>}<>{({}<>{})<>}<>
Entrada:
7, 8
Resultado:
56
Fibonacci. Fonte:
<>((()))<>{({}[])<>({}<>)<>(({})<>({}<>))<>}<>
Entrada:
5
Resultado:
13
8
5
3
2
1
1
{[({})]}
As brechas padrão se aplicam e a resposta mais curta em bytes vence.
- ¹: Isso foi realmente um erro da minha parte.
{...}
deve avaliar a soma de todas as suas execuções, que é uma das características mais legais do cérebro. No entanto, para os propósitos deste desafio, suponha que seja{...}
avaliado como 0.
fonte
{...}
avalia?{...}
avaliada como 0. Além disso, os argumentos são enviados por ordem e, por isso,2
são enviados e, então3
, quando o programa é iniciado, a segunda entrada (3
) fica no topo da pilha. Vou esclarecer os dois no post.Respostas:
Pip
-n
,15114810198 bytesLeva a lista de entradas como argumentos da linha de comando e o código Brain-Flak de (uma linha de) stdin. Experimente online!
Editar: salvei muitos bytes em relação à minha abordagem original, alternando para uma estratégia de conversão e avaliação.
Ungolfed e comentou
Esta versão também inclui alguma saída de depuração, mostrando o código Pip resultante da tradução, bem como o conteúdo da pilha após a execução.
fonte
Brain-Flak Classic ,
127112471239 bytesExperimente online!
+4 bytes de correção de um bug com a condição na
{...}
mônada e -36 bytes de vários campos de golfe.1238 bytes de código, +1 byte para o
-a
sinalizador (que pode ser combinado com o sinalizador de idioma).Agora isso é avaliado
{...}
como zero pela especificação de desafio. Observe que o próprio Brain-Flak foi avaliado{...}
como a soma de todas as execuções desde a correção de 7 de maio de 2016 dois dias antes do lançamento deste desafio.O código a seguir interpreta o Brain-Flak Classic corretamente, com
{...}
a soma de todas as execuções. A única diferença entre os dois intérpretes é a colocação de um{}
nilad.Experimente online!
A entrada (para qualquer intérprete) é o programa Brain-Flak Classic para interpretar, uma nova linha e uma lista de números inteiros separados por espaço. Nenhuma validação é realizada na entrada. A nova linha é necessária, mesmo que o programa ou entrada esteja em branco.
A primeira etapa é analisar todas as entradas, começando pelos colchetes:
Em seguida, os números inteiros são analisados. Normalmente, isso não seria necessário, mas a entrada foi aceita como ASCII. Isso tem um lado positivo: a entrada de texto nos permite determinar a altura da pilha, o que simplifica as coisas quando não temos acesso ao nilad da altura da pilha.
Os números inteiros são analisados em dois números na segunda pilha: um para o valor absoluto e outro para o sinal. Estes são então retornados para a primeira pilha.
As pilhas interpretadas são armazenadas abaixo do código na primeira pilha na seguinte ordem: altura atual da pilha, pilha atual, outra altura da pilha, outra pilha. O 0 para a outra altura da pilha não precisa ser pressionado neste momento, pois será um zero implícito na primeira vez que for lido.
A representação do código agora é movida de volta para a pilha esquerda. Para facilitar as coisas posteriormente, subtraímos 4 dos colchetes de abertura das nilads, para que cada operação tenha um número inteiro único de -1 a -8.
A parte principal do programa é realmente interpretar as instruções. No início de cada iteração do loop principal, a instrução atual está no topo da pilha esquerda, tudo depois que está abaixo na mesma pilha e tudo antes dela na pilha direita. Costumo visualizar isso como tendo um livro aberto para uma determinada página.
Depois de sair do loop principal, todo o código está na pilha certa. As únicas coisas na pilha esquerda são zero e as duas pilhas interpretadas. Produzir a saída correta é uma questão simples.
fonte
{...}
, que é o comportamento correto para o cérebro moderno e (acho) cérebro clássico, no entanto, escrevi no desafio que{...}
avalia como 0. Você provavelmente poderia jogar um número significativo de bytes de removendo essa funcionalidade, embora seria bom para manter a volta original, porque é tecnicamente mais correto em geral (apenas errado para este desafio)APL,
255257 bytesIsso leva o programa como argumento certo e a entrada do programa como argumento esquerdo, ou seja:
Versão não destruída: aqui .
fonte
APL (Dyalog Classic) , 146 bytes
Experimente online!
um clássico interpretando outro :)
fonte
Python 3, 429 bytes
Usado como
g('[{}{}]', 2, 3)
Ele usa
re.sub
para "compilar" a fonte de quebra de cérebros em python e depois executa o python. (para depuração, substituaexec
porprint
para obter uma lista do código python)Recuar corretamente aninhado enquanto loops consome muitos bytes no código.
fonte
Python, 616 bytes
Instruções:
[1,2,...]
formato e pressione enterBasicamente, o que esse programa faz é "compilar" recursivamente o código Brain-flak em listas aninhadas e interpretar recursivamente essa lista. Provavelmente existe uma maneira de combinar os dois ...
Vou tentar refazer a lógica mais tarde.
fonte
Perl 5.6,
419414 bytesEu já joguei um pouco, mas provavelmente há espaço para melhorias. Novas linhas e guias adicionadas aqui para facilitar a leitura:
fonte
Python 2 ,
361, 348 bytesExperimente online!
-13 bytes salvos graças a @Mr. Xcoder!
fonte