Remplacer une chaîne par elle-même

Votre objectif est de remplacer une chaîne par elle-même en remplaçant chaque caractère de la chaîne d'origine par celui qui le précède, en commençant par le premier caractère et en faisant un tour. Voici quelques exemples pour montrer ce que je veux dire:

1er exemple:

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ème exemple:

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)

3e exemple:

Input: x
Output: x

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

4ème exemple:

Input: xy
Output: xx

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

Sidenotes:

• La chaîne xne contiendra que des caractères alphanumériques en minuscules et des espaces
• C'est le code-golf donc le code le plus court en octets gagne!

CJam, 11 octets

q__1m>.{er}

Testez-le ici.

Explication

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

TeaScript est JavaScript pour le golf

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

Agréable et court

Essayez-le en ligne (surveillez les espaces à la fin de l'entrée)

Non golfé et explication

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 octets

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>

Rubis, 50 48 octets

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

Tester:

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 octets

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

Pyth, 13 octets

u:G.*HC.>Bz1z

Essayez-le en ligne. Suite de tests.

k2 - 17 caractères

Fonction prenant 1 argument.

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

k2 a une commande intégrée appelée _ssrpour S Tring S echerchez et R eplace. _ssr[x;y;z]trouveront ydans xet le remplacer par z. Nous utilisons donc /pour replier cette fonctionnalité sur chaque remplacement que nous voulons faire. Pour ceux qui ne connaissent pas le pliage (comme dans la programmation fonctionnelle), _ssr/[x; (y1; y2; y3); (z1; z2; z3)]devient essentiellement _ssr[_ssr[_ssr[x; y1; z1]; y2; z2]; y3; z3]. Les chaînes sont des listes de leurs caractères, nous pouvons donc simplement faire reculer l'entrée d'une étape et obtenir les remplacements, puis nous connecter directement.

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

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

Dommage, Haskell n'a même pas de fonction de substitution intégrée.

PHP, 76 octets

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

Voici la version non golfée:

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 octets

Solution simple, examinera quelque chose pour raccourcir cela. Merci à @RandyC pour avoir économisé 5 octets.

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

L'entrée doit être entre guillemets.

Haskell, 58 octets

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

Assez similaire à la solution de Christian, mais en utilisant mapet le fait qu'il zipignore les éléments superflus si les listes sont de longueur inégale. Il parcourt la liste des remplacements (sur le formulaire (from,to)), mettant à jour la chaîne en mappant la fonction de remplacement manuscrite rsur chaque lettre.

L'expression a flip$map.rété dérivée à l'aide du plug-in "Pointless" de LambdaBot.