Basierend auf DIESER Frage.

Ersetzen Sie ()[]{}<>bei einer gegebenen Zeichenfolge jede Klammer durch eine Klammer des entsprechenden Typs, sodass die Klammern übereinstimmen und die verschachtelten Klammern wie folgt wechseln:

1. Die äußersten sind ()
2. Direkt drinnen ()sollte sein[]
3. Direkt drinnen []sollte sein{}
4. Direkt drinnen {}sollte sein<>
5. Direkt innerhalb von <>wird ()wieder sein (Zyklen)

Alle Zeichen ohne Klammer müssen genau so bleiben, wie sie sind. Offene Klammern dürfen nur durch offene Klammern irgendeiner Art und geschlossene Klammern durch geschlossene Klammern ersetzt werden.

Die Eingabe wird dies immer ermöglichen. Dies bedeutet, dass die Klammern korrekt übereinstimmen, wenn ihr Typ ignoriert wird. Also, {ab<)c]ist eine gültige Eingabe, aber ab)(cdoder ab((cdnicht.

Beispiele:

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

Die Verwendung der nativen Transformation von Eingaben auf diese Weise (automatische Syntax der Sprache) ist nicht zulässig.

Wie immer: kürzester Code gewinnt.

JavaScript (ES6), 79 Byte

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

Testfälle

let f =

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

console.log(f("2#jd {¤>."));
console.log(f("abcdef"));
console.log(f("(3×5+(4-1))"));
console.log(f("<<<>><<>><<<<<<>>>>>>>"));

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();}

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, das ein char[]einziges Argument annimmt . Wir durchlaufen das Array und speichern seine Position in unserer Zeichenfolge ( s) in einer Variablen ( k). Wir prüfen, ob es sich um eine öffnende oder schließende Klammer handelt ( s.indexAt()), und ersetzen sie durch die entsprechende Klammer, basierend auf der Verschachtelungsebene ( s.charAt()), wobei wir eine entsprechende Schleife verwenden%4

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

Probieren Sie es auf ideone. Verwendungszweck:

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

Erläuterung

fEs werden drei Argumente verwendet: Eine Zeichenfolge, die als Stapel zum Schließen von Klammern dient, ein Int nzum Zählen der Verschachtelungstiefe und der Eingabezeichenfolge.

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