केस मैचिंग रिप्लेसमेंट खोजें

Question

तीन इनपुट लें, पाठ की एक स्ट्रिंग T, पात्रों की एक स्ट्रिंग को बदलने के लिए F; और वर्णों की स्ट्रिंग, के साथ उन्हें बदलने के लिए R। प्रत्येक T(केस असंवेदनशील) वर्णों के विकल्प के रूप में F, उन्हें वर्णों के साथ बदलें R। हालाँकि, मूल पाठ के समान ही मामला रखें।

अगर वहाँ में और अधिक चरित्र Rकी तुलना में Fके रूप में वे कर रहे हैं, अतिरिक्त वर्ण इसी मामले होना चाहिए R। यदि संख्याएँ या चिह्न हैं F, तो संबंधित वर्णों को Rउनके पास मौजूद मामले को रखना चाहिए R। Fजरूरी में दिखाई नहीं देगा T।

आप मान सकते हैं कि सभी पाठ मुद्रण योग्य ASCII रेंज में होंगे।

उदाहरण

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

सैंडबॉक्स लिंक

Comments

अजीब आवरण के साथ एक उदाहरण का अनुरोध:"TeXT input", "text", "test"

— इंजीनियर टोस्ट

@EngineerToast जोड़ा गया उदाहरण

— एंड्रयू

इस बात पर ध्यान न दें कि मुझे "The birch canoe slid on the smooth planks", "o", " OH MY "इतना हास्यप्रद क्यों लगा , लेकिन मुझे वह उदाहरण बहुत अच्छा लगा।

— मैजिक ऑक्टोपस Urn

Answer 1

रेटिना , 116 बाइट्स

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

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

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

यह खोज करता है Tऔर जब भी मैच के लिए लुकहेड के खिलाफ एक केस-असंवेदनशील मैच होता है, तो उसे नए समाचारों के Fएक समूह में घेर लिया जाता है और लुकहेड को Rभी सम्मिलित किया जाता है।

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

कॉपी की प्रत्येक पत्र Rको मैच के मैच के मामले में समायोजित किया जाता है, जिसके बाद इसे कार्य क्षेत्र से बाहर ले जाया जाता है ताकि अगले पत्र को संसाधित किया जा सके, जब तक कि या तो कॉपी Rया मैच पत्र से बाहर न चला जाए।

¶¶¶¶.*|¶

यदि Rपत्रों की रनों की प्रतिलिपि बाहर निकलती है, तो मैच के शेष भाग को 4 नई सुर्खियों में रखा जाएगा, इसलिए इसे हटा दें। अन्यथा, कुछ भी छोड़ दिया जाएगा प्रतियों के टुकड़ों पर Rजिसके परिणामस्वरूप परिणाम का उत्पादन करने के लिए इनपुट के गैर-मिलान भागों के साथ समाहित किया जाना चाहिए।

Answer 2

एपीएल (डायलॉग) , 75 73 72 बाइट्स

के लिए संकेत देता T, Rऔर Fइसी क्रम में। RDyalog परिवर्तन प्रारूप Fमें दिया जाना चाहिए और PCRE प्रारूप में दिया जाना चाहिए।

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

इसे ऑनलाइन आज़माएं!

⍞ के लिए शीघ्र T

⊢ उपज (जो 1 और अलग करती है T)

⍞⎕R(... और निम्नलिखित समारोह के परिणाम के साथ आर eplace मैच के )⍠1 लिए संकेत :F

 ⍞∘{…}Rबाईं ओर तर्क के रूप  में संकेत के लिए बांधने से एक राक्षसी कार्य प्राप्त करें:

  ≢⍺ में अक्षरों की संख्या गिनें R

  ⍺⍵.Match↑¨⍨Rमैच के  प्रत्येक अक्षर और मैच
   _{⍺को लेफ्ट लॉजिक है, जिसे हमने बाँध दिया Rहै।
   ⍵एक नेमस्पेस है जिसमें Matchवर्तमान में पाया गया स्ट्रिंग है।}

  ↑ उन दोनों को एक दो-पंक्ति मैट्रिक्स में मिलाएं

  d← के रूप में स्टोर d

  (… )  उस के लिए निम्नलिखित tacit फ़ंक्शन लागू करें:

   819⌶ लोअरकेस (महामारी: 819 बड़ा दिखता है )

   l← उस फंक्शन को स्टोर करें l

  d≠ बूलियन जहां dअलग होता है (यानी प्रत्येक लोअरकेस / अपरकेस अक्षर के लिए 0/1 देता है)

  (… ) उस के लिए निम्नलिखित tacit फ़ंक्शन लागू करें:

   ≠⌿ ऊर्ध्वाधर XOR

   (… )∧ बूलियन और निम्नलिखित सरणी के साथ:

    l⎕A लोवरकेस एक lphabet

    ⎕A, आगे जोड़ते अपरकेस एक lphabet

    d∊ प्रत्येक पत्र के लिए बूलियन घ कि क्या उस का एक सदस्य (यानी कि क्या एक पत्र)

    ⊢⌿ अंतिम पंक्ति यानी मैच के चरित्र के लिए चाहे वह एक पत्र हो

   1∘⌷≠ पहली पंक्ति के साथ XOR, यानी कि प्रत्येक वर्ण Rअपरकेस है

  (... का )l¨⍨ उपयोग करें कि लोअरकेस (यदि 0) या अपरकेस (यदि 1) का प्रत्येक अक्षर:

   ⊣⌿ पहली पंक्ति, यानी R

