Escreva um intérprete clássico de quebra-cabeças!

18

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

Máquina da verdade

{[({})]}

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.
DJMcMayhem
fonte
Existe uma regra referente ao valor inteiro mínimo que o programa precisa manipular?
0 '
O que a mônada {...}avalia?
Neil
Em que ordem estão os argumentos de subtração? Estou recebendo a negação do que espero.
Neil
@ Neil Desculpe por isso. A mônada é {...}avaliada como 0. Além disso, os argumentos são enviados por ordem e, por isso, 2são enviados e, então 3, quando o programa é iniciado, a segunda entrada ( 3) fica no topo da pilha. Vou esclarecer os dois no post.
DJMcMayhem

Respostas:

6

Pip -n , 151 148 101 98 bytes

YRVg;VqR^"{}()<>[]";,8R J,8<>2AL,8("POy|i o0Syl1v0W@y{ }1yPU$+[ ]&@y0 1P$+[ ]"R0" (V{"R1"i}) "^s)y

Leva 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.

;;; Setup ;;;

; y is the active stack, l is the off-stack
; y is initialized from command-line arguments
y:RVg   (reversed to put the last input at the top)
; l is preset to empty list by default

; p is the program (read from stdin)
p:q

; Translate from braces to numbers 0-7 (we do this so that the
; later replacement step won't try to replace the braces in the
; Pip code)
p R: ^"()[]{}<>" 0,8

;;; Replace nilads with the appropriate code ;;;

; () => o (variable preset to 1)
p R: 01 "o"

; [] => v (variable preset to -1)
p R: 23 "v"

; {} => POy|i
; Pop y; return that value OR i (variable preset to 0)
p R: 45 "POy|i"

; <> => (V{Syli})
; Eval the code Syl to swap stacks y and l, then return i (i.e. 0)
p R: 67 "(V{Syli})"

;;; Replace monads with the appropriate code ;;;

; ( ) => yPU$+[ ]&@y
; Sum ($+) the inside and push (PU) the sum onto y; return
; the just-pushed value, which is the first element of y (@y)
; y will always be truthy (nonempty), since we just pushed a value onto it
p R: 0 "yPU$+["
p R: 1 "]&@y"

; [ ] => P$+[ ]
; Sum ($+) the inside, print (P) the sum, and return it
p R: 2 "P$+["
p R: 3 "]"

; { } => (V{W@y{ }i})
; Eval the code W@y{ }, which wraps the inside in curly braces
; and runs it while (W) the first element of y (@y) is truthy
; (i.e. not zero, and not nil from an empty stack)
; Then return i (i.e. 0)
p R: 4 "(V{W@y{"
p R: 5 "}i})"

; < > => (V{ i})
; Eval the inside, then return i (i.e. 0)
p R: 6 "(V{"
p R: 7 "i})"

; Debug: print the resulting translated code and a blank line
Pp.n

;;; Run the code ;;;

; Eval the translated code
(Vp)

; Output the active stack, newline-separated
PyJn

; Debug: print the active stack and the off-stack
P"Active stack: ".RPy
"Off-stack: ".RPl
DLosc
fonte
O pip é mais novo que esse desafio?
DJMcMayhem
@DJMcMayhem Nope ! Também não estou usando nenhum recurso mais recente que o desafio.
DLosc 3/02
59

Brain-Flak Classic , 1271 1247 1239 bytes

