A tarefa

Escreva um programa ou função que, com três seqüências de caracteres, A, B, Cproduza uma sequência de saída em que cada instância de Bin Afoi recursivamente substituída por C. Substituir recursivamente significa repetir uma substituição em que em cada etapa todas as instâncias não sobrepostas de Bin A(escolhidas avidamente da esquerda para a direita) são substituídas por Caté que Bnão esteja mais contida A.

Entrada / Saída

• Você pode usar qualquer um dos métodos padrão para I / O .
• As seqüências conterão apenas caracteres ASCII imprimíveis (e podem conter qualquer um deles).
• Bnunca será uma string vazia, enquanto Ae Cpode ser.
• Seqüências de caracteres devem ser consideradas texto sem formatação, você não pode, por exemplo, tratar Bcomo um padrão Regex.
• Algumas combinações de entradas nunca terminam. Seu programa pode fazer qualquer coisa nesses casos.

Casos de teste

Estes estão no formato: 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}
)

Exemplos que não terminam:

grow/ow/oow

loop/lo/lo

05AB1E , 2 bytes

`:

Experimente online!

Explicação

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

Pode ser :de 1 byte se não tivermos que lidar com cadeias vazias.

Python 2 , 43 bytes

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

Experimente online!

Avalia uma sequência do formulário

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

Para atingir um ponto fixo, se houver, basta fazer substituições iguais ao comprimento da string original.

ES6 (Javascript), 47, 43 bytes

• Salvo 4 bytes usando currying (Obrigado @ Neil!)

Golfe

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

Tente

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

A contagem de bytes assume a codificação ISO 8859-1.

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

A entrada deve ser separada pela alimentação de linha.

Experimente online! (Por conveniência, usa um formato de entrada do conjunto de testes em que cada linha é um caso de teste separado por barra).

C #, 44 bytes

Versão curta:

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

Programa de exemplo:

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();
        }
    }
}

Explicação: A função é escrita como uma expressão recursiva de cauda, ​​evitando a palavra-chave de retorno e os colchetes, explorando o seguinte:

• Uma atribuição entre parênteses retorna o valor atribuído
• O lado esquerdo da verificação de igualdade será avaliado antes da atribuição do lado direito, permitindo comparar antes / depois da linha e ainda acessar o resultado

Isso nos permite manter uma única declaração.

EDIT: Voltamos a omitir o tipo de função r, pois isso parece ser aceitável. Na declaração de tipo usando matrizes, são 68 caracteres. Sem, são 44 caracteres.

Japonês , 15 bytes

@¥(U=UqV qW}a@U

Teste online!

Como funciona

@¥(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

O Japt possui uma substituição recursiva integrada, mas vê a primeira entrada como um regex. Se fosse garantido que as entradas contivessem apenas caracteres alfanuméricos, esta solução de três bytes funcionaria:

eVW

Se a entrada tiver permissão para conter qualquer caractere ^, exceto,, \ou ], essa solução de 12 bytes será válida:

eV®"[{Z}]"ÃW

C #, 33 49 bytes

Provavelmente, um dos menores trechos escritos em C # ... E como Replaceé nativo da stringestrutura, não há necessidade de usings ( pelo menos não no recurso interno do VS, C # interativo ... )

Além disso, como Bsempre tem um valor, o código não precisa de validações.

Golfe

(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;
}

Código completo

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();
        }
    }
}

Lançamentos

• v1.1 - +19 bytes- Solução fixa não sendo recursiva.
• v1.0 -  33 bytes- Solução inicial.

Processando, 75 72 bytes

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

Imprime os resultados. Chame comog("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]&

Argumentos dados como uma sequência. Nunca termina por growexemplo, retorna looppor loopexemplo. Três bytes de folga graças à sugestão de Martin.

Ruby, 29 bytes

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

Dados 3 argumentos, aplique a substituição ao primeiro até que não haja mais nada para substituir.

Explicação

• 1antes do whileé simplesmente um nop
• gsub!retorna a string ou nilse nenhuma substituição ocorreu

Pyke, 6 bytes

hVQtX:

Experimente aqui!

/// , 3 bytes

///

Coloque a corda B após a primeira barra, C após a segunda e A no final, ou seja:

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

Experimente online!

JavaScript (Firefox 48 ou anterior), 43 bytes

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

Aceita argumentos em ordem inversa. O Firefox costumava ter um terceiro parâmetro não padrão para o replacequal os sinalizadores de regexp especificados. Este parâmetro foi removido no Firefox 49.

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

Um dos raros casos em que a criação de uma função é realmente MAIS CURTA no SmileBASIC.

Javascript 130 bytes

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

O Javascript substituirá tudo simultaneamente se você fornecer um regex. Para fazer esse regex funcionar para todos os valores, todos os caracteres usados ​​para regex precisam ser substituídos pela versão de escape. Finalmente, a substituição é avaliada para substituir todas as instâncias de B em A por C e passando isso de volta para a função novamente.

q, 15 bytes

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

Exemplo:

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

ligação para download do intérprete

Explicação: ssr , / (converge)

Cheddar, 37 bytes

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

No telefone, é um pouco difícil adicionar o link TIO. Basicamente, usa recursão enquanto a verificação é b está em a. A solução poderia ter sido, (a,b,c)->a.sub(Regex{b,"cr"},c)mas não funciona por algum motivo.

Perl 6 , 40 bytes

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

Experimente (se tio.run for atualizado)
Experimente uma versão alterada

Expandido:

{
  $^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;

Casos de teste (funcionais)

Caso de teste com erro de loop

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];}

Para entrada vazia, ele retorna uma string vazia.

StackOverflowExceptionFalha com erro quando Bestá vazio ou é alimentado com dados como este A/A/A.

Como funciona:

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

Código de código ungolfed com comentários:

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%e %3%são os 3 primeiros argumentos passados ​​para uma função
Se uma função espera um argumento variável, os %s são descartados. A
alteração da configuração de distinção entre maiúsculas e minúsculas custa 19 bytes, mas, sem ela, você obtém coisas como downpercase is down.