Vous recevrez une chaîne qui ne contient que des lettres de l'alphabet anglais, à la fois en minuscules et en majuscules (ASCII 65-90 et 97-122). Votre tâche consiste à sortir la version Fizz-Buzzified de la chaîne.

Comment Fizz-Buzzify une chaîne?

• Chaque lettre qui a un index pair dans l'alphabet anglais (l'alphabet doit être indexé à 1:) a->1,b->2,...,z->26sera transformée fizzsi elle est en minuscule et FIZZsi elle est en majuscule ( f -> fizz, F -> FIZZ).

• Chaque lettre qui a un index impair dans l'alphabet anglais sera transformée buzzsi elle est en minuscule et BUZZsi elle est en majuscule ( e -> buzz, E -> BUZZ).

• Prenons un exemple, pour illustrer l'algorithme, en utilisant la chaîne CodeGolf(espaces ajoutés pour plus de clarté):

  "C o d e G o l f" ->  "BUZZ buzz fizz buzz BUZZ buzz fizz fizz"
   ^ ^ ^ ^ ^ ^ ^ ^
   1 1 0 1 1 1 0 0       (1 is odd index, 0 is even index)
  

• Si cela convient mieux à votre langue, vous pouvez également laisser des espaces simples entre les groupes ( fizz, buzz, FIZZ, BUZZ). Par conséquent, un résultat comme fizzBUZZbuzzbuzzpeut également être renvoyé sous la forme fizz BUZZ buzz buzz. Les autres séparateurs ne sont pas autorisés.

Cas de test:

Entrée -> Sortie 

"oeuf" -> "buzzbuzzbuzz"
"CodeGolf" -> "BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
"Réinitialiser" -> "FIZZbuzzbuzzbuzzfizz"
"ATOM" -> "BUZZFIZZBUZZBUZZ"
"yOuArEgReAt" -> "buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

• Toute méthode standard d'E / S peut être utilisée.

• Les échappatoires par défaut s'appliquent.

• Vous êtes uniquement autorisé à saisir des données dans le type de chaîne native de votre langue. Il en va de même pour la sortie.

• Vous pouvez supposer que l'entrée ne sera pas vide.

• Le code le plus court en octets dans chaque langue gagne. Bonne chance et Fizz-Buzz!

Fusain , 26 24 octets

ＦθＦ⎇﹪℅ι²buzz¦fizz⎇№αι↥κκ

Essayez-le en ligne! Inspiré à l'origine par @CarlosAlejo. Edit: enregistré 2 octets en bouclant sur les lettres de fizz / buzz au lieu de les affecter à un temporaire. Explication:

Ｆθ          Loop over the input (i = loop variable)
  Ｆ         Choose and loop over the word (k = loop variable)
   ⎇        Ternary
    ﹪℅ι²    If i has an odd ASCII code
    buzz
    fizz
            Print (implicit)
  ⎇         Ternary
   №αι      If i is an uppercase letter
    ↥κ      Uppercase(k)
     κ      k

C #, 92 octets

using System.Linq;a=>string.Concat(a.Select(x=>x%2<1?x<97?"FIZZ":"fizz":x<97?"BUZZ":"buzz"))

Python 3 , 73 69 octets

4 octets grâce aux ovs.

lambda s:"".join("fbFBiuIUzzZZzzZZ"[(c<"a")*2+ord(c)%2::4]for c in s)

Essayez-le en ligne!

C (gcc) , 75 octets

f(char*s){for(;*s;++s)printf(*s>90?*s%2?"buzz":"fizz":*s%2?"BUZZ":"FIZZ");}

Essayez-le en ligne!

Java (OpenJDK 8) , 105 100 94 91 90 octets

s->{for(int i:s.getBytes())System.out.print(i%2<1?i>90?"fizz":"FIZZ":i>90?"buzz":"BUZZ");}

Essayez-le en ligne!

Beaucoup jouable au golf, très octets, donc Java!

Très golfé par @KevinCruijssen de 9 octets!

JavaScript (ES6), 79 77 octets

s=>s.replace(/./g,c=>['BUZZ','buzz','FIZZ','fizz'][parseInt(c,36)%2*2|c>'Z'])

Cas de test

let f =

s=>s.replace(/./g,c=>['BUZZ','buzz','FIZZ','fizz'][parseInt(c,36)%2*2|c>'Z'])

console.log(f("egg"        )) // "buzzbuzzbuzz"
console.log(f("CodeGolf"   )) // "BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
console.log(f("Reset"      )) // "FIZZbuzzbuzzbuzzfizz"
console.log(f("ATOM"       )) // "BUZZFIZZBUZZBUZZ"
console.log(f("yOuArEgReAt")) // "buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

C #, 97 octets

using System.Linq;s=>string.Concat(s.Select(c=>"fizzbuzzFIZZBUZZ".Substring(c%2*4+(c>96?0:8),2)))

Gelée , 21 octets

“=%“Ƈ×»ẋ13Œu;$ɓØWiЀị

Essayez-le en ligne!

Pyth , 23 21 octets

smr<d\a@c"fizzbuzz"4C

Suite de tests .

Anglais ordinaire , 820 632 610 octets

M. Xcoder a suggéré d'éliminer un piège d'erreur inutile, qui a permis d'économiser 22 octets.

A fizzy string is a string.
To convert a s string to a z fizzy string:
Clear the z.
Slap a r rider on the s.
Loop.
If the r's source's first is greater than the r's source's last, exit.
Put the r's source's first's target in a b byte.
If the b is not any letter, bump the r; repeat.
Put "FIZZ" in a t string.
If the b is d, put "BUZZ" in the t.
If the b is _, lowercase the t.
Append the t to the z.
Bump the r.
Repeat.
To decide if a b byte is d:
Put the b in a n number.
If the n is odd, say yes.
Say no.
To decide if a b byte is _:
Put the b in a c byte.
Lowercase the c.
If the c is the b, say yes.
Say no.

Code non golfé:

A fizzy string is a string.

To convert a string to a fizzy string:
  Clear the fizzy string.
  Slap a rider on the string.
  Loop.
    If the rider's source's first is greater than the rider's source's last, exit.
    Put the rider's source's first's target in a byte.
    If the byte is not any letter, bump the rider; repeat.
    Put "FIZZ" in another string.
    If the byte is odd, put "BUZZ" in the other string.
    If the byte is lower case, lowercase the other string.
    Append the other string to the fizzy string.
    Bump the rider.
  Repeat.

To decide if a byte is odd:
  Put the byte in a number.
  If the number is odd, say yes.
  Say no.

To decide if a byte is lower case:
  Privatize the byte.
  Lowercase the byte.
  If the byte is the original byte, say yes.
  Say no.

L'IDE en anglais simple est disponible sur github.com/Folds/english . L'IDE s'exécute sur Windows. Il se compile en code x86 32 bits.

Fusain , 40 36 octets

Ｆθ¿№αι¿﹪⌕αι²FIZZ¦BUZZ¿﹪⌕βι²fizz¦buzz

Essayez-le en ligne!

Explication:

Ｆθ                                      for every char i in the input:
   ¿№αι                                    if i is found in the uppercase alphabet
       ¿﹪⌕αι²                             if i is an even uppercase char
              FIZZ¦BUZZ                    print "FIZZ" or else "BUZZ"
                       ¿﹪⌕βι²             if i is an even lowercase char
                              fizz¦buzz    print "fizz" or else "buzz"

Une alternative avec le même nombre d'octets:

ＡfizzφＡbuzzχＦθ¿№αι¿﹪⌕αι²↥φ↥χ¿﹪⌕βι²φχ

Essayez-le en ligne! ( Version verbeuse )

• 4 octets économisés grâce à Neil!

> <> , 68 octets

<vv?("^"$%2:;?(0:i
v\?\"zzif"
v \\"zzub"
v \ "ZZIF"
v  \"ZZUB"
\oooo

Essayez-le en ligne ou regardez-le au terrain de pêche !

(Mais regardez la réponse d'Aaron qui est plus courte de 13 octets!)

Si vous n'êtes pas familier avec> <>, il y a un poisson qui nage dans le code en 2D et les bords s'enroulent. Les symboles >, <, ^et vdéfinir la direction du poisson, /et \sont des miroirs qui reflètent et il ?signifie « faire l'instruction suivante si la chose en haut sur la pile est non nul, sinon sauter sur l'instruction suivante ».

Dans la première ligne, le poisson prend un caractère d'entrée ( i); si c'est -1 pour EOF, il arrête ( :0(?;); il obtient le charcode mod 2 ( :2%$); et il pousse un 1 ou 0 sur la pile selon que le charcode est inférieur ou supérieur au charcode de "^" ( "^"(). Les trois lignes suivantes redirigent le poisson vers la chaîne fizz / buzz de droite, puis la dernière ligne l'imprime (une opour chaque caractère) et renvoie le poisson au début.

> <> , 55 octets

Basé sur Pas la réponse d' un arbre .

<v%2$)"^":;?(0:i
 \?v"ZZIF"
~v >"ZZUB"!
^>{:}" "*+ol1=?

Au lieu de représenter les 4 sorties possibles dans le code, je ne représente que leurs versions en majuscules et j'ajoute 32 au code de caractère pour obtenir les équivalents minuscules.

Essayez-le en ligne!

Code modifié pour l' interpréteur en ligne , qui remplit son espace de code avec des cellules vides:

<v%2$)"^":;?(0:i
 \?v"ZZIF"
~v >"ZZUB"     !
^>{:}" "*+o l1=?

Perl5 , 50 + 1 octets

perl -nE'say+((FIZZ,BUZZ)x48,(fizz,buzz)x16)[unpack"C*",$_]'

Crée une liste de 128 éléments qui mappe les caractères ASCII au mot de code approprié.

05AB1E , 22 octets

v‘FIZZÒÖ‘#yÇÉèAyåil}J?

Essayez-le en ligne!

Explication

v                        # for each char y of input string
 ‘FIZZÒÖ‘#               # push the list ['FIZZ','BUZZ']
          yÇÉ            # check if y has an odd character code
             è           # use this to index into the list
              Ayåi       # if y is a member of the lowercase alphabet
                  l}     # convert to lowercase
                    J?   # unwrap from list and print

Solution alternative de 22 octets

ÇÉAISå·+‘FIZZÒÖ‘#Dl«èJ

PHP , 67 octets

for(;$c=$argn[$i++];)echo[FIZZ,BUZZ,fizz,buzz][ord($c)%2+2*($c>Z)];

Essayez-le en ligne!

F # , 154 153 145 octets

enregistré 1 9 octets grâce à @Mr. Xcoder

let g s=
 Seq.map(fun c->match int c with
|x when x>64&&x<91->if x%2=0 then"FIZZ"else"BUZZ"
|x->if x%2=0 then"fizz"else"buzz")s
|>String.concat""

Essayez-le en ligne!

Mathematica, 134 octets

""<>{(s=Max@ToCharacterCode@#;If[96<s<123,If[EvenQ@s,c="fizz",c="buzz"]];If[64<s<91,If[EvenQ@s,c="FIZZ",c="BUZZ"]];c)&/@Characters@#}&

Java 8, 89 octets

s->s.chars().mapToObj(i->i%2<1?i>90?"fizz":"FIZZ":i>90?"buzz":"BUZZ").collect(joining());

Cela suppose import static java.util.stream.Collectors.*;

q / kdb +, 48 octets

Solution:

raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$

Exemples:

q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"egg"
"buzzbuzzbuzz"
q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"CodeGolf"
"BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"Reset"
"FIZZbuzzbuzzbuzzfizz"
q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"ATOM"
"BUZZFIZZBUZZBUZZ"
q)raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$"yOuArEgReAt"
"buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

Explication:

Assez simple, prenez la chaîne d'entrée, transtypez en valeurs ASCII, créez une liste de 1 ou 0 selon qu'elle est impaire ou paire (indice A = 65 = impair), puis utilisez cette liste pour indexer dans une liste de fizzet buzz. Cast ceci dans une chaîne, puis pour les cas où l'entrée est <91 (inférieure à un Z), nous appliquons la upperfonction pour obtenir un FIZZou un BUZZ.

q est interprété de droite à gauche:

raze{@[string `fizz`buzz x mod 2;where x < 91;upper]}"i"$ / ungolfed version
                                                     "i"$ / cast input to ascii values
    {                                               }     / anonymous lambda
     @[                         ;            ;     ]      / apply 
                                              upper       / upper-case
                                 where x < 91             / indices where input is less than 91 (ie uppercase)
                         x mod 2                          / returns 0 if even and 1 if odd
              `fizz`buzz                                  / 2 item list, which we are indexing into
       string                                             / cast symbols to strings `buzz -> "buzz"
raze                                                      / raze (merge) list into a single string

Ruby , 61 + 1 = 62 octets

Utilise le -pdrapeau.

gsub(/./){k=$&.ord%2*4;$&<?_?"FIZZBUZZ"[k,4]:"fizzbuzz"[k,4]}

Essayez-le en ligne!

Swift 4 , 144 135 octets

func f(s:String){print(s.map{let d=Int(UnicodeScalar("\($0)")!.value);return d%2<1 ?d>90 ?"fizz":"FIZZ":d>90 ?"buzz":"BUZZ"}.joined())}

Non-golfé:

func f(s:String){
    print(
        s.map{
            let d=Int(UnicodeScalar("\($0)")!.value)
            return d%2 < 1 ? d > 90 ? "fizz" : "FIZZ" : d > 90 ? "buzz" : "BUZZ"
        }.joined()
    )
}

Ce que je fais, c'est boucler sur chaque caractère de la chaîne. Je convertis chacun à sa valeur ASCII, vérifie ensuite s'il est pair ou impair, puis vérifie s'il est en majuscules ou en minuscules et affiche la valeur correspondante à partir de la boucle. Je joins ensuite tous les éléments du tableau résultant en une seule chaîne et je l'imprime.

Cette solution utilise Swift 4, il n'est donc pas encore possible de la tester facilement en ligne.

Merci à @ Mr.Xcoder de m'avoir sauvé 9 octets!

R, 150 123 108 108 octets

i=ifelse
cat(i(sapply(el(strsplit(scan(,''),'')),utf8ToInt)>91,i(x%%2,'buzz','fizz'),i(x%%2,'BUZZ','FIZZ')))

Doit être plus court en utilisant ASCII? C'était plus court. Voir l'historique des modifications pour l'ancienne réponse, qui a été utilisée letters.

Vérifie chaque lettre pour (1) si elle est en majuscule ou non ( >91) et si c'est un fizzou un buzz.

Java

str.chars().forEach(ch ->{
    if(ch >= 97)
        strb.append(ch % 2 == 0 ? "fizz" : "buzz");
    else
        strb.append(ch % 2 == 0 ? "FIZZ" : "BUZZ");
});