<>(()){<>((([][][][][])<(((({}){})(({})({}))[])({}(({})({}({})({}{}(<>)))))[])>{()<{}>}{})<{{}}{}>())}{}<>(<(({()(((<>))<>)}{}{<({}(([][][])((({})({}))[]{})){})>((){[]<({}{})((){[]<({}{}<>((({})({})){}{}){})(<>)>}{}){{}{}<>(<({}{}())>)(<>)}>}{}){(<{}{}{}((<>))<>>)}{}}<>)<{({}[]<({}<>)<>{(<{}>)<>{<>({}[])}{}<>({}<>)(<>)}{}>)}{}<>>)>)<>{(({}[])(){(<{}>)<><(({})[])>[][][][]{()()()()(<{}>)}{}<>}{}<>)<>}<>{}{(({})<({()<<>({}<>)>}{})>([]))((){[](<(({}()()(<>))()()()){(<{}>)<>}>)}{}<>){{}((){[]<({}())((){[]<({}())((){[]<({}())((){[]<({}())((){[]<({}())((){[]<({}())((){[](<{}<>{({}<>)<>}{}(({}))({<{}({}<>)<>>{}(<<>({}[]<>)>)}<><{({}<>)<>}>{})>)}{}){{}{}(<([])>)}>}{}){{}<>{({}<>)<>}{}((({})())<{({}[]<({}<>)<>>)}>{}){({}[]<><({}<><({()<({}[]<({}<>)<>>)>}{}<>)><>)<>({()<({}[]<({}<>)<>>)>}{}<>)>)}<>(<{({}<>)<>}>)}>}{}){{}{}(<(())>)}>}{}){(<{}{}>)<>{({}<>)<>}{}(({}))({<{}({}<>)<>>({})(<<>({}<>)>)}<><{({}<>)<>}>){{}([][][])<>(((<{}>)<>))}}>}{}){{}(<([{}])>)}>}{}){{}((<{}>))}>}{}){{}(({})(<()>)<<>{({}<>)<>}{}({}()<>)<>>)<>(<({}<>)>)<>{({}<>)<>}}{}(<({}<({}<>)<>>{})<>({}<>)>)<>(<({}())>)}{}({}<{({}[]<({}<>)<>>)}{}>){((({}[]<>){(<{}({}<>)>)}{}())<{({}()<({}<>)<>(({})[])>{[][](<{}>)}{})}{}>()){{}(<>)}}{}}{}{({}[]<[{}]>)}{}{({}[]<{}>)}{}

