Ein einfacher FizzBuzz mit Strings.

Gegeben

• 1 Wort oder Satz (Zeichenfolge)
• 2 einzigartige Charaktere

Ausgabe

Das Wort oder die Phrase, bei der jedes Vorkommen des ersten Zeichens durch Fizz und jedes des zweiten Zeichens durch Buzz ersetzt wird

Regeln

• Der erste Buchstabe in Fizz und Buzz muss groß geschrieben bleiben
• Für den Rest der Wörter "Fizz" und "Buzz" müssen Sie die Groß- und Kleinschreibung des ersetzten Zeichens berücksichtigen.
• Wenn die angegebenen Zeichen nicht in der Phrase enthalten sind, geben Sie die ursprüngliche Phrase aus

Testfälle

Given: Hello, h, l
Output: FIZZeBuzzBuzzo

Given: test, a, b
Output: test

Given: PCG rocks!,  , !
PCGFizzrocksBuzz

Given: This
Is
SPARTA!, 
, S
Output: ThiBuzzFizzIBuzzFizzBUZZPARTA!

Given: FizzBuzz, a, b
Output: FizzBUZZuzz

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes!

Hinweis

Die technische Abwicklung des Newline-Falls (This Is SPARTA!) Ist Teil der Herausforderung. Ich werde jedoch keine Antwort für ungültig erklären, da dies in einigen Sprachen sehr herausfordernd oder sogar unmöglich ist.

Jelly , 34 Bytes

Œl=€⁹Œl¤ȧ€"“¡Ṭ4“Ụp»o"/ȯ"Œu⁹Œln$T¤¦

Probieren Sie es online!

Wie?

Œl=€⁹Œl¤ȧ€"“¡Ṭ4“Ụp»o"/ȯ"Œu⁹Œln$T¤¦ - Main link: characters, string
Œl                                 - lowercase the characters
       ¤                           - nilad followed by link(s) as a nilad:
    ⁹                              -     right argument, the string
     Œl                            -     lowercase
  =€                               - equals (vectorises) for €ach (a list of 2 lists that identify the indexes of the string matching the characters regardless of case)
           “¡Ṭ4“Ụp»                - dictionary strings ["Fizz", "Buzz"]
          "                        - zip with
        ȧ€                         -     logical and (non-vectorising) for €ach (replace the 1s with the words)
                     /             - reduce with:
                    "              -     zip with:
                   o               -         logical or (vectorises) (make one list of zeros and the words)
                                   - implicit right argument, string
                       "           - zip with:
                      ȯ            -     logical or (non-vectorising) (replace the zeros with the original characters from the string)
                                 ¦ - apply...
                        Œu         -     uppercase
                                   - ...to the indexes (the words at indexes):
                                ¤  -     nilad followed by link(s) as a nilad:
                          ⁹        -         right argument, the string
                              $    -         last two links as a monad (i.e. the string on both sides):
                           Œl      -             lowercase
                             n     -             not equals (vectorises)
                               T   -         truthy indexes (the indexes of the capital letters in the string)

Python 3 , 180 174 168 160 152 Bytes

from sys import*
J=''.join
L=str.lower
s,a,b=J(stdin).split(', ')
print(J('FBFBiuIUzzZZzzZZ'[L(k)==L(b)::2][k!=L(k)::2]*(L(k)in L(a+b))or k for k in s))

Dies ist nur eine gelungenere Version von Stephens Antwort in Python 3. Dadurch werden 42% seiner Bytes entfernt. Python 2 würde ein Byte im Druck sparen, aber das ist der Preis für den Fortschritt. Dies behandelt Zeilenumbrüche richtig.

Vielen Dank an Blckknight für das Speichern von 8 Bytes bei der Eingabe.

Python, 109 Bytes

lambda s,w:"".join([c,"Fizz","Buzz","BUZZ","FIZZ"][-~w.lower().find(c.lower())*-~(-2*c.isupper())]for c in s)

Probieren Sie es online!

Nimmt die beiden Zeichen als einzelne Zeichenfolge

Bearbeiten: Testfall zu TIO-Link hinzugefügt, Newline funktioniert auch

Python 2 , 271 , 261 Bytes

import fileinput as f
a=''
for m in f.input():a+=m
a=a.split(', ')
l=L=list(a[0])
for i in range(0,len(a[0])):
 j,k=l[i].lower(),l[i].istitle()
 if j==a[1].lower():
  L[i]='FIZZ'if k else'Fizz'
 elif j==a[2].lower():
  L[i]='BUZZ'if k else'Buzz'
print''.join(L)

Probieren Sie es online!

Wow, das war ein Trottel! Es stellt sich heraus, dass Python keine mehrzeiligen Eingaben akzeptiert und daher fileinputverwendet werden muss.

edit: sollte jetzt alle fälle bestehen :)

MATLAB / Octave , 106 102 111 Bytes

@(a,b,c)regexprep(a,num2cell([lower([b c]) upper([b c]) '1234']),{'2','4','1','3','FIZZ','Fizz','BUZZ','Buzz'})

Dies könnte wahrscheinlich weiter optimiert werden.

Es wird ein einfacher Regex-Ersatz verwendet. Ein Zwischenschritt ist jedoch erforderlich, indem die eingegebenen Zeichen zuerst durch Zahlen ersetzt werden. Dies ist so, dass, wenn die zweite Eingabe einen Ersetzungsbuchstaben enthielt Fizz, derFizz nicht dann ersetzt werden , wenn die nächsten regex durchgeführt wird.

