Basé sur CETTE question.

Étant donné une chaîne, remplacez chaque parenthèse ()[]{}<>par une parenthèse du type approprié afin que les parenthèses correspondent, et les parenthèses imbriquées cycle comme suit:

1. Les plus externes sont ()
2. Directement à l' intérieur de ()devrait être[]
3. Directement à l' intérieur de []devrait être{}
4. Directement à l' intérieur de {}devrait être<>
5. Directement à l'intérieur de <>sera à ()nouveau (cycles)

Tous les caractères sans parenthèse doivent rester exactement tels qu'ils sont. Les parenthèses ouvertes ne peuvent être remplacées que par des parenthèses ouvertes d'un certain type et les parenthèses fermées par des parenthèses fermées.

L'entrée rendra cela toujours possible. Cela signifie que ses crochets correspondent correctement si leur type est ignoré. Alors, {ab<)c]est une entrée valide, mais ab)(cdou ab((cdne sont pas.

Exemples:

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

L'utilisation de la transformation native des entrées de cette façon (syntaxe automatique du langage) n'est pas autorisée.

Comme toujours: le code le plus court gagne.

JavaScript (ES6), 79 octets

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

Cas de test

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 octets

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

Java, 155 octets

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 qui prend un char[]comme argument unique. Nous parcourons le tableau, stockant sa position dans notre chaîne de crochets ( s) dans une variable ( k). Nous vérifions s'il s'agit d'un support d'ouverture ou de fermeture ( s.indexAt()), et le remplaçons par le support approprié en fonction de son niveau d'imbrication ( s.charAt()), en bouclant de manière appropriée avec%4

Haskell, 126 octets

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

Essayez-le sur ideone. Usage:

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

Explication

fprend trois arguments: une chaîne qui fonctionne comme une pile pour fermer les crochets, un int npour compter la profondeur d'imbrication et la chaîne d'entrée.

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