Nehmen Sie drei Eingänge, einen Text - String, T; eine Zeichenfolge, die ersetzt werden soll F; und eine Zeichenfolge, die durch, ersetzt werden soll R. Ersetzen Sie für jeden Teilstring Tmit den gleichen Zeichen (ohne Berücksichtigung der Groß- und Kleinschreibung) wie Fdiese durch die Zeichen in R. Behalten Sie jedoch die gleiche Schreibweise wie beim Originaltext bei.

Wenn mehr Zeichen Rals enthalten sind F, sollten die zusätzlichen Zeichen mit denen in identisch sein R. Wenn Zahlen oder Symbole in enthalten sind F, sollten die entsprechenden Zeichen in Rder Groß- / Kleinschreibung beibehalten werden R. Ferscheint nicht unbedingt in T.

Sie können davon ausgehen, dass sich der gesamte Text im druckbaren ASCII-Bereich befindet.

Beispiele

"Text input", "text", "test" -> "Test input"

"tHiS Is a PiEcE oF tExT", "is", "abcde" -> "tHaBcde Abcde a PiEcE oF tExT"

"The birch canoe slid on the smooth planks", "o", " OH MY " -> "The birch can OH MY e slid  OH MY n the sm OH MY  OH MY th planks"

"The score was 10 to 5", "10", "tEn" -> "The score was tEn to 5"

"I wrote my code in Brain$#@!", "$#@!", "Friend" -> "I wrote my code in BrainFriend"

"This challenge was created by Andrew Piliser", "Andrew Piliser", "Martin Ender" -> "This challenge was created by Martin Ender"

// Has a match, but does not match case 
"John does not know", "John Doe", "Jane Doe" -> "Jane does not know"

// No match
"Glue the sheet to the dark blue background", "Glue the sheet to the dark-blue background", "foo" -> "Glue the sheet to the dark blue background"

// Only take full matches
"aaa", "aa", "b" -> "ba"

// Apply matching once across the string as a whole, do not iterate on replaced text
"aaaa", "aa", "a" -> "aa"

"TeXT input", "text", "test" -> "TeST input"

Sandbox-Link

Netzhaut , 116 Bytes

i`(.+)(?=.*¶\1(¶.*)$)|.*¶.*$
¶¶$2¶$1¶¶
{T`l`L`¶¶.(?=.*¶[A-Z])
T`L`l`¶¶.(?=.*¶[a-z])
}`¶¶¶(.)(.*¶).
$1¶¶¶$2
¶¶¶¶.*|¶

Probieren Sie es online! Erläuterung:

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

Diese Suche wird ausgeführt, Tund Fjedes Mal, wenn zwischen Groß- und Kleinschreibung kein Unterschied zwischen dem Lookahead und dem Match besteht, werden mehrere Zeilen mit Zeilenumbrüchen Reingefügt, und der Lookahead to wird ebenfalls eingefügt.

