Écrivez du code qui agit comme un programme cat. C'est-à-dire, pour entrer une chaîne et la sortir telle quelle. Mais la réversion normale de votre code doit produire la réversion normale de la chaîne d'entrée. Et la réversion visuelle de votre code doit produire la réversion visuelle de la chaîne d'entrée.

La réversion normale est la séquence de caractères inversée d'une chaîne. La réversion visuelle est la réversion normale avec les caractères ()[]{}<>remplacés )(][}{><respectivement.

Vous pouvez utiliser n'importe quelle page de code contenant les caractères ()[]{}<>et publiée avant ce défi pour définir les caractères. Vous devez utiliser la même page de code pour tout votre code. Votre code d'origine doit être valide dans cette page de code, et l'application de l'un de vos codes inversés à celui-ci devrait se produire.

C'est le code-golf , le code le plus court en octets gagne.

Exemple

Pour la chaîne AB(XY), ses inversions normales et visuelles sont )YX(BAet (YX)BArespectivement.

Si votre code (dans une langue hypothétique) l'est AB(XY), alors le code )YX(BAet (YX)BAdevrait produire respectivement les inversions normales et visuelles de la chaîne d'entrée. Et AB(XY)devrait agir comme un programme de chat.

05AB1E , 16 octets

Utilise le fait que 05AB1E a une constante prédéfinie "()<>[]{}"et n'est pas affectée à la réversion visuelle.

Code:

,q‡"}{][><)("užR

Explication:

,                 # Pop and print the input.
 q                # Quit.
  ‡"}{][><)("užR  # This part is ignored.

Essayez-le en ligne!

Renversé:

Ržu"()<>[]{}"‡q,

Explication:

R                 # Reverse the input.
 žu               # Short for "()<>[]{}".
   "()<>[]{}"     # Push this string.
             ‡    # Transliterate (no-op, since everything is transliterated to itself).
              q   # Quit and implicitly print.
               ,  # This part is ignored.

Essayez-le en ligne!

Visuellement inversé:

Ržu")(><][}{"‡q,

Explication:

R                 # Reverse the input.
 žu               # Short for "()<>[]{}".
   ")(><][}{"     # Push this string.   
             ‡    # Transliterate (giving the visually reversed string).
              q   # Quit and implicitly print.
               ,  # This part is ignored.       

Essayez-le en ligne!

Utilise l' encodage CP-1252 .

CJam, 21 octets

qe#ere$_"}{][><)("%Wq

Testez-le ici.

Réversion normale:

qW%"()<>[]{}"_$ere#eq

Testez-le ici.

Réversion visuelle:

qW%")(><][}{"_$ere#eq

Testez-le ici.

Explication

Tout d'abord, le code normal:

qe#ere$_"}{][><)("%Wq

C'est simple: qlit toutes les entrées, e#commente le reste du programme et l'entrée est imprimée implicitement à la fin.

Maintenant, la réversion normale:

q            e# Read all input.
W%           e# Reverse it.
"()<>[]{}"   e# Push this string.
_$           e# Duplicate and sort it. However, the string is already sorted
             e# so we just get two copies of it.
er           e# Transliteration (i.e. character-wise substitution). But since the
             e# source and target string are identical, the reversed input
             e# is left unchanged.
e#eq            Just a comment...

Et enfin, la réversion visuelle:

q            e# Read all input.
W%           e# Reverse it.
")(><][}{"   e# Push this string.
_$           e# Duplicate and sort it. This gives us "()<>[]{}", i.e. the
             e# same string with each bracket pair swapped.
er           e# Transliteration (i.e. character-wise substitution). This
             e# time, this toggles all the brackets in the reversed input
             e# completing the visual reversion.
e#eq            Just a comment...

Haskell, 124 octets

Vers l'avant:

f=id
--esrever.q pam=2>1|esrever=2<1|f;x=x q;')'='(' q;'('=')' q;']'='[' q;'['=']' q;'>'='<' q;'<'='>' q;'}'='{' q;'{'='}' q

Marche arrière normale:

q '}'='{';q '{'='}';q '>'='<';q '<'='>';q ']'='[';q '['=']';q ')'='(';q '('=')';q x=x;f|1<2=reverse|1>2=map q.reverse--
di=f

Inverse visuel:

q '{'='}';q '}'='{';q '<'='>';q '>'='<';q '['=']';q ']'='[';q '('=')';q ')'='(';q x=x;f|1>2=reverse|1<2=map q.reverse--
di=f

Chaque version définit une fonction fqui prend et retourne une chaîne. En mode avant fest la fonction d'identité id, le reste du code est un commentaire. En mode normal , la marche arrière garde 1<2en fest - True, donc reverseest appliquée. En mode d'inversion visuelle, le <est commuté sur >et le protecteur l'est False. Le deuxième garde est juste l'inverse et Trueen mode visuel, donc en plus qest appliqué ce qui commute "() <> {} []".

f|1<2=reverse|1>2=map q.reverse      -- normal reverse mode
f|1>2=reverse|1<2=map q.reverse      -- visual reverse mode

En plus <et >dans les gardes, mon code n'utilise aucun des crochets, donc ils ne peuvent pas être foirés.

Utilitaires Linux communs Bash +, 51

• 2 octets enregistrés grâce à @ jimmy23013
• 2 octets économisés grâce à @AdamKatz

#'><}{][)(' `P5BD706D5AC79E196iFe- cd` rt|ver|
\cat

Réversion normale:

tac\
|rev|tr `dc -eFi691E97CA5D607DB5P` '()[]{}<>'#

Réversion visuelle:

tac\
|rev|tr `dc -eFi691E97CA5D607DB5P` ')(][}{><'#

L'astuce principale ici est que la chaîne ()[]{}<>est codée 691E97CA5D607DB5 (base 15). La dccommande résultante donnera ce même résultat après l'un ou l'autre type de réversion. Cependant, le '()[]{}<>'littéral de chaîne est sensible au type d'inversion.

tacest nécessaire pour inverser l'ordre des lignes d'entrée et revest requis pour inverser les caractères de chaque ligne. Toute entrée ASCII doit être acceptable.

MATL, 26 24 22 16 octets

Vers l'avant

DPEXSt'><}{][)('

Essayez-le en ligne!

Explication:

                % Implicitly grab the input as a string
D               % Pop the top of the stack and display it
P               % Tries to flip the top element on the stack but errors out
                % because the stack is empty. Program terminates.
EXSt'><}{][)('  % Not executed

Réversion normale:

'()[]{}<>'tSXEPD

Essayez-le en ligne!

Explication:

            % Implicitly grab input as a string
'()[]{}<>'  % String literal (search string)
tS          % Duplicate and sort to create the replacement string: '()[]{}<>'
XE          % Replace all entries in the input using the search and replacement strings. 
            % Corresponding characters in the strings are used for the replacement.
            % Effectively a no-op
P           % Flip the string
D           % Explicitly display result

Réversion visuelle:

')(][}{><'tSXEPD

Essayez-le en ligne!

Explication:

            % Implicitly grab the input as a string
')(][}{><'  % String literal (search string)
tS          % Duplicate and sort to create the replacement string: '()[]{}<>'
XE          % Replace all entries in the input using the search and replacement strings. 
            % Corresponding characters in the strings are used for the replacement. 
P           % Flip the result
D           % Explicitly display the result

GolfScript, 32 28 octets

#%{=1-[=-\7?@.`{[(<>)]}.}%1-

Essayez-le en ligne!

Réversion normale:

-1%}.}])><([{`.@?7\-=[-1={%#

Essayez-le en ligne!

Réversion visuelle:

-1%{.{[(<>)]}`.@?7\-=]-1=}%#

Essayez-le en ligne!

Le fait qu'un système inégalé }termine le programme dans GolfScript, a rendu cela assez simple. Cependant, je suis presque sûr que mon code pour permuter les crochets n'est pas encore optimal.

Python 2.7, 208 octets

Vers l'avant

import sys#
print''.join(sys.stdin)#
#0:tpecxe
#"]1-::[)nidts.sys(nioj.'' tnirp"cexe:yrt
#0:tpecxe
#"(('<>{}[]()','><}{][)(')snartekam.s)etalsnart.[1-::](nidts.sys)nioj.'' tnirp"cexe:yrt
#s sa gnirts,sys tropmi

Réversion normale

import sys,string as s#
try:exec"print''.join)sys.stdin(]::-1[.translate)s.maketrans)'()[]{}<>',')(][}{><'(("#
except:0#
try:exec"print''.join(sys.stdin)[::-1]"#
except:0#
#)nidts.sys(nioj.''tnirp
#sys tropmi

https://eval.in/574639

Réversion visuelle

import sys,string as s#
try:exec"print''.join(sys.stdin)[::-1].translate(s.maketrans(')(][}{><','()[]{}<>'))"#
except:0#
try:exec"print''.join)sys.stdin(]::-1["#
except:0#
#(nidts.sys)nioj.''tnirp
#sys tropmi

https://eval.in/574638

Toutes les directions sont lues de stdin jusqu'à EOF.

Rien de super intelligent ici. Commentaires de fin pour exécuter uniquement le code en avant par rapport au code en arrière, puis une execinstruction dans un bloc try pour intercepter les erreurs de syntaxe pour les deux inversions différentes.