Ваша задача: написать программу / функцию, которая при задании строки, содержащей только символы ASCII, выводит / возвращает строку в обратном порядке.

Пример:

1) вход

Hello, World!

2) Количество уникальных символов на входе. (Входная строка, разделенная пайпами ( |) для удобства чтения)

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

3) Для повторяющихся символов найдите первое вхождение этого символа и присвойте ему одинаковый номер с первым номером.

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

4) Переверните строку, но не цифры.

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

5) Удалите символы выше повторяющихся чисел. (Удаленные символы обозначены звездочкой.)

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

6) Замените удаленные символы символом, который появляется над первым появлением числа, над которым удален символ.

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

7) Выход

!dlloW ,olleH

Тестовые случаи:

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

Pyth , 1 байт

X

Проверьте все контрольные примеры.

Pyth имеет прекрасные встроенные модули :-)

Pyth ,  8  7 байтов

sm@_QxQ

Проверьте все контрольные примеры.

Как это работает

Это более интересный не встроенный подход.

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 байт

^{-5 байт благодаря Artyer}

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

Попробуйте онлайн!

Желе , 5 байт

iЀịṚ

Попробуйте онлайн!

CJam , 7 байтов

q__W%er

Попробуйте онлайн!

объяснение

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 байтов

PGt&m)

Попробуйте онлайн!

           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 байта

R‡

Попробуйте онлайн!

Объяснение:

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

Алиса , 17 байт

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

Попробуйте онлайн!

объяснение

/...@
\.../

Это просто обычный шаблон для линейного кода в обычном режиме. Если мы развернем это, действительная программа просто станет:

i.!?D.?.Ryyo

Идея здесь похожа на идею моего ответа CJam . Поскольку у Алисы нет простого способа индексирования в строки с целыми числами, проще всего воспроизвести это поведение с помощью транслитерации ( yв Алисе). Однако семантика транслитерации Алисы гораздо более общая, чем у CJam, что означает, что Алиса не просто игнорирует повторные отображения. Например, если бы мы просто хотели транслитерировать Mmm, marshmallowsв обратном направлении, это представляло бы следующий список отображений:

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

Обратите внимание , что у нас есть, например, m -> w, m -> o, m -> aи m -> a. CJam просто отбрасывает все, кроме первого сопоставления, но Алиса вместо этого циклически перебирает их. Таким образом, первое mбудет отображено w, второе - к oпятому снова wи так далее. В данном случае это не полезно, потому что в целом , если мы выполняем yна AAB(для некоторых строк Aи B) , как мы это делали в CJam, мы всегда просто получить Bв Алисе.

Итак, как мы вычисляем отображение, которое работает y(то есть, как мы отбрасываем повторные отображения вручную)? Конечно, с помощью другой транслитерации. :)

Источником отображения, которое мы хотим, должен быть узел ввода (т. Е. Дедуплицированный вход). Если мы применим вышеупомянутое сопоставление к кусочку, то каждый символ появляется только один раз, поэтому мы используем только первое из каждого из повторяющихся сопоставлений. Таким образом, транслитерируя нуб с помощью ввода и его реверса, мы фактически просто отбрасываем дублированные отображения. Затем мы можем использовать нуб и этот новый результат в качестве отображения для исходного ввода. Я уверен, что это имеет смысл для кого-то ...

Итак, код:

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.                       []

Пайк , 7 байт

L@Q_M@s

Попробуй это здесь!

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 байта

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

Попробуйте онлайн!

Благодаря записи Алисы @ MartinEnder за идею транслитерации

JavaScript ES6 50 байт

3 байта сохранены благодаря Джастину Маринеру

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

Попробуй это:

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 байт

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

Проверьте контрольные примеры!

Порты 05AB1E Эрика метод для 3 байта меньше. Это был не первый, но это был первый, который я увидел.

старая версия:

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

Проверить все контрольные примеры - распечатывает вектор с вводом в качестве имен и выводом в кавычках ниже.

Довольно наивная реализация, но я не думаю, что в R это становится короче (и я с нетерпением жду, чтобы ошибиться в этом). По сути, это R-порт ответа Питона на Rod, но он был разработан независимо.

Необузданное объяснение:

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 байт

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

Попробуйте онлайн!

Аргумент должен быть модифицируемой строкой; Строка изменяется на месте.

Рёда , 27 байт

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

Попробуйте онлайн!

Он принимает список символов в качестве входных данных и возвращает поток символов.

Использование типа данных строки (40 байт):

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

Попробуйте онлайн!

Python ,191 128 байт

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)

Попробуйте онлайн

Java 10, 100 99 97 байт

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

Порт @ C ответ LeakyNun в . Я сомневаюсь, что это можно сделать короче, не делая что-то подобное в Java.
-1 байт благодаря @ceilingcat .

Вводится как char[](символьный массив) и изменяет этот ввод вместо возврата нового для сохранения байтов.

Попробуй это здесь.