Hintergrund

Stack Cats ist eine reversible esoterische Sprache von Martin Ender. Jeder Befehl in Stack Cats ist entweder das Inverse von sich selbst (dargestellt als symmetrisches Zeichen, wie z. B. -_:T|) oder hat ein inverses Kommando (dargestellt als Spiegelbild, wie z. B. () {} [] <>). Stack Cats hat eine starke syntaktische Anforderung, dass das gesamte Programm das Spiegelbild von sich selbst sein sollte. Beachten Sie, dass dies bedeutet, dass jedes gültige Stack Cats-Programm ein natürliches spiegelbildliches Ambigramm ist .

Hier ist der gesamte Befehlssatz von Stack Cats:

• Selbstsymmetrisch: !*+-:=ITX^_|
• Symmetrische Paare: () {} [] <> \/

Alle anderen Zeichen sind ungültig. Alle Eingaben mit einem Zeichen, das nicht im obigen Zeichensatz enthalten ist, sollten false ausgeben.

Die Sprache unterliegt einer zusätzlichen Einschränkung, ()und {}Paare müssen immer ausgeglichen sein. Der Einfachheit halber müssen Sie diese Bedingung jedoch nicht überprüfen.

Im Folgenden finden Sie einige Beispiele für ein gültiges Stack Cats-Programm (beachten Sie auch hier, dass Sie nicht auf ausgeglichene Parens prüfen):

{[+]==[+]}
[)>^<(]
({T)}|{(T})
<(*]{[:!-_:>}<[<)*(>]>{<:_-!:]}[*)>

Diese sind nicht:

