Sostituisci una stringa con se stessa

Il tuo obiettivo è sostituire una stringa con se stessa sostituendo ogni carattere nella stringa originale con quello precedente, iniziando dal primo carattere e avvolgendolo. Ecco alcuni esempi per mostrare cosa intendo:

1o esempio:

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)

2 ° esempio:

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)

3 ° esempio:

Input: x
Output: x

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

4 ° esempio:

Input: xy
Output: xx

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

Note a margine:

• La stringa xconterrà solo caratteri e spazi alfanumerici minuscoli
• Questo è code-golf, quindi vince il codice più breve in byte !

CJam, 11 byte

q__1m>.{er}

Provalo qui.

Spiegazione

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 byte 19 21 24

TeaScript è JavaScript per il golf

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

Bello e breve

Provalo online (guarda per gli spazi bianchi finali nell'input)

Ungolfed & Spiegazione

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 byte

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>

Rubino, 50 48 byte

->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 byte

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

Pyth, 13 byte

u:G.*HC.>Bz1z

Provalo online. Suite di test.

k2 - 17 caratteri

Funzione che accetta 1 argomento.

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

k2 ha incorporato chiamato _ssrper S tring S earch e R eplace. _ssr[x;y;z]troveranno yin xe sostituirlo con z. Quindi usiamo /per piegare questa funzionalità su ogni sostituzione che vogliamo fare. Per chi non ha familiarità con il pieghevole (come nella programmazione funzionale), _ssr/[x; (y1; y2; y3); (z1; z2; z3)]diventa essenzialmente _ssr[_ssr[_ssr[x; y1; z1]; y2; z2]; y3; z3]. Le stringhe sono elenchi dei loro caratteri, quindi possiamo semplicemente ruotare l'ingresso di un passo indietro e ottenere i rimpiazzi e collegarli subito.

  {_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 byte

[]#_=[];(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

Peccato, Haskell non ha nemmeno una funzione di sostituzione integrata.

PHP, 76 byte

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

Ecco la versione ungolfed:

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 byte

Una soluzione semplice, cercherà qualcosa per accorciarlo. Grazie a @RandyC per aver salvato 5 byte.

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

L'input dovrebbe essere tra virgolette.

Haskell, 58 byte

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

Abbastanza simile alla soluzione di Christian, ma usando mape il fatto che zipignora elementi superflui se le liste sono di lunghezza diversa. Piega l'elenco delle sostituzioni (sul modulo (from,to)), aggiornando la stringa mappando la funzione di sostituzione scritta a mano rsu ogni lettera.

L'espressione è flip$map.rstata derivata usando il plug-in "Pointless" di LambdaBot.