Experimente 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 -asinalizador (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:

# Move to right stack, and push 1 to allow loop to start
<>(())
{
   # While keeping -5 on third stack:
   <>((([][][][][])<

       # Pop bracket or newline k from left stack, and push 0, k-10, k-40, k-60, k-91, k-123 on right stack
       (((({}){})(({})({}))[])({}(({})({}({})({}{}(<>)))))[])

   # Search this list for a zero, and push the number of nonzero entries popped minus 5 
   # (thus replacing the 0 if it was destroyed)
   >{()<{}>}{})

   # Remove rest of list, and push the same number plus 1
   # Result is -4 for {, -3 for [, -2 for <, -1 for (, 0 for newline, or 1 for everything else (assumed closing bracket)
   <{{}}{}>())

# Repeat until newline found
}{}<>

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.

(<((

    # If stack nonempty, register first stack entry.
    {()(((<>))<>)}{}

    # For each byte k of input:
    {

        # Push -3, -13, and k-32
        <({}(([][][])((({})({}))[]{})){})>

        # Evaluate to 1 if space
        # If not space (32):
        ((){[]<

            # If not minus (45):
            ({}{})((){[]<

                # Replace top of right stack (n) with 10*n + (k-48)
                ({}{}<>((({})({})){}{}){})(<>)

            # Else (i.e., if minus):
            >}{}){

                # Remove excess "else" entry and -3
                {}{}

                # Set sign to negative (and destroy magnitude that shouldn't even be there yet)
                <>(<({}{}())>)(<>)}

        # Else (i.e., if space):
        >}{}){

            # Remove working data for byte, and push two more 0s onto right stack
            (<{}{}{}((<>))<>>)

    # Push number of integers found
    }{}}<>)

    # For each integer:
    <{({}[]<

        # Move magnitude back to left stack
        ({}<>)<>

        # If sign is negative, negate
        {(<{}>)<>{<>({}[])}{}<>({}<>)(<>)}{}

    >)}{}

    # Push stack height onto stack
    <>>)

# Push 0
>)

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.

# For each bracket in the code:
<>{

    # Push k-1 and evaluate to k
    (({}[])()

    # If not closing bracket:
    {

        # Check next bracket (previously checked, since we started at the end here)
        (<{}>)<><(({})[])>

        # Subtract 4 if next bracket is closing bracket
        # Inverting this condition would save 8 bytes here, but cost 12 bytes later.
        [][][][]{()()()()(<{}>)}{}

    <>}{}

    # Push result onto left stack
    <>)

<>}<>{}

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.

{

    (

        # Get current instruction
        ({})

        # Move all code to left stack, and track the current position in code
        <({()<<>({}<>)>}{})>

        # Push -1, signifying that the code will move forward to just before a matching }.
        # In most cases, this will become 0 (do nothing special) before it is acted upon
        ([])

    # Push instruction minus 1
    )

    # If opening bracket:
    ((){[](<

        # Push instruction+1 and instruction+4
        (({}()()(<>))()()())

        # If instruction+4 is nonzero (not loop monad), replace the earlier -1 with 0 to cancel forward seek
        # This would be clearer as {(<{}>)<>(<{}>)<>}, but that would be unnecessarily verbose
        {(<{}>)<>}

    # Else (i.e., if closing bracket):
    >)}{}<>){

# If closing bracket, parse command
# Post-condition for all: if not moving to {, pop two and push evaluation, 0.
# (For nilads, can assume second from top is 0.)
# If moving to {, pop one, push -3, 0, 0.

        # Seven nested if/else statements, corresponding to eight possible instruction.
        # The "else" statements end with 0 already on the stack, so no need to push a 0 except in the innermost if.
        # Each one beyond the first increments the instruction by 1 to compare the result with 0
        # Each instruction will pop the instruction, leaving only its evaluation (with a 0 on top).
        {}((){[]<
        ({}())((){[]<
        ({}())((){[]<
        ({}())((){[]<
        ({}())((){[]<
        ({}())((){[]<
        ({}())((){[](<

            # -7: pop
            # Pop instruction to reveal existing 0 evaluation
            {}

            # Move code out of the way to access stack
            <>{({}<>)<>}{}

            # Duplicate stack height (only useful if stack height is zero)
            (({}))

            (

                # If stack height nonzero
                {

                    # Save stack height on second stack
                    <{}({}<>)<>>

                    # Pop stack
                    {}

                    # Move stack height back and subtract 1
                    (<<>({}[]<>)>)

                }

                # Move code back to normal position
                <><{({}<>)<>}>{}

            # Evaluate as popped entry (0 if nothing popped)
            )

        # (else)
        >)}{}){

            # -6: -1 nilad
            # Just evaluate as -1
            {}{}(<([])>)

        # (else)
        }>}{}){

            # -5: swap nilad
            # Move code out of the way to access stack
            {}<>{({}<>)<>}{}

            # Number of integers to move: stack height + 1 (namely, the stack height and every entry in the stack)
            ((({})())

            # Move to second stack
            <{({}[]<({}<>)<>>)}>{}

            # Do (stack height + 1) times again
            ){({}[]<><

                # Get stack element
                ({}<><

                    # Move alternate (interpreted) stack to second (real) stack, and push length on top of it
                    ({()<({}[]<({}<>)<>>)>}{}<>)

                # Push current stack element below alternate stack
                ><>)

                # Move alternate stack back above newly pushed element
                <>({()<({}[]<({}<>)<>>)>}{}<>)

            >)}

            # Move code back to normal position
            <>(<{({}<>)<>}>)

        # (else)
        }>}{}){

            # -4: 1
            # Just evaluate to 1
            {}{}(<(())>)

        # (else)
        }>}{}){

            # -3: loop
            # Create zero on stack while keeping existing evaluation
            # This becomes (<{}{}>) in the version that meets the challenge spec
            (<{}>)

            # Move code out of the way to access stack
            <>{({}<>)<>}{}

            # Duplicate stack height
            (({}))

            (

                # If stack height nonzero
                {

                    # Save stack height on second stack
                    <{}({}<>)<>>

                    # Peek at top of stack
                    ({})

                    # Move stack height back
                    (<<>({}<>)>)

                }

                # Move code back to normal position
                <><{({}<>)<>}>

            # Look at peeked entry
            # Remove the {} in the version meeting the challenge spec
            {})

            # If peeked entry is nonzero
            {

                # Replace -3 instruction on third stack
                {}([][][])

                # Replace loop indicator to 0 (to be incremented later to 1)
                <>(((<{}>)

                # Create dummy third stack entry to pop
                <>))

            }

        # (else)
        }>}{}){

            # -2: print
            # Just print evaluation without modifying it
            {}(<([{}])>)

        # (else)
        }>}{}){

            # -1: evaluate as zero
            # Just change evaluation to 0
            {}((<{}>))

        # else
        }>}{}){

            # 0: push
            # Get current evaluation (without modifying it)
            {}(({})

                # Create zero on stack as barrier
                (<()>)

                # Move code out of the way to access stack
                <<>{({}<>)<>}{}

                # Increment stack height and save on other stack
                ({}()<>)<>

            # Push evaluation
            >)

            # Move stack height back (and push zero)
            <>(<({}<>)>)

            # Move code back to normal position
            <>{({}<>)<>}

        }{}

        # Update third stack by adding evaluation to previous entry's evaluation
        # Previous entry's instruction is saved temporarily on left stack
        (<({}<({}<>)<>>{})<>({}<>)>)

        # Increment loop indicator
        # If instruction was loop monad and top of stack was nonzero, this increments 0 to 1 (search backward)
        # Otherwise, this increments -1 to 0 (do nothing)
        <>(<({}())>)

    }{}

    # While holding onto loop indicator
    ({}<

        # Go to immediately after executed symbol
        {({}[]<({}<>)<>>)}{}

    >)

    # If looping behavior:
    {

        # Switch stack and check if searching forward
        ((({}[]<>)

        # If so:
        {

            # Move just-executed { back to left stack, and move with it
            (<{}({}<>)>)

        }{}

        # Either way, we are currently looking at the just-executed bracket.
        # In addition, the position we wish to move to is on the current stack.

        # Push unmodified loop indicator as initial value in search
        ())

        # While value is nonzero:
        <{

            # Add 1
            ({}()

                # Move current instruction to other stack
                <({}<>)<>

                # Check whether next instruction is closing bracket
                (({})[])>

                # If opening bracket, subtract 2 from value
                {[][](<{}>)}{}

            )

        }{}>

        # If searching backward, move back to left stack
        ()){{}(<>)}

    }{}

}

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.

# Pop the zero
{}

# Output current stack
{({}[]<[{}]>)}{}

# Discard other stack to avoid implicit printing
{({}[]<{}>)}{}
Nitrodon
fonte
12
: O que o ... Ok, recompensando imediatamente. Bom trabalho! : D
DJMcMayhem
4
Deixe-me ver se entendi direito ... você criou um intérprete para o idioma que deve ser interpretado. YoDawg
tisaconundrum 4/17/17
OK, por que ele tem apenas um número de votação de 2 dígitos?
NieDzejkob
Bom trabalho na implementação correta do acumulador {...}, 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)
DJMcMayhem
@DJMcMayhem Fixed. Só não me faça portar o intérprete inteiro para essa versão hipotética do Brain-Flak.
Nitrodon 10/10
8

