Göreviniz: yalnızca ASCII karakterleri içeren bir dize verildiğinde, dizeyi tersine ish olarak veren / döndüren bir program / işlev yazın.

Misal:

1) Giriş

Hello, World!

2) Girişteki benzersiz karakterleri numaralandırın. ( |Okunabilirlik için borular ( ) ile ayrılmış giriş dizesi )

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

3) Yinelenen karakterler için, o karakterin ilk oluşumunu bulun ve yinelenen karakteri birinciyle aynı numarayla numaralandırı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) Dizeyi tersine çevirin, ancak sayıları değil.

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

5) Tekrarlanan numaraların üzerindeki karakterleri silin. (Yıldız işareti ile gösterilen silinen karakterler.)

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

6) Silinmiş karakterleri, silinen karakterin bittiğinin ilk tekrarında görünen karakterle değiştirin.

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

7) Çıktı

!dlloW ,olleH

Test senaryoları:

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

Pyth , 1 bayt

X

Tüm test senaryolarını doğrulayın.

Pyth harika yerleşik var :-)

Pyth ,  8  7 bayt

sm@_QxQ

Tüm test senaryolarını doğrulayın.

Nasıl çalışır

Bu daha ilginç yerleşik olmayan yaklaşımdır.

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 bayt

^{Artyer sayesinde -5 bayt}

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

Çevrimiçi deneyin!

Jöle , 5 bayt

iЀịṚ

Çevrimiçi deneyin!

CJam , 7 bayt

q__W%er

Çevrimiçi deneyin!

açıklama

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 bayt

PGt&m)

Çevrimiçi deneyin!

           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 bayt

R‡

Çevrimiçi deneyin!

Açıklama:

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

Alice , 17 bayt

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

Çevrimiçi deneyin!

açıklama

/...@
\.../

Bu sadece Normal modda doğrusal kod için olağan bir şablondur. Bunu açarsak, gerçek program basitçe şöyle olur:

i.!?D.?.Ryyo

Buradaki fikir CJam cevabımla aynı . Alice'in tamsayılarla dizgileri dizine eklemenin kolay bir yolu olmadığından, bu davranışı harf çevirisi ile ( yAlice'te) çoğaltmak en kolay yoldur . Bununla birlikte, Alice'in harf çevirisi semantiği CJam'ınkinden çok daha geneldir, yani Alice sadece tekrarlanan eşlemeleri göz ardı etmez. Örneğin, tam Mmm, marshmallowstersine çevirmek isteseydik , bu şu eşleme listesini temsil eder:

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

Not elimizdeki bu, örneğin, m -> w, m -> o, m -> ave m -> a. CJam sadece ilk haritalama hariç hepsini atacaktı, ama Alice bunun yerine dolaşacaktı. Bu yüzden birincisi , ikincisi , beşincisi tekrar vb. İle meşlenir . Genel olarak Gerçekleştirdiğimiz çünkü eğer, yararlı değildir Bu durumda üzerinde (bazı dizeleri ve ) biz CJam olduğu gibi, her zaman sadece alırsınız Alice.wowyAABABB

Peki, işe yarayan bir eşlemeyi nasıl hesaplayabiliriz y(yani tekrarlanan eşlemeleri el ile nasıl atarız)? Tabii ki, başka bir harf çevirisi kullanarak. :)

İstediğimiz eşlemenin kaynağı girdinin yumruğu olmalıdır (yani tekilleştirilen girdi). Yukarıdaki eşlemeyi yumruya uygularsak, her karakter yalnızca bir kez görünür, bu nedenle tekrarlanan eşlemelerin her birinin yalnızca ilkini kullanırız. Çıkıntıyı girdi ve tersi ile çevirerek, çoğaltılan eşlemeleri etkili bir şekilde atıyoruz. Daha sonra yumru ve bu yeni sonucu orijinal girdi için bir eşleme olarak kullanabiliriz. Eminim birisine mantıklı geliyor ...

Yani 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 bayt

L@Q_M@s

Burada deneyin!

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 bayt

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

Çevrimiçi deneyin!

@ MartinEnder'in harf çevirisi fikrine Alice girişi sayesinde

JavaScript ES6 50 bayt

Justin Mariner sayesinde 3 bayt kurtardı

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

Dene:

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 bayt

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

Test senaryolarını doğrulayın!

Limanlar Erik'in 05AB1E 3 bayt az yöntemi. İlk değil, ama ilk gördüğüm oldu.

eski versiyon:

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

Tüm test durumlarını doğrulayın - vektörü girdi olarak adlar ve çıktıyı aşağıdaki alıntılarla yazdırır.

Oldukça naif bir uygulama, ama bunun R'de kısaldığını düşünmüyorum (ve bu konuda yanlış olmayı dört gözle bekliyorum). Aslında Rod'un python cevabının bir R portu ama bağımsız olarak geliştirildi.

Açıklanamayan açıklama:

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 bayt

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

Çevrimiçi deneyin!

Bağımsız değişken değiştirilebilir bir dize olmalıdır; dize yerinde değiştirilir.

Röda , 27 bayt

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

Çevrimiçi deneyin!

Bu, bir karakter listesini girdi olarak alır ve bir karakter akışı döndürür.

Dize veri türünü kullanma (40 bayt):

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

Çevrimiçi deneyin!

Python ,191 128 bayt

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)

Çevrimiçi deneyin

Java 10, 100 99 97 bayt

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

Bağlantı noktası @ LeakyNun'un C cevabı . Java'da benzer bir şey yapmadan daha kısa yapılabileceğinden şüpheliyim. @Ceilingcat
sayesinde -1 bayt .

Girdi char[](karakter dizisi) ve bayt kaydetmek için yenisini döndürmek yerine bu girdiyi değiştirir.

Burada deneyin.