Anexa o antepone? Depende


23

¡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 , 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. :)


1
maximum brownie pointsCreo que ofrecer máximos puntos de brownie y galletas en su lugar alentaría Brain-Flaking este desafío más que solo puntos de brownie, ya que no creo que sea trivial en ningún idioma, y ​​mucho menos Brain-Flak. : P
Erik the Outgolfer

FYI: Todas las pruebas terminan con corchetes abiertos, todas las pruebas terminan con corchetes cerrados.
Jonathan Allan

2
Yo diría que "ambos" es el término equivocado. Una cadena como ][es , no puede agregar nada, como nada puede anexar puede hacer que sea válida. Del mismo modo, no es prependable. ¡Es ... 'insertable'! Puede insertarlo en una cadena para hacer que todo Brainflak sea válido.
orlp

¿Son cuerdas equilibradas ambas o ninguna?
Wheat Wizard

@wheatwizard Las cadenas equilibradas no se darán como entrada. You can assume that the input will never be valid brain-flak or empty.
DJMcMayhem

Respuestas:


6

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


5

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

[]})>]Guarda un byte.
Martin Ender

@MartinEnder Ah, es porque los juegos de caracteres no pueden estar vacíos, ¡gracias!
Kritixi Lithos

Esto no funciona para todas las entradas no anexables, por ejemplo (][). Creo que se puede arreglar a un costo de un byte cambiando 101a ...+.
Neil

@Neil Gracias por notar el error, me pregunto si también hay casos Bothasí
Kritixi Lithos

No, creo que 10es la única combinación válida para Both.
Neil

3

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.


3

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.

2

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

2

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


"Siempre que cada salida sea distinta y consistente, está bien". Esto no parece tener un valor consistente para ninguno de los dos.
Cyoce

@Cyoce Ahora está arreglado
Jörg Hülsermann
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.