Zastąp ciąg samym sobą

Twoim celem jest zastąpienie łańcucha samym sobą poprzez zastąpienie każdego znaku w oryginalnym ciągu poprzednim, zaczynając od pierwszego znaku i zawijając go. Oto kilka przykładów, które pokazują, co mam na myśli:

Pierwszy przykład:

Input: program
Output: apgopra

How:
Program -> mrogram (replace p by m in program)
-> mpogpam (replace r by p in mrogram)
-> mprgpam (replace o by r in mpogpam)
-> mpropam (replace g by o in mprgpam)
-> mpgopam (replace r by g in mpropam)
-> mpgoprm (replace a by r in mpgopam)
-> apgopra (replace m by a in mpgoprm)

Drugi przykład:

Input: robot
Output: orbro

How:
Robot -> tobot (replace r by t in robot)
-> trbrt (replace o by r in tobot)
-> trort (replace b by o in trbrt)
-> trbrt (replace o by b in trort)
-> orbro (replace t by o in trbrt)

Trzeci przykład:

Input: x
Output: x

How:
x -> x (replace x by x in x)

Czwarty przykład:

Input: xy
Output: xx

How:
xy -> yy (replace x by y in xy)
-> xx (replace y by x in yy)

Sidenotes:

• Ciąg xbędzie zawierał tylko małe litery i spacje alfanumeryczne
• To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach !

CJam, 11 bajtów

q__1m>.{er}

Sprawdź to tutaj.

Wyjaśnienie

q__    e# Read input and make two copies.
1m>    e# Rotate the second copy one character to the right.
.{er}  e# For each pair of characters from the second and third string,
       e# replace occurrences of the first with the second.

TeaScript , 17 bajtów 19 21 24

TeaScript to JavaScript do gry w golfa

xd(#lg(i,xC(1#a))

Miło i krótko

Wypróbuj online (uważaj na końcowe białe znaki na wejściu)

Niegolfowane i objaśnienie

x.reduce     // Reduce over input
  (#         // Anonymous function expands to ((l,i,a)=>
    l.g(        // global replace...
     i          // replace var i with...
     x.cycle(1) // Cycle x 1
     [a]        // At position a
    )
  )

JavaScript ES6, 69 bajtów

s=>[...s].reduce((p,c,i)=>p.replace(RegExp(c,'g'),s.slice(i-1)[0]),s)

F=s=>[...s].reduce((p,c,i)=>p.replace(RegExp(c,'g'),s.slice(i-1)[0]),s)

input.oninput=()=>output.innerHTML=F(input.value)

#input, #output {
  width: 100%;
}

<textarea id='input' rows="5">
</textarea>
<div id="output"></div>

Rubin, 50 48 bajtów

->s{t=s.dup;t.size.times{|i|t.tr!s[i],s[i-1]};t}

Test:

f=->s{t=s.dup;t.size.times{|i|t.tr!s[i],s[i-1]};t}
f["program"]
=> "apgopra"

Mathematica, 89 75 74 57 bajtów

""<>Fold[#/.#2&,c=Characters@#,Thread[c->RotateRight@c]]&

Pyth, 13 bajtów

u:G.*HC.>Bz1z

Wypróbuj online. Zestaw testowy.

k2 - 17 znaków

Funkcja przyjmująca 1 argument.

{_ssr/[x;x;-1!x]}

K2 wbudowany ekwiwalent zwaną _ssrdla S tring S earch i R EUmieãæ. _ssr[x;y;z]znajdzie ysię xi wymienić ją z. Używamy więc /tej funkcji do złożenia każdego zamiennika, który chcemy wykonać. Dla tych, którzy nie są zaznajomieni ze składaniem (jak w programowaniu funkcjonalnym), w istocie _ssr/[x; (y1; y2; y3); (z1; z2; z3)]staje się _ssr[_ssr[_ssr[x; y1; z1]; y2; z2]; y3; z3]. Ciągi są listami ich znaków, więc możemy po prostu obrócić wejście z powrotem o krok, uzyskać zamienniki i podłączyć się od razu.

  {_ssr/[x;x;-1!x]} "program"
"apgopra"
  {_ssr/[x;x;-1!x]} "robot"
"orbro"
  {_ssr/[x;x;-1!x]} (,"x")   / one-letter strings are ,"x" and parens are required
,"x"
  {_ssr/[x;x;-1!x]} "xy"
"xx"

Haskell, 76 bajtów

[]#_=[];(x:y)#g@(a,b)|x==a=b:y#g|2>1=x:y#g;h x=foldl(#)x$zip x$last x:init x

Szkoda, że ​​Haskell nie ma nawet wbudowanej funkcji zastępowania.

PHP, 76 bajtów

function($s){$f=str_split;echo str_replace($f($s),$f(substr($s,-1).$s),$s);}

Oto wersja bez golfa:

function selfSubstitute($originalString)
{
    $shiftedString = substr($originalString, -1) . $originalString;

    $splitOriginalString = str_split($originalString);
    $splitShiftedString = str_split($shiftedString);

    echo str_replace($splitOriginalString, $splitShiftedString, $originalString);
}

Python, 67 64 62 57 bajtów

Proste rozwiązanie, znajdzie coś, co może to skrócić. Dzięki @RandyC za oszczędność 5 bajtów.

c=input()
for x in zip(c,c[-1]+c):c=c.replace(*x)
print c

Dane wejściowe powinny być w cudzysłowach.

Haskell, 58 bajtów

r(x,y)c|x==c=y|0<1=c;f s=foldl(flip$map.r)s.zip s$last s:s

Całkiem podobne do rozwiązania Christiana, ale używając mapi fakt, że zipignoruje zbędne elementy, jeśli listy mają nierówną długość. Składa listę zamienników (w formularzu (from,to)), aktualizując ciąg, mapując ręcznie napisaną funkcję zastępczą rna każdą literę.

Wyrażenie flip$map.rwyprowadzono za pomocą wtyczki „Pointless” LambdaBot.