Dies setzt natürlich voraus, dass die Eingabe keine Zahlen enthält. In Anbetracht der Frage, dass die Eingabe ein Wort oder eine Phrase ist, halte ich dies für eine akzeptable Annahme.

Der Code behandelt neue Zeilen in der Eingabe korrekt.

Sie können es online ausprobieren!

Bash 4.4 + GNU sed, 70 228 222 227 Bytes

IFS=;alias e=echo;K=`sed $([[ $2 != '
' ]]&&e "s/${2,}/Fizz/g;s/${2^}/FIZZ/g"||:)$([[ $3 != '
' ]]&&e ";s/${3,}/Buzz/g;s/${3^}/BUZZ/g"||:)<<<"$1"`;[[ $2 = '
'||$3 = '
' ]]&&e ${K//$'\n'/`[[ $2 = '
' ]]&&e Fizz||e Buzz`}||e "$K"

Offenbar alias e=echo ein Fehler ausgelöst, wenn in Bash 4.3 oder niedriger verwiesen wird, der anscheinend von der Version TIO verwendet wird. Aus diesem Grund wird der längere und äquivalente Bash 4.3-Code in der folgenden TIO-Testsuite zum Testen angegeben. Damit sind alle Testfälle bestanden, das ist schön.

Probieren Sie es online!

JavaScript (ES6), 92 Byte

Übernimmt die Eingabe als Zeichenfolge und als Array mit zwei Zeichen. Unterstützt Zeilenumbrüche.

f=(s,[a,b],r='Fizz')=>a?f(s.replace(RegExp(a,'gi'),m=>m<'a'?r.toUpperCase():r),[b],'Buzz'):s

Testfälle

f=(s,[a,b],r='Fizz')=>a?f(s.replace(RegExp(a,'gi'),m=>m<'a'?r.toUpperCase():r),[b],'Buzz'):s

console.log(f("Hello", ['h', 'l']))
console.log(f("test", ['a', 'b']))
console.log(f("PCG rocks!", [' ', '!']))
console.log(f(`This
Is
SPARTA!`, [`
`, 'S']))
console.log(f("FizzBuzz", ['a', 'b']))

Pyth - 25 Bytes

sXzsrBQ1scL2rB"FizzBuzz"1

Test Suite .

GNU sed , 135 + 1 (r Flag) = 136 Bytes

Standardmäßig wird ein sed-Skript so oft ausgeführt, wie Eingabezeilen vorhanden sind. Um die mehrzeilige Eingabe zu handhaben, setze ich eine Schleife ein, um alle möglichen verbleibenden Zeilen an die erste anzuhängen, ohne einen neuen Zyklus zu starten.

:r
$!N
$!br
s:, (.), (.):;\u\1FIZZ;\l\1Fizz;\u\2BUZZ;\l\2Buzz:
s:^:,:
:
s:,(.)(.*;\1)(...)(.):\3,\4\2\3\4:
s:,(.):\1,:
/,;.F/!t
s:,.*::

Probieren Sie es online!

Die in Zeile 4 verwendete Ersetzungstabelle muss genau in dieser Reihenfolge vorliegen, dh "Fizz" und "Buzz" nach ihren Großbuchstaben. Das liegt am sed regex.* , dass der bei der Tabellensuche verwendete gierig ist. Wenn das aktuelle Zeichen, das ersetzt werden muss, kein Buchstabe ist (keine Groß- / Kleinschreibung), wird die Zeichenfolge in Kleinbuchstaben benötigt (zuletzt abgeglichen).

Da sed keine Datentypen hat, verwende ich ein Zeichentrennzeichen, um eine Zeichenfolge zu iterieren. Es markiert meine aktuelle Position und ich verschiebe sie in einer Schleife von links nach rechts. Zum Glück kann ich ,dafür verwenden, da es das Eingabedaten-Trennzeichen ist.

Erläuterung:

:r                                                 # reading loop
$!N                                                # append next input line
$!br                                               # repeat till EOF
s:, (.), (.):;\u\1FIZZ;\l\1Fizz;\u\2BUZZ;\l\2Buzz: # create replacement table
s:^:,:                                             # append my string delimiter
:                                                  # main loop
s:,(.)(.*;\1)(...)(.):\3,\4\2\3\4:                 # apply char replacement, if any
s:,(.):\1,:                                        # shift delimiter to right
/,;.F/!t                                           # repeat till end of string
s:,.*::                                            # print only the final string

Haskell, 114 Bytes

u=Data.Char.toUpper
p[f,b]x|f==u x="Fizz"|b==u x="Buzz"|2>1=[x]
q x y|u y<y=x|2>1=u<$>x
r x=concatMap$q=<<p(u<$>x)

rNimmt die Fizz- und Buzz-Zeichen als 2-Element-Liste als erstes Argument und die Eingabezeichenfolge als zweites Argument. Zeilenumbrüche und Unicode sollten angemessen behandelt werden, obwohl die Funktion leider nicht vollständig ist (bei ungültigen Eingaben werden 5 Byte gespart).

Mathematica, 94 Bytes

a=ToLowerCase;b=ToUpperCase;StringReplace@{a@#->"Fizz",b@#->"FIZZ",a@#2->"Buzz",b@#2->"BUZZ"}&

Anonyme Funktion. Nimmt zwei Zeichenfolgen als Eingabe und gibt eine Funktion zurück, die eine Zeichenfolge als Eingabe und eine Zeichenfolge als Ausgabe als Ausgabe verwendet. Es muss im Format aufgerufen werden prog["c1", "c2"]["s"], wo "s"die Zielzeichenfolge ist und "c1"und "c2"sind die beiden Charaktere. Könnte wahrscheinlich weiter golfen werden.