Types de supports égaux

9

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.

code-golf string balanced-string Dirk Reichel
la source
Je ne comprends pas le défi. Quelle doit être la sortie en termes d'entrée?
xnor
@xnor la sortie doit être la même chaîne que l'entrée, à l'exception des quatre types de crochets. Ils doivent être remplacés pour correspondre au modèle.
Dirk Reichel
Ah, maintenant je vois. Je ne comprenais pas que le «devrait être» sont des choses que vous êtes censé rendre vraies. Je vais modifier pour essayer de le rendre plus clair.
xnor
1
@DirkReichel Je ne pense pas que ce soit quelque chose dont vous devez vous inquiéter. Je ne peux pas imaginer que n'importe quelle langue puisse effectuer cette transformation spécifique de manière native, et dans le cas peu probable où il y aurait une telle langue, cela signifierait que les réponses dans cette langue ne seront pas très intéressantes.
Martin Ender
2
@DirkReichel quel est le point? Restez avec ASCII. L'utilisation de caractères différents n'ajoute rien au défi, à part des restrictions inutiles sur les langues ASCII uniquement.
FlipTack

Réponses:

2

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

Afficher l'extrait de code

Arnauld
la source
1

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();}
Rainer P.
la source
Vous pouvez économiser 27 octets (lex portable) ou 30 octets (en utilisant flexcomme compilateur) en supprimant respectivement les deux ou trois dernières lignes, au prix d'un certain nombre d'octets (probablement 2, 3 ou 4; les règles ne sont pas claires) en pénalités pour l' -lloption de ligne de commande lors de la liaison du fichier C résultant. (Autrement dit, au lieu de compiler avec lex brackets.l; cc lex.yy.c, vous compilez avec lex brackets.l; cc lex.yy.c -ll.) C'est certainement un compromis à faire dans cette situation.
1

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

Xanderhall
la source
1

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
Laikoni
la source