b<+>d
())(
({[<++<]})

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die bestimmt, ob die angegebene Zeichenfolge ein gültiges Stack Cats-Programm ist. Ihr Code sollte auch ein natürliches spiegelbildliches Ambigramm sein , was bedeutet:

• Ihr Code sollte ein Spiegelbild von sich selbst sein.
  • Ihr Code kann eine oder mehrere Zeilenumbrüche enthalten, solange der gesamte Code, der auf natürliche Weise angezeigt wird, ein Spiegelbild von sich selbst ist.
  • Sie können abschließende Leerzeichen in jeder Zeile weglassen oder hinzufügen, da dies die Anzeige nicht verändert.
  • Tabulatorzeichen sind nicht zulässig, da sie eine gewisse Mehrdeutigkeit aufweisen.

Hinweis: Ihr Code muss kein gültiges Stack Cats-Programm sein. Es kann bestimmte zusätzliche Zeichen enthalten, die in Stack Cats nicht zulässig sind. (Siehe unten für die vollständige Liste.)

Zum Beispiel sind die folgenden zwei Programme symmetrisch (und somit eine gültige Einreichung ), während das dritte nicht ist:

({bTd})
[<q|p>]

({bTd})
  IXI

({bTd})
IXI

• In Bezug auf "Spiegelsymmetrie" wird nur die Stack-Cats-Symmetrie berücksichtigt (z. B. ({IH})ist keine gültige Einreichung, obwohl sie Spiegelsymmetrie aufweist).
• Ihr Code kann nur diese Zeichensätze plus Zeilenvorschub enthalten:
  • Selbstsymmetrisch: space ( 0x20) +!"'*+-.8:=AHIMOTUVWXY^_ovwx|
  • Symmetrische Paare: () /\ <> [] bd pq {}

Der Zeichensatz wird streng symmetrisch oder selbstsymmetrisch gewählt, wenn er als Code in SE angezeigt wird.

Ein- und Ausgang

Der Eingabebereich ist eine einzeilige Zeichenfolge aus druckbaren ASCII-Zeichen .

Sie können festlegen, ob die Eingabe als Zeichenfolge, Liste der Zeichen oder Liste der ASCII-Werte erfolgen soll.

Sie können wählen, ob Sie Folgendes ausgeben möchten:

• Alle wahrheitsgemäßen / falschen Werte, wie sie in der Sprache Ihrer Wahl definiert sind
  • Die tatsächlichen Ergebniswerte können zwischen den Eingaben abweichen (z. B. Ausgabe 1 für eine wahrheitsgemäße Eingabe und 2 für eine andere wahrheitsgemäße Eingabe).
  • Das Austauschen von wahren und falschen Werten ist nicht gestattet.
• Beliebige zwei konstante Werte für true / false
  • In diesem Fall sollten die Ergebniswerte genau einer der beiden konstanten Werte sein.

Sie sollten Ihre Eingabemethode und Ausgabewerte in Ihrer Einreichung angeben.

Gewinnbedingung

Dies ist Codegolf , daher gewinnt das niedrigste Byte in jeder Sprache.

Anmerkungen

• Standardlücken sind wie gewohnt verboten.
• Natürlich können Sie dies in Stack Cats lösen, aber die Chance besteht darin, dass Sie kein Flag verwenden können, mit dem Sie Ihre Codegröße um die Hälfte reduzieren können. Und es ist sehr schwer, die Sprache zu lernen: P

JavaScript (ES6), 487 467 378 298 292 280 266 264 Byte

14 Bytes dank @Bubbler gespart

I=>(V=v=>!I[v]||((T=o=>[[]][+!!A[o]]||[(I[v]!=A[o]||A)[o^o<88/8]]+T(++o))(8-8)==I.pop())*V(++v))(V|(A='(){}[]<>\\/ !*+-:=ITX^_|'))//\\(('|_^XTI=:-+*! \//<>[]{}()'=A)|V)((v++)V*(()qoq.I==(8-8)((o++)T+[[8\88>o^o](A||[o]A=![v]I)]||[[o]A!!+][[]]<=o=T))||[v]I!<=v=V)<=I

Definiert eine anonyme Funktion, die ein Array von Zeichen annimmt und die gewünschte Ausgabe zurückgibt. Die Ausgabe ist wahr / falsch; normalerweise 1/ 0, aber die leere Zeichenfolge gibt true.

Wie?

Der naheliegendste Trick besteht darin //\\, die gespiegelte Version des Codes als Mittelpunkt auszukommentieren. Danach wird es ein Spiel, den kürzesten Weg zu finden, um das Problem nur mit dem angegebenen Zeichensatz zu lösen.

Das erste Problem, auf das wir stoßen, ist das Fehlen von Schlüsselwörtern und integrierten Funktionen. Wir haben es auf wundersame Weise immer noch .pop(), aber alles andere muss über die zulässigen Operatoren (einschließlich a[b]und f(c)) mit Rekursion zum Emulieren von Schleifen erfolgen.

Das zweite Problem ist der Mangel an logischen Operatoren. Weder noch &und ?sind erlaubt, was bedeutet, dass der einzige Entscheidungsträger, den wir verwenden können, ist ||. Daher müssen wir unsere Logik sorgfältig strukturieren, um dies zu berücksichtigen.

Als erstes habe ich eine Funktion definiert T, die ein individuelles Zeichen widerspiegelt. Die Grundidee besteht darin, jedes Zeichen in einer Folge von spiegelbaren Zeichen zu durchlaufen und jedes Zeichen auf Gleichheit mit dem angegebenen Zeichen zu testen. Wenn es gleich ist, geben wir seinen Spiegel zurück - den char at index^1for (){}[]<>\/oder den char selbst für den Rest.

Das erste Problem, auf das ich hier gestoßen bin, war das Abrufen des gespiegelten Zeichens oder eines falschen Werts für jede Iteration. Die Lösung, die ich letztendlich gefunden habe, war (x!=A[o]||A)[o^o<88/8]: Wo xist das Eingabezeichen, Aist das spiegelnde Alphabet und oist der aktuelle Index. If xist nicht dasselbe wie A[o], was ergibt true, und der Indexausdruck ergibt undefined; Andernfalls wird die ||Aaktiviert und wir erhalten A[o^(o<11)].

Das zweite Problem ist das Beenden der Rekursion. Ich fand, dass der beste Weg, dies zu tun, darin besteht, die Ergebnisse jeder Iteration einfach zu verketten und die leere Zeichenfolge zurückzugeben, wenn das Ende von Aerreicht ist. Dies stellt uns vor zwei weitere Probleme: Konvertieren der undefineds in leere Zeichenfolgen und Zurückgeben der leeren Zeichenfolge ||. Diese Probleme können durch Array-Missbrauch behoben werden: [a]+""Gibt die Zeichenfolgendarstellung aoder die leere Zeichenfolge an, wenn sie nicht adefiniert ist. Als Bonus []ist wahr , wird aber zur leeren Zeichenkette, so dass wir dies bequem als "wahrheitsgemäße leere Zeichenkette" verwenden können.

Jetzt können wir die TFunktion verwenden, um jedes einzelne Zeichen zu spiegeln. Wir tun dies rekursiv, den Spiegel des Vergleichens I[v++]zu , I.pop()bis das Ende des Arrays von Zeichen erreicht ist. Wir können nicht &&oder verwenden &, um zu überprüfen, ob alle Vergleiche wahr sind, sondern verwenden *stattdessen. Das Multiplizieren aller dieser Ergebnisse ergibt, 1ob jedes Zeichen der Spiegel des anderen ist oder 0ob ein Vergleich fehlschlägt.

Und so funktioniert diese Antwort im Grunde. Wahrscheinlich habe ich es nicht sehr deutlich erklärt. Bitte stellen Sie alle Fragen, die Sie haben, und weisen Sie auf Fehler hin, die ich gemacht habe.

Stax , 76-70 Bytes

:Wx^^MH_=_"{([</!*+-:=ITX^_|":W-!*pq*!-W:"|_^XTI=:-+*!\>])}"_=_HM^^xW:

Führen Sie es aus und debuggen Sie es

Stax ist mit Stack Cats befreundet und verfügt über Interna, um die spätere Hälfte eines Stack Cats-Programms aus der ersten Hälfte zu generieren. Wenn uns die Einschränkung der Quelle egal ist und wir den Zeichensatz nicht überprüfen müssen, ist hier eine 4-Byte-Lösung:

4 Bytes

:R_=

Führen Sie es aus und debuggen Sie es

Erläuterung

:Wx^^MH_=_"{([</!*+-:=ITX^_|":W-!*pq...
:W                                         "Mirror" the string
                                           Equivalent to appending the reverse of the string to itself
                                           And map `{([</\>])}` to its mirror in the appended string
  x^^                                      2, but we can't just use `2` here ...
     MH                                    Partition the "mirror"ed string to two parts, take the later part.
       _=                                  The string is the same as the original one (*)
                                           `:Wx^^MH_=` is just `:R_=`, but we can't use `R` here ...
         _                                 Input string
          "{([</!*+-:=ITX^_|":W-           Remove valid characters from input
                                !          The final string is empty (**)
                                 *         (*) and (**)
                                  p        Pop and print result
                                   q       Peek stack and print
                                           Since the stack is now empty, this causes the program to terminate
                                    ...    Not executed