이 질문을 바탕으로 합니다.

문자열이 주어지면 각 브래킷 ()[]{}<>을 적절한 유형의 브래킷 으로 교체 하여 브래킷이 일치하고 중첩 된 브래킷이 다음과 같이 순환합니다.

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])
<<<>><<>><<<<<<>>>>>>> = ([{}][{}][{<([{}])>}])

이 방법으로 입력을 기본적으로 변환하는 것은 사용할 수 없습니다 (언어의 자동 구문).

항상 그렇듯이 가장 짧은 코드가 승리합니다.

자바 스크립트 (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();}

자바, 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[]단일 인수로 사용 되는 람다 . 우리는 배열을 반복하여 배열 ( s) 안의 문자열을 변수 ( k)에 저장합니다. 우리는 여는 또는 닫는 괄호 ( s.indexAt()) 인지 확인 하고 중첩 수준 ( s.charAt()) 에 따라 적절한 괄호로 바꿉니다.%4

하스켈, 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

아이디어로 사용해보십시오. 용법:

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

설명

f괄호를 닫기위한 스택으로 작동하는 문자열 n, 중첩 깊이를 계산하기 위한 int 및 입력 문자열.

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