Escreva um código que atue como um programa para gatos. Ou seja, para inserir uma string e produzi-la como está. Mas a reversão normal do seu código deve gerar a reversão normal da string de entrada. E a reversão visual do seu código deve gerar a reversão visual da sequência de entrada.

A reversão normal é a sequência de caracteres invertida de uma sequência. A reversão visual é a reversão normal, com os caracteres ()[]{}<>substituídos por )(][}{><respectivamente.

Você pode usar qualquer página de código que tenha os caracteres ()[]{}<>e seja publicada antes deste desafio para definir caracteres. Você deve usar a mesma página de código para todo o seu código. Seu código original deve ser válido nesta página de códigos, e a aplicação de qualquer código reverso a ele deve render-se.

Este é o código-golfe , o código mais curto em bytes vence.

Exemplo

Para a corda AB(XY), suas reversões normal e visual são )YX(BAe (YX)BArespectivamente.

Se o seu código (em um idioma hipotético) for AB(XY), então o código )YX(BAe (YX)BAdeve gerar as reversões normal e visual da sequência de entrada, respectivamente. E AB(XY)deve atuar como um programa para gatos.

05AB1E , 16 bytes

Usa o fato de 05AB1E ter uma constante predefinida "()<>[]{}"e não afetar a reversão visual.

Código:

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

Explicação:

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

Experimente online!

Invertida:

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

Explicação:

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.

Experimente online!

Visualmente invertido:

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

Explicação:

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.       

Experimente online!

Usa a codificação CP-1252 .

CJam, 21 bytes

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

Teste aqui.

Reversão normal:

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

Teste aqui.

Reversão visual:

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

Teste aqui.

Explicação

Primeiro, o código normal:

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

Isso é simples: qlê todas as entradas, e#comenta o restante do programa e a entrada é impressa implicitamente no final.

Agora a reversão normal:

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...

E, finalmente, a reversão visual:

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 bytes

Frente:

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

Reversão normal:

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

Reversão visual:

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

Cada versão define uma função fque pega e retorna uma string. No modo de encaminhamento fé a função de identidade id, o restante do código é um comentário. No modo inverso normal, a guarda 1<2no fé True, por isso, reverseé aplicada. No modo de reversão visual, o <comutador é para >e a proteção é False. A segunda guarda é inversamente e Trueno modo visual, portanto, qé aplicado adicionalmente que alterna "() <> {} []".

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

Além disso, <e >nos guardas, meu código não usa nenhum dos colchetes, então eles não podem ser bagunçados.

Bash + utilitários linux comuns, 51

• 2 bytes salvos graças a @ jimmy23013
• 2 bytes salvos graças a @AdamKatz

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

Reversão normal:

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

Reversão visual:

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

O principal truque aqui é que a sequência ()[]{}<>é codificada como 691E97CA5D607DB5 (base 15). O dccomando resultante produzirá esse mesmo resultado após qualquer tipo de reversão. No entanto, a '()[]{}<>'string literal é sensível ao tipo de reversão.

tacé necessário para reverter a ordem das linhas de entrada e revé necessário reverter os caracteres de cada linha. Qualquer entrada ASCII deve ser aceitável.

MATL, 26 24 22 16 bytes

frente

DPEXSt'><}{][)('

Experimente Online!

Explicação:

                % 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

Reversão normal:

'()[]{}<>'tSXEPD

Experimente Online!

Explicação:

            % 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

Reversão visual:

')(][}{><'tSXEPD

Experimente Online!

Explicação:

            % 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 bytes

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

Experimente online!

Reversão normal:

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

Experimente online!

Reversão visual:

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

Experimente online!

O fato de um incomparável }finalizar o programa no GolfScript tornou isso bastante simples. No entanto, tenho certeza de que meu código para trocar os colchetes ainda não é o ideal.

Python 2.7, 208 bytes

frente

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

Reversão normal

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

Reversão visual

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

Todas as instruções são lidas de stdin até EOF.

Nada super inteligente aqui. Comentários finais para executar apenas o código de encaminhamento versus o código de execretorno e, em seguida, uma instrução em um bloco try para detectar erros de sintaxe para as duas reversões diferentes.