Igualdad de tipos de soporte

9

Basado en esta pregunta.

Dada una cadena, reemplace cada corchete ()[]{}<>con un corchete del tipo apropiado para que los corchetes coincidan, y los corchetes anidados se ciclan de la siguiente manera:

  1. Los más externos son ()
  2. Directamente dentro de ()debe ser[]
  3. Directamente dentro de []debe ser{}
  4. Directamente dentro de {}debe ser<>
  5. Directamente dentro de <>será ()nuevamente (ciclos)

Todos los caracteres sin corchetes deben permanecer exactamente como están. Los corchetes abiertos solo pueden reemplazarse con corchetes abiertos de algún tipo, y los corchetes cerrados con corchetes cerrados.

La entrada siempre lo hará posible. Esto significa que sus corchetes coinciden correctamente si se ignora su tipo. Entonces, {ab<)c]es una entrada válida, pero ab)(cdo ab((cdno lo son.

Ejemplos:

2#jd {¤>. = 2#jd (¤).
abcdef    = abcdef
(3×5+(4-1)) = (3×5+[4-1])
<<<>><<>><<<<<<>>>>>>> = ([{}][{}][{<([{}])>}])

El uso de la transformación nativa de entrada de esta manera (sintaxis automática del lenguaje) no está permitido.

Como siempre: el código más corto gana.

code-golf string balanced-string Dirk Reichel
fuente
No entiendo el desafío. ¿Cuál debe ser la salida en términos de entrada?
xnor
@xnor la salida debe ser la misma cadena que la entrada, excepto los cuatro tipos de corchetes. Necesitan ser reemplazados para que coincidan con el patrón.
Dirk Reichel
Ah, ya veo. No entendí que el "debería ser" son cosas que se supone que debes hacer realidad. Lo editaré para tratar de hacerlo más claro.
xnor
1
@DirkReichel No creo que sea algo de lo que deba preocuparse. No puedo imaginar que ningún idioma pueda hacer esta transformación específica de forma nativa, y en el improbable caso de que exista dicho lenguaje, todo lo que significa es que las respuestas en ese idioma no serán muy interesantes.
Martin Ender
2
@DirkReichel, ¿qué sentido tiene? Solo quédate con ASCII. El uso de diferentes caracteres no agrega nada al desafío, aparte de restricciones innecesarias en los idiomas de solo ASCII.
FlipTack

Respuestas:

2

JavaScript (ES6), 79 bytes

s=>s.replace(/./g,c=>~(p=l.indexOf(c))?l[p&4?--k&3|4:k++&3]:c,l='([{<)]}>',k=0)

Casos de prueba

Mostrar fragmento de código

Arnauld
fuente
1

Lex, 132 bytes

%{
int i,o[4]={40,91,123,60};
%}
%%
[[({<] {putchar(o[i++&3]);}
[])}>] {putchar(o[--i&3]+2-!(i&3));}
%%
yywrap(){}
main(){yylex();}
Rainer P.
fuente
Puede guardar 27 bytes (lex portátil) o 30 bytes ( flexcomo compilador) eliminando las últimas dos o tres líneas respectivamente, a un costo de cierto número de bytes (probablemente 2, 3 o 4; las reglas son algo poco claras) en penalizaciones por la -llopción de línea de comando al vincular el archivo C resultante. (Es decir, en lugar de compilar con lex brackets.l; cc lex.yy.c, compila con lex brackets.l; cc lex.yy.c -ll). Definitivamente, es una compensación que vale la pena hacer en esta situación.
1

Java, 155 bytes

a->{String s="([{<)]}>";for(int i=0,j=0,k;i<a.length;i++){k=s.indexOf(a[i]);if(k>3){a[i]=s.charAt(--j%4+4);}else if(k>-1){a[i]=s.charAt(j++%4);}}return a;}

Lambda que toma un char[]argumento único. Recorremos la matriz, almacenando su posición en nuestra cadena de corchetes ( s) en una variable ( k). Verificamos si es un corchete de apertura o cierre ( s.indexAt()), y lo reemplazamos con el corchete apropiado en función de su nivel de anidamiento ( s.charAt()), haciendo un bucle apropiado con%4

Xanderhall
fuente
1

Haskell, 126 bytes

b="([{<"
d=")]}>"
y=cycle
(!)=elem
f(e:c)n(x:r)|x!b=y b!!n:f(y d!!n:e:c)(n+1)r|x!d=e:f c(n-1)r|1<3=x:f(e:c)n r
f c n s=s
f" "0

Pruébalo con ideone. Uso:

*Main> f" "0 "<<<>><<>><<<<<<>>>>>>>"
"([{}][{}][{<([{}])>}])"

Explicación

ftoma tres argumentos: una cadena que funciona como pila para cerrar corchetes, una int npara contar la profundidad de anidamiento y la cadena de entrada.

f c n "" = ""                            -- base case for recursion: input string is empty
f (e:c) n (x:r)                          -- for the current char x
   | elem x "([{<" =                     -- check if it is an opening bracket
       (cycle "([{<")!!n :               --   if so, replace it with a bracket of the current nesting depth
           f ((cycle ")]}>")!!n : e : c) --   push the matching closing bracket on the stack
               (n+1) r                   --   increase depth level and check the next char
   | elem x ")]}>" =                     -- if x is a closing bracket
       e :                               --   replace it by the closing bracket from on top of the stack
           f c (n-1) r                   --   decrement depth level and check the next char
   | otherwise     = x : f (e:c) n r     -- otherwise keep x and check the next char
Laikoni
fuente