Die Aufgabe

Schreiben Sie ein Programm oder eine Funktion, die mit drei Zeichenfolgen A, B, Ceine Ausgabezeichenfolge erzeugt, durch die jede Instanz von Bin Arekursiv ersetzt wurde C. Rekursives Ersetzen bedeutet das Wiederholen eines Ersetzens, wobei bei jedem Schritt alle nicht überlappenden Instanzen von Bin A(gierig von links nach rechts gewählt) durch ersetzt werden, Cbis Bnicht mehr in enthalten ist A.

Input-Output

• Sie können eine der Standardmethoden für E / A verwenden .
• Zeichenfolgen enthalten nur druckbare ASCII-Zeichen (und können beliebige davon enthalten).
• Bwird niemals eine leere Zeichenfolge sein, während Aund Cmöglicherweise.
• Zeichenfolgen sind als Klartext zu betrachten, Sie können sie beispielsweise nicht Bals Regex-Muster behandeln.
• Einige Kombinationen von Eingaben werden niemals beendet. Ihr Programm kann in diesen Fällen alles tun.

Testfälle

Diese sind im Format: A/B/C\nOutput

Hello, world!/world!/PPCG
Hello, PPCG

Uppercase is up/up/down
Uppercase is down

ababababa/aba/ccc
cccbcccba

delete/e/{empty string}
dlt

{empty string}/no/effect
{empty string}

llllrrrr/lr/rl
rrrrllll

+-+-+-+/+-+/+
+

ababababa/aba/bada
badabbadbada

abaaba/aba/ab
abb

((())())())/()/{empty string}
)

Beispiele, die nicht enden:

grow/ow/oow

loop/lo/lo

05AB1E , 2 Bytes

`:

Probieren Sie es online!

Erläuterung

`    # split input to stack
 :   # replace (until string doesn't change)

Dies könnte :für 1 Byte sein, wenn wir uns nicht mit leeren Zeichenfolgen befassen müssten .

Python 2 , 43 Bytes

lambda s,*l:eval('s'+'.replace(*l)'*len(s))

Probieren Sie es online!

Wertet eine Zeichenfolge des Formulars aus

s.replace(*l).replace(*l).replace(*l) ...

Um einen festen Punkt zu erreichen, genügt es, Ersetzungen vorzunehmen, die der Länge der ursprünglichen Zeichenfolge entsprechen.

ES6 (Javascript), 4743 Bytes

• 4 Bytes mit currying gespeichert (Danke @Neil!)

Golf gespielt

c=>b=>R=a=>(x=a.split(b).join(c))==a?x:R(x)

Versuch es

Q=c=>b=>R=a=>(x=a.split(b).join(c))==a?x:R(x)

function doit() {
  console.log(Q(C.value)(B.value)(A.value));
}

A: <input type="text" value="abaaba" id="A"/> B: <input type="text" value="aba" id="B"/> C: <input type="text" value="ab" id="C"/> <input type="submit" onclick="doit();" value="REPLACE"/>

Retina , 27 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

+`(.+)(?=.*¶\1¶(.*))
$2
G1`

Der Eingang sollte durch Zeilenvorschub getrennt sein.

Probieren Sie es online! (Verwendet der Einfachheit halber ein Testsuite-Eingabeformat, bei dem jede Zeile durch Schrägstriche getrennte Testfälle darstellt.)

C #, 44 Bytes

Kurzfassung:

r=(a,b,c)=>a==(a=a.Replace(b,c))?a:r(a,b,c);

Beispielprogramm:

using System;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
        {
            Func<string, string, string, string> r = null;
            r=(a,b,c)=>a==(a=a.Replace(b,c))?a:r(a,b,c);

            Action <string, string, string, string> test =
                (a, b, c, answer) =>
                {
                    var result = r(a, b, c);
                    Console.WriteLine("A: \"{0}\"\r\nB: \"{1}\"\r\nC: \"{2}\"\r\nResult: \"{3}\"\r\n{4}\r\n\r\n",
                        a, b, c, result, result == answer ? "CORRECT" : "INCORRECT"
                        );
                };

            test("Hello, world!", "world!", "PPCG", "Hello, PPCG");
            test("Uppercase is up", "up", "down", "Uppercase is down");
            test("ababababa", "aba", "ccc", "cccbcccba");
            test("delete", "e", "", "dlt");
            test("", "no", "effect", "");
            test("llllrrrr", "lr", "rl", "rrrrllll");
            test("+-+-+-+", "+-+", "+", "+");
            test("ababababa", "aba", "bada", "badabbadbada");
            test("abaaba", "aba", "ab", "abb");
            test("((())())())", "()", "", ")");


            Console.WriteLine("Press any key...");
            Console.ReadKey();
        }
    }
}

