Un FizzBuzz simple utilisant des chaînes.

Donné

• 1 mot ou expression (chaîne)
• 2 personnages uniques

Production

Le mot ou la phrase avec chaque occurrence du premier caractère remplacé par fizz et chacun du deuxième caractère remplacé par buzz

Règles

• La première lettre de Fizz et Buzz doit rester en majuscule
• Pour le reste des mots fizz et buzz, vous devez faire correspondre la casse du caractère remplacé (si aucun cas, gardez les minuscules)
• Si les caractères donnés ne sont pas dans la phrase, sortez la phrase d'origine

Cas de 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

C'est du code-golf donc le code le plus court, en octets, gagne!

Remarque

La gestion technique du boîtier de nouvelle ligne (This Is SPARTA!) Fait partie du défi. Cependant, je n'annulerai pas une réponse pour ne pas l'avoir incluse, car elle est très difficile voire impossible dans certaines langues.

Gelée , 34 octets

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

Essayez-le en ligne!

Comment?

Œ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 174 168 160 152 octets

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

Ceci est juste une version plus golfée de la réponse de Stephen , en Python 3. Cela ébrèche 42% de ses octets. Python 2 économiserait un octet sur l'impression, mais tel est le prix de la progression. Cela gère correctement les retours à la ligne.

Merci à Blckknight pour avoir économisé 8 octets en entrée.

Python, 109 octets

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

Essayez-le en ligne!

Prend les deux caractères comme une seule chaîne

Edit: Ajout d'un cas de test au lien TIO, la nouvelle ligne fonctionne aussi

Python 2 , 271 , 261 octets

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)

Essayez-le en ligne!

Wow celui-ci était un doozie! Il s'avère que python n'acceptera pas les entrées multilignes et fileinputdoit donc être utilisé.

modifier: devrait passer tous les cas maintenant :)

MATLAB / Octave , 106 102 111 octets

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

Cela pourrait probablement être optimisé davantage.

Il utilise un simple remplacement Regex. Cependant, une étape intermédiaire est requise en remplaçant d'abord les caractères saisis par des nombres. C'est ainsi que si la deuxième lettre de remplacement d'entrée était contenue dans Fizzle, elle Fizzn'est pas remplacée lors de la prochaine expression régulière.

Cela suppose bien sûr qu'il n'y a pas de chiffres dans l'entrée. Cependant, étant donné que la question dit que l'entrée est un mot ou une phrase, je pense que c'est une hypothèse acceptable.

Le code gérera correctement les nouvelles lignes dans l'entrée.

Vous pouvez l' essayer en ligne!

Bash 4,4 + GNU sed, 70 228 222 227 octets

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"

Apparemment, alias e=echojette une erreur si elle est référencée dans Bash 4.3 ou inférieur, la version TIO est apparemment en train d'utiliser. Par conséquent, le code Bash 4.3 plus long et équivalent est donné dans la suite de tests TIO ci-dessous à des fins de test. Cela passe tous les cas de test, donc c'est bien.

Essayez-le en ligne!

JavaScript (ES6), 92 octets

Prend l'entrée sous la forme d'une chaîne et d'un tableau de deux caractères. Prend en charge les nouvelles lignes.

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

Cas de 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 octets

sXzsrBQ1scL2rB"FizzBuzz"1

Suite de tests .

GNU sed , 135 + 1 (drapeau r) = 136 octets

Par défaut, un script sed est exécuté autant de fois qu'il y a de lignes d'entrée. Pour gérer l'entrée multi-lignes, j'utilise une boucle pour ajouter toutes les lignes restantes possibles à la première, sans démarrer un nouveau cycle.

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

Essayez-le en ligne!

Le tableau de remplacement utilisé à la ligne 4 doit être dans cet ordre exact, c'est-à-dire «Fizz» et «Buzz» après leurs formes majuscules. C'est parce que le regex sed.* , utilisé lors de la recherche de table, est gourmand. Si le caractère actuel devant être remplacé n'est pas une lettre (pas de casse), alors la chaîne en minuscules est nécessaire (mise en correspondance en dernier).

Puisque sed n'a pas de types de données, j'utilise un délimiteur de caractères pour itérer une chaîne. Il marquera ma position actuelle et dans une boucle je la décale de gauche à droite. Heureusement, je peux l'utiliser ,pour cela, car il s'agit du délimiteur de données d'entrée.

Explication:

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

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)

rprend les caractères fizz et buzz comme une liste de 2 éléments comme premier argument et la chaîne d'entrée comme deuxième argument. Les retours à la ligne et l'unicode doivent être traités de manière appropriée, bien que la fonction ne soit malheureusement pas totale (permettant des entrées non valides enregistrées 5 octets).

Mathematica, 94 octets

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

Fonction anonyme. Prend deux chaînes en entrée et renvoie une fonction qui prend une chaîne en entrée et renvoie une chaîne en sortie en sortie. Il doit être appelé au format prog["c1", "c2"]["s"], où "s"est la chaîne cible et "c1"et "c2"sont les deux caractères. Pourrait probablement être joué plus loin.