Contexte

Stack Cats est un langage ésotérique réversible créé par Martin Ender. Chaque commande dans Stack Cats est soit l'inverse d'elle-même (représentée comme un caractère symétrique, comme -_:T|), soit possède sa commande inverse (représentée comme l'image miroir, comme () {} [] <>). Stack Cats a une forte exigence syntaxique que tout le programme soit l'image miroir de lui-même. Notez que cela signifie que tout programme Stack Cats valide est un ambigramme d'image miroir naturel .

Voici l'ensemble des commandes de Stack Cats:

• Auto-symétrique: !*+-:=ITX^_|
• Paires symétriques: () {} [] <> \/

Tout autre caractère n'est pas valide; toute entrée dont le caractère ne se trouve pas dans le jeu de caractères ci-dessus doit afficher false.

La langue a une contrainte supplémentaire ()et les {}paires doivent toujours être équilibrées, mais pour des raisons de simplicité, vous n'avez pas à vérifier cette condition.

Voici quelques exemples d'un programme Stack Cats valide (encore une fois, notez que vous ne vérifiez pas les parens équilibrés):

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

Ce ne sont pas:

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

Défi

Écrivez un programme ou une fonction qui détermine si la chaîne donnée est un programme Stack Cats valide. Votre code doit également être un ambigramme d'image miroir naturel , ce qui signifie:

• Votre code doit être une image miroir de lui-même.
  • Votre code peut avoir une ou plusieurs nouvelles lignes, tant que le code entier, affiché naturellement, est une image miroir de lui-même.
  • Vous pouvez omettre ou ajouter des espaces blancs de fin sur chaque ligne, car cela ne change pas l'affichage.
  • Les caractères de tabulation ne sont pas autorisés car ils présentent une certaine ambiguïté.

Remarque: votre code ne doit pas nécessairement être un programme Stack Cats valide; il peut contenir certains caractères supplémentaires qui ne sont pas autorisés dans Stack Cats. (Voir ci-dessous pour la liste complète.)

Par exemple, les deux programmes suivants sont symétriques (et donc une soumission valide ), tandis que le troisième ne l'est pas:

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

({bTd})
  IXI

({bTd})
IXI

• En ce qui concerne la "symétrie miroir", seule la symétrie de style Stack Cats est prise en compte (par exemple, ({IH})n'est pas une soumission valide, même si elle a une symétrie miroir).
• Votre code ne peut contenir que ces jeux de caractères, plus la nouvelle ligne:
  • Auto-symétrique: espace ( 0x20) +!"'*+-.8:=AHIMOTUVWXY^_ovwx|
  • Paires symétriques: () /\ <> [] bd pq {}

Le jeu de caractères est choisi pour être strictement symétrique ou auto-symétrique lorsqu'il est affiché sous forme de code sur SE.

Entrée et sortie

La plage d'entrée est une chaîne d'une ligne de caractères ASCII imprimables .

Vous pouvez choisir de prendre l'entrée comme une chaîne, une liste de caractères ou une liste de valeurs ASCII.

Vous pouvez choisir de sortir soit:

• N'importe laquelle des valeurs véridiques / fausses telles que définies par la langue de votre choix
  • Les valeurs de résultat réelles peuvent différer entre les entrées (par exemple, la sortie 1 pour une entrée véridique et 2 pour une autre véridique).
  • L'échange de valeurs véridiques et fausses n'est pas autorisé.
• Deux valeurs constantes respectivement pour vrai / faux
  • Dans ce cas, les valeurs de résultat doivent être exactement l'une des deux valeurs constantes.

Vous devez spécifier votre méthode d'entrée et les valeurs de sortie dans votre soumission.

Condition gagnante

Il s'agit de code-golf , donc les octets les plus bas dans chaque langue l'emportent.

Remarques

• Les failles standard sont interdites comme d'habitude.
• Bien sûr, vous pouvez résoudre ce problème dans Stack Cats, mais il est possible que vous ne puissiez pas utiliser un indicateur qui permet de réduire de moitié la taille de votre code. Et c'est un langage vraiment difficile à comprendre: P

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

14 octets enregistrés grâce à @Bubbler

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

Définit une fonction anonyme qui prend un tableau de caractères et renvoie la sortie souhaitée. La sortie est véridique / fausse; habituellement 1/ 0, mais la chaîne vide donne true.

Comment?

L'astuce la plus évidente consiste à utiliser //\\comme point central pour commenter la version miroir du code. Après cela, cela devient un jeu pour trouver le moyen le plus court de résoudre le problème en utilisant uniquement le jeu de caractères donné.

Le premier problème que nous rencontrons est le manque de mots clés et de fonctionnalités intégrées. Nous avons miraculeusement encore .pop(), mais tout le reste devra être fait via les opérateurs autorisés (qui comprenda[b] et f(c)), avec récursivité pour émuler les boucles.

Le deuxième problème est le manque d'opérateurs logiques. Ni &et ?sont autorisés, ce qui signifie que le seul opérateur de prise de décision que nous pouvons utiliser est|| . Par conséquent, nous devons soigneusement structurer notre logique pour en tenir compte.

La première chose que j'ai faite a été de définir une fonction Tqui reflète un caractère individuel. L'idée de base est de parcourir chaque caractère dans une chaîne de caractères miroir, testant chacun l'égalité avec le caractère donné. S'il est égal, nous retournons son miroir - le caractère à index^1pour (){}[]<>\/ou le caractère lui-même pour le reste.

Le premier problème que j'ai rencontré ici a été d'obtenir le caractère miroir ou une valeur falsifiée à chaque itération. La solution que j'ai finalement trouvée était (x!=A[o]||A)[o^o<88/8], où xest le caractère d'entrée, Al'alphabet miroir et ol'index actuel. Si xn'est pas le même que A[o], cela donne true, et l'expression d'index est évaluée à undefined; sinon, le ||Aest activé, et nous finissons par l'obtenir A[o^(o<11)].

Le deuxième problème est de savoir comment mettre fin à la récursivité. J'ai trouvé que la meilleure façon de le faire est de simplement concaténer les résultats de chaque itération, en retournant la chaîne vide lorsque la fin de Aest atteinte. Cela nous pose deux autres problèmes: convertir le undefineds en chaînes vides et retourner ||quelque chose à la chaîne vide . Ceux-ci peuvent être résolus avec un abus de tableau: [a]+""donne la représentation sous forme de chaîne aou la chaîne vide si elle an'est pas définie. En prime, []est véridique mais se transforme en chaîne vide, nous pouvons donc l'utiliser de manière pratique comme une "chaîne vide véridique".

Maintenant, nous pouvons utiliser la Tfonction pour refléter n'importe quel caractère unique. Nous le faisons récursivement, en comparant le miroir de I[v++]à I.pop()jusqu'à ce que la fin du tableau de caractères soit atteinte. Nous ne pouvons pas utiliser &&ou &pour vérifier si toutes les comparaisons sont véridiques, mais utilisez-les à la *place. La multiplication de tous ces résultats donne 1si chaque personnage est le miroir de celui opposé, ou 0si une comparaison échoue.

Et c'est essentiellement ainsi que fonctionne cette réponse. Je ne l'ai probablement pas expliqué très clairement, veuillez donc poser toutes vos questions et signaler toutes les erreurs que j'ai commises.

Stax , 76 70 octets

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

Exécuter et déboguer

Stax est ami de Stack Cats et possède des éléments internes pour générer la dernière moitié d'un programme Stack Cats à partir de la première moitié. Si nous ne nous soucions pas de la restriction sur la source et n'avons pas besoin de vérifier le jeu de caractères, voici une solution à 4 octets:

4 octets

:R_=

Exécuter et déboguer

Explication

: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