Sie erhalten eine Zeichenfolge, die nur Buchstaben des englischen Alphabets in Klein- und Großbuchstaben enthält (ASCII 65-90 und 97-122). Ihre Aufgabe ist es, die Fizz-Buzzified-Version des Strings auszugeben.

Wie lässt sich eine Zeichenfolge mit einem Fizz-Buzz-Effekt versehen?

• Jeder Buchstabe mit einem geraden Index im englischen Alphabet (das Alphabet muss 1-indiziert a->1,b->2,...,z->26sein:) wird in fizzKleinbuchstaben und FIZZin Großbuchstaben umgewandelt ( f -> fizz, F -> FIZZ).

• Jeder Buchstabe mit einem ungeraden Index im englischen Alphabet wird in buzzKleinbuchstaben und BUZZin Großbuchstaben umgewandelt ( e -> buzz, E -> BUZZ).

• Ein Beispiel zur Veranschaulichung des Algorithmus anhand der Zeichenfolge CodeGolf(Leerzeichen zur Verdeutlichung hinzugefügt):

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

• Wenn es für Ihre Sprache praktischer ist, können Sie auch einzelne Leerzeichen zwischen den Gruppen lassen ( fizz, buzz, FIZZ, BUZZ). Daher kann ein Ergebnis wie fizzBUZZbuzzbuzzauch als zurückgegeben werden fizz BUZZ buzz buzz. Andere Trennzeichen sind nicht zulässig.

Testfälle:

Eingabe -> Ausgabe 

"egg" -> "buzzbuzzbuzz"
"CodeGolf" -> "BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
"Zurücksetzen" -> "FIZZbuzzbuzzbuzzfizz"
"ATOM" -> "BUZZFIZZBUZZBUZZ"
"yOuArEgReAt" -> "buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

• Jede Standardmethode für E / A kann verwendet werden.

• Es gelten Standardlücken .

• Sie dürfen nur Eingaben in der systemeigenen Zeichenfolge Ihrer Sprache vornehmen. Gleiches gilt für die Ausgabe.

• Sie können davon ausgehen, dass die Eingabe nicht leer sein wird.

• Kürzester Code in Bytes in jeder Sprache gewinnt. Viel Glück und Fizz-Buzz!

Holzkohle , 26 24 Bytes

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

Probieren Sie es online! Ursprünglich inspiriert von @CarlosAlejo. Bearbeiten: Speichert 2 Bytes, indem die Buchstaben von Fizz / Buzz durchlaufen werden, anstatt sie einem temporären zuzuweisen. Erläuterung:

Ｆθ          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 Bytes

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

Python 3 , 73 69 Bytes

4 Bytes dank ovs.

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

Probieren Sie es online!

C (gcc) , 75 Bytes

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

Probieren Sie es online!

Java (OpenJDK 8) , 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");}

Probieren Sie es online!

Viel Golf, sehr Bytes, also Java!

Sehr golfen von @KevinCruijssen um 9 Bytes!

JavaScript (ES6), 79.77 Byte

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

Testfälle

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 Bytes

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

Jelly , 21 Bytes

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

Probieren Sie es online!

Pyth , 23 21 Bytes

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

Testsuite .

Englisch , 820 632 610 Bytes

Herr Xcoder schlug vor, eine unnötige Fehlerfalle zu beseitigen, die 22 Bytes einspart .

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.

Die Plain English IDE ist unter github.com/Folds/english verfügbar . Die IDE läuft unter Windows. Es wird in 32-Bit-x86-Code kompiliert.

Kohle , 40 36 Bytes

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

Probieren Sie es online!

Erläuterung:

Ｆθ                                      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"

Eine Alternative mit der gleichen Byteanzahl:

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

Probieren Sie es online! ( Ausführliche Version )

• 4 Bytes gespart dank Neil!

> <> 68 Bytes

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

Probieren Sie es online aus oder schauen Sie es sich auf dem Fischspielplatz an !

(Aber sieh dir Aarons Antwort an, die 13 Bytes kürzer ist!)

Wenn Sie nicht mit> <> vertraut sind, gibt es einen Fisch, der in 2D durch den Code schwimmt, und die Kanten werden umbrochen. Die Symbole >, <, ^und vdie Richtung des Fisches festgelegt, /und \sind Spiegel , die es reflektieren, und ?bedeutet „die nächste Anweisung tun , wenn die Top-Sache auf dem Stapel nicht Null ist , sonst die nächste Anweisung springen“.

In der ersten Zeile erhält der Fisch das Zeichen input ( i). Wenn es für EOF -1 ist, stoppt es ( :0(?;); es bekommt den charcode mod 2 ( :2%$); und es drückt eine 1 oder 0 auf dem Stapel, abhängig davon, ob der Zeichencode kleiner oder größer als der Zeichencode von "^" ( "^"() ist. Die nächsten drei Zeilen leiten den Fisch zur richtigen Fizz / Buzz-Zeichenfolge um, dann wird er in der letzten Zeile gedruckt (eine ofür jedes Zeichen) und der Fisch zum Anfang zurückgeschickt.

> <> , 55 Bytes

Basierend auf der Antwort von Not a Tree .

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

Anstatt die 4 möglichen Ausgaben im Code darzustellen, stelle ich nur ihre großgeschriebenen Versionen dar und addiere 32 zum Zeichencode, um die kleinen Falläquivalente zu erhalten.

Probieren Sie es online!

Geänderter Code für den Online-Interpreter , der seinen Codespace mit leeren Zellen auffüllt:

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

Perl5 , 50 + 1 Bytes

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

Erstellt eine Liste mit 128 Elementen, die ASCII-Zeichen dem richtigen Codewort zuordnet.

05AB1E , 22 Bytes

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

Probieren Sie es online!

Erläuterung

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-Lösung

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

PHP , 67 Bytes

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

Probieren Sie es online!

F # , 154 153 145 Bytes

gespeichert 1 9 Byte dank @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""

Probieren Sie es online!

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@#}&

Java 8, 89 Bytes

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

Es geht davon aus import static java.util.stream.Collectors.*;

q / kdb +, 48 Bytes

Lösung:

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

Beispiele:

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"

Erläuterung:

Ziemlich einfach, nehmen Sie die Eingabezeichenfolge, wandeln Sie sie in ASCII-Werte um, erstellen Sie eine Liste mit 1 oder 0, je nachdem, ob sie gerade oder ungerade ist (Hinweis A = 65 = ungerade), und indizieren Sie diese Liste dann in eine Liste mit fizzund buzz. Wandeln Sie dies in eine Zeichenfolge um. In Fällen, in denen die Eingabe <91 (niedriger als ein Z) ist, wenden wir die Zeichenfolge anupper Funktion an, um a FIZZoder a zu erhalten BUZZ.

q wird von rechts nach links interpretiert:

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 Bytes

Verwendet die -pFlagge.

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

Probieren Sie es online!

Swift 4 , 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())}

Nicht golfen:

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

Was ich tue, ist Schleifen über jedes Zeichen in der Zeichenfolge. Ich konvertiere jedes in seinen ASCII-Wert, überprüfe dann, ob es gerade oder ungerade ist, und überprüfe dann, ob es groß oder klein geschrieben ist, und gebe den passenden Wert aus der Schleife aus. Ich füge dann alle Elemente des resultierenden Arrays zu einer einzigen Zeichenfolge zusammen und drucke sie aus.

Diese Lösung verwendet Swift 4, so dass es noch keine einfache Möglichkeit gibt, sie online zu testen.

Vielen Dank an @ Mr.Xcoder, der mir 9 Bytes gespart hat!

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

Muss mit ASCII kürzer sein? Es war kürzer. Siehe Bearbeitungsverlauf für die alte Antwort, die verwendet wurde letters.

Überprüft jeden Buchstaben auf (1), ob es sich um Großbuchstaben handelt oder nicht ( >91) und ob es sich um einen fizzoder einen handelt buzz.

Java

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