Lấy ba đầu vào, một chuỗi văn bản , T; một chuỗi các ký tự để thay thế , F; và một chuỗi các ký tự để thay thế chúng bằng R. Đối với mỗi chuỗi con Tcó cùng ký tự (không phân biệt chữ hoa chữ thường) F, hãy thay thế chúng bằng các ký tự trong R. Tuy nhiên, giữ nguyên trường hợp như văn bản gốc.

Nếu có nhiều ký tự Rhơn F, các ký tự phụ sẽ là trường hợp tương tự như trong chúng R. Nếu có số hoặc ký hiệu F, thì các ký tự tương ứng Rsẽ giữ nguyên trường hợp chúng có R. Fsẽ không nhất thiết phải xuất hiện trong T.

Bạn có thể giả sử tất cả văn bản sẽ nằm trong phạm vi ASCII có thể in được.

Ví dụ

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

Liên kết hộp cát

Võng mạc , 116 byte

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

Hãy thử trực tuyến! Giải trình:

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

Tìm kiếm này Tvà bất cứ khi nào có một trận đấu không phân biệt chữ hoa chữ thường so với giao Fdiện của trận đấu được bao quanh trong một loạt các dòng mới và giao diện Rcũng được chèn vào.

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

Mỗi chữ cái của bản sao Rđược điều chỉnh trong trường hợp khớp với chữ cái của trận đấu, sau đó nó được di chuyển ra khỏi khu vực làm việc để chữ cái tiếp theo có thể được xử lý, cho đến khi bản sao của Rhoặc khớp hết chữ.

¶¶¶¶.*|¶

Nếu bản sao Rhết chữ cái, phần còn lại của trận đấu sẽ được dẫn trước bởi 4 dòng mới, vì vậy hãy xóa nó. Mặt khác, mọi thứ còn lại sẽ là các phần còn lại của các bản sao Rcần được nối với các phần không khớp của đầu vào để tạo ra kết quả.

APL (Dyalog) , 75 73 72 byte

Nhắc nhở cho T, Rvà Ftheo thứ tự đó. Rphải b đưa ra ở định dạng chuyển đổi Dyalog và Fphải được đưa ra ở định dạng PCRE.

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

Hãy thử trực tuyến!

⍞ Nhắc cho T

⊢ mang lại (tách 1 và T)

⍞⎕R(... )⍠1 nhắc cho Fvà R trận eplace với kết quả của hàm sau:

 ⍞∘{…} rút ra một hàm đơn âm bằng cách nhập đối số được nhắc Rlà trái:

  ≢⍺ đếm số lượng chữ cái trong R

  ⍺⍵.Match↑¨⍨ lấy nhiều chữ cái từ mỗi Rvà đối số
   _{⍺là đối số bên trái, mà chúng ta gắn Rvới nhau.
   ⍵là một không gian tên trong đó Matchchứa chuỗi hiện được tìm thấy.}

  ↑ trộn hai thứ đó thành một ma trận hai hàng

  d← lưu trữ như d

  (... )  áp dụng các chức năng ngầm sau đó:

   819⌶ chữ thường (mnemonic: 819 trông giống như Big )

   l← lưu trữ chức năng đó như là l

  d≠ Boolean nơi dkhác nhau (nghĩa là cho 0/1 cho mỗi chữ cái viết thường / chữ hoa)

  (... ) áp dụng các chức năng ngầm sau đó:

   ≠⌿ XOR dọc

   (... )∧ Boolean AND với các mảng sau:

    l⎕A hạ cấp A lph.us

    ⎕A, thêm vào trước chữ hoa Một lphabet

    d∊ Boolean cho mỗi chữ cái trong d cho dù là thành viên của chữ đó (nghĩa là một chữ cái)

    ⊢⌿ hàng cuối cùng, ví dụ như ký tự của trận đấu cho dù đó là một chữ cái

   1∘⌷≠ XOR với hàng đầu tiên, nghĩa là mỗi ký tự của Rchữ hoa

  (... )l¨⍨ sử dụng mà thành chữ thường (nếu 0) hoặc chữ hoa (nếu 1) mỗi chữ cái của:

   ⊣⌿ hàng đầu tiên, tức là R

* Số lượng byte cho Dyalog Classic sử dụng ⎕OPT thay vì ⍠.

Perl 5 , 108 byte

107 byte mã + 1 cho -p.

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

Hãy thử trực tuyến!

Rút tiền. Câu trả lời của Dom đánh bại nó bằng một cú sút xa.

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

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

Hãy thử trực tuyến!

đã thực hiện một cắt giảm lớn sau khi @Dom Hastings đề cập \Q

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

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}

Hãy thử trực tuyến!

PowerShell , 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]})})

Hãy thử trực tuyến!

Giải trình:

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

Scriptblock thay thế nào:

$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

Các trường hợp thử nghiệm:

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 byte

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

Định dạng gốc thông thường:

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

(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``
)*/

Ít chơi gôn hơn:

(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 byte đến từ hàm thoát regex này do chương trình phải xử lý các ký hiệu. :(

Python 2 , 193 200 byte

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

Hãy thử trực tuyến!

Con trăn 3 , 183 byte

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

Hãy thử trực tuyến!

re.split + giữ tất cả các phần tử chẵn và thay thế tất cả các phần tử lẻ bằng cách chuyển đổi chính xác của chuỗi thay thế:

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

Phải thêm một byte để sửa lỗi viết hoa cho testcase "BrainFriend"

Wow thật là tẻ nhạt ... Bây giờ để chơi golf một số byte

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

Hãy thử trực tuyến!

C # (trình biên dịch Mono C #) , 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)); 
}
}

Hãy thử trực tuyến!