Su tarea: escribir un programa / función que cuando se le da una cadena que contiene solo caracteres ASCII, genera / devuelve la cadena en reversa.

Ejemplo:

1) entrada

Hello, World!

2) Número de caracteres únicos en la entrada. (Cadena de entrada separada por tuberías ( |) para facilitar la lectura)

H|e|l|l|o|,| |W|o|r|l|d|!
1 2 3   4 5 6 7   8   9 10

3) Para los caracteres duplicados, encuentre la primera aparición de ese carácter y numere el carácter duplicado con el mismo número que el primero.

H|e|l|l|o|,| |W|o|r|l|d|!
1 2 3 3 4 5 6 7 4 8 3 9 10

4) Invierta la cadena, pero no los números.

!|d|l|r|o|W| |,|o|l|l|e|H
1 2 3 3 4 5 6 7 4 8 3 9 10

5) Eliminar los caracteres arriba de los números repetidos. (Caracteres eliminados representados con un asterisco).

!|d|l|*|o|W| |,|*|l|*|e|H
1 2 3 3 4 5 6 7 4 8 3 9 10

6) Reemplace los caracteres eliminados con el carácter que aparece sobre la primera vez que aparece el número eliminado.

!|d|l|l|o|W| |,|o|l|l|e|H
1 2 3 3 4 5 6 7 4 8 3 9 10

7) salida

!dlloW ,olleH

Casos de prueba:

Input -> Output
"Hello, World!" -> "!dlloW ,olleH"
"18464399" -> "99343488"
"Code Golf" -> "floG eloC"
"abcdefgABCDEFG" -> "GFEDCBAgfedcba"
"Mmm, marshmallows" -> "swwllwmhsrwm  mms"
"15147" -> "74751"

Pyth , 1 byte

X

Verifique todos los casos de prueba.

Pyth tiene maravillosas funciones integradas :-)

Pyth ,  8  7 bytes

sm@_QxQ

Verifique todos los casos de prueba.

Cómo funciona

Este es el enfoque no integrado más interesante.

sm@_QxQ  - Full program.

 m       - Map over the input.
  @_Q    - Get the index in the reversed input.
     xQ  - Of the first index of each character in the String.
s        - Join the list.

Python 2 , 46 41 bytes

^{-5 bytes gracias a Artyer}

lambda x:''.join(x[~x.find(n)]for n in x)

Pruébalo en línea!

Jalea , 5 bytes

iЀịṚ

Pruébalo en línea!

CJam , 7 bytes

q__W%er

Pruébalo en línea!

Explicación

q   e# Read all input.
__  e# Make two copies.
W%  e# Reverse the third copy.
er  e# Transliterate the input, mapping the input to its own reverse. Due
    e# to the way transliteration works in CJam, if a character in the source
    e# of the mapping is repeated, all but the first occurrence of that
    e# character are ignored.

MATL , 6 bytes

PGt&m)

Pruébalo en línea!

           implicit input
P          flip
 Gt        paste input back to stack and dup
   &m      alternate ismember, returns duplicated indices
     )     apply indices to the reversed char array
           implicit output, print as char

05AB1E , 2 bytes

R‡

Pruébalo en línea!

Explicación:

R‡
R  Reverse input
 ‡ Transliterate the input with itself and its reverse (as above) (it only keeps first occurrences)

Alice , 17 bytes

/?.R?y.@
\i.!yDo/

Pruébalo en línea!

Explicación

/...@
\.../

Esta es solo la plantilla habitual para el código lineal en modo ordinal. Si desarrollamos esto, el programa real simplemente se convierte en:

i.!?D.?.Ryyo

La idea aquí es similar a la de mi respuesta de CJam . Dado que Alice no tiene una forma fácil de indexar en cadenas con enteros, es más fácil replicar este comportamiento con transliteración ( yen Alice). Sin embargo, la semántica de transliteración de Alice es mucho más general que la de CJam, lo que significa que Alice no solo ignora las asignaciones repetidas. Por ejemplo, si solo quisiéramos transcribir Mmm, marshmallowsa su reverso, esto representaría la siguiente lista de asignaciones:

M -> s
m -> w
m -> o
, -> l
  -> l
m -> a
a -> m
r -> h
s -> s
h -> r
m -> a
a -> m
l ->  
l -> ,
o -> m
w -> m
s -> M

Tenga en cuenta que lo que tenemos, por ejemplo, m -> w, m -> o, m -> ay m -> a. CJam simplemente descartaría todo excepto el primer mapeo, pero Alice en cambio pasaría por estos. Entonces, el primero mse asignaría a w, el segundo a o, el quinto nuevamente a wy así sucesivamente. En este caso, eso no es útil, porque en general si actuamos yen AAB(para algunas cadenas Ay B) como lo hicimos en CJam, siempre llegaremos a BAlice.

Entonces, ¿cómo calculamos una asignación que funciona y(es decir, cómo descartamos las asignaciones repetidas manualmente)? Por supuesto, al usar otra transliteración. :)

La fuente de la asignación que queremos tiene que ser el meollo de la entrada (es decir, la entrada deduplicada). Si aplicamos la asignación anterior a la protuberancia, entonces cada carácter solo aparece una vez, por lo que solo estamos haciendo uso de la primera de cada una de las asignaciones repetidas. Entonces, al transliterar la protuberancia con la entrada y su reversa, simplemente descartamos las asignaciones duplicadas. Entonces podemos usar la protuberancia y este nuevo resultado como un mapeo para la entrada original. Estoy seguro de que tiene sentido para alguien ...

Entonces el código:

i   Read input.                   ["Mmm, marshmallows"]
.!  Store a copy on the tape.
?D  Push the nub of the input.    ["Mmm, marshmallows" "Mm, arshlow"]
.   Duplicate.                    ["Mmm, marshmallows" "Mm, arshlow" "Mm, arshlow"]
?   Retrieve input.               ["Mmm, marshmallows" "Mm, arshlow" "Mm, arshlow" "Mmm, marshmallows"]
.R  Push its reverse.             ["Mmm, marshmallows" "Mm, arshlow" "Mm, arshlow" "Mmm, marshmallows" "swollamhsram ,mmM"]
y   Transliterate.                ["Mmm, marshmallows" "Mm, arshlow" "swllmhsr mm"]]
y   Transliterate.                ["swwllwmhsrwm  mms"]
o   Output.                       []

Pyke , 7 bytes

L@Q_M@s

Pruébalo aquí!

L@      - Get the index of the first index of each character.
  Q     - Push the input to the stack.
   _    - Reverse it.
    M@  - Get the element at (each) position in ^^^ in ^.
      s - Join.

Perl 5 , 23 + 1 ( -p) = 24 bytes

eval"y/$_/".reverse."/"

Pruébalo en línea!

Gracias a la entrada de Alice de @ MartinEnder por la idea de transliteración

JavaScript ES6 50 bytes

3 bytes guardados gracias a Justin Mariner

s=>[...s].map(x=>s.slice(~s.indexOf(x))[0]).join``

Pruébalo:

f=s=>s.split``.map(x=>s.slice(~s.indexOf(x))[0]).join``

let inp = document.getElementById("inp");
let out = document.getElementById("out");

function change() {
  out.innerText = f(inp.value);
}

change();

<input id="inp" type="text" oninput="change()" value="Hello, World!" /><br>
<p id="out"></p>

R , 68 65 bytes

function(s)chartr(paste(rev(el(strsplit(s,''))),collapse=''),s,s)

¡Verifique los casos de prueba!

Puertos 05AB1E de Erik método en los 3 bytes menos. No fue el primero, pero fue el primero que vi.

versión antigua:

function(s)paste(rev(s<-el(strsplit(s,'')))[match(s,s)],collapse='')

Verifique todos los casos de prueba : imprime el vector con la entrada como nombres y la salida entre comillas a continuación.

Una implementación bastante ingenua, pero no creo que esto se acorte en R (y espero equivocarme al respecto). Es esencialmente un puerto R de la respuesta python de Rod, pero se desarrolló de forma independiente.

Explicación sin golf:

function(s){
 s <- el(strsplit(s,''))      # string to characters
 r <- rev(s)                  # reverse s
 idx <- match(s,s)            # indices of first matches
 r <- r[idx]                  # do the replacement of duplicates
 paste(r, collapse = "")      # characters to string
}                             # implicit return of last evaluated statement

C (gcc) , 98 bytes

i,n,a[256];char*f(char*c){n=strlen(c);for(i=n;i>0;i--)a[c[i-1]]=c[n-i];for(;i<n;i++)c[i]=a[c[i]];}

Pruébalo en línea!

El argumento debe ser una cadena modificable; la cadena se modifica en el lugar.

Röda , 27 bytes

f x{x|[x[-1-indexOf(_,x)]]}

Pruébalo en línea!

Esto toma una lista de caracteres como entrada y devuelve una secuencia de caracteres.

Usando el tipo de datos de cadena (40 bytes):

f x{x=x/""x|[x[-1-indexOf(_,x)]]|concat}

Pruébalo en línea!

Python ,191 128 bytes

w=input("")
c=[]
for x in range(0,len(word)):
  chars.append(word[x])
back = []
for x in chars:
  back.insert(0,x)
final = ""
for x in back:
  final = final + x
print(final)

Pruébalo en línea

Java 10, 100 99 97 bytes

s->{var a=new char[256];int l=s.length,i=l;for(;i>0;a[s[--i]]=s[l+~i]);for(;i<l;s[i]=a[s[i++]]);}

Puerto de la respuesta C de @ LeakyNun . Dudo que se pueda hacer más corto sin hacer algo similar en Java.
-1 byte gracias a @ceilingcat .

Ingrese como char[](matriz de caracteres), y modifica esta entrada en lugar de devolver una nueva para guardar bytes.

Pruébalo aquí.