Un semplice FizzBuzz che utilizza le stringhe.

Dato

• 1 parola o frase (stringa)
• 2 personaggi unici

Produzione

La parola o la frase con ciascuna occorrenza del primo carattere sostituita con Fizz e ciascuno del secondo carattere sostituito con ronzio

Regole

• La prima lettera sia in Fizz che in Buzz deve rimanere maiuscola
• Per il resto delle parole fizz e buzz, devi abbinare il caso del carattere sostituito (se non lo è, mantieni il minuscolo)
• Se determinati caratteri non sono presenti nella frase, genera la frase originale

Casi test

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

Questo è code-golf, quindi il codice più corto, in byte, vince!

Nota

Gestire tecnicamente il caso newline (This Is SPARTA!) È una parte della sfida. Tuttavia, non annullerò una risposta per non averla inclusa, poiché è molto impegnativa o addirittura impossibile in alcune lingue.

Gelatina , 34 byte

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

Provalo online!

Come?

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

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

Questa è solo una versione più giocosa della risposta di Stephen , in Python 3. In questo modo il 42% dei suoi byte viene eliminato. Python 2 salverebbe un byte sulla stampa, ma questo è il prezzo del progresso. Questo gestisce correttamente le newline.

Grazie a Blckknight per aver salvato 8 byte in input.

Python, 109 byte

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

Provalo online!

Accetta i due caratteri come una singola stringa

Modifica: aggiunta testcase al collegamento TIO, anche newline funziona

Python 2 , 271 , 261 byte

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)

Provalo online!

Wow, questo era un doozie! Python non accetta input multi-linea, quindi fileinputdeve essere usato.

modifica: ora dovrebbe passare tutti i casi :)

MATLAB / Octave , 106 102 111 byte

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

Questo potrebbe probabilmente essere ulteriormente ottimizzato.

Utilizza una semplice sostituzione Regex. Tuttavia, è necessario un passaggio intermedio sostituendo prima i caratteri di input con i numeri. Questo è così che se la seconda lettera di sostituzione di input era contenuta in Fizzquella Fizznon viene quindi sostituita quando viene eseguita la regex successiva.

Questo ovviamente presuppone che non ci siano numeri nell'input. Comunque, dato che la domanda dice che l'input è una parola o frase, penso che questo sia un presupposto accettabile.

Il codice gestirà correttamente le nuove righe nell'input.

Puoi provarlo online!

Bash 4.4 + GNU sed, 70 228 222 227 byte

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"

Apparentemente alias e=echogenera un errore se indicato in Bash 4.3 o precedente, apparentemente la versione TIO sta usando. Pertanto, il codice Bash 4.3 più lungo ed equivalente viene fornito nella suite di test TIO di seguito per motivi di test. Questo supera tutti i casi di test, quindi è carino.

Provalo online!

JavaScript (ES6), 92 byte

Accetta input come una stringa e una matrice di due caratteri. Supporta newline.

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

Casi test

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 byte

sXzsrBQ1scL2rB"FizzBuzz"1

Test Suite .

GNU sed , 135 + 1 (flag r) = 136 byte

Per impostazione predefinita, uno script sed viene eseguito tante volte quante sono le righe di input. Per gestire l'input multi-linea, utilizzo un loop per aggiungere tutte le possibili righe rimanenti alla prima, senza iniziare un nuovo ciclo.

: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:,.*::

Provalo online!

La tabella di sostituzione utilizzata nella riga 4, deve essere nell'ordine esatto, ovvero "Fizz" e "Buzz" dopo i loro moduli in maiuscolo. Questo perché sedge regex.* , usato durante la ricerca del tavolo, è avido. Se il carattere corrente deve essere sostituito non è una lettera (nessun caso), è necessaria la stringa minuscola (ultima corrispondenza).

Poiché sed non ha tipi di dati, uso un delimitatore di caratteri per iterare una stringa. Contrassegnerà la mia posizione attuale e in un ciclo la sposto da sinistra a destra. Fortunatamente, posso usarlo ,per questo, poiché è il delimitatore dei dati di input.

Spiegazione:

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

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)

raccetta i caratteri fizz e buzz come un elenco di 2 elementi come primo argomento e la stringa di input come secondo argomento. Newline e unicode dovrebbero essere gestiti in modo appropriato, anche se sfortunatamente la funzione non è totale (consentendo input non validi salvati 5 byte).

Mathematica, 94 byte

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

Funzione anonima. Accetta due stringhe come input e restituisce una funzione che accetta una stringa come input e restituisce una stringa come output come output. Deve essere chiamato nel formato prog["c1", "c2"]["s"], dove si "s"trova la stringa di destinazione "c1"e "c2"sono i due caratteri. Probabilmente potrebbe essere ulteriormente giocato a golf.