Übereinstimmende Groß- / Kleinschreibung Suchen Ersetzen

14

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

code-golf  string  code-golf  string  ascii-art  alphabet  code-golf  number  sequence  counting  code-golf  sequence  counting  code-golf  quine  source-layout  code-golf  string  code-golf  decision-problem  game  code-golf  string  quine  source-layout  subsequence  code-golf  quine  code-golf  array-manipulation  integer  code-golf  ascii-art  code-golf  sequence  integer  code-golf  kolmogorov-complexity  code-golf  array-manipulation  integer  code-golf  number  array-manipulation  integer  code-golf  string  number  integer  code-golf  string  ascii-art  code-challenge  test-battery  expression-building  source-layout  printable-ascii  code-bowling  code-golf  number  code-golf  number  string  binary  code-golf  matrix  conversion  code-golf  number  arithmetic 
— Andrew sagt Reinstate Monica
quelle
Anfordern eines Beispiels mit seltsamem Gehäuse:"TeXT input", "text", "test"
— Engineer Toast
@EngineerToast Beispiel hinzugefügt
— Andrew sagt Reinstate Monica
Unsicher, warum ich das "The birch canoe slid on the smooth planks", "o", " OH MY "so witzig fand, aber ich liebte dieses Beispiel.
— Magic Octopus Urn

Antworten:

3

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.

— Neil
quelle
3

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 ⍠.

— Adam
quelle
2

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!

— Xcali
quelle
Besteht jetzt alle Testfälle;) 108: Online
— Dom Hastings
Du solltest es posten. Es übertrifft meins um einiges.
— Xcali
Meinetwegen! Hat Spaß gemacht. Ich genieße die Herausforderung!
— Dom Hastings
2

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
    }

}
— TessellatingHeckler
quelle
1

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))
— Kaz
quelle
1

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

Code-Snippet anzeigen

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. :(

— darrylyeo
quelle
1

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!

— Stange
quelle
Diese (193 Bytes, von der TIO-Verbindung) findet keine Übereinstimmungen am Ende der Zeichenfolge.
— Tehtmi
1

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']
— jferard
quelle
1

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!

— Cleblanc
quelle
Ich vermisse wahrscheinlich etwas Offensichtliches, aber warum brauchst du das, *(p=f)wenn du es p=c=tgleich danach einstellst ? Ich habe es mit just versucht *fund es hat nicht funktioniert, daher wird es nicht sofort überschrieben.
— Andrew sagt Reinstate Monica
f ist aus Versehen ein int, so dass wir es nicht dereferenzieren können, um ein char zu erhalten, aber p ist ein char *
— cleblanc
Ah, das macht Sinn. Es ist also eine kürzere Schreibweise *((char*)f)? Cool!
— Andrew sagt Reinstate Monica
1

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!

— rivalC
quelle
1
Willkommen bei PPCG! Sie können hier einiges an Leerzeichen entfernen, und tatsächlich müssen Sie die Eingaben entweder als Argumente oder als Eingabe verwenden (das Einkodieren ist verboten), oder Sie können die Funktion einfach einschließen. Sie brauchen nicht einmal das Action<string,string,string> r =Teil
— HyperNeutrino
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.