Ihre Aufgabe: Schreiben Sie ein Programm / eine Funktion, die / die eine Zeichenfolge mit nur ASCII-Zeichen in umgekehrter Reihenfolge ausgibt / zurückgibt.

Beispiel:

1) Eingabe

Hello, World!

2) Nummerieren Sie eindeutige Zeichen in der Eingabe. (Eingabezeichenfolge durch Pipes ( |) zur besseren Lesbarkeit getrennt)

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

3) Suchen Sie bei doppelten Zeichen das erste Vorkommen dieses Zeichens und nummerieren Sie das doppelte Zeichen mit derselben Nummer wie das erste.

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

4) Kehren Sie die Zeichenfolge um, aber nicht die Zahlen.

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

5) Löschen Sie die Zeichen über den Wiederholungsnummern. (Gelöschte Zeichen, die mit einem Sternchen dargestellt sind.)

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

6) Ersetzen Sie die gelöschten Zeichen durch das Zeichen, das beim ersten Auftreten der Nummer angezeigt wird, bei der das gelöschte Zeichen abgelaufen ist.

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

7) Ausgabe

!dlloW ,olleH

Testfälle:

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

Pyth , 1 Byte

X

Überprüfen Sie alle Testfälle.

Pyth hat wundervolle Einbauten :-)

Pyth ,  8  7 Bytes

sm@_QxQ

Überprüfen Sie alle Testfälle.

Wie es funktioniert

Dies ist der interessantere nicht eingebaute Ansatz.

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 dank Artyer}

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

Probieren Sie es online aus!

Gelee , 5 Bytes

iЀịṚ

Probieren Sie es online aus!

CJam , 7 Bytes

q__W%er

Probieren Sie es online aus!

Erläuterung

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)

Probieren Sie es online aus!

           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‡

Probieren Sie es online aus!

Erläuterung:

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/

Probieren Sie es online aus!

Erläuterung

/...@
\.../

Dies ist nur die übliche Vorlage für linearen Code im Ordnungsmodus. Wenn wir dies entfalten, wird das eigentliche Programm einfach:

i.!?D.?.Ryyo

Die Idee hier ähnelt der meiner CJam-Antwort . Da Alice keine einfache Möglichkeit hat, Zeichenfolgen mit ganzen Zahlen zu indizieren, ist es am einfachsten, dieses Verhalten mit Transliteration ( yin Alice) zu replizieren . Die Transliterationssemantik von Alice ist jedoch viel allgemeiner als die von CJam, was bedeutet, dass Alice wiederholte Zuordnungen nicht einfach ignoriert. Wenn wir beispielsweise nur Mmm, marshmallowsumgekehrt transliterieren möchten, würde dies die folgende Liste von Zuordnungen darstellen:

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

Beachten Sie, dass wir haben, zum Beispiel m -> w, m -> o, m -> aund m -> a. CJam würde nur alle außer der ersten Zuordnung verwerfen, aber Alice würde stattdessen diese durchlaufen. Also würde der erste zugeordnet mwerden w, der zweite auf o, der fünfte erneut auf wund so weiter. In diesem Fall, der nicht hilfreich, weil in der Regel , wenn wir führen yauf AAB(für einige Saiten Aund B) , wie wir in CJam haben, werden wir immer bekommen , nur Bin Alice.

Wie berechnen wir ein Mapping, für das es funktioniert y(dh wie verwerfen wir die wiederholten Mappings manuell)? Natürlich mit einer anderen Transliteration. :) :)

Die Quelle des gewünschten Mappings muss der Knoten der Eingabe sein (dh die deduplizierte Eingabe). Wenn wir die obige Zuordnung auf den Knoten anwenden, wird jedes Zeichen nur einmal angezeigt, sodass wir nur die erste der wiederholten Zuordnungen verwenden. Indem wir den Knoten mit der Eingabe und ihrer Umkehrung transliterieren, werden die duplizierten Zuordnungen einfach verworfen. Wir können dann den Knoten und dieses neue Ergebnis als Zuordnung für die ursprüngliche Eingabe verwenden. Ich bin sicher, das hat für jemanden Sinn gemacht ...

Also der Code:

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

Probieren Sie es hier aus!

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

Probieren Sie es online aus!

Vielen Dank an @ MartinEnders Alice-Eintrag für die Transliterationsidee

JavaScript ES6 50 Bytes

3 Bytes dank Justin Mariner gespeichert

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

Probier es aus:

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)

Testfälle überprüfen!

Ports Eriks 05AB1E- Methode für 3 Bytes weniger. Es war nicht das erste, aber es war das erste, das ich sah.

alte Version:

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

Überprüfen Sie alle Testfälle - druckt den Vektor mit der Eingabe als Namen und der Ausgabe in Anführungszeichen aus.

Eine ziemlich naive Implementierung, aber ich denke nicht, dass dies in R kürzer wird (und ich freue mich darauf, falsch zu liegen). Es ist im Wesentlichen ein R-Port von Rods Python-Antwort, aber es wurde unabhängig entwickelt.

Ungolfed Erklärung:

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

Probieren Sie es online aus!

Das Argument muss eine veränderbare Zeichenfolge sein. Zeichenfolge wird an Ort und Stelle geändert.

Röda , 27 Bytes

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

Probieren Sie es online aus!

Dies nimmt eine Liste von Zeichen als Eingabe und gibt einen Strom von Zeichen zurück.

Verwenden des String-Datentyps (40 Byte):

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

Probieren Sie es online aus!

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)

Probieren Sie es online aus

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

Port von @ LeakyNuns C-Antwort . Ich bezweifle, dass es kürzer geht, ohne etwas Ähnliches in Java zu tun.
-1 Byte dank @ceilingcat .

Geben Sie als char[](Zeichen-Array) ein und ändern Sie diese Eingabe, anstatt eine neue zurückzugeben, um Bytes zu speichern.

Probieren Sie es hier aus.