APL, 255 257 bytes

b←{S←(⌽⍺)⍬
e←{0=⍴⍵:0
v+∇⊃_ v←∇{r←⊂2↓⍵
'()'≡n←2↑⍵:r,1
'[]'≡n:r,¯1
'{}'≡n:r,{i←⊃⊃⊃S⋄S[1]↓⍨←1⋄i}⍬
'<>'≡n:r,0⊣S⌽⍨←1
r←⊂⍵↓⍨i←0⍳⍨(+\c=⍵)-+\')]>}'['([<{'⍳c←⊃⍵]=⍵
i←1↓¯1↓c←i↑⍵
'('=c←⊃c:r,S[1],⍨←⍺⍺i
'['=c:r,+⎕←⍺⍺i
'{'=c:r,{0≠⊃⊃⊃S:∇e i⋄0}⍬
'<'=c:r,0⊣⍺⍺i}⍵}
⎕←⍪⊃S⊣e⍵}

Isso leva o programa como argumento certo e a entrada do programa como argumento esquerdo, ou seja:

      2 3 b '({}{})'
5
      2 3 b '({}<>){({}[])<>({}[])<>}<>'
¯1
      7 8 b '({}<>)<>({}[]){({}[])<>(({}))<>}<>{({}<>{})<>}<>'
56
      5 b '<>((()))<>{({}[])<>({}<>)<>(({})<>({}<>))<>}<>'
13
 8
 5
 3
 2
 1
 1

Versão não destruída: aqui .

marinus
fonte
7

APL (Dyalog Classic) , 146 bytes

↑⍕¨s⊣{⍎⍕1 ¯1'(s↓⍨←1)⊢⊃s' '0⊣s t←t s' 's,⍨←+/∇¨a' '⎕←+/∇¨a' '∇{×⊃s:∇⍺⍺¨a⋄0}0' '0⊣+/∇¨a'[(⊃⍵)+4×⍬≢a1↓⍵]}¨⍎∊(')',⍨'(',¨⍕¨⍳4)[0,4,⍨'([{<'⍳⍞]⊣s←⌽⎕⊣t←⍬

Experimente online!

um clássico interpretando outro :)

ngn
fonte
6

Python 3, 429 bytes

import re
S='s+=[v];v=0';T='v+=s.pop()';i=0
d={'()':'v+=1','(':S,')':'a+=[v];'+T,'[]':'v-=1','[':S,']':'print(v);'+T,'<>':'a.reverse()','<':S,'>':T,'{}':'v+=0if a[-1]==""else a.pop()','{':S+';while a[-1]:','}':T}
def r(m):global i;t=m.group();i-=(t=='}');s=' '*i;i+=(t=='{');return''.join(s+r+'\n'for r in d[t].split(';'))
def g(c,*a):
 a,s,v=['']+list(a),[],0;exec(re.sub(r'[<({[]?[]})>]?',r,c));
 while a[-1]!="":print(a.pop())

Usado como g('[{}{}]', 2, 3)

Ele usa re.subpara "compilar" a fonte de quebra de cérebros em python e depois executa o python. (para depuração, substitua execpor printpara obter uma lista do código python)

Recuar corretamente aninhado enquanto loops consome muitos bytes no código.

RootTwo
fonte
3

Python, 616 bytes

Instruções:

  1. Executar com python
  2. Digite a lista no [1,2,...]formato e pressione enter
  3. Cole / escreva programa e pressione enter novamente
  4. Feito

Basicamente, 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.

y="([{<)]}>"
w,z,g=print,len,input
def c(s):
 if z(s)<1:return[]
 t,i,o=[],1,0
 t.append(y.index(s[0]))
 while z(t)>0:
  x=y.index(s[i])
  if x<4:t.append(x)
  else:o=t.pop()
  i+=1
 r=[[o,c(s[1:i-1])]]
 r.extend(c(s[i:]))
 return r
p=lambda t:t.pop()if z(t)>0 else 0
k=lambda t:t[z(t)-1]if z(t)>0 else 0
r,l=[],eval(g())
a=l
def i(u):
 v=0
 global a
 for t,n in u:
  if t<1:
   if n:o=i(n);v+=o;a.append(o)
   else:v+=1
  if t==1:
   if n:o=i(n);v+=o;w(o)
   else:v-=1
  if t==2:
   if n:
    while k(a)!=0:i(n)
   else:v+=p(a)
  if t>2:
   if n:i(n)
   elif a==l:a=r
   else:a=l
 return v
i(c(g()))
for n in a:w(n)
Azul
fonte
3

Perl 5.6, 419 414 bytes

Eu já joguei um pouco, mas provavelmente há espaço para melhorias. Novas linhas e guias adicionadas aqui para facilitar a leitura:

use Text::Balanced extract_bracketed;
$s=shift;
@a=reverse@ARGV;
sub p
{
    my($c)=@_;
    my$s=0;
    while(my$n=extract_bracketed($c)){
        $s+='()'eq$n||'{}'eq$n&&shift@a;
        $s-='[]'eq$n;
        @t=@a,@a=@i,@i=@t if'<>'eq$n;
        my$m=chop($n);
        $n=substr($n,1);
        if($n){
            p($n)while'}'eq$m&&$a[0];
            p($n)if'}'ne$m;
            $s+=$v,unshift@a,$v if')'eq$m;
            $s+=$v,print"n=$n m=$m v=$v\n"if']'eq$m;
        }
    }
    $v=$s;
}
p($s);
foreach(@a){
    print"$_\n";
}
Neil
fonte
1

Python 2 , 361 , 348 bytes

c,s=input();s=s,[]
a=s[0]
def w():global a,s;s=s[::-1];a=s[0];return 0
def p(c):a.append(c);return c
def n(c):print c;return c
z=lambda c:0
def l(f):
 global a
 while a and a[-1]:f()
 return 0
for x,y in zip("() ( [] {} <> [ < { } ] >".split(),"+1 +p( -1 +(len(a)and(a.pop())) +w() +n( +z( +l(lambda: ) ) )".split()):c=c.replace(x,y)
exec c
print a

Experimente online!

-13 bytes salvos graças a @Mr. Xcoder!

DJMcMayhem
fonte