Il tuo compito: scrivi un programma / funzione che quando viene data una stringa contenente solo caratteri ASCII, genera / restituisce la stringa in senso inverso.

Esempio:

1) Ingresso

Hello, World!

2) Numero di caratteri univoci in input. (Stringa di input separata da pipe ( |) per leggibilità)

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

3) Per i caratteri duplicati, trova la prima occorrenza di quel personaggio e numera il personaggio duplicato con lo stesso numero del primo.

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

4) Invertire la stringa, ma non i numeri.

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

5) Elimina i caratteri sopra i numeri di ripetizione. (Caratteri eliminati rappresentati con un asterisco.)

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

6) Sostituisci i caratteri eliminati con il carattere che appare sopra la prima occorrenza del numero su cui si trova il carattere eliminato.

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

7) Uscita

!dlloW ,olleH

Casi test:

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

Pyth , 1 byte

X

Verifica tutti i casi di test.

Pyth ha dei meravigliosi incorporati :-)

Pyth ,  8  7 byte

sm@_QxQ

Verifica tutti i casi di test.

Come funziona

Questo è l'approccio non incorporato più 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 byte

^{-5 byte grazie ad Artyer}

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

Provalo online!

Gelatina , 5 byte

iЀịṚ

Provalo online!

CJam , 7 byte

q__W%er

Provalo online!

Spiegazione

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 byte

PGt&m)

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

R‡

Provalo online!

Spiegazione:

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

Alice , 17 byte

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

Provalo online!

Spiegazione

/...@
\.../

Questo è solo il solito modello per il codice lineare in modalità Ordinale. Se lo spieghiamo, il programma effettivo diventa semplicemente:

i.!?D.?.Ryyo

L'idea qui è simile a quella della mia risposta CJam . Poiché Alice non ha un modo semplice per indicizzare stringhe con numeri interi, è più semplice replicare questo comportamento con la traslitterazione ( yin Alice). Tuttavia, la semantica della traslitterazione di Alice è molto più generale di quella di CJam, il che significa che Alice non ignora le mappature ripetute. Ad esempio, se volessimo solo traslitterare Mmm, marshmallowsal suo contrario, ciò rappresenterebbe il seguente elenco di mappature:

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

Si noti che abbiamo, per esempio, m -> w, m -> o, m -> ae m -> a. CJam avrebbe semplicemente scartato tutto tranne la prima mappatura, ma Alice avrebbe invece scorrere questi. Quindi il primo mverrebbe mappato su w, il secondo su o, il quinto di nuovo su we così via. In questo caso, che non è utile, perché in generale, se eseguiamo ysu AAB(per alcune stringhe Ae B) come abbiamo fatto nel CJam, avremo sempre e solo ottenere Bin Alice.

Quindi, come possiamo calcolare una mappatura che funziona y(ovvero come scartare manualmente le mappature ripetute)? Certo, usando un'altra traslitterazione. :)

La fonte della mappatura che vogliamo deve essere il nocciolo dell'input (ovvero l'input deduplicato). Se applichiamo la mappatura di cui sopra al nub, ogni carattere appare solo una volta, quindi utilizziamo solo la prima di ciascuna delle mappature ripetute. Quindi, traslitterando il nub con l'input e il suo contrario, stiamo semplicemente scartando i mapping duplicati. Possiamo quindi utilizzare il nub e questo nuovo risultato come mappatura per l'input originale. Sono sicuro che avesse senso per qualcuno ...

Quindi il codice:

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 byte

L@Q_M@s

Provalo qui!

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 byte

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

Provalo online!

Grazie alla voce Alice di @ MartinEnder per l'idea di traslitterazione

JavaScript ES6 50 byte

3 byte salvati grazie a Justin Mariner

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

Provalo:

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 byte

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

Verifica i casi di test!

Porta il metodo 05AB1E di Erik per 3 byte in meno. Non è stato il primo, ma è stato il primo che ho visto.

vecchia versione:

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

Verifica tutti i casi di test : stampa il vettore con l'input come nome e l'output tra virgolette di seguito.

Un'implementazione abbastanza ingenua, ma non credo che questo si accorcia in R (e non vedo l'ora di sbagliarmi). È essenzialmente una porta R della risposta del pitone di Rod, ma è stata sviluppata in modo indipendente.

Spiegazione non golfata:

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 byte

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

Provalo online!

L'argomento deve essere una stringa modificabile; la stringa viene modificata sul posto.

Röda , 27 byte

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

Provalo online!

Questo prende un elenco di caratteri come input e restituisce un flusso di caratteri.

Usando il tipo di dati stringa (40 byte):

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

Provalo online!

Python ,191 128 byte

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)

Provalo online

Java 10, 100 99 97 byte

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

Porta della risposta C di LeakyNun . Dubito che possa essere fatto più breve senza fare qualcosa di simile in Java.
-1 byte grazie a @ceilingcat .

Immettere come char[](array di caratteri) e modifica questo input invece di restituirne uno nuovo per salvare i byte.

Provalo qui.