Erläuterung: Die Funktion ist als rekursiver Ausdruck mit Endung geschrieben, wobei das Schlüsselwort return und geschweifte Klammern vermieden werden, indem Folgendes ausgenutzt wird:

• Eine Zuordnung in Klammern gibt den zugewiesenen Wert zurück
• Die linke Seite der Gleichheitsprüfung wird vor der Zuweisung auf der rechten Seite ausgewertet, sodass wir vor / nach dem Inline-Vergleich noch auf das Ergebnis zugreifen können

So können wir es auf eine einzige Aussage beschränken.

BEARBEITEN: Ging zurück, um die Art der Funktion r wegzulassen, da dies akzeptabel erscheint. Bei der Typdeklaration mit Arrays sind es 68 Zeichen. Ohne ist es 44 Zeichen.

Japt , 15 Bytes

@¥(U=UqV qW}a@U

Online testen!

Wie es funktioniert

@¥(U=UqV qW}a@U  // Implicit: U, V, W = input strings
            a@U  // Return the first non-negative integer mapped by the function X => U
@          }     // that returns truthily when mapped through this function:
     UqV qW      //   Split U at instances of V, and rejoin with W.
  (U=            //   Set U to this new value.
 ¥               //   Return (old U == new U). This stops the loop when U stops changing.
                 // Implicit: output result of last expression

Japt verfügt über eine integrierte Funktion zum rekursiven Ersetzen, sieht die erste Eingabe jedoch als regulären Ausdruck. Wenn die Eingaben garantiert nur alphanumerische Zeichen enthalten würden, würde diese Drei-Byte-Lösung funktionieren:

eVW

Wenn die Eingabe Zeichen außer ^, \oder enthalten darf, ist ]stattdessen diese 12-Byte-Lösung gültig:

eV®"[{Z}]"ÃW

C #, 33 49 Bytes

Wahrscheinlich eines der kleinsten in C # geschriebenen Snippets ... Und da Replacees in der stringStruktur enthalten ist, ist kein usings erforderlich ( Zumindest nicht in der integrierten VS-Funktion C # Interactive ... )

Da Bder Code immer einen Wert hat, muss er auch nicht validiert werden.

Golf gespielt

(a,b,c)=>{while(a!=(a=a.Replace(b,c)));return a;}

Ungolfed

(a, b, c) => {
    while( a != ( a = a.Replace( b, c ) ) );

    return a;
}

Vollständiger Code

using System;

namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            Func<string, string, string, string> func = (a, b, c) => {
                // Recursively ( now truly recursive ) replaces every 'b' for 'c' on 'a',
                // while saving the value to 'a' and checking against it. Crazy, isn't it?
                while( a != ( a = a.Replace( b, c ) ) );

                return a;
            };

            int index = 1;

            // Cycle through the args, skipping the first ( it's the path to the .exe )

            while( index + 3 < args.Length ) {
                Console.WriteLine( func(
                    args[index++],
                    args[index++],
                    args[index++]) );
            }

            Console.ReadLine();
        }
    }
}

Releases

• v1.1 - +19 bytes- Problem, bei dem die Lösung nicht rekursiv war - gefixt
• v1.0 -  33 bytes- Anfangslösung.

Verarbeitung, 75 bis 72 Bytes

void g(String a,String[]s){for(;a!=(a=a.replace(s[0],s[1])););print(a);}

Druckt die Ergebnisse. Nenne es sog("llllrrrr", new String[]{"lr","rl"});

void Q110278(String a, String[]s){             //a is the string to be replaced
                                               //s is the array containing the subsitution

  for(; a!=                                    
            (a = a.replace(s[0], s[1])) ;);

  //for-loop where we continuously perform substitution on a
  //until a is equal to substituted a


  //at the end, print the final version of a
  print(a);
}

Mathematica, 35 32 Bytes

#//.x_:>StringReplace[x,#2->#3]&

Argumente als Folge angegeben. Kündigt zum growBeispiel nie ab , kehrt loopzum loopBeispiel zurück. Drei Bytes weniger dank Martins Vorschlag.

Ruby, 29 Bytes

->a,b,c{1while a.gsub! b,c;a}

Wenden Sie bei 3 Argumenten die Substitution auf die erste an, bis nichts mehr zu ersetzen ist.

Erläuterung

• 1 Vor dem while ist einfach ein noppe
• gsub!Gibt den String zurück oder nilwenn keine Ersetzung stattgefunden hat

Pyke, 6 Bytes

hVQtX:

Probieren Sie es hier aus!

/// , 3 Bytes

///

Setzen Sie den String B nach dem ersten Schrägstrich, C nach dem zweiten und A am Ende, dh:

/<B>/<C>/<A>

