基于 这个问题。

给定一个字符串，将每个括号替换()[]{}<>为适当类型的括号，以使括号匹配，并且嵌套括号循环如下：

1. 最外面的是 ()
2. 直接的内()应[]
3. 直接的内[]应{}
4. 直接的内{}应<>
5. 直接在内<>将()再次出现（周期）

所有非括号字符必须保持原样。开括号只能用某种类型的开括号替换，而闭括号则要用闭括号替换。

输入将始终使之成为可能。这意味着如果忽略其类型，则其括号正确匹配。所以，{ab<)c]是一个有效的输入，但ab)(cd还是ab((cd没有。

例子：

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

不允许使用这种方式对输入进行本机转换（语言的自动语法）。

与往常一样：最短的代码获胜。

JavaScript（ES6），79个字节

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

测试用例

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个字节

%{
int i,o[4]={40,91,123,60};
%}
%%
[[({<] {putchar(o[i++&3]);}
[])}>] {putchar(o[--i&3]+2-!(i&3));}
%%
yywrap(){}
main(){yylex();}

Java，155个字节

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

仅char[]作为参数的lambda 。我们遍历数组，将其位置存储s在变量（k）中的方括号（）中。我们检查它是否是左括号或右括号（s.indexAt()），并根据其嵌套水平（s.charAt()）将其替换为适当的括号，并使用%4

Haskell，126个字节

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

在ideone上尝试。用法：

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

说明

f接受三个参数：一个字符串，用作堆栈，用于括弧，一个int n用于计算嵌套深度和输入字符串。

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