[Question]
  [
You will be given a String that only contains letters of the English Alphabet, both lowercase and uppercase (ASCII 65-90 and 97-122). Your task is to output the Fizz-Buzzified version of the String.
### How to Fizz-Buzzify a String?
* Each letter that has an even index in the English alphabet (the alphabet **must** be 1-indexed: `a->1,b->2,...,z->26`) will be turned into `fizz` if it is lowercase and `FIZZ` if it is uppercase (`f -> fizz, F -> FIZZ`).
* Each letter that has an odd index in the English alphabet will be turned into `buzz` if it is lowercase, and `BUZZ` if it is uppercase (`e -> buzz, E -> BUZZ`).
* Let's have an example, to illustrate the algorithm, using the string `CodeGolf` (spaces added for clarity): 
```
"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)
```
* If it is more convenient for your language, you may also leave *single spaces* between the groups (`fizz, buzz, FIZZ, BUZZ`). Hence, a result like `fizzBUZZbuzzbuzz` can also be returned as `fizz BUZZ buzz buzz`. Other separators are not allowed.
---
# Test Cases:
```
Input  ->  Output 
"egg"          ->  "buzzbuzzbuzz"
"CodeGolf"     ->  "BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
"Reset"        ->  "FIZZbuzzbuzzbuzzfizz"
"ATOM"         ->  "BUZZFIZZBUZZBUZZ"
"yOuArEgReAt"  ->  "buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"
```
---
* [Any standard method for I/O](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) can be used.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply.
* You are only allowed to take input in your language's native String type. The same applies for output.
* You can assume that the input will not be empty.
* Shortest code in bytes in every language wins. Good Luck and Fizz-Buzz!
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~26~~ 24 bytes
```
ＦθＦ⎇﹪℅ι²buzz¦fizz⎇№αι↥κκ
```
[Try it online!](https://tio.run/##S85ILErOT8z5///9nmXndgCJR33t73euetTSem7noU1JpVVVh5alZVZVAYUftUw7t/HczkdtS8/tOrfr/383oLATUAEA "Charcoal – Try It Online") Originally inspired by @CarlosAlejo. Edit: Saved 2 bytes by looping over the letters of fizz/buzz instead of assigning to a temporary. Explanation:
```
Ｆθ          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
```
[Answer]
# C#, 92 bytes
```
using System.Linq;a=>string.Concat(a.Select(x=>x%2<1?x<97?"FIZZ":"fizz":x<97?"BUZZ":"buzz"))
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~73~~ 69 bytes
4 bytes thanks to ovs.
```
lambda s:"".join("fbFBiuIUzzZZzzZZ"[(c<"a")*2+ord(c)%2::4]for c in s)
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHYSklJLys/M09DKS3JzSmz1DO0qioqCoSVojWSbZQSlTS1jLTzi1I0kjVVjaysTGLT8osUkhUy8xSKNf8XFGXmlWikaSilpqcraWpywfnO@Smp7vk5aSiCQanFqSUoIo4h/r4oApX@pY5FrulBqY4ghf8B "Python 3 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 75 bytes
```
f(char*s){for(;*s;++s)printf(*s>90?*s%2?"buzz":"fizz":*s%2?"BUZZ":"FIZZ");}
```
[Try it online!](https://tio.run/##VYxBC4IwHMXP7VPIQNimgnirgWJR0SEEqUs3W5sJpeJUSPGz/zP10rs83o/HTzipEACKiGdSMU17VVSEM80tS9OyyvJaEab9tRswbXoBvjddhzdYZb@a0fZ6u43ocBqL8gHeSZYTYbd0UrKW9wgZY2azZbWc9mi1uLHpudpwfAPbrKV8Ok5n8jfLptYE44UMCA0AMk1hVzzksXgpiKWWNYSX6AyfqAmrfRrLsP4C "C (gcc) – Try It Online")
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~105~~ ~~100~~ ~~94~~ ~~91~~ 90 bytes
```
s->{for(int i:s.getBytes())System.out.print(i%2<1?i>90?"fizz":"FIZZ":i>90?"buzz":"BUZZ");}
```
[Try it online!](https://tio.run/##lY4xa8MwEIV3/4rDUJCHiKZbndTBCW3pEAJJu6R0UGxJyLElY50CTvBvd4VjKHTzLQffe@/eFezCZqbmusjPfe1OpcogK5m1sGVKwy0AGKlFhn5djMqh8ho5YKO0/P4B1kgbDVaAwt@jDlVJhdMZKqPpxmjrKt4s74EExEtvZ8lNmIYojaBiSyXHdYvckig6tBZ5RY1DWns/EvXwtJyvVPL8uAqFul7DOHz7OB7D@I5ObkDrL4@iRdfDMItgeEdQlmW8RhJyKb08wP8NpSaj8mffmJy/m1JMyey55TglkH7utlP87c6lzavc83Ss6YKu/wU "Java (OpenJDK 8) – Try It Online")
Much golfable, very bytes, so Java!
Very golfed by @KevinCruijssen by 9 bytes!
[Answer]
# [Plain English](https://github.com/Folds/english), ~~820~~ ~~632~~ 610 bytes
[Mr. Xcoder](https://codegolf.stackexchange.com/users/59487) suggested eliminating an unneeded error trap, which saved 22 bytes.
```
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.
```
Ungolfed code:
```
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.
```
The Plain English IDE is available at [github.com/Folds/english](https://github.com/Folds/english). The IDE runs on Windows. It compiles to 32-bit x86 code.
[Answer]
## JavaScript (ES6), ~~79~~ 77 bytes
```
s=>s.replace(/./g,c=>['BUZZ','buzz','FIZZ','fizz'][parseInt(c,36)%2*2|c>'Z'])
```
### Test cases
```
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"
```
[Answer]
# C#, 97 bytes
```
using System.Linq;s=>string.Concat(s.Select(c=>"fizzbuzzFIZZBUZZ".Substring(c%2*4+(c>96?0:8),2)))
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 21 bytes
```
“=%“Ƈ×»ẋ13Œu;$ɓØWiÐ€ị
```
[Try it online!](https://tio.run/##ATMAzP9qZWxsef//4oCcPSXigJzGh8OXwrvhuosxM8WSdTskyZPDmFdpw5Digqzhu4v///9lZ2c "Jelly – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~23~~ 21 bytes
```
smr<d\a@c"fizzbuzz"4C
```
[Test suite](http://pyth.herokuapp.com/?code=smr%3Cd%5Ca%40c%22fizzbuzz%224C&test_suite=1&test_suite_input=%22egg%22%0A%22CodeGolf%22%0A%22Reset%22%0A%22ATOM%22%0A%22yOuArEgReAt%22&debug=0).
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 40 36 bytes
```
Ｆθ¿№αι¿﹪⌕αι²FIZZ¦BUZZ¿﹪⌕βι²fizz¦buzz
```
[Try it online!](https://tio.run/##S85ILErOT8z5///9nmXndhza/6hl2rmN53Ye2v9@56pHPVPB7E1unlFRh5Y5hQJJmPgmkHhaZlXVoWVJpVVV//8756ekuufnpAEA "Charcoal – Try It Online")
Explanation:
```
Ｆθ                                      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"
```
An alternative with the same byte count:
```
ＡfizzφＡbuzzχＦθ¿№αι¿﹪⌕αι²↥φ↥χ¿﹪⌕βι²φχ
```
[Try it online!](https://tio.run/##S85ILErOT8z5///9noVpmVVV59uAjKRSIKP9/Z5l53Yc2v@oZdq5jed2Htr/fueqRz1TwexNj9qWnm8DEe1w8U0g8fNt59v//3fOT0l1z89JAwA "Charcoal – Try It Online") ([Verbose version](https://tio.run/##Zc69DsIgEMDxvU9x6cQldHHtZJroZOLiA1DglIRwFcShL49I/Eoc@d3dP@iLipqVL2WbkjsH0ZNb114C4di9ac6NdCXiCOKKHYAjEBPncBNKOsT2PrDJnsXOBdNUburgGF1dOi2LjVolKwhx/ENd8RX9jczPCHwr9DmtnyllYmP37KkM9zIk/wA))
* 4 bytes saved thanks to Neil!
[Answer]
## [><>](https://esolangs.org/wiki/Fish), 68 bytes
```
<vv?("^"$%2:;?(0:i
v\?\"zzif"
v \\"zzub"
v \ "ZZIF"
v  \"ZZUB"
\oooo
```
[Try it online](https://tio.run/##S8sszvj/36aszF5DKU5JRdXIytpew8Aqk6ssxj5GqaoqM02Jq0whBsQsTQIzFZSiojzdQEyFGCAz1EmJKyYfCP7/D0vNKUstcUrNyan0ScwrSS3KK85ILMoGAA "><> – Try It Online"), or watch it at the [fish playground](https://fishlanguage.com/playground)!
(But look at [Aaron's answer](https://codegolf.stackexchange.com/a/128653/66104) which is 13 bytes shorter!)
If you're not familiar with ><>, there's a fish that swims through the code in 2D, and the edges wrap. The symbols `>`, `<`, `^` and `v` set the direction of the fish, `/` and `\` are mirrors that reflect it, and `?` means "do the next instruction if the top thing on the stack is non-zero, otherwise jump over the next instruction".
In the first line, the fish takes a character of input (`i`); if it's -1 for EOF, it halts (`:0(?;`); it gets the charcode mod 2 (`:2%$`); and it pushes a 1 or 0 on the stack depending on whether the charcode is less than or greater than the charcode of "^" (`"^"(`). The next three lines redirect the fish to the right fizz/buzz string, then the last line prints it (one `o` for each character) and sends the fish back to the start.
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 55 bytes
Based on Not a tree's [answer](https://codegolf.stackexchange.com/a/128636/41881).
```
<v%2$)"^":;?(0:i
 \?v"ZZIF"
~v >"ZZUB"!
^>{:}" "*+ol1=?
```
Instead of representing the 4 possible output in the code, I only represent their capitalized versions and add 32 to the character code to get the small case equivalents.
[Try it online !](https://tio.run/##S8sszvj/36ZM1UhFUylOycraXsPAKpNLIca@TCkqytNNiauuTMEOyAx1UlLkirOrtqpVUlDS0s7PMbS1///fOT8l1T0/Jw0A)
Modified code for the [online interpreter](https://fishlanguage.com/playground), which pads its codespace with empty cells :
```
<v%2$)"^":;?(0:i
 \?v"ZZIF"
~v >"ZZUB"     !
^>{:}" "*+o l1=?
```
[Answer]
# [Perl5](http://www.perl.org/), 50+1 bytes
```
perl -nE'say+((FIZZ,BUZZ)x48,(fizz,buzz)x16)[unpack"C*",$_]'
```
Creates a 128-item list that maps ASCII chars to the proper code word.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 22 bytes
```
v‘FIZZÒÖ‘#yÇÉèAyåil}J?
```
[Try it online!](https://tio.run/##MzBNTDJM/f@/7FHDDDfPqKjDkw5PAzKVKw@3H@48vMKx8vDSzJxaL/v//yv9Sx2LXNODUh1LAA "05AB1E – Try It Online")
**Explanation**
```
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
```
**Alternative 22 byte solution**
```
ÇÉAISå·+‘FIZZÒÖ‘#Dl«èJ
```
[Answer]
# [PHP](https://php.net/), 67 bytes
```
for(;$c=$argn[$i++];)echo[FIZZ,BUZZ,fizz,buzz][ord($c)%2+2*($c>Z)];
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwKWSWJSeZ6vknJ@S6p6fk6Zk/T8tv0jDWiXZFiwTrZKprR1rrZmanJEf7eYZFaXjFAok0jKrqnSSSquqYqPzi1I0VJI1VY20jbSADLsozVjr//8B "PHP – Try It Online")
[Answer]
# [F#](http://fsharp.org/), ~~154~~ ~~153~~ 145 bytes
saved ~~1~~ 9 bytes thanks to [@Mr. Xcoder](https://codegolf.stackexchange.com/users/59487/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""
```
[Try it online!](https://tio.run/##XYvBCoJAFEX3fsXlgWELpSKCIAWDglZB0sadDTPjgI7WPMnCfzepXbtzuOcqF9aNbcaxkgwNF3vI5D2qizZQnYUIEw91waKEsQyBp@HSA4Yez1Ja9MlmPZv1u@0yTIxC76/iBXha6HjKc5KVk7S/ToTv6T9S5v3@RbduornzMCQZP4zVkWisKBhEYzs5KwvyHSHQoNe5Sx8HfZEp03z8AA "F# (Mono) – Try It Online")
[Answer]
# Mathematica, 134 bytes
```
""<>{(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@#}&
```
[Answer]
# Java 8, 89 bytes
```
s->s.chars().mapToObj(i->i%2<1?i>90?"fizz":"FIZZ":i>90?"buzz":"BUZZ").collect(joining());
```
It assumes `import static java.util.stream.Collectors.*;`
[Answer]
# q/kdb+, 48 bytes
**Solution:**
```
raze{@[($)`fizz`buzz x mod 2;(&)x<91;upper]}"i"$
```
**Examples:**
```
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"
```
**Explanation:**
Fairly straightforward, take the input string, cast into ASCII values, create a list of 1 or 0 depending whether it is odd or even (hint A=65=odd), then use this list to index into a list of `fizz` and `buzz`. Cast this to a string, and then for cases where the input is <91 (lower than a Z) we apply the `upper` function to get a `FIZZ` or a `BUZZ`.
q is interpreted right to left:
```
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
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 61+1 = 62 bytes
Uses the `-p` flag.
```
gsub(/./){k=$&.ord%2*4;$&<?_?"FIZZBUZZ"[k,4]:"fizzbuzz"[k,4]}
```
[Try it online!](https://tio.run/##KypNqvyvrFgEpBR0C/6nF5cmaejr6WtWZ9uqqOnlF6WoGmmZWKuo2djH2yu5eUZFOYVGRSlFZ@uYxFoppWVWVSWVVlVB@LX//zvnp6S65@ekAQA "Ruby – Try It Online")
[Answer]
# [Swift 4](https://swift.org/blog/swift-4-0-release-process/), ~~144~~ 135 bytes
```
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())}
```
Un-golfed:
```
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()
    )
}
```
What I am doing is looping over each character in the string. I convert each to its ASCII value, then check to see if it is even or odd, and then check to see if it is upper or lowercase and output the matching value from the loop. I then join all the elements of the resulting array into a single string and print it.
This solution uses Swift 4, so there is no way to easily test it online yet.
Thanks to @Mr.Xcoder for saving me 9 bytes! 
[Answer]
## R, ~~150~~ ~~123~~ 108 bytes
```
i=ifelse
cat(i(sapply(el(strsplit(scan(,''),'')),utf8ToInt)>91,i(x%%2,'buzz','fizz'),i(x%%2,'BUZZ','FIZZ')))
```
~~Has to be shorter using ASCII?~~ It was shorter. See edit history for old answer, which used `letters`.
Checks each letter for (1) whether it's capital or not (`>91`) and whether it's a `fizz` or a `buzz`.
]