Probieren Sie es online!

JavaScript (Firefox 48 oder früher), 43 Byte

c=>b=>g=a=>a==(a=a.replace(b,c,'g'))?a:g(a)

Nimmt Argumente in umgekehrter Reihenfolge auf. Firefox hatte früher einen nicht standardmäßigen dritten Parameter, für replaceden reguläre Ausdrücke festgelegt wurden. Dieser Parameter wurde in Firefox 49 entfernt.

SmileBASIC, 72 68 Bytes

I=0DEF R A,B,C
I=INSTR(A,B)?A*(I<0)A=SUBST$(A,I,LEN(B),C)R A,B,C
END

Einer der seltenen Fälle, in denen eine Funktion erstellt wird, ist SHORTER in SmileBASIC.

Javascript 130 Bytes

f=(a,b,c)=>a.indexOf(b)<0?a:f(eval("a.replace(/"+b.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&")+"/g,c)"),b,c)

Javascript wird nur dann alle gleichzeitig ersetzen, wenn Sie ihm einen regulären Ausdruck geben. Damit dieser reguläre Ausdruck für alle Werte funktioniert, müssen alle Zeichen, die für den regulären Ausdruck verwendet werden, durch die maskierte Version ersetzt werden. Schließlich wird das Ersetzen ausgewertet, um alle Instanzen von B in A durch C zu ersetzen und das wieder an die Funktion zurückzugeben.

q, 15 Bytes

{ssr[;y;z]/[x]}

Beispiel:

q){ssr[;y;z]/[x]}["llllrrrr";"lr";"rl"]
"rrrrllll"

Verknüpfung zum Dolmetscher-Download

Erklärung: ssr , / (konvergieren)

Cheddar, 37 Bytes

(a,b,c)f->a has b?f(a.sub(b,c),b,c):a

Am Telefon ist also TIO-Link etwas schwer hinzuzufügen. Verwendet im Allgemeinen die Rekursion, während das Überprüfen von b in a erfolgt. Die Lösung könnte gewesen sein (a,b,c)->a.sub(Regex{b,"cr"},c), funktioniert aber aus irgendeinem Grund nicht.

Perl 6 , 40 Bytes

{$^b;$^c;($^a,{S:g/$b/$c/}...*eq*)[*-1]}

Probieren Sie es aus (wenn tio.run aktualisiert wird)
Probieren Sie eine geänderte Version aus

Erweitert:

{
  $^b;           # declare second parameter ( not used here )
  $^c;           # declare third parameter  ( not used here )

  (

    $^a,         # declare first parameter, and use it to seed the sequence

    {S:g/$b/$c/} # replace globally

    ...          # keep doing that

    * eq *       # until there are two that match

  )[*-1]
}

PHP, 46 Bytes

function g($a,$b,$c){echo strtr($a,[$b=>$c]);}

PHP, 102 Bytes

list($n,$s,$a,$b)=$argv;$f=str_replace($a,$b,$s);while($s!=$f){$s=$f;$f=str_replace($a,$b,$s);}echo$f;

Testfälle (funktional)

Testfall mit Schleifenfehler

Java - 157 Bytes

String r(String f){if(f.length()<1)return "";String[]x=f.split("/");if(x[0].contains(x[1]))return r(x[0].replace(x[1],x[2])+'/'+x[1]+'/'+x[2]);return x[0];}

Bei leerer Eingabe wird eine leere Zeichenfolge zurückgegeben.

Abstürze mit StackOverflowExceptionFehler, wenn Bleer ist oder Daten wie diese eingespeist werdenA/A/A .

Wie es funktioniert:

r("ABCD/A/F") returns value of r("FBCD/A/F") which returns FBCD
If there is no more characters to be replaced it returns the final output

Ungolfed Code Code mit Kommentaren:

String r (String f) {
    if(f.length() < 1)
        return ""; // For empty input return empty output
    String[] x = f.split("/"); // Get all 3 parameters
    if (x[0].contains(x[1])) // If input contains replaced value
        return r(x[0].replace(x[1],x[2])+'/'+x[1]+'/'+x[2]); // Return value of r() with one character replaced
    return x[0]; // If nothing to replace return the output(modified input)
}

AutoHotkey, 87 Bytes

StringCaseSense,On
Loop{
IfNotInString,1,%2%,Break
StringReplace,1,1,%2%,%3%
}
Send,%1%

%1%,, %2%und %3%sind die ersten 3 Argumente, die an eine Funktion übergeben werden.
Wenn eine Funktion ein variables Argument erwartet, werden die %s gelöscht. Das
Ändern der Einstellung für die Groß- und Kleinschreibung kostet 19 Byte, aber ohne diese Angabe erhalten Sie Dinge wie downpercase is down.