{T`l`L`¶¶.(?=.*¶[A-Z])
T`L`l`¶¶.(?=.*¶[a-z])
}`¶¶¶(.)(.*¶).
$1¶¶¶$2

Jeder Buchstabe der Kopie von Rwird so angepasst, dass er mit dem des Streichholzes übereinstimmt, woraufhin er aus dem Arbeitsbereich verschoben wird, damit der nächste Buchstabe verarbeitet werden kann, bis entweder die Kopie von Roder der Streichholz keine Buchstaben mehr aufweist.

¶¶¶¶.*|¶

Wenn die RAnzahl der Buchstaben in der Kopie nicht mehr ausreicht, werden vor dem Rest der Übereinstimmung 4 neue Zeilen eingefügt. Löschen Sie sie daher. Andernfalls bleiben Kopien übrig R, die mit den nicht übereinstimmenden Teilen der Eingabe verknüpft werden müssen, um das Ergebnis zu erzielen.

APL (Dyalog) , 75 73 72 Bytes

Fordert zur Eingabe von T, Rund Fin dieser Reihenfolge auf. Rmuss im Dyalog-Transformationsformat und Fim PCRE-Format angegeben werden.

⍞⎕R(⍞∘{(⊣⌿d)l¨⍨(1∘⌷≠(⊢⌿d∊⎕A,l⎕A)∧≠⌿)d≠(l←819⌶)d←↑⍺⍵.Match↑¨⍨≢⍺})⍠1⊢⍞

Probieren Sie es online!

⍞ Eingabeaufforderung für T

⊢ ergeben, dass (trennt 1 und T)

⍞⎕R(... )⍠1 Prompt für Fund R eplace Einstimmungen mit dem Ergebnis der folgenden Funktion:

 ⍞∘{…} leiten Sie eine monadische Funktion ab, indem Sie das angeforderte RArgument als linkes Argument verknüpfen mit:

  ≢⍺ Zählen Sie die Anzahl der Buchstaben in R

  ⍺⍵.Match↑¨⍨ nimm so viele Buchstaben von jedem von Rund die Übereinstimmung
   _{⍺ist das linke Argument, das wir Rals gebunden haben .
   ⍵ist ein Namespace, in dem Matchdie aktuell gefundene Zeichenfolge enthalten ist.}

  ↑ mische diese beiden zu einer zweireihigen Matrix

  d← speichern als d

  (… )  Wenden darauf folgende implizite Funktion an:

   819⌶ Kleinbuchstaben (Mnemonik: 819 sieht aus wie Big )

   l← Speichern Sie diese Funktion als l

  d≠ Boolescher Wert, bei dem dsich der Wert unterscheidet (dh 0/1 für jeden Klein- / Großbuchstaben)

  (… ) Wenden darauf folgende implizite Funktion an:

   ≠⌿ vertikales XOR

   (… )∧ Boolesches AND mit folgendem Array:

    l⎕A Kleinbuchstaben A lphabet

    ⎕A, voranstellen A lphabet

    d∊ Boolescher Wert für jeden Buchstaben in d, ob ein Mitglied davon (dh ob ein Buchstabe)

    ⊢⌿ letzte Zeile, dh für das Zeichen der Übereinstimmung, ob es sich um einen Buchstaben handelt

   1∘⌷≠ XOR mit der ersten Zeile, dh ob jedes Zeichen in RGroßbuchstaben geschrieben ist

  (… )l¨⍨ Benutze das, um jeden Buchstaben von:

   ⊣⌿ die erste Reihe, dh R

* Byteanzahl für Dyalog Classic unter Verwendung von ⎕OPT anstelle von ⍠.

Perl 5 , 108 Bytes

107 Byte Code + 1 für -p.

chomp(($s,$r)=<>);s|\Q$s|$&=~s!.!$_=substr$r,"@-",1;$&=~/[a-z]/i?$&eq uc$&?uc:lc:$_!egr.substr$r,"@-"+1|gie

Probieren Sie es online!

Zurückgezogen. Doms Antwort schlägt es bei weitem.

# Perl 5 , 136 + 1 (-p) = 137 Bytes

$f=<>;chomp$f;@R=($r=<>)=~/./g;for$i(/\Q$f/gi){$c=$n='';$"=$R[$c++],$n.=/[A-Z]/?uc$":/[a-z]/?lc$":$"for$i=~/./g;s/\Q$i/$n.substr$r,$c/e}

Probieren Sie es online!

machte einen großen Schnitt nach @ Dom Hastings erwähnt \Q

# Perl 5 , 176 + 1 (-p) = 177 Bytes

sub h($){chomp@_;pop=~s/[^a-z0-9 ]/\\$&/gir}$f=h<>;@R=($r=<>)=~/./g;for$i(/$f/gi){$c=$n='';$"=$R[$c++],$n.=/[A-Z]/?uc$":/[a-z]/?lc$":$"for$i=~/./g;$i=h$i;s/$i/$n.substr$r,$c/e}

Probieren Sie es online!

Power Shell , 190 Byte

param($T,$F,$R)[regex]::Replace($T,'(?i)'+[regex]::escape($F),{param($m)-join(0..$R.Length|%{(($y=$R[$_]),("$y"."To$((('Low','Upp')[($z="$m"[$_])-cmatch($C='[A-Z]')]))er"()))[$z-match$C]})})

Probieren Sie es online!

Erläuterung:

[Regex]::Replace( 
    input text T,
    Find text F with case insensitive and [regex]::escape() for symbols,
    {scriptblock} for computing the replacement
)

Der Ersetzungsskriptblock führt Folgendes aus:

$m is the matched text with case information
loop over each character in R as $y
    $z is the same index character in $m ($null if R overruns)
    $z-match'[A-Z]' checks if alphabetic, so we must to case-match
      otherwise, non-alphabetic or null, no case-match, return $y unchanged.
    if case-matching, check if z case-sensitive matches '[A-Z]' and
      use dynamic method calling from a generated string, either 
      $y."ToLower"()
      $y."ToUpper"()
      to force the match
-join the loop output into a replacement string

Testfälle:

function f {
param($T,$F,$R)[regex]::Replace($T,'(?i)'+[regex]::escape($F),{param($m)-join(0..$R.Length|%{(($y=$R[$_]),("$y"."To$((('Low','Upp')[($z="$m"[$_])-cmatch($C='[A-Z]')]))er"()))[$z-match$C]})})
}

Import-Module Pester

$Cases = @(
    @{Text = "Text input"; Find = "text"; Replace = "test"; Result = "Test input" }
    @{Text = "tHiS Is a PiEcE oF tExT"; Find = "is"; Replace = "abcde"; Result = "tHaBcde Abcde a PiEcE oF tExT" }
    @{Text = "The birch canoe slid on the smooth planks"; Find = "o"; Replace = " OH MY "; Result = "The birch can OH MY e slid  OH MY n the sm OH MY  OH MY th planks" }
    @{Text = "The score was 10 to 5"; Find = "10"; Replace = "tEn"; Result = "The score was tEn to 5" }
    @{Text = "I wrote my code in Brain$#@!"; Find = "$#@!"; Replace = "Friend"; Result = "I wrote my code in BrainFriend" }
    @{Text = "This challenge was created by Andrew Piliser"; Find = "Andrew Piliser"; Replace = "Martin Ender"; Result = "This challenge was created by Martin Ender" }
    @{Text = "John does not know"; Find = "John Doe"; Replace = "Jane Doe" ; Result ="Jane does not know" }
    @{Text = "Glue the sheet to the dark blue background"; Find = "Glue the sheet to the dark-blue background"; Replace = "foo"; Result ="Glue the sheet to the dark blue background" }
    @{Text = "aaa" ; Find = "aa"; Replace = "b"; Result ="ba" }
    @{Text = "aaaa"; Find = "aa"; Replace = "a"; Result ="aa" }
    @{Text = "TeXT input"; Find = "text"; Replace = "test"; Result ="TeST input" }
)

Describe "Tests" {

    It "works on /<Text>/<Find>/<Replace>/ == '<Result>'" -TestCases $Cases {
        param($Text, $Find, $Replace, $Result)
        f $Text $Find $Replace | Should -BeExactly $Result
    }

}

TXR Lisp, 285 Bytes

(defun f(s f r)(let*((w(copy s))(x(regex-compile ^(compound,(upcase-str f))))(m(reverse(tok-where(upcase-str s)x))))(each((n m))(set[w n]r) (for((i(from n)))((< i (min(to n)(len w))))((inc i))(cond((chr-isupper[s i])(upd[w i]chr-toupper))((chr-islower[s i])(upd[w i]chr-tolower)))))w))

Konventionell formatiertes Original:

(defun f (s f r)
  (let* ((w (copy s))
         (x (regex-compile ^(compound ,(upcase-str f))))
         (m (reverse (tok-where (upcase-str s) x))))
    (each ((n m))
      (set [w n] r)
      (for ((i (from n))) ((< i (min (to n) (len w)))) ((inc i))
        (cond ((chr-isupper [s i]) (upd [w i] chr-toupper))
              ((chr-islower [s i]) (upd [w i] chr-tolower)))))
    w))

JavaScript, 177 Bytes

(T,F,R)=>T.replace(eval(`/${F.replace(/[-\/\\^$*+?.()|[\]{}]/g,'\\$&')}/gi`),F=>[...R].map((r,i)=>/[A-Z]/i.test(f=F[i]||'')?r[`to${f>'`'&&f<'{'?'Low':'Upp'}erCase`]():r).join``)

F=
(T,F,R)=>T.replace(eval(`/${F.replace(/[-\/\\^$*+?.()|[\]{}]/g,'\\$&')}/gi`),F=>[...R].map((r,i)=>/[A-Z]/i.test(f=F[i]||'')?r[`to${f>'`'&&f<'{'?'Low':'Upp'}erCase`]():r).join``)

document.write([
  ["Text input", "text", "test"],
  ["tHiS Is a PiEcE oF tExT", "is", "abcde"],
  ["The birch canoe slid on the smooth planks", "o", " OH MY "],
  ["The score was 10 to 5", "10", "tEn"],
  ["I wrote my code in Brain$#@!", "$#@!", "Friend"],
  ["This challenge was created by Andrew Piliser", "Andrew Piliser", "Martin Ender"],
  ["John does not know", "John Doe", "Jane Doe"],
  ["Glue the sheet to the dark blue background", "Glue the sheet to the dark-blue background", "foo"],
  ["aaa", "aa", "b"],
  ["aaaa", "aa", "a"],
  ["TeXT input", "text", "test"],
].map(a=>F(...a)).join('<br>'))

/*
(T,F,R)=>T.replace(
	eval(`/${F.replace(/[-\/\\^$*+?.()|[\]{}]/g,'\\$&')}/gi`),
    //F=>eval("for(i in R)r+=(f=F[i])&&/[A-Z]/i.test(f)?R[i][`to${f>'`'&&f<'{'?'Low':'Upp'}erCase`]():R[i];r",r='')
	//F=>[...R].map((r,i)=>(f=F[i])&&/[A-Z]/i.test(f)?r[`to${f>'`'&&f<'{'?'Low':'Upp'}erCase`]():r).join``
    //F=>[...R].reduce((s,r,i)=>s+(f=F[i])&&/[A-Z]/i.test(f)?r[`to${f>'`'&&f<'{'?'Low':'Upp'}erCase`]():r,'')
    F=>[...R].map((r,i)=>/[A-Z]/i.test(f=F[i]||'')?r[`to${f>'`'&&f<'{'?'Low':'Upp'}erCase`]():r).join``
)*/

Weniger golfen:

(T,F,R) => T.replace(
    eval(`/${F.replace(/[-\/\\^$*+?.()|[\]{}]/g,'\\$&')}/gi`),
    F=>[...R].map((r,i) =>
        /[A-Z]/i.test(f = F[i] || '')
            ? r[`to${
                f > '`' && f < '{'
                    ? 'Low'
                    : 'Upp'
                }erCase`]()
            : r
    ).join``
)

47 Bytes stammen aus dieser Regex-Escape-Funktion, da das Programm Symbole verarbeiten muss. :(

Python 2 , 193 200 Bytes

T,F,R=input()
w=str.lower
i=-len(T)
l=len(F)
T+=' '
while i:
 s=T[i:i+l]
 if w(s)==w(F):T=T[:i]+`[[y,[w(y),y.upper()][x<'a']][x.isalpha()]for x,y in zip(s,R)]`[2::5]+R[l:]+T[i+l:];i+=l-1
 i+=1
print T

Probieren Sie es online!

Python 3 , 183 Bytes

import re
j="".join
f=lambda T,F,R:j((p,j((y,(y.lower(),y.upper())[x<'a'])[x.isalpha()]for(x,y)in zip(p,R))+R[len(F):])[i%2>0]for i,p in enumerate(re.split('('+re.escape(F)+')',T,0,2)))

Probieren Sie es online!

re.split + Behalte alle geraden Elemente bei und ersetze alle ungeraden Elemente durch die korrekte Transformation des Ersetzungsstrings:

>>> re.split("(is)","tHiS Is a PiEcE oF tExT",0,2) # 2=re.IGNORE_CASE
['tH', 'iS', ' ', 'Is', ' a PiEcE oF tExT']

C (GCC) , 210 211 207 189 Bytes

Musste ein Byte hinzufügen, um einen Fehler mit der Großschreibung für den Testfall "BrainFriend" zu beheben

Wow war das langweilig ... Jetzt ein paar Bytes weggolfen

char*c,*p;d,l;f(t,f,r){for(d=isalpha(*(p=f)),p=c=t;c=strcasestr(c,f);p=c+=l>0?l:0){for(l=strlen(f);p<c;)putchar(*p++);for(p=r;*p;p++,c+=l-->0)putchar(d*l<1?*p:*c&32?*p|32:*p&~32);}puts(p);}

Probieren Sie es online!

C # (Mono C # -Compiler) , 241 Byte

using System.Text.RegularExpressions;
class Program {
static void Main(string[] args) {
r("Text input","text","Test");
}
static void r(string v,string i,string u)
{
System.Console.WriteLine(Regex.Replace(v,i,u,RegexOptions.IgnoreCase)); 
}
}

Probieren Sie es online!