Twoje zadanie: napisz program / funkcję, która otrzyma ciąg zawierający tylko znaki ASCII, wyprowadza / zwraca ciąg w odwrotnej kolejności.

Przykład:

1) Wejście

Hello, World!

2) Wpisz unikatowe znaki na wejściu. (Ciąg wejściowy oddzielony potokami ( |) dla czytelności)

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

3) W przypadku zduplikowanych znaków znajdź pierwsze wystąpienie tego znaku i ponumeruj zduplikowany znak o takim samym numerze jak pierwszy.

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

4) Odwróć ciąg, ale nie cyfry.

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

5) Usuń znaki powyżej powtarzających się liczb. (Usunięte znaki reprezentowane gwiazdką).

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

6) Zastąp usunięte znaki znakiem, który pojawia się przy pierwszym wystąpieniu liczby, nad którą usunięto znak.

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

7) Wyjście

!dlloW ,olleH

Przypadki testowe:

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

Pyth , 1 bajt

X

Sprawdź wszystkie przypadki testowe.

Pyth ma wspaniałe wbudowane :-)

Pyth ,  8  7 bajtów

sm@_QxQ

Sprawdź wszystkie przypadki testowe.

Jak to działa

Jest to bardziej interesujące podejście niewbudowane.

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 bajtów

^{-5 bajtów dzięki Artyerowi}

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

Wypróbuj online!

Galaretka , 5 bajtów

iЀịṚ

Wypróbuj online!

CJam , 7 bajtów

q__W%er

Wypróbuj online!

Wyjaśnienie

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 bajtów

PGt&m)

Wypróbuj 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 bajty

R‡

Wypróbuj online!

Wyjaśnienie:

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

Alice , 17 bajtów

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

Wypróbuj online!

Wyjaśnienie

/...@
\.../

Jest to zwykły szablon dla kodu liniowego w trybie porządkowym. Jeśli to rozwiążemy, rzeczywisty program stanie się po prostu:

i.!?D.?.Ryyo

Pomysł tutaj jest podobny do mojej odpowiedzi CJam . Ponieważ Alice nie ma łatwego sposobu indeksowania na ciągi liczb całkowitych, najłatwiej jest powtórzyć to zachowanie za pomocą transliteracji ( yw Alice). Jednak semantyka transliteracji Alicji jest znacznie bardziej ogólna niż CJama, co oznacza, że ​​Alice nie ignoruje tylko powtarzających się mapowań. Na przykład, jeśli chcemy po prostu dokonać transliteracji Mmm, marshmallowsdo jej odwrotnej strony, reprezentuje to następującą listę odwzorowań:

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

Należy pamiętać, że mamy na przykład m -> w, m -> o, m -> ai m -> a. CJam po prostu odrzuciłby wszystkie oprócz pierwszego mapowania, ale Alice zamiast tego je zmieniała. Tak więc pierwszy mzostanie zmapowany w, drugi do o, piąty ponownie do witd. W tym przypadku nie jest pomocne, ponieważ w ogóle jeśli wykonujemy yna AAB(dla niektórych ciągów Ai B) jak my w CJam, będziemy zawsze po prostu Bw Alice.

Jak więc obliczyć mapowanie, które działa y(tj. W jaki sposób ręcznie odrzucamy powtarzane mapowania)? Oczywiście przy użyciu innej transliteracji. :)

Źródłem pożądanego mapowania musi być nub wejścia (tj. Wejście deduplikowane). Jeśli zastosujemy powyższe mapowanie do nub, każda postać pojawi się tylko raz, więc wykorzystujemy tylko pierwsze z każdego z powtarzanych mapowań. Zatem transliterując nub z wejściem i jego odwrotnością, skutecznie po prostu odrzucamy zduplikowane odwzorowania. Następnie możemy użyć nub i tego nowego wyniku jako mapowania oryginalnego wejścia. Jestem pewien, że to miało sens dla kogoś ...

Więc kod:

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 bajtów

L@Q_M@s

Wypróbuj tutaj!

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 bajty

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

Wypróbuj online!

Dzięki wpisowi Alicji @ MartinEndera za pomysł transliteracji

JavaScript ES6 50 bajtów

3 bajty zapisane dzięki Justin Mariner

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

Sprawdź to:

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 bajtów

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

Sprawdź przypadki testowe!

Porty Metoda Erika 05AB1E dla 3 bajtów mniej. To nie był pierwszy, ale pierwszy.

stara wersja:

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

Sprawdź wszystkie przypadki testowe - drukuje wektor z danymi wejściowymi jako nazwami i danymi wyjściowymi w cudzysłowach poniżej.

Dość naiwna implementacja, ale nie sądzę, że będzie ona krótsza w R (i cieszę się, że się mylę). Zasadniczo jest to port R odpowiedzi pytona Rod, ale został opracowany niezależnie.

Wyjaśnienie bez golfa:

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 bajtów

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

Wypróbuj online!

Argument musi być ciągiem modyfikowalnym; ciąg jest modyfikowany w miejscu.

Röda , 27 bajtów

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

Wypróbuj online!

To pobiera listę znaków jako dane wejściowe i zwraca strumień znaków.

Przy użyciu typu danych ciągu (40 bajtów):

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

Wypróbuj online!

Python ,191 128 bajtów

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)

Wypróbuj online

Java 10, 100 99 97 bajtów

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

Port odpowiedzi C @ LeakyNun . Wątpię, że można to zrobić krócej bez robienia czegoś podobnego w Javie.
-1 bajt dzięki @ceilingcat .

Wprowadź jako char[](tablica znaków) i modyfikuje to wejście zamiast zwracać nowe, aby zapisać bajty.

Wypróbuj tutaj.