Um simples FizzBuzz usando strings.

Dado

• 1 palavra ou frase (string)
• 2 caracteres únicos

Resultado

A palavra ou frase com cada ocorrência do primeiro caractere substituído por efervescência e cada um do segundo caractere substituído por zumbido

Regras

• A primeira letra do Fizz e do Buzz deve permanecer em maiúscula
• Para o restante das palavras "fizz" e "buzz", você deve corresponder ao caso do caractere substituído (se nenhum caso for mantido em letras minúsculas)
• Se os caracteres fornecidos não estiverem na frase, imprima a frase original

Casos de teste

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

Isso é código-golfe, então o código mais curto, em bytes, vence!

Nota

Manipular tecnicamente o caso da nova linha (Isso é SPARTA!) Faz parte do desafio. No entanto, não anularei uma resposta por não incluí-la, pois é muito desafiadora ou mesmo impossível em alguns idiomas.

Geléia , 34 bytes

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

Experimente online!

Quão?

Œ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 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 é apenas uma versão mais desafiadora da resposta de Stephen , em Python 3. Isso corta 42% de seus bytes. O Python 2 economizaria um byte na impressão, mas esse é o preço do progresso. Isso lida com as novas linhas corretamente.

Agradecimentos a Blckknight por salvar 8 bytes na 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)

Experimente online!

Pega os dois caracteres como uma única sequência

Edit: Adicionado testcase ao link do TIO, a nova linha também 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)

Experimente online!

Uau, este foi um doozie! Acontece que o python não aceita entradas com várias linhas, portanto fileinputdeve ser usado.

edit: deve passar todos os casos agora :)

MATLAB / Oitava , 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'})

Provavelmente isso poderia ser otimizado ainda mais.

Ele usa uma substituição simples do Regex. No entanto, é necessária uma etapa intermediária substituindo os caracteres de entrada pelos números primeiro. Isso é feito para que, se a segunda letra de substituição de entrada estiver contida emFizz que o Fizznão, em seguida, são substituídos quando a próxima regex é realizada.

Obviamente, isso pressupõe que não há números na entrada. No entanto, considerando que a pergunta diz que a entrada é uma palavra ou frase, sinto que essa é uma suposição aceitável.

O código manipulará novas linhas na entrada corretamente.

Você pode experimentá-lo online!

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=echogera um erro se mencionado no Bash 4.3 ou abaixo, a versão que o TIO aparentemente está usando. Portanto, o código Bash 4.3 mais longo e equivalente é fornecido no conjunto de testes TIO abaixo para fins de teste. Isso passa em todos os casos de teste, o que é bom.

Experimente online!

JavaScript (ES6), 92 bytes

Recebe entrada como uma sequência e uma matriz de dois caracteres. Suporta novas linhas.

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

Casos de teste

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

Pitão - 25 bytes

sXzsrBQ1scL2rB"FizzBuzz"1

Conjunto de Teste .

GNU sed , 135 + 1 (sinalizador r) = 136 bytes

Por padrão, um script sed é executado quantas vezes houver linhas de entrada. Para lidar com a entrada de várias linhas, eu uso um loop para anexar todas as linhas restantes possíveis à primeira, sem iniciar um novo 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:,.*::

Experimente online!

A tabela de substituição usada na linha 4 precisa estar na ordem exata, ou seja, 'Fizz' e 'Buzz' após as formas maiúsculas. Isso ocorre porque o sed regex .*, usado durante a pesquisa da tabela, é ganancioso. Se o caractere atual que precisa ser substituído não for uma letra (sem maiúsculas e minúsculas), a seqüência de caracteres em minúsculas será necessária (correspondida por último).

Como sed não possui tipos de dados, eu uso um delimitador de caracteres para iterar uma string. Ele marcará minha posição atual e, em um loop, eu a desligo da esquerda para a direita. Felizmente, eu posso usar ,isso, pois é o delimitador de dados de entrada.

Explicação:

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

rusa os caracteres fizz e buzz como uma lista de 2 elementos como o primeiro argumento e a string de entrada como o segundo argumento. Novas linhas e unicode devem ser tratados adequadamente, embora a função infelizmente não seja total (permitindo entradas inválidas salvas em 5 bytes).

Mathematica, 94 bytes

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

Função anônima. Pega duas strings como entrada e retorna uma função que pega uma string como entrada e retorna uma string como saída como saída. Ele deve ser chamado no formato prog["c1", "c2"]["s"], onde "s"é a cadeia alvo e "c1"e "c2"são os dois personagens. Provavelmente poderia ser jogado ainda mais.