Un simple FizzBuzz con cadenas.

Dado

• 1 palabra o frase (cadena)
• 2 personajes únicos

Salida

La palabra o frase con cada aparición del primer carácter reemplazado con efervescencia y cada uno de los segundos caracteres reemplazados con zumbido

Reglas

• La primera letra en Fizz y Buzz debe permanecer en mayúscula
• Para el resto de las palabras fizz y zumbido, debe coincidir con las mayúsculas y minúsculas del carácter reemplazado (si no hay mayúsculas y minúsculas)
• Si los caracteres dados no están en la frase, envíe la frase original

Casos de prueba

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

Este es el código de golf, por lo que gana el código más corto, en bytes.

Nota

Técnicamente, manejar el caso de la nueva línea (¡Esto es SPARTA!) Es parte del desafío. Sin embargo, no anularé una respuesta por no incluirla, ya que es muy difícil o incluso imposible en algunos idiomas.

Jalea , 34 bytes

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

Pruébalo en línea!

¿Cómo?

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

Esta es solo una versión más golfizada de Stephen la respuesta , en Python 3. Esto elimina el 42% de sus bytes. Python 2 ahorraría un byte en la impresión, pero ese es el precio del progreso. Esto maneja las nuevas líneas correctamente.

Gracias a Blckknight por guardar 8 bytes en la entrada.

Python, 109 bytes

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

Pruébalo en línea!

Toma los dos caracteres como una sola cadena

Editar: Se agregó un caso de prueba al enlace TIO, la nueva línea también funciona

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)

Pruébalo en línea!

Wow, este era un doozie! Resulta que Python no aceptará entradas de varias líneas, por lo que fileinputdebe usarse.

editar: debería pasar todos los casos ahora :)

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

Esto probablemente podría optimizarse aún más.

Utiliza un reemplazo simple de Regex. Sin embargo, se requiere un paso intermedio reemplazando los caracteres de entrada por números primero. Esto es para que si la segunda letra de reemplazo de entrada estuviera contenida, Fizzla Fizzno se reemplace cuando se realice la siguiente expresión regular.

Por supuesto, esto supone que no hay números en la entrada. Sin embargo, dado que la pregunta dice que la entrada es una palabra o frase, creo que esta es una suposición aceptable.

El código manejará nuevas líneas en la entrada correctamente.

¡Puedes probarlo en línea!

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"

Aparentemente alias e=echoarroja un error si se hace referencia en Bash 4.3 o inferior, la versión que TIO aparentemente está usando. Por lo tanto, el código Bash 4.3 más largo y equivalente se proporciona en el siguiente conjunto de pruebas TIO en aras de la prueba. Esto pasa todos los casos de prueba, por lo que es bueno.

Pruébalo en línea!

JavaScript (ES6), 92 bytes

Toma la entrada como una cadena y una matriz de dos caracteres. Soporta nuevas líneas.

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

Casos de prueba

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

Por defecto, un script sed se ejecuta tantas veces como haya líneas de entrada. Para manejar la entrada de varias líneas, utilizo un bucle para agregar todas las líneas restantes posibles a la primera, sin comenzar un nuevo 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:,.*::

Pruébalo en línea!

La tabla de reemplazo utilizada en la línea 4 debe estar en ese orden exacto, es decir, 'Fizz' y 'Buzz' después de sus formas mayúsculas. Esto se debe a que la expresión regular sed .*, utilizada durante la búsqueda de la tabla, es codiciosa. Si el carácter actual que se debe reemplazar no es una letra (sin mayúsculas y minúsculas), entonces se necesita la cadena en minúsculas (coincide con la última).

Como sed no tiene tipos de datos, uso un delimitador de caracteres para iterar una cadena. Marcará mi posición actual y en un bucle la cambio de izquierda a derecha. Afortunadamente, puedo usar ,para esto, ya que es el delimitador de datos de entrada.

Explicación:

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

rtoma los caracteres fizz y buzz como una lista de 2 elementos como el primer argumento, y la cadena de entrada como el segundo argumento. Las líneas nuevas y Unicode deben manejarse adecuadamente, aunque desafortunadamente la función no es total (permitiendo entradas no válidas guardadas en 5 bytes).

Mathematica, 94 bytes

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

Función anónima. Toma dos cadenas como entrada y devuelve una función que toma una cadena como entrada y devuelve una cadena como salida como salida. Debe invocarse en el formato prog["c1", "c2"]["s"], donde "s"está la cadena de destino "c1"y "c2"son los dos caracteres. Probablemente podría jugar más golf.