---

* के ⎕OPT बजाय Dyalog क्लासिक का उपयोग करने के लिए बाइट गिनती ⍠।

Answer 3

पर्ल 5 , 108 बाइट्स

107 बाइट्स कोड + 1 के लिए -p।

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

इसे ऑनलाइन आज़माएं!

Answer 4

वापस ले लिया। डॉम का जवाब उसे लंबे शॉट से मारता है।

# पर्ल 5 , 136 + 1 (-पी) = 137 बाइट्स

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

इसे ऑनलाइन आज़माएं!

@Dom Hastings के उल्लेख के बाद भारी कटौती की गई \Q

# पर्ल 5 , 176 + 1 (-पी) = 177 बाइट्स

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}

इसे ऑनलाइन आज़माएं!

Comments

अब सभी परीक्षण मामलों को पास करता है;) 108: इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

आपको इसे पोस्ट करना चाहिए। यह मेरा थोड़ा बहुत द्वारा धड़कता है।

— Xcali

काफी उचित! मजा आ रहा था। मैं चुनौती का आनंद लेता हूं!

— डोम हेस्टिंग्स

Answer 5

पॉवरशेल , 190 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

प्रतिकृति स्क्रिप्टब्लॉक करता है:

$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

परीक्षण के मामलों:

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
    }

}

Answer 6

TXR लिस्प, 285 बाइट्स

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

पारंपरिक रूप से स्वरूपित मूल:

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

Answer 7

जावास्क्रिप्ट, 177 बाइट्स

(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,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 बाइट्स इस रेगेक्स एस्केप फ़ंक्शन से आए क्योंकि कार्यक्रम को प्रतीकों को संभालना है। :(

Answer 8

पायथन 2 , 193 200 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

यह (193 बाइट्स, TIO लिंक से) स्ट्रिंग के अंत में मैच खोजने में विफल रहेगा।

— तहमती ०

Answer 9

पायथन 3 , 183 बाइट्स

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

इसे ऑनलाइन आज़माएं!

re.split + सभी तत्वों को रखें और प्रतिस्थापन स्ट्रिंग के सही परिवर्तन द्वारा सभी विषम तत्वों को प्रतिस्थापित करें:

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

Answer 10

C (gcc) , 210 211 207 189 बाइट्स

"ब्रेनफ्रेंड" टेस्टकेस के लिए कैपिटलाइज़ेशन के साथ बग को ठीक करने के लिए एक बाइट जोड़ना था

वाह यह थकाऊ था ... अब कुछ बाइट दूर गोल्फ के लिए

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

इसे ऑनलाइन आज़माएं!

Comments

मुझे शायद कुछ स्पष्ट याद आ रहा है, लेकिन *(p=f)जब आपको p=c=tबस बाद में सेट करना है तो आपको इसकी आवश्यकता क्यों है ? मैंने इसे बस के साथ आजमाया *fऔर यह काम नहीं किया, इसलिए यह तुरंत नहीं लिखा जा रहा है।

— एंड्रयू

f एक बीफॉल्ट द्वारा एक int है, इसलिए हम इसे एक चार पाने के लिए नहीं कर सकते, लेकिन p एक char * है

— Cleblanc

आह, यह समझ में आता है। तो यह लिखने का एक छोटा तरीका है *((char*)f)? ठंडा!

— एंड्रयू

Answer 11

सी # (मोनो सी # संकलक) , 241 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

PPCG में आपका स्वागत है! आप यहाँ पर काफी व्हाट्सएप को हटा सकते हैं, और वास्तव में आपको या तो इनपुट्स को तर्क या इनपुट के रूप में लेना होगा (उन्हें कोड करना निषिद्ध है) या आप वास्तव में केवल फ़ंक्शन को शामिल कर सकते हैं; तुम भी जरूरत नहीं है Action<string,string,string> r =भाग

— HyperNeutrino