Reversión de cadena normal y visual

17

Escriba un código que actúe como un programa cat. Es decir, ingresar una cadena y enviarla como está. Pero la reversión normal de su código debe generar la reversión normal de la cadena de entrada. Y la reversión visual de su código debe generar la reversión visual de la cadena de entrada.

La reversión normal es la secuencia de caracteres invertida de una cadena. La reversión visual es la reversión normal con los caracteres ()[]{}<>reemplazados por )(][}{><respectivamente.

Puede usar cualquier página de códigos que tenga los caracteres ()[]{}<>y se publique antes de este desafío para definir los caracteres. Debe usar la misma página de códigos para todo su código. Su código original debe ser válido en esta página de códigos, y la aplicación de cualquiera de sus códigos invertidos a eso debería rendirse.

Este es el código de golf , el código más corto en bytes gana.

Ejemplo

Para la cadena AB(XY), sus reversiones normales y visuales son )YX(BAy (YX)BArespectivamente.

Si su código (en un lenguaje hipotético) es AB(XY), entonces el código )YX(BAy (YX)BAdebería generar las reversiones normales y visuales de la cadena de entrada respectivamente. Y AB(XY)debe actuar como un programa de gatos.

code-golf string source-layout jimmy23013
fuente
¿Se espera que las cadenas de entrada puedan contener nuevas líneas?
Trauma digital
@DigitalTrauma No pensé en eso ... Su programa debería admitir cualquier rutina de entrada que use podría devolver (siempre que devuelva una cadena). Y debería funcionar en el código original en sí.
jimmy23013
1
Codegolf.stackexchange.com/q/28190/15599
Level River St

Respuestas:

9

05AB1E , 16 bytes

Utiliza el hecho de que 05AB1E tiene una constante predefinida "()<>[]{}"y no se ve afectada por la reversión visual.

Código:

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

Explicación:

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

Pruébalo en línea!

Invertido:

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

Explicación:

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.

Pruébalo en línea!

Visualmente invertido:

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

Explicación:

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.

Pruébalo en línea!

Utiliza la codificación CP-1252 .

Adnan
fuente
6

CJam, 21 bytes

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

Pruébalo aquí.

Reversión normal:

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

Pruébalo aquí.

Reversión visual:

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

Pruébalo aquí.

Explicación

Primero, el código normal:

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

Esto es simple: qlee todas las entradas, e#comenta el resto del programa y la entrada se imprime implícitamente al final.

Ahora la reversión 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...

Y finalmente, la reversión 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...
Martin Ender
fuente
Yo tenía exactamente este código yo mismo.
jimmy23013
6

Haskell, 124 bytes

Adelante:

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

Reversa normal:

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

Visual reverso:

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

Cada versión define una función fque toma y devuelve una cadena. En el modo directo fes la función de identidad id, el resto del código es un comentario. En el modo inverso normal, la protección 1<2en sí festá True, por lo que reversese aplica. En el modo visual inverso, <se cambia a >y el protector es False. La segunda protección es al revés y Trueen modo visual, por lo que adicionalmente qse aplica lo que cambia "() <> {} []".

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

Además <y >en los guardias, mi código no usa ninguno de los corchetes, por lo que no se pueden estropear.

nimi
fuente
6

Bash + utilidades comunes de Linux, 51

  • 2 bytes guardados gracias a @ jimmy23013
  • 2 bytes guardados gracias a @AdamKatz
#'><}{][)(' `P5BD706D5AC79E196iFe- cd` rt|ver|
\cat

Reversión normal:

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

Reversión visual:

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

El truco principal aquí es que la cadena ()[]{}<>está codificada como 691E97CA5D607DB5 (base 15). El dccomando resultante producirá este mismo resultado después de cualquier tipo de reversión. Sin embargo, el '()[]{}<>'literal de cadena es sensible al tipo de inversión.

tacse requiere para invertir el orden de las líneas de entrada y revpara invertir los caracteres de cada línea. Cualquier entrada ASCII debe ser aceptable.

Trauma digital
fuente
5

MATL, 26 24 22 16 bytes

Adelante

DPEXSt'><}{][)('

Pruébalo en línea!

Explicación:

                % 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

Reversión normal:

'()[]{}<>'tSXEPD

Pruébalo en línea!

Explicación:

            % 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

Reversión visual:

')(][}{><'tSXEPD

Pruébalo en línea!

Explicación:

            % 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
Suever
fuente
La reversión visual es la reversión normal con los caracteres ()[]{}<>reemplazados por )(][}{><respectivamente.
Erik the Outgolfer
@ ΈρικΚωνσταντόπουλος Actualizado.
Suever
3

GolfScript, 32 28 bytes

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

Pruébalo en línea!

Reversión normal:

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

Pruébalo en línea!

Reversión visual:

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

Pruébalo en línea!

El hecho de que un programa incomparable }termina el programa en GolfScript, lo hizo bastante simple. Sin embargo, estoy bastante seguro de que mi código para intercambiar los corchetes aún no es óptimo.

Martin Ender
fuente
0

Python 2.7, 208 bytes

Adelante

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

Reversión 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

Reversión 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 las instrucciones se leen desde stdin hasta EOF.

Nada súper inteligente aquí. Los comentarios finales solo ejecutan el código hacia adelante y hacia atrás, luego una execdeclaración en un bloque try para detectar errores de sintaxis para las dos reversiones diferentes.

Orez
fuente