Nhiệm vụ của bạn: viết một chương trình / hàm mà khi được cung cấp một chuỗi chỉ chứa các ký tự ASCII, xuất / trả về chuỗi theo chiều ngược lại.

Thí dụ:

1) Đầu vào

Hello, World!

2) Số ký tự duy nhất trong đầu vào. (Chuỗi đầu vào được phân tách bằng ống ( |) để dễ đọc)

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

3) Đối với các ký tự trùng lặp, tìm lần xuất hiện đầu tiên của ký tự đó và đánh số ký tự trùng lặp có cùng số với ký tự đầu tiên.

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

4) Đảo ngược chuỗi, nhưng không phải là số.

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

5) Xóa các ký tự trên số lặp lại. (Đã xóa các ký tự được biểu thị bằng dấu hoa thị.)

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

6) Thay thế các ký tự đã xóa bằng ký tự xuất hiện trong lần xuất hiện đầu tiên của số mà ký tự đã xóa kết thúc.

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

7) Đầu ra

!dlloW ,olleH

Các trường hợp thử nghiệm:

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

Bình thường , 1 byte

X

Xác nhận tất cả các trường hợp thử nghiệm.

Pyth có tích hợp tuyệt vời :-)

Bình thường ,  8  7 byte

sm@_QxQ

Xác nhận tất cả các trường hợp thử nghiệm.

Làm thế nào nó hoạt động

Đây là cách tiếp cận không tích hợp thú vị hơn.

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 nhờ Artyer}

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

Hãy thử trực tuyến!

Thạch , 5 byte

iЀịṚ

Hãy thử trực tuyến!

CJam , 7 byte

q__W%er

Hãy thử trực tuyến!

Giải trình

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)

Hãy thử trực tuyến!

           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‡

Hãy thử trực tuyến!

Giải trình:

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/

Hãy thử trực tuyến!

Giải trình

/...@
\.../

Đây chỉ là mẫu thông thường cho mã tuyến tính trong chế độ Ordinal. Nếu chúng ta mở ra điều này, chương trình thực tế sẽ trở thành:

i.!?D.?.Ryyo

Ý tưởng ở đây tương tự như câu trả lời của tôi . Vì Alice không có cách dễ dàng lập chỉ mục thành các chuỗi với số nguyên, nên dễ dàng nhất để sao chép hành vi này bằng cách chuyển ngữ ( ytrong Alice). Tuy nhiên, ngữ nghĩa chuyển ngữ của Alice chung chung hơn nhiều so với của CJam, điều đó có nghĩa là Alice không bỏ qua các ánh xạ lặp đi lặp lại. Ví dụ: nếu chúng ta chỉ muốn chuyển ngữ Mmm, marshmallowsngược lại, thì điều này sẽ đại diện cho danh sách ánh xạ sau đây:

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

Lưu ý rằng chúng tôi đã có, ví dụ, m -> w, m -> o, m -> avà m -> a. CJam sẽ loại bỏ tất cả ngoại trừ ánh xạ đầu tiên, nhưng Alice thay vào đó sẽ quay vòng qua những thứ này. Vì vậy, cái đầu tiên msẽ được ánh xạ tới w, thứ hai đến o, thứ năm một lần nữa wvà như vậy. Trong trường hợp này không hữu ích, vì nói chung nếu chúng tôi thực hiện ytrên AAB(đối với một số chuỗi Avà B) như chúng tôi đã làm ở CJam, chúng tôi sẽ luôn Btham gia Alice.

Vậy làm thế nào để chúng ta tính toán một ánh xạ hoạt động cho y(nghĩa là làm thế nào để chúng ta loại bỏ các ánh xạ lặp lại theo cách thủ công)? Tất nhiên, bằng cách sử dụng một phiên âm khác. :)

Nguồn của ánh xạ mà chúng ta muốn phải là nub của đầu vào (tức là đầu vào bị trùng lặp). Nếu chúng ta áp dụng ánh xạ trên cho nub, thì mỗi ký tự chỉ xuất hiện một lần, vì vậy chúng ta chỉ sử dụng ánh xạ đầu tiên của mỗi ánh xạ lặp lại. Vì vậy, bằng cách chuyển ngữ từ nub với đầu vào và ngược lại, chúng ta thực sự chỉ cần loại bỏ các ánh xạ trùng lặp. Sau đó chúng ta có thể sử dụng nub và kết quả mới này làm ánh xạ cho đầu vào ban đầu. Tôi chắc chắn điều đó có ý nghĩa với ai đó ...

Vì vậy, mã:

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

Hãy thử nó ở đây!

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

Hãy thử trực tuyến!

Cảm ơn mục Alice của @ MartinEnder cho ý tưởng chuyển ngữ

JavaScript ES6 50 byte

3 byte được lưu nhờ Justin Mariner

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

Kiểm tra nó:

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)

Xác nhận trường hợp kiểm tra!

Cổng 05AB1E Erik của phương pháp cho 3 byte ít hơn. Đó không phải là lần đầu tiên, nhưng đó là lần đầu tiên tôi thấy.

phiên bản cũ:

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

Xác minh tất cả các trường hợp kiểm tra - in ra vectơ với đầu vào là tên và đầu ra trong dấu ngoặc kép bên dưới.

Một triển khai khá ngây thơ, nhưng tôi không nghĩ rằng điều này sẽ ngắn hơn trong R (và tôi mong muốn được sai về điều đó). Nó thực chất là một cổng R của câu trả lời trăn của Rod nhưng nó được phát triển độc lập.

Lời giải thích bất đắc dĩ:

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

Hãy thử trực tuyến!

Đối số phải là một chuỗi có thể sửa đổi; chuỗi được sửa đổi tại chỗ.

Röda , 27 byte

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

Hãy thử trực tuyến!

Cái này lấy một danh sách các ký tự làm đầu vào và trả về một luồng các ký tự.

Sử dụng kiểu dữ liệu chuỗi (40 byte):

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

Hãy thử trực tuyến!

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)

Dùng thử trực tuyến

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

Câu trả lời của cảng @ LeakyNun . Tôi nghi ngờ nó có thể được thực hiện ngắn hơn mà không làm điều gì đó tương tự trong Java.
-1 byte nhờ @ceilingcat .

Nhập dưới dạng char[](mảng ký tự) và sửa đổi đầu vào này thay vì trả về một cái mới để lưu byte.

Hãy thử nó ở đây.