Scrivi del codice che funge da programma per gatti. Cioè, per inserire una stringa e inviarla così com'è. Ma la normale inversione del codice deve generare la normale inversione della stringa di input. E l'inversione visiva del codice deve generare l'inversione visiva della stringa di input.

L'inversione normale è la sequenza di caratteri invertiti di una stringa. L'inversione visiva è l'inversione normale con i caratteri ()[]{}<>sostituiti )(][}{><rispettivamente da .

È possibile utilizzare qualsiasi codepage con i caratteri ()[]{}<>ed è pubblicato prima di questa sfida per definire i personaggi. È necessario utilizzare la stessa tabella codici per tutto il codice. Il codice originale deve essere valido in questa tabella di codici e l'applicazione di uno dei codici invertiti a questo dovrebbe restituire se stesso.

Questo è code-golf , vince il codice più corto in byte.

Esempio

Per la stringa AB(XY), i suoi ritorni normale e visive sono )YX(BAe (YX)BArispettivamente.

Se il tuo codice (in un linguaggio ipotetico) è AB(XY), allora il codice )YX(BAe (YX)BAdovrebbe generare rispettivamente le inversioni normali e visive della stringa di input. E AB(XY)dovrebbe agire come un programma per gatti.

05AB1E , 16 byte

Usa il fatto che 05AB1E ha una costante predefinita "()<>[]{}"e non è influenzata dall'inversione visiva.

Codice:

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

Spiegazione:

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

Provalo online!

invertito:

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

Spiegazione:

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.

Provalo online!

Visivamente invertito:

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

Spiegazione:

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.       

Provalo online!

Utilizza la codifica CP-1252 .

CJam, 21 byte

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

Provalo qui.

reversione normale:

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

Provalo qui.

Visiva reversione:

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

Provalo qui.

Spiegazione

In primo luogo, il codice normale:

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

Questo è semplice: qlegge tutti gli input, e#commenta il resto del programma e l'input viene stampato implicitamente alla fine.

Ora la reversione 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...

E, infine, l'inversione visiva:

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 byte

Inoltrare:

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

inverso Normale:

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

Visiva inverso:

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

Ogni versione definisce una funzione fche accetta e restituisce una stringa. In modalità avanti fè la funzione identità id, il resto del codice è un commento. In modalità inversa normale guardia 1<2in fIS True, quindi reverseviene applicato. In modalità visiva inversa, <si passa a >e la protezione è False. La seconda guardia è semplicemente il contrario e Truein modalità visiva, così inoltre qviene applicata che commuta "() <> {} []".

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

Oltre <e >nelle guardie, il mio codice non utilizza nessuna delle staffe, in modo che non possano essere incasinato.

Bash + utility Linux comuni, 51

• 2 byte salvati grazie a @ jimmy23013
• 2 byte salvati grazie @AdamKatz

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

reversione normale:

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

Visiva reversione:

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

Il trucco principale qui è che la stringa ()[]{}<>è codificata come 691E97CA5D607DB5 (base 15). Il risultante dccomando produrrà questo stesso risultato dopo entrambi i tipi di reversione. Tuttavia il '()[]{}<>'letterale stringa è sensibile al tipo di inversione.

tacè necessario per ordine di linee di ingresso inversa ed revè necessaria per invertire i caratteri di ogni riga. Qualsiasi input ASCII dovrebbe essere accettabile.

MATL, 26 24 22 16 byte

Inoltrare

DPEXSt'><}{][)('

Provalo online!

Spiegazione:

                % 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

reversione normale:

'()[]{}<>'tSXEPD

Provalo online!

Spiegazione:

            % 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

Visiva reversione:

')(][}{><'tSXEPD

Provalo online!

Spiegazione:

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

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

Provalo online!

reversione normale:

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

Provalo online!

Visiva reversione:

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

Provalo online!

Il fatto che un corrispondente }termina il programma in GolfScript, rese questa abbastanza semplice. Tuttavia, sono abbastanza sicuro che il mio codice per scambiare le parentesi non è ancora ottimale.

Pitone 2.7, 208 byte

Inoltrare

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

reversione 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

visiva reversione

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

Tutte le direzioni leggere dallo standard input fino EOF.

Niente super intelligente qui. Trailing commenti per eseguire solo in avanti contro il codice all'indietro, quindi execun'istruzione in un blocco try per errori di sintassi cattura per i due ritorni diversi.