Stack Cats ist eine umkehrbare, stapelbasierte Sprache. Seine reversible Natur sorgt für etwas seltsame Schleifen. Bei dieser Herausforderung geht es um die bedingte Schleife (...). Wenn diese Schleifen auf bestimmte Weise verschachtelt sind, kann der Code transformiert werden, um die Verschachtelungstiefe zu verringern. Hier sind die Regeln (wo Aund Bfür einen beliebigen Ausschnitt stehen):

1. Wenn eine Schleife mit einer anderen beginnt, können wir die innere Schleife nach vorne extrahieren: ((A)B)wird (A)(B).
2. Wenn eine Schleife mit einer anderen Schleife endet, können wir die innere Schleife bis zum Ende extrahieren: (B(A))wird (B)(A).
3. Leere Loops ()können vollständig aus dem Programm entfernt werden. Als Folgerung (in Verbindung mit den anderen Regeln) ((A))ist äquivalent zu (A).

Die einzige verschachtelten Schleifen , die von der Form bleiben (A(B)C), wo A, Bund Cnicht leer ist .

Die Herausforderung

Sie erhalten ein gültiges Stack Cats-Programm. Ihre Aufgabe ist es, mithilfe der obigen Transformationen die Verschachtelungsebene von Schleifen so weit wie möglich zu verringern, ohne leere Schleifen zu hinterlassen.

Ein gültiges Stack Cats Programm ...

• ... besteht nur aus den Zeichen ()/\<>[]{}!"*+-:=ITX^_|.
• ... hat Spiegelsymmetrie (zB \(]{}!{}[)/ist ein gültiges Programm, ist es aber /|/nicht).
• ... hat richtig abgestimmt und verschachtelt ()und {}( [], <>und \/müssen nicht unbedingt wie üblich zusammengepaßt werden, obwohl sie paarweise auf Grund der Spiegelsymmetrie Anforderung erscheinen werden).

Sie können entweder eine Zeichenfolge oder eine Liste von Zeichen als Eingabe verwenden, die Ausgabe muss jedoch im gleichen Format erfolgen.

Sie können ein Programm oder eine Funktion schreiben und eine unserer Standardmethoden zum Empfangen von Eingaben und zum Bereitstellen von Ausgaben verwenden. Beachten Sie, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

Testfälle sind jeweils zwei Zeilen (Eingabe und Ausgabe), die durch Leerzeilen getrennt sind. Beachten Sie, dass eine Ausgabe leer ist. Sie müssen auch die leere Eingabe unterstützen (was zu einer leeren Ausgabe führen sollte).

(((=+|+=)))
(=+|+=)

({(=+|+=)})
({(=+|+=)})

((\)/)I(\(/))
(\)(/)I(\)(/)

(()()(())()())


((<|>((X((T)))[_]))\^/(([_](((T))X))<|>))
(<|>)(X)(T)([_])(\^/)([_])(T)(X)(<|>)

Retina 0,8,2 , 113 107 67 66 Bytes

+`\(\)|(\()?(\(((\()|(?<-4>\))|[^()])*(?(4)@)\))(?(1)|(\)))
$5$2$1

Probieren Sie es online! Enthält 3 4 Byte Einsparung dank @MartinEnder. Erläuterung:

+`

Wenden Sie die Auswechslung wiederholt an, bis keine Übereinstimmungen mehr vorliegen.

\(\)|

Passen Sie eine leere Schleife an (in diesem Fall wird nichts erfasst, sodass die Ersetzung sie einfach löscht) oder:

(\()?

Optional passend zu a (. Dies wird in Gruppe 1 erfasst, wenn es übereinstimmt, aber nicht, wenn es nicht übereinstimmt.

(\(

Erfasse den Hauptteil des Matches in Gruppe 2 und passe a an (.

(
 (\()
|
 (<-4>\))
|
 [^()]
)*

Ordnen Sie wiederholt entweder a zu (, erfassen Sie es in Gruppe 4 oder a ), entfernen Sie ein Capture aus Gruppe 4 (schlägt fehl, wenn es keines gibt) oder etwas anderes.

(?(4)@)

Stellen Sie sicher, dass in Gruppe 4 keine Ersatzaufnahmen mehr vorhanden sind.

\))

Beenden Sie die Erfassungsgruppe 2 mit einer anderen ).

(?(1)|(\)))

Wenn die Erfassungsgruppe 1 leer war, erfassen Sie eine )in Erfassungsgruppe 5. (Also wird genau eine dieser beiden Gruppen erfasst).

$5$2$1

Verschieben Sie die in Gruppe 1 oder Gruppe 5 festgehaltene Klammer auf die andere Seite von Gruppe 2. Dies hat zur Folge, dass die innere Schleife nach vorne oder zum Ende der äußeren Schleife verschoben wird, je nachdem, zu welcher Seite sie passt.

Stax v1.0.3 +, 76 65 64 62 58 Bytes ^CP437

îÜ•$o,Γ{í]Üf╒9♦╛üΣóç*\$ñ₧└ΦJ♠¥c╥jóu≥3E.╘ⁿ◄◘W₧<¶┼7úê╟┴zç↨aG

70 Bytes beim Auspacken,

{{.((:/Yc{Z{40=+_41=-c^Ci~^Fdy,,\32&jEa:{a:{a4l$c}Md}X!:Rx!:Rc.()z:rgp

Online ausführen und debuggen!

Erläuterung

{.((:/Yc{Z{40=+_41=-c^Ci~^Fdy,,\32&jEa:{a:{a4l$c}Mdist ein Block, der sich A((B)C)Din vier Teile aufteilt und in konvertiertA(B)(C)D .

X!:Rx!:RFührt den Block in der Eingabezeichenfolge aus (Schritt 1), spiegelt dann die Zeichenfolge wider (Zeichenfolgenreflexion in Stax bezieht sich auf das Umkehren der Zeichenfolge plus das Ersetzen (Übersetzen) (<[{/durch (nach) \}]>)) und führt den Block in der erhaltenen Zeichenfolge aus und spiegelt ihn dann zurück (Schritt 2). Schritt 2 konvertiert im Wesentlichen (A(B))zu (A)(B).

c.()z:r entfernen Sie alle leeren Schleifen (Schritt 3).

gpist ein Generator, der den Fixpunkt einer Iteration findet. In diesem Fall wird die Zeichenfolge mit dem dreistufigen Prozess iteriert, bis sie sich nicht mehr ändert.

Implizite Ausgabe.

Python 3 , 226 223 212 206 Bytes

Okay, hier ist ein Versuch, dies in einer Sprache zu lösen, die rekursiven regulären Ausdruck nicht unterstützt.

lambda s:g(g(s,*'()'),*')(').replace('()','')
def g(s,t,u):
 m,*a={},;i=v=0
 for c in s:
  i+=1;a+=[i]*(c==t)
  if c==u:*a,x=a;m[x]=i;v=m.get(x+1)
  if v:return g(s[:x]+s[x+1:v]+t+s[v:],t,u)
 return s[::-1]

Probieren Sie es online!

Bearbeitungen:

• Überarbeitete [::-1]6 Bytes zu speichern, dank Mr.Xcoder.

Die gFunktion ist der Grundbaustein, der ein Vorkommen findet ((A)B), es ändert (A)(B)und sich dann auf das Ergebnis bezieht, bis keine Transformation mehr möglich ist.

Die Hauptschritte sind:

• gNormalerweise auf den Eingang anwenden .
• Auf gden Eingang anwenden gekippt. Dieser Lauf findet das Auftreten ))A(B(in der umgekehrten Eingabe, die effektiv behandelt (A(B)).
• Entfernen Sie alle Vorkommen von ().

Das Problem ist, gdass die Kontrollstruktur so schlecht ist, dass der Versuch, eine Linie zu bilden, zu einer schlechten Aufblähung geführt hat. Ich denke also nicht, dass eine wesentliche Verbesserung auf der Grundlage dieser Lösung möglich ist.