Brain-flak faz um ano amanhã! Em homenagem ao seu aniversário, estamos tendo uma festa de aniversário no estilo PPCG, na qual vários usuários postam perguntas relacionadas ao cérebro! Ajude-nos a celebrar! :)

Brain-flak é uma linguagem esotérica que escrevi, onde todos os comandos são colchetes e todos os colchetes devem ser totalmente compatíveis. Para emprestar minha própria definição :

• Para o propósito deste desafio, um "suporte" é qualquer um desses caracteres: ()[]{}<>.

• Um par de colchetes é considerado "correspondente" se os colchetes de abertura e fechamento estiverem na ordem correta e não tiverem caracteres dentro deles, como

  ()
  []{}
  

  Ou se todos os subelementos dentro dele também corresponderem.

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

  Os subelementos também podem ser aninhados com várias camadas de profundidade.

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

• Uma cadeia é considerada "Totalmente compatível" se e somente se:

  1. Cada caractere é um colchete,

  2. Cada par de suportes possui o suporte de abertura e fechamento correto e na ordem correta

Em comemoração ao primeiro aniversário do brain-flak, o desafio de hoje é pegar um conjunto desequilibrado de parênteses e determinar que tipos de operações são necessárias para torná-lo válido.

• Por exemplo, ((não é um código de quebra-cabeça válido, mas se acrescentamos ))a ele, ele se torna (())totalmente equilibrado e, portanto, válido. Isso torna essa entrada anexável .

• Da mesma forma, >}não é válido, mas podemos acrescentar {<a ele o make {<>}, que é válido. Isso torna essa entrada pré-selecionável .

• Algumas entradas são um pouco mais complicadas. Por exemplo, )][({não é possível validar puramente anexando ou anexando. Mas isso pode ser validado [(acrescentando e acrescentando })]. Portanto, essa entrada é tanto prependable e appendable .

• Por fim, algumas entradas nunca podem ser tornadas válidas como uma combinação de anexos ou anexos. Por exemplo, (>nunca pode ser válido. (Anexar <cria <(>e anexa )cria (>), nenhuma das quais é válida) Portanto, essa entrada não é nem anexável nem pré-selecionável.

Para o desafio de hoje, você deve escrever um programa ou função que use uma sequência de colchetes e determine se a sequência é

appendable
prependable
both
neither

Você pode escolher quais valores você usa para representar para cada caso. Por exemplo, saída 1, 2, 3, 4, ou 'a', 'p', 'b', 'n', ou 1, 'foo', 3.1415, -17, ou o que estiver bom. Contanto que cada saída seja distinta e consistente , tudo bem. No entanto, você deve especificar claramente qual saída corresponde a qual caso.

Você pode retornar esse valor no formato que for mais conveniente (por exemplo, retornar de uma função, imprimir em STDOUT, modificar argumentos, gravar em um arquivo etc.).

Você pode supor que a entrada nunca será válida e não funcionará.

Exemplos

As seguintes entradas são todas pré - selecionáveis :

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

Estes são todos anexáveis :

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

Estes são todos os dois :

))((
>()[(()){
>{

E estes são todos nem :

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

Como de costume, isso é código-golfe , então as brechas padrão se aplicam e a resposta mais curta em bytes vence!

Esse desafio é particularmente difícil no cérebro, então o máximo de brownie aponta para toda e qualquer resposta escrita no cérebro. :)

Geléia , 33 32 37 35 34 bytes

bug encontrado, correção horrível +5 bytes, melhor correção - 2 bytes, usando um truque de Adnan que eu vi aqui por -1 a mais.

“({[<“)}]>”Z;@WœṣF¥/µÐLO‘&2µIṀ>0ȯQ

Valores de retorno:

prepends [2]
 appends [0]
    both [2,0]
 neither 1

(Entrada inválida retorna resultados espúrios, embora válido Brain-flack, retorna [].)

Experimente online! - um conjunto de testes (gravuras mushed representações, então20para[2,0], e ignora as linhas contendo qualquer-).

Retina , 41 40 41 bytes

1 byte salvo graças a @MartinEnder

+`\(\)|\[]|{}|<>

[]})>]+
1
\W+
0
...+
01

Experimente online!

• Prependível é 1
• Anexável é 0
• Ambos é 10
• Nenhuma é 01

Edições

• Obteve 1 byte para corrigir o erro observado por @Neil

Lote, 337 bytes

@echo off
set/ps=
:g
set "t=%s:<>=%
set "t=%t:()=%
set "t=%t:[]=%
set "t=%t:{}=%
if not "%t%"=="%s%" set "s=%t%"&goto g
set "s=%s:<=[%
set s=%s:>=]%
set s=%s:(=[%
set s=%s:)=]%
set s=%s:{=[%
set s=%s:}=]%
:l
if %s:~,2%==]] set s=%s:~1%&goto l
:r
if %s:~-2%==[[ set s=%s:~,-1%&goto l
if not _%s:~2%==_ set s=[]
echo %s%

Saídas ]para pré-anexar, [para anexar, ][para ambos, []para nenhum.

Haskell , 115 108 bytes

EDITAR:

• -7 bytes: use mais guardas.

(""#)
s#""=[s>"",1>0]
s#(c:d)|Just a<-lookup c$zip"([{<"")]}>"=(a:s)#d|(a:b)<-s=[1|a==c]>>b#d|0<1=take 1$s#d

Experimente online!

Use como (""#) "))". Os resultados são apresentados como:

[False,True]: needs nothing
[False]: prependable
[True,True]: appendable
[True]: both
[]: neither

Como funciona

• A codificação de saída é escolhida de forma que a necessidade de prefixar seja sinalizada, descartando o segundo elemento do resultado para o restante, se houver, enquanto uma incompatibilidade completa é sinalizada, eliminando todos eles.
• s#danalisa uma sequência restante d, considerando uma sequência / pilha sde colchetes esperados.
  • A s#""linha verifica se todos os colchetes de fechamento foram encontrados no final da cadeia, caso contrário é necessário anexar.
  • A primeira ramificação de s#(c:d)verificações se o próximo caractere cé um colchete de abertura e, se houver, deixa o colchete de fechamento correspondente na pilha para a recursão.
  • Caso contrário, se a pilha contiver colchetes de fechamento, a segunda ramificação verificará se a primeira corresponde ao próximo caractere e, se não, retorna uma lista vazia em vez de repetir.
  • Por fim, na última ramificação, a pilha está vazia e temos um colchete de fechamento incomparável, que pode ser corrigido com uma pré-inserção, antes da repetição.

Japonês , 44 bytes

=Ue"%(%)|%[]|\{}|<>" ®c -1&2|1})f31 |UfD |Ug

Saídas 1para prependable, 3para appendable, 13para ambos, e 31para nenhum.

Teste online! ou Verifique todos os casos de teste de uma só vez.

Como funciona

 =Ue"%(%)|%[]|\{}|<>" ®   c -1&2|1})f31 |UfD |Ug
U=Ue"%(%)|%[]|\{}|<>" mZ{Zc -1&2|1})f31 |UfD |Ug

                    // "(((()()())))}"  "([({}{})"    ">()[(()){"  "((((<>()]"
Ue"%(%)|%[]|\{}|<>" // Recursively remove all instances of "()", "[]", "{}", and "<>" from U.
                    // "}"              "(["          ">[{"        "((((]"
mZ{Zc -1&2|1}       // Replace each char Z with (Z.charCodeAt() - 1) & 2 | 1.
                    // "1"              "33"          "133"        "33331"
U=                  // Save the result in U.
f31 |UfD |Ug        // Match all instances of "31" and "13" (D = 13) and bitwise-OR the results with the first char.
                    // null|null|1      null|null|3   null|13|1    31|null|3
                    // 1                3             13           31
                    // Implicit: output result of last expression

PHP, 137 bytes

for($c=1;$c;)$a=preg_replace("#<>|\(\)|\[\]|\{\}#","",$a=&$argn,-1,$c);echo($a=preg_replace(["#[]})>]+#","#[[{(<]+#"],[1,2],$a))<13?$a:0;

1 => anexável,

2 => prependível,

12 => ambos,

0 => nenhum

Casos de teste