Ersetzen Sie eine Zeichenfolge durch sich selbst

Ihr Ziel ist es, eine Zeichenfolge durch eine eigene Zeichenfolge zu ersetzen, indem Sie jedes Zeichen in der ursprünglichen Zeichenfolge durch das vorangegangene Zeichen ersetzen. Beginnen Sie dabei mit dem ersten Zeichen und setzen Sie den Zeilenumbruch fort. Hier sind einige Beispiele zu zeigen, was ich meine:

1. Beispiel:

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. Beispiel:

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. Beispiel:

Input: x
Output: x

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

Viertes Beispiel:

Input: xy
Output: xx

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

Nebenbemerkungen:

• Die Zeichenfolge xwird nur alphanumerische Zeichen und Leerzeichen enthalten Kleinbuchstaben
• Dies ist Code-Golf so kürzester Code in Bytes gewinnt!

CJam, 11 Bytes

q__1m>.{er}

Teste es hier.

Erläuterung

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

TeaScript ist JavaScript zum Golfen

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

Schön und kurz

Versuchen Sie es online (achten Sie auf nachfolgende Leerzeichen in der Eingabe)

Ungolfed & Erklärung

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

Rubin, 50 48 Bytes

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

Prüfung:

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 Bytes

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

Pyth, 13 Bytes

u:G.*HC.>Bz1z

Probieren Sie es online aus. Testsuite.

k2 - 17 char

Funktion mit 1 Argument.

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

k2 hat einen eingebauten genannt _ssrfür S tring S uche und R eplace. _ssr[x;y;z]finde es yin xund ersetze es durch z. Deshalb /falten wir diese Funktionalität über jeden Ersatz, den wir vornehmen möchten. Für diejenigen , die nicht mit Falten (wie in funktionaler Programmierung), im wesentlichen _ssr/[x; (y1; y2; y3); (z1; z2; z3)]wird _ssr[_ssr[_ssr[x; y1; z1]; y2; z2]; y3; z3]. Strings sind Listen ihrer Charaktere, also können wir die Eingabe einfach einen Schritt zurückdrehen und die Ersetzungen erhalten und direkt einstecken.

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

haben zu schlecht, ist Haskell nicht einmal ein Build-in Ersetzungsfunktion.

PHP, 76 Byte

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

Hier ist die ungolfed Version:

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 Bytes

Einfache Lösung, wird sich in etwas so zu verkürzen. Dank @RandyC für 5 Byte zu speichern.

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

Der Eingang sollte in Anführungszeichen gesetzt werden.

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

Ziemlich ähnlich zu Christians Lösung, aber mit mapund der Tatsache, dass zipüberflüssige Elemente ignoriert werden, wenn die Listen ungleich lang sind. Es faltet die Liste der Ersetzungen (auf dem Formular (from,to)) durch und aktualisiert die Zeichenfolge, indem die handgeschriebene Ersetzungsfunktion rauf jeden Buchstaben abgebildet wird .

Der Ausdruck flip$map.rwurde mit dem LambdaBot-Plugin "Pointless" abgeleitet.