¡Brain-Flak cumple un año mañana! En honor a su cumpleaños, tenemos una fiesta de cumpleaños al estilo PPCG, ¡donde varios usuarios publican preguntas relacionadas con el cerebro! ¡Ayúdanos a celebrar! :)

Brain-flak es un lenguaje esotérico que escribí donde todos los comandos son paréntesis y todos los paréntesis deben coincidir completamente. Para tomar prestada mi propia definición :

• A los efectos de este reto, un "soporte" es cualquiera de los siguientes caracteres: ()[]{}<>.

• Un par de paréntesis se considera "coincidente" si los paréntesis de apertura y cierre están en el orden correcto y no tienen caracteres dentro de ellos, como

  ()
  []{}
  

  O si cada subelemento dentro de él también coincide.

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

  Los subelementos también se pueden anidar en varias capas de profundidad.

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

• Una cadena se considera "Totalmente coincidente" si y solo si:

  1. Cada personaje es un paréntesis,

  2. Cada par de soportes tiene el soporte de apertura y cierre correcto y en el orden correcto

Para celebrar el primer cumpleaños de Brain-Flak, el desafío de hoy es tomar un par de paréntesis desequilibrados y determinar qué tipos de operaciones son necesarias para que sea válido.

• Por ejemplo, ((no es un código válido de ataque cerebral, pero si lo agregamos )), se convierte en (())un equilibrio completo y, por lo tanto, un ataque cerebral válido. Eso hace que esta entrada sea accesible .

• Del mismo modo, >}no es válido, pero podemos anteponerlo {<a hacer {<>}, que es válido. Eso hace que esta entrada sea prependable .

• Algunas entradas son un poco más complicadas. Por ejemplo, )][({no puede hacerse válido simplemente agregando o anteponiendo. Pero puede hacerse válido anteponiendo [(y agregando })]. Por lo tanto, esta entrada es a la vez prependable y appendable .

• Por último, algunas entradas nunca se pueden convertir en un código válido de brain-flak mediante una combinación de agregar o anteponer. Por ejemplo, (>nunca se puede hacer válido. (Prepending <crea <(>, y anexar )crea (>), ninguno de los cuales son válidos) Por lo tanto, esta entrada no es ni agregar nada o prependable.

Para el desafío de hoy, debe escribir un programa o función que tome una cadena de corchetes y determine si la cadena es

appendable
prependable
both
neither

Puede elegir qué valores usar para representar para cada caso. Por ejemplo, generar 1, 2, 3, 4, o 'a', 'p', 'b', 'n', o 1, 'foo', 3.1415, -17, o lo que sea que esté bien. Mientras cada salida sea distinta y consistente , está bien. Usted debe , sin embargo, especificar claramente lo que corresponde a la salida cuyo caso.

Puede devolver este valor en el formato que sea más conveniente (por ejemplo, regresar de una función, imprimir en STDOUT, modificar argumentos, escribir en un archivo, etc.).

Puede suponer que la entrada nunca será válida para el cerebro o vacía.

Ejemplos

Las siguientes entradas son todas prependable :

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

Todos estos son anexables :

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

Estos son todos los dos :

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

Y estos son todos no :

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

Como de costumbre, este es el código de golf , por lo que se aplican las lagunas estándar, ¡y gana la respuesta más corta en bytes!

Este desafío es particularmente difícil en brain-flak, por lo que el máximo brownie apunta a todas y cada una de las respuestas escritas en brain-flak. :)

Jalea , 33 32 37 35 34 bytes

error encontrado, corrección horrible +5 bytes, mejor solución - 2 bytes, usando un truco de Adnan que vi aquí por -1 más.

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

Valores de retorno:

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

(La entrada no válida devuelve resultados espurios, aunque es válido Brain-flack, vuelve [])

Pruébalo en línea! - un conjunto de pruebas (imprime representaciones desordenadas,20porlo tanto[2,0], e ignora las líneas que contienen alguna-).

Retina , 41 40 41 bytes

1 byte guardado gracias a @MartinEnder

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

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

Pruébalo en línea!

• Prependable es 1
• Anexable es 0
• Ambos es 10
• Ninguno es 01

Ediciones

• Ganó 1 byte para corregir el error notado 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%

Salidas ]para anteponer, [para agregar, ][para ambos, []para ninguno.

Haskell , 115108 bytes

EDITAR:

• -7 bytes: usa más guardias.

(""#)
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

Pruébalo en línea!

Utilizar como (""#) "))". Los resultados se dan como:

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

Cómo funciona

• La codificación de salida se elige de tal manera que la necesidad de anteponer se señale al soltar el segundo elemento del resultado para el resto, si lo hay, mientras que un desajuste completo se señaliza al soltarlos a todos.
• s#danaliza una cadena restante d, dada una cadena / pila sde corchetes de cierre esperados.
  • La s#""línea verifica si se han encontrado todos los corchetes de cierre al final de la cadena; de lo contrario, es necesario agregarlos.
  • La primera rama de s#(c:d)cheques si el siguiente carácter ces un paréntesis de apertura, y si es así, deja el paréntesis de cierre correspondiente en la pila para la recursividad.
  • De lo contrario, si la pila contiene corchetes de cierre, la segunda rama verifica si la superior coincide con el siguiente carácter y, si no, devuelve una lista vacía en lugar de volver a aparecer.
  • Por último, en la última rama, la pila está vacía, y tenemos un corchete de cierre inigualable que puede arreglarse anteponiendo, antes de recurrir.

Japt , 44 bytes

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

Salidas 1para prependable, 3para appendable, 13para ambos y 31para ninguno.

¡Pruébelo en línea! o Verifique todos los casos de prueba a la vez.

Cómo 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 => anexable,

2 => prependable,

12 => ambos,

0 => ninguno

Casos de prueba