[Question]
  [
## Substitute a string with itself
Your goal is to substitute a string with itself by replacing each character in the original string with the one before it, starting with the first character and wrapping around. Here are some examples to show what I mean:
1st example:
```
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)
```
2nd example: 
```
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)
```
3rd example:
```
Input: x
Output: x
How:
x -> x (replace x by x in x)
```
4th example:
```
Input: xy
Output: xx
How:
xy -> yy (replace x by y in xy)
-> xx (replace y by x in yy)
```
Sidenotes:
* The string `x` will only contain lowercase alphanumeric characters and spaces
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code in **bytes** wins!
  
[Answer]
## CJam, 11 bytes
```
q__1m>.{er}
```
[Test it here.](http://cjam.aditsu.net/#code=q__1m%3E.%7Ber%7D&input=program)
### Explanation
```
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.
```
[Answer]
# [TeaScript](https://esolangs.org/wiki/TeaScript), 17 bytes ~~19~~ ~~21~~ ~~24~~
TeaScript is JavaScript for golfing
```
xd(#lg(i,xC(1#a))
```
Nice and short
[Try it online](http://vihanserver.tk/p/TeaScript/?code=xd(%23lg(i%2CxC(1)%5Ba%5D))&input=program) (watch for trailing whitespace in the input)
### Ungolfed & Explanation
```
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
    )
  )
```
[Answer]
# JavaScript ES6, 69 bytes
```
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>
```
[Answer]
# Ruby, ~~50~~ 48 bytes
```
->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"
```
[Answer]
# Mathematica, ~~89~~ ~~75~~ ~~74~~ 57 bytes
```
""<>Fold[#/.#2&,c=Characters@#,Thread[c->RotateRight@c]]&
```
[Answer]
# Pyth, 13 bytes
```
u:G.*HC.>Bz1z
```
[Try it online.](https://pyth.herokuapp.com/?code=u%3AG.*HC.%3EBz1z&input=program) [Test suite.](https://pyth.herokuapp.com/?code=u%3AG.*HC.%3EBz1z&test_suite=1&test_suite_input=program%0Arobot%0Ax%0Axy)
[Answer]
# k2 - 17 char
Function taking 1 argument.
```
{_ssr/[x;x;-1!x]}
```
k2 has a builtin called `_ssr` for **S**tring **S**earch and **R**eplace. `_ssr[x;y;z]` will find `y` in `x` and replace it with `z`. So we use `/` to fold this functionality over each replacement we want to make. For those unfamiliar with folding (as in functional programming), essentially `_ssr/[x; (y1; y2; y3); (z1; z2; z3)]` becomes `_ssr[_ssr[_ssr[x; y1; z1]; y2; z2]; y3; z3]`. Strings are lists of their characters, so we may simply rotate the input back a step and get the replacements, and plug right in.
```
  {_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"
```
[Answer]
# Haskell, 76 bytes
```
[]#_=[];(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
```
Too bad, Haskell doesn't even have a build-in substitution function.
[Answer]
## PHP, 76 bytes
```
function($s){$f=str_split;echo str_replace($f($s),$f(substr($s,-1).$s),$s);}
```
Here is the ungolfed version:
```
function selfSubstitute($originalString)
{
    $shiftedString = substr($originalString, -1) . $originalString;
    $splitOriginalString = str_split($originalString);
    $splitShiftedString = str_split($shiftedString);
    echo str_replace($splitOriginalString, $splitShiftedString, $originalString);
}
```
[Answer]
# Python, ~~67~~ ~~64~~ ~~62~~ 57 Bytes
Straightforward solution, will look into something to shorten this. Thanks to @RandyC for saving 5 bytes.
```
c=input()
for x in zip(c,c[-1]+c):c=c.replace(*x)
print c
```
Input should be in quotes.
[Answer]
# Haskell, 58 bytes
```
r(x,y)c|x==c=y|0<1=c;f s=foldl(flip$map.r)s.zip s$last s:s
```
Pretty similar to Christian's solution, but using `map` and the fact that `zip` ignores superfluous elements if the lists are of unequal length. It folds through the list of replacements (on the form `(from,to)`), updating the string by mapping the hand written replacement function `r` on each letter.
The expression `flip$map.r` was derived using LambdaBot's "Pointless" plugin.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~10~~ ~~9~~ 7 bytes
```
ṙ-ż@y@ƒ
```
[Try it online!](https://tio.run/##y0rNyan8///hzpm6R/c4VDocm/T/cPujpjWR//8rFRTlpxcl5irpKCgV5Sfll4AYFWCiUgkA "Jelly – Try It Online")
Having seen caird's `y`-based solution, I spent several hours trying to use matrix multiplication instead, but eventually I took a crack at `y` and arrived at this.
Speaking of caird's solution, I was about to pose the question to JHT of how to outdo `J_.ịƲU` for "obtaining pairs of elements from the input followed by the elements preceding them, wrapping around", but as I wrote that whole thing out I realized I never did actually try using `ż`!
The edit history contains some nice old explanations if anyone wants to read them.
```
ṙ          Rotate the input left
 -         by -1.
  ż@       Zip the input with the rotated input.
      ƒ    Starting with the input, reduce the resulting pairs by
    y@     substitution.
```
[Answer]
# [J](http://jsoftware.com/), 18 bytes
```
rplc~/@,~|.,.1|.|.
```
[Try it online!](https://tio.run/##y/r/P81WT6GoICe5Tt9Bp65GT0fPsEavRu9/anJGvkKagnpBUX56UWKuOhdMoCg/Kb8Ewa1Q/w8A "J – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
żṙ-$,µ,Ḣy¥¥/ḷ/¿
```
[Try it online!](https://tio.run/##y0rNyan8///onoc7Z@qq6BzaqvNwx6LKQ0sPLdV/uGO7/qH9/w@3P9y5SjPy/3@lgqL89KLEXCUdBaWi/KT8EhCjAkxUKgEA "Jelly – Try It Online")
Jelly sucks at strings
## How it works
```
żṙ-$,µ,Ḣy¥¥/ḷ/¿ - Main link. Takes a string S on the left
   $            - Group the previous two links together:
  -             -   -1
 ṙ              -   Rotate S 1 unit to the right
ż               - Zip S with rotated S; Call this M
    ,           - Pair with S; [M, S]
     µ          - Begin a new link with this pair as the argument
          ¥     - Group the previous two links together as a dyad f(p, s):
         ¥      -   Group the previous two links together as a dyad g(p, s):
       Ḣ        -     Remove the first pair in p and use it; [c, t]
        y       -     Replace c with t in s
      ,         -   Yield a pair with the modified p and the replaced s
              ¿ - While:
            ḷ/  -   The first element is truthy
           /    -   Run f(M, S)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 5 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
dUíUé
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=ZFXtVek&input=InByb2dyYW0i)
```
dUíUé     :Implicit input of string U
d         :For each pair XY in the following string, recursively replace X with Y
 Uí       :  Interleave U with
   Ué     :  U rotated right
```
[Answer]
# [Perl 5](https://www.perl.org/) `-pF`, 34 bytes
```
for$a(0..$#F){s/$F[$a]/$F[$a-1]/g}
```
[Try it online!](https://tio.run/##K0gtyjH9/z8tv0glUcNAT09F2U2zulhfxS1aJTEWQukaxuqn1/7/X1CUn16UmMtVlJ@UX8JVwVVR@S@/oCQzP6/4v25BjhsA "Perl 5 – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 29 bytes
```
⟨tc≡⟩⟨gcs₂ᶠ⟩{gᵗz{tᵛ&th|h}ᵐ}ˡb
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRu/6htw6Ompoe7Omsfbp3w/9H8FSXJjzoXPpq/EshMTy4GyW1bAORWpz/cOr2quuTh1tlqJRk1GSDltacXJv3/H61UUJSfXpSYq6SjoFSUn5RfAmJUgIlKpVgA "Brachylog – Try It Online")
```
  c                   Concatenate
 t                    the last item of the input
⟨  ≡⟩                 with the input.
       c              Concatenate
      g               that result in a singleton list
     ⟨  s₂ᶠ⟩          with a list of its length-2 substrings.
             ... b    Remove the extra element from the final result.
{             }ˡ      Left fold:
 gᵗz                  zip each element of the first element with the entire second element,
    {       }ᵐ        and for each of those pairs:
     tᵛ               the last element of both is the same
       &th            and the first element of the last element of the pair
          |           is the output, or
           h          the first element of the pair is the output.
```
]