Sua tarefa: escreva um programa / função que, ao receber uma sequência contendo apenas caracteres ASCII, produza / retorne a sequência em ordem inversa.

Exemplo:

1) Entrada

Hello, World!

2) Numere caracteres únicos na entrada. (String de entrada separada por pipes ( |) para facilitar a leitura)

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

3) Para caracteres duplicados, encontre a primeira ocorrência desse caractere e numere o caractere duplicado com o mesmo número que o primeiro.

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

4) Inverta a string, mas não os 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) Exclua os caracteres acima dos números repetidos. (Caracteres excluídos representados com um asterisco.)

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

6) Substitua os caracteres excluídos pelo caractere que aparece sobre a primeira ocorrência do número em que o caractere excluído acabou.

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

7) Saída

!dlloW ,olleH

Casos de teste:

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

Pitão , 1 byte

X

Verifique todos os casos de teste.

Pyth tem maravilhosos recursos embutidos :-)

Pitão ,  8  7 bytes

sm@_QxQ

Verifique todos os casos de teste.

Como funciona

Essa é a abordagem não integrada mais interessante.

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 graças a Artyer}

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

Experimente online!

Gelatina , 5 bytes

iЀịṚ

Experimente online!

CJam , 7 bytes

q__W%er

Experimente online!

Explicação

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)

Experimente online!

           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‡

Experimente online!

Explicação:

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/

Experimente online!

Explicação

/...@
\.../

Este é apenas o modelo usual para código linear no modo Ordinal. Se desdobrarmos isso, o programa atual se tornará:

i.!?D.?.Ryyo

A idéia aqui é semelhante à da minha resposta CJam . Como Alice não tem uma maneira fácil de indexar em seqüências de caracteres com números inteiros, é mais fácil replicar esse comportamento com transliteração ( yem Alice). No entanto, a semântica de transliteração de Alice é muito mais geral que a de CJam, o que significa que Alice não apenas desconsidera os mapeamentos repetidos. Por exemplo, se quiséssemos transliterar Mmm, marshmallowspara o reverso, isso representaria a seguinte lista de mapeamentos:

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

Note que nós temos, por exemplo, m -> w, m -> o, m -> ae m -> a. O CJam descartaria todos, exceto o primeiro mapeamento, mas Alice passaria por eles. Portanto, o primeiro mseria mapeado para w, o segundo para o, o quinto novamente para we assim por diante. Neste caso, que não é útil, porque em geral se realizar yem AAB(para algumas cordas Ae B) como fizemos no CJam, vamos sempre é só pegar Bna Alice.

Então, como calculamos um mapeamento que funciona y( por exemplo, como descartamos os mapeamentos repetidos manualmente)? Claro, usando outra transliteração. :)

A fonte do mapeamento que queremos deve ser o número da entrada (isto é, a entrada deduplicada). Se aplicarmos o mapeamento acima ao nub, cada caractere aparecerá apenas uma vez; portanto, estamos usando apenas o primeiro de cada um dos mapeamentos repetidos. Portanto, ao transliterar o nub com a entrada e seu reverso, estamos efetivamente simplesmente descartando os mapeamentos duplicados. Podemos então usar o nub e esse novo resultado como um mapeamento para a entrada original. Tenho certeza de que fazia sentido para alguém ...

Então o 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

Experimente aqui!

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

Experimente online!

Agradecimentos à entrada de Alice do @ MartinEnder pela idéia de transliteração

JavaScript ES6 50 bytes

3 bytes salvos graças a Justin Mariner

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

Teste-o:

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

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

Verifique os casos de teste!

Portos o método 05AB1E do Erik por 3 bytes a menos. Não foi o primeiro, mas foi o primeiro que vi.

versão antiga:

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

Verificar todos os casos de teste - imprime o vetor com a entrada como nomes e a saída entre aspas abaixo.

Uma implementação bastante ingênua, mas não acho que isso fique mais curto no R (e estou ansioso para estar errado sobre isso). É essencialmente uma porta R da resposta python de Rod, mas foi desenvolvida de forma independente.

Explicação ungolfed:

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]];}

Experimente online!

O argumento deve ser uma sequência modificável; string é modificada no local.

Röda , 27 bytes

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

Experimente online!

Isso pega uma lista de caracteres como entrada e retorna um fluxo de caracteres.

Usando o tipo de dados string (40 bytes):

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

Experimente online!

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)

Experimente online

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++]]);}

Porto da resposta C de @ LeakyNun . Duvido que possa ser feito mais curto sem fazer algo semelhante em Java.
-1 byte graças a @ceilingcat .

Insira como char[](matriz de caracteres) e modifique essa entrada em vez de retornar uma nova para salvar bytes.

Experimente aqui.