Votre tâche: écrire un programme / une fonction qui, lorsqu'il reçoit une chaîne contenant uniquement des caractères ASCII, génère / renvoie la chaîne en sens inverse.

Exemple:

1) Entrée

Hello, World!

2) Nombre de caractères uniques en entrée. (Chaîne d'entrée séparée par des tuyaux ( |) pour plus de lisibilité)

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

3) Pour les caractères en double, recherchez la première occurrence de ce caractère et numérotez le caractère en double avec le même numéro que le premier.

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

4) Inversez la chaîne, mais pas les chiffres.

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

5) Supprimez les caractères au-dessus des numéros de répétition. (Caractères supprimés représentés par un astérisque.)

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

6) Remplacez les caractères supprimés par le caractère qui apparaît sur la première occurrence du nombre sur lequel le caractère supprimé est terminé.

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

7) Sortie

!dlloW ,olleH

Cas de test:

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

Pyth , 1 octet

X

Vérifiez tous les cas de test.

Pyth a de magnifiques fonctionnalités intégrées :-)

Pyth ,  8  7 octets

sm@_QxQ

Vérifiez tous les cas de test.

Comment ça fonctionne

Il s'agit de l'approche non intégrée la plus intéressante.

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 octets

^{-5 octets grâce à Artyer}

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

Essayez-le en ligne!

Gelée , 5 octets

iЀịṚ

Essayez-le en ligne!

CJam , 7 octets

q__W%er

Essayez-le en ligne!

Explication

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 octets

PGt&m)

Essayez-le en ligne!

           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 octets

R‡

Essayez-le en ligne!

Explication:

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

Alice , 17 octets

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

Essayez-le en ligne!

Explication

/...@
\.../

Ceci est juste le modèle habituel pour le code linéaire en mode Ordinal. Si nous déplions cela, le programme réel devient simplement:

i.!?D.?.Ryyo

L'idée ici est similaire à celle de ma réponse CJam . Puisqu'Alice n'a aucun moyen facile d'indexer dans des chaînes avec des entiers, il est plus facile de répliquer ce comportement avec translittération ( ydans Alice). Cependant, la sémantique de translittération d'Alice est beaucoup plus générale que celle de CJam, ce qui signifie qu'Alice ne fait pas que négliger les mappages répétés. Par exemple, si nous voulions simplement translittérer Mmm, marshmallowsdans le sens inverse, cela représenterait la liste de mappages suivante:

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

Notez que nous avons, par exemple, m -> w, m -> o, m -> aet m -> a. CJam rejetterait tout, sauf le premier mappage, mais Alice les parcourrait à la place. Ainsi, le premier mserait mappé sur w, le second sur o, le cinquième sur wet ainsi de suite. Dans ce cas, cela n'est pas utile, car en général, si nous jouons ysur AAB(pour certaines chaînes Aet B) comme nous l'avons fait dans CJam, nous allons toujours simplement entrer Bdans Alice.

Alors, comment calculer un mappage qui fonctionne y(c'est-à-dire comment éliminer manuellement les mappages répétés)? Bien sûr, en utilisant une autre translittération. :)

La source du mappage que nous voulons doit être le nœud de l'entrée (c'est-à-dire l'entrée dédupliquée). Si nous appliquons le mappage ci-dessus au nœud, alors chaque caractère n'apparaît qu'une seule fois, nous n'utilisons donc que le premier de chacun des mappages répétés. Donc, en translittérant le nœud avec l'entrée et son inverse, nous éliminons simplement les mappages dupliqués. Nous pouvons ensuite utiliser le nœud et ce nouveau résultat comme mappage pour l'entrée d'origine. Je suis sûr que cela avait du sens pour quelqu'un ...

Donc le 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 octets

L@Q_M@s

Essayez-le ici!

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 octets

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

Essayez-le en ligne!

Merci à l'entrée Alice de @ MartinEnder pour l'idée de translittération

JavaScript ES6 50 octets

3 octets économisés grâce à Justin Mariner

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

Essaye-le:

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 octets

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

Vérifiez les cas de test!

Ports 05AB1E Erik méthode pour 3 octets moins. Ce n'était pas le premier, mais c'était le premier que j'ai vu.

ancienne version:

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

Vérifiez tous les cas de test - imprime le vecteur avec l'entrée en tant que noms et la sortie entre guillemets ci-dessous.

Une implémentation assez naïve, mais je ne pense pas que cela raccourcisse dans R (et j'ai hâte de me tromper à ce sujet). Il s'agit essentiellement d'un port R de la réponse python de Rod, mais il a été développé indépendamment.

Explication non golfée:

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 octets

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

Essayez-le en ligne!

L'argument doit être une chaîne modifiable; la chaîne est modifiée sur place.

Röda , 27 octets

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

Essayez-le en ligne!

Cela prend une liste de caractères en entrée et renvoie un flux de caractères.

En utilisant le type de données chaîne (40 octets):

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

Essayez-le en ligne!

Python ,191 128 octets

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)

Essayez-le en ligne

Java 10, 100 99 97 octets

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 de la réponse C de @ LeakyNun . Je doute que cela puisse être fait plus court sans faire quelque chose de similaire en Java.
-1 octet grâce à @ceilingcat .

Entrez en tant que char[](tableau de caractères) et modifiez cette entrée au lieu d'en renvoyer une nouvelle pour enregistrer les octets.

Essayez-le ici.