Gleiche Klammertypen

9

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.

Dirk Reichel
quelle
Ich verstehe die Herausforderung nicht. Was muss die Ausgabe in Bezug auf die Eingabe sein?
xnor
@xnor Die Ausgabe sollte dieselbe Zeichenfolge wie die Eingabe sein, mit Ausnahme der vier Arten von Klammern. Sie müssen ersetzt werden, um dem Muster zu entsprechen.
Dirk Reichel
Ah, jetzt verstehe ich. Ich habe nicht verstanden, dass das "sollte" Dinge sind, die du wahr machen sollst. Ich werde bearbeiten, um es klarer zu machen.
xnor
1
@DirkReichel Ich glaube nicht, dass du dir darüber Sorgen machen musst. Ich kann mir nicht vorstellen, dass eine Sprache diese spezifische Transformation nativ durchführen kann, und in dem unwahrscheinlichen Fall, dass es eine solche Sprache gibt, bedeutet dies nur, dass Antworten in dieser Sprache nicht sehr interessant sind.
Martin Ender
2
@DirkReichel was ist der Sinn? Bleib einfach bei ASCII. Die Verwendung unterschiedlicher Zeichen erhöht die Herausforderung nur durch unnötige Einschränkungen für Nur-ASCII-Sprachen.
FlipTack

Antworten:

2

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

Arnauld
quelle
1

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();}
Rainer P.
quelle
Sie können 27 Bytes (portables Lex) oder 30 Bytes ( flexals Compiler verwenden) speichern, indem Sie die letzten zwei bzw. drei Zeilen löschen. Dies kostet einige Bytes (wahrscheinlich 2, 3 oder 4; die Regeln sind etwas unklar). in Strafen für die -llBefehlszeilenoption beim Verknüpfen der resultierenden C-Datei. (Das heißt, anstatt mit zu kompilieren lex brackets.l; cc lex.yy.c, kompilieren Sie mit lex brackets.l; cc lex.yy.c -ll.) Das ist definitiv ein Kompromiss, der sich in dieser Situation lohnt.
1

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

Xanderhall
quelle
1

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
Laikoni
quelle