Size hem İngilizce hem de büyük harf içeren İngilizce Alfabe harfleri içeren bir Dize verilecektir (ASCII 65-90 ve 97-122). Senin görevin dizenin Fizz-Buzzified sürümü çıktı için.

Nasıl bir dize Fizz-Buzzify?

• İngiliz alfabesinde eşit indeksi vardır Her harf (alfabe gerekir 1-endeksli be: a->1,b->2,...,z->26) dönüşmüş olacak fizzo küçük harf ise ve FIZZo büyük ise ( f -> fizz, F -> FIZZ).

• İngilizce alfabesinde tek bir dizine sahip olan buzzher harf, küçük harf ve BUZZbüyük harf ( e -> buzz, E -> BUZZ) ise dönüştürülür.

• Dize CodeGolf(açıklık için eklenen boşluklar) kullanarak algoritmayı göstermek için bir örnek verelim :

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

• Diliniz için daha uygunsa , gruplar ( ) arasında tek boşluk bırakabilirsiniz fizz, buzz, FIZZ, BUZZ. Böylece, gibi bir sonuç fizzBUZZbuzzbuzzda döndürülebilir fizz BUZZ buzz buzz. Diğer ayırıcılara izin verilmez.

Test Durumları:

Giriş -> Çıkış 

"yumurta" -> "buzzbuzzbuzz"
"CodeGolf" -> "BUZZbuzzfizzbuzzBUZZbuzzfizzfizz"
"Sıfırla" -> "FIZZbuzzbuzzbuzzfizz"
"ATOM" -> "BUZZFIZZBUZZBUZZ"
"yOuArEgReAt" -> "buzzBUZZbuzzBUZZfizzBUZZbuzzFIZZbuzzBUZZfizz"

• G / Ç için herhangi bir standart yöntem kullanılabilir.

• Varsayılan Loopholes uygulanır.

• Yalnızca dilinizin yerel Dize türünde girdi almanıza izin verilir. Aynısı çıktı için de geçerlidir.

• Girişin boş olmayacağını varsayabilirsiniz.

• Her dilde bayt cinsinden en kısa kod kazanır. İyi Şanslar ve Fizz-Buzz!

Odun kömürü , 26 24 bayt

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

Çevrimiçi deneyin! Başlangıçta @CarlosAlejo'dan esinlenilmiştir. Düzenleme: Bir geçici atamak yerine fizz / buzz harfleri üzerinde döngü yaparak 2 bayt kaydedildi. Açıklama:

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

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

Python 3 , 73 69 bayt

Ovs sayesinde 4 bayt.

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

Çevrimiçi deneyin!

C (gcc) , 75 bayt

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

Çok golf edilebilir, çok bayt, yani Java!

@KevinCruijssen tarafından 9 bayt tarafından çok golf!

JavaScript (ES6), 79 77 bayt

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

Test senaryoları

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 bayt

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

Jöle , 21 bayt

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

Çevrimiçi deneyin!

Pyth , 23 21 bayt

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

Test takımı .

Düz İngilizce , 820 632 610 bayt

Bay Xcoder , 22 bayt tasarruf sağlayan gereksiz bir hata tuzağının ortadan kaldırılmasını önerdi.

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.

Kod çözülmemiş kod:

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.

Plain English IDE'yi github.com/Folds/english adresinde bulabilirsiniz . IDE Windows üzerinde çalışır. 32 bit x86 koduyla derlenir.

Kömür , 40 36 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Aynı bayt sayısına sahip bir alternatif:

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

Çevrimiçi deneyin! ( Ayrıntılı sürüm )

• Neil sayesinde 4 bayt kurtardı!

> <> , 68 bayt

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

Çevrimiçi deneyin veya balık oyun alanında izleyin !

(Ama Aaron'un 13 bayt daha kısa olan cevabına bakın !)

> <> Bilgisine sahip değilseniz, 2B kodda yüzen bir balık vardır ve kenarlar sarılır. Semboller >, <, ^ve vbalıkların yönünü ayarlamak, /ve \bunu yansıtan aynalar ve olan ?araçlar "yığın üst şey sıfırdan ise aksi takdirde sonraki talimat yapmak sonraki talimatı üzerinden atlamak".

İlk satırda, balık bir girdi karakteri alır (i ) ; EOF için -1 ise durur (:0(?; ); mod 2 ( :2%$) kodunu alır ; ve "^" ( "^"() karakterinin kodundan küçük veya büyük olmasına bağlı olarak yığına 1 veya 0 iter . Sonraki üç satır balığı sağ fizz / buzz dizesine yönlendirir, ardından son satır onu ( oher karakter için bir tane) yazdırır ve balıkları tekrar başlangıca gönderir.

> <> , 55 bayt

Bir ağacın cevabı değil .

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

Koddaki 4 olası çıktıyı temsil etmek yerine, yalnızca büyük harfli sürümlerini temsil ediyorum ve küçük harf eşdeğerlerini elde etmek için karakter koduna 32 ekledim.

Çevrimiçi deneyin!

Kod alanını boş hücrelerle dolduran çevrimiçi yorumlayıcı için değiştirilmiş kod :

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

Perl5 , 50 + 1 bayt

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

ASCII karakterlerini uygun kod sözcüğüyle eşleyen 128 öğeli bir liste oluşturur.

05AB1E , 22 bayt

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

Çevrimiçi deneyin!

açıklama

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

Alternatif 22 baytlık çözüm

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

PHP , 67 bayt

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

Çevrimiçi deneyin!

F # , 154 153 145 bytes

@Mr sayesinde 1 9 bayt tasarruf etti. 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""

Çevrimiçi deneyin!

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

It assumes import static java.util.stream.Collectors.*;

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

Ruby, 61+1 = 62 bytes

Uses the -p flag.

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

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

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!

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.

Java

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