Mümkün olan en kısa karışık FizzBuzz uygulamasını oluşturun.

Karışık olarak kabul edilmesi için, aşağıdakilerden en az birini sağlaması gerekir:

1. "Fizz", "Buzz" veya "FizzBuzz" kelimelerini içermez.
2. 3, 5 veya 15 sayılarını içermez.
3. Yukarıdakilerden herhangi birini yanıltıcı şekilde kullanın.

Unutmayın: Amaç kısa ve takip etmesi zor olmaktır.

Bu soruya ilham veren kod örneği şöyledir:

public class Default
{
        enum FizzBuzz
        {
            Buzz = 1,
            Fizz,
            FizzBuzz
        }
        public static void Main(string[] args)
        {
            byte[] foo = 
              Convert.FromBase64String("IAmGMEiCIQySYAiDJBjCIAmGMEiCIQySYA==");
            MemoryStream ms = new MemoryStream(foo);
            byte[] myByte = new byte[1];
            do
            {
                FizzBuzz fb;
                ms.Read(myByte, 0, 1);
                for (int i = 0; i < 4; i++)
                {
                    fb = (FizzBuzz)(myByte[0] >> (2 * i) 
                         & (int)FizzBuzz.FizzBuzz);
                    Console.Out.WriteLine( (((int)fb > 0) ? "" + fb : "" 
                         + ((ms.Position - 1) * 4 + i + 1)));
                }
            } while (ms.Position < ms.Length);
        }
}

GolfScript, 75 69 65 60 59 karakter

100,{)6,{.(&},{1$1$%{;}{4*35+6875*25base{90\-}%}if}%\or}%n*

Yani, GolfScript'in kendi başına zaten karışık olduğunu düşünüyorsunuz, değil mi? Eh, sadece teknik özelliklere uymak için, programın "fizz", "buzz" ya da 3, 5 ya da 15 sayıları içermemesine karar verdim. :-)

Evet, 25, 35, 90, 100 ve 6875 gibi 5 katları olan bazı sayılar vardır. Bunlar kırmızı ringa balığı mı? Sen karar ver. ;-)

Javascript 97 karakter - numara yok

Sayılar? Javascript olduğunda kim numaraya ihtiyaç duyar!

a=b=!![]+![],a--,c=b+b;while(++a)e=!(a%(c+c+b)),alert(!(a%(c+b))?e?"FizzBuzz":"Fizz":e?"Buzz":a);

Not: Sıralamayı uyaracak sonsuz bir döngü var.

Bonus (666 karakter)

• Numara yok
• Mektup yok (yalnızca zfortüm komut dosyasında kullanılıyor)

.

_=$=+!![];$__=((_$={})+'')[_+$+_+$+_];__$=((![])+'')[$];_$_=((_$={})+'')
[_+$+_+$+_+$];____=[][$__+((_$={})+'')[$]+(($)/(![])+'')[$]+$__+__$+_$_];$__$=(!![]+"")
[$+$+$]+([][(![]+"")[$+$+$]+(+[]+{})[$+$]+(!![]+"")[$]+(!![]+"")[+[]]]+"")[($+$)+""+
($+$+$)]+(![]+"")[$]+(![]+"")[$+$];$_$_=____()[$-$][$__$]("\"\\"+($)+($+$+$+$+$+$+$)+
($+$)+"\"");_$=(![]+'')[$-$]+([][[]]+[])[$+$+$+$+$]+$_$_+$_$_;$_=(_+{})[$+$+$]+(!![]+'')
[_+$]+$_$_+$_$_;_--,$$=$+$;____()[$-$][$__$]((![]+"")[+[]]+(+[]+{})[$+$]+(!![]+"")[$]+
"(;++_;)$$$=!(_%("+($$+$$+$)+")),____()[+[]][__$+((![])+'')["+($+$)+"]+((!![])+'')["+
($+$+$)+"]+((!![])+'')[+!![]]+_$_](!(_%("+($$+$)+"))?$$$?_$+$_:_$:$$$?$_:_);");

Python - 78 karakter

i=0
while 1:i+=1;print"".join("BzuzzizF"[::2*j]for j in(-1,1)if 1>i%(4+j))or i

PostScript, 96 bayt

Bu yüzden şaşkın rastgele çöp gibi görünüyor.

1<~0o0@eOuP7\C+tf6HS7j&H?t`<0f>,/0TnSG01KZ%H9ub#H@9L>I=%,:23M].P!+.F6?RU#I;*;AP#XYnP"5~>cvx exec

Kullanımı: $ gs -q -dNODISPLAY -dNOPROMPT file.ps

C ++: 886 karakter

'Fizz'i ve' vızıltıyı 'gizlemeye çalıştım. Onları işaret edebilir misin?

#include <iostream>
#define d(a,b) a b
#define _(a,b) d(#b,#a)
#define b(b) _(b,b)
#define y _(i,f)c
#define x _(u,b)c
#define c b(z)
#define i int
#define p main
#define s char
#define q 810092048
#define h for
#define m 48
#define a ++
#define e ==
#define g 58
#define n 49
#define l <<
#define oe std::cout<<
#define v '\n'

int  p   (i,  s*t     ){i   j  =   q;h   (*(
i    *     )    t     =  m  ;  2     [     t
]?   0    :    1      ??(   t  ]    ?     a
1    [   t    ]       e  g  ?  1   [     t
]    =   48,  ++0     ??(    t]e   g?0   ??(

t]=  n   ,1[  t]=
2    [     t    ]
=m   :    1    :
1    :   a    0
[    t   ??)  ==g

?0[   t  ]   =49   ,1[
t  ]  =  m     :     1
;j=   (  j    /     4
)  |  (  (   j     &
3)l    28)   )oe   (j&

3?j  &   1?j  &2?
y    x     :    y
:x   :    t    )
l    v   ;    }
i    f   =m&  ~g;

DC ( 256 255 bayt)

İşte, mektuplar dışında herhangi bir şeyi gizlemeye çalıştım (oldukça başarılı bir şekilde söyleyebilseydim) ve +-[];:=(şaşırtmak için hayati ve imkansız olan). Makinemde yaklaşık 8482 ye yaklaştıktan sonra segfault yapıyor, ancak bu özyinelemenin uygulanma biçimiyle ilgili yığın sorunları ile ilgili. Çözümün kendisi doğru. Boşluğu kaldırırsanız 255 bayt (okuma kolaylığı için dahil edilir)

Izzzdsa+dsbrsc+dsdd+sozdsezzsm+s
nloddd++splbz++ddaso+dln-dstsqlm
d+-sr[PPPP]ss[IP]su[lpdlqlrlsxlu
x]lm:f[lpdltdI+lm+rlblm+-lsxlux]
ln:f[[]sulm;fxln;f[IP]sux]la:f[;
fsk]sg[lmlgx]sh[lnlgx]si[lalgx]s
j[lc[lcp]sklerldlolclerlblolcler
lalox=hx=ix=jlkxclcz+scllx]dslx

Bu, girintiyi kullanarak gömmek için biraz zordu:

Ruby, 4312 karakter

https://gist.github.com/dzucconi/1f88a6dffa2f145f370f

eval("                                                 

















































                                                                                                                             ".split(/\n/).map(&:size).pack("C*"))

Brainfuck - 626 656

+[[>+>+<<-]>>>+++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]<[<+>>+<-]>>[-]+++>[
<<<+>>>-]>[-]<<<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[-]<<<<[>+<-]>>>[<
<<+>>>-]<<[>>+<<-]<[>+>+<<-]>[<+>-]+>[<->[-]]<[>>>[-]>[-]<>+++++++[<++
++++++++>-]<.>+++++[<+++++++>-]<.+++++++++++++++++..[-]+<<<-]<[-]>>>[<
+<+>>-]<[>+<-]+<[>-<[-]]>[>>>[-]>[-]<>++++++[<+++++++++++>-]<.>+++++[<
++++++++++>-]<+.+++++..[-]<+<<-]>[-]>[<+<+>>-]<[>+<-]+<[>-<[-]]>[<<<<[
>+>>>>+<<<<<-]>[<+>-]>>>>>>--[<->+++++]<--<[->-[>+>>]>[+[-<+>]>+>>]<<<
<<]>[-]<-[>-<+++++]>--->>[<<[<+>>>+<<-]<[>+<-]>>>.[-]]++++++++++<[->-[
>+>>]>[+[-<+>]>+>>]<<<<<]>[-]<<[>+>>>+<<<<-]>>>>.[-]<<<[>>+<<-]>>.[-]<
<<<<-]<<<++++++++++.[-]<+]

1 - 255 arası

Brainfuck, 708 karakter

++++++++++[>++++++++++<-]>>++++++++++>->>>>>>>>>>>>>>>>-->+++++++[->++
++++++++<]>[->+>+>+>+<<<<]+++>>+++>>>++++++++[-<++++<++++<++++>>>]++++
+[-<++++<++++>>]>>-->++++++[->+++++++++++<]>[->+>+>+>+<<<<]+++++>>+>++
++++>++++++>++++++++[-<++++<++++<++++>>>]++++++[-<+++<+++<+++>>>]>>-->
---+[-<+]-<[+[->+]-<<->>>+>[-]++[-->++]-->+++[---++[--<++]---->>-<+>[+
+++[----<++++]--[>]++[-->++]--<]>++[--+[-<+]->>[-]+++++[---->++++]-->[
->+<]>>[.>]++[-->++]]-->+++]---+[-<+]->>-[+>>>+[-<+]->>>++++++++++<<[-
>+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>
+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->+++
+++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]+[-<+]->>]+[-]<<<.>>>+[
-<+]-<<]

Nasıl çalıştığının açıklaması, Kod İnceleme sorumdan edinilebilir

Haskell - 147 142 138 karakter

fi=zz.bu
bu=zz.(:).(++"zz")
[]#zz=zz;zz#__=zz
zZ%zz=zZ zz$zZ%zz
zz=(([[],[]]++).)
z=zipWith3(((#).).(++))(bu%"Fi")(fi%"Bu")$map show[1..]

Kod, olması gerekenden 19 karakterden daha uzun, ama estetiğin buna değer olduğunu düşündüm! Üç “hedefin” de tatmin olduğuna inanıyorum.

> take 20 z
["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14",
"FizzBuzz","16","17","Fizz","19","Buzz"]

33, 33 karakter / 92 bayt (rekabetçi olmayan)

ѨŃ(1,ṥ)ć⇀ᵖɘƃ႖סР깜 #ē($%3⅋4,$%5?4:8)⋎$⸩

Try it here (Firefox only).

Bu dil, kısıtlı kaynak zorlukları için çok OP'dir.

Javascript, 469 bayt

Bu muhtemelen şimdiye kadar yaşadığınız en eğlenceli oldu.

z=0;_=(function(){b=0;window[0xA95ED.toString(36)]((function(){yay="&F bottles of beer on the wall, &F bottles of beer. Take one down, pass it around, &z Bottles of beer on the wall.";return atob("eisrOyAg") + "console.log(((function(y){if((y%0xf)==0){return [1,72,84,84,86,78,84,84]}else if(y%0b11==0){return [1,72,84,84]}else if(y%0b101==0){return [86,78,84,84]}else{b=1;return [y]}})(z).map(function(x){return b==0?yay[x]:x}) ).join(''))"})())});setInterval(_,1000);

Burada dene

Yakut - 165 karakter

(1..100).each{|i|i%0xF==0? puts(["46697A7A42757A7A"].pack("H*")):i%(0xD-0xA)==0? puts(["46697A7A"].pack("H*")):i%(0xF-0xA)==0? puts(["42757A7A"].pack("H*")):puts(i)}

Bu benim ilk kod golf denememdi. Çok eğlendim. =)

Perl 6 (52 bayt)

say "Fizz"x$_%%(2+1)~"Buzz"x$_%%(4+1)||$_ for 1..100

Buraya bir açıklama yapmama izin verin. Bu tür görevlerde yaptığım en kötü kural istismarı. Ne dediğini biliyorum - açık Fizzve Buzzburada var. Ama hadi kurallara bir göz atalım.

Karışık olarak kabul edilmesi için, aşağıdakilerden en az birini sağlaması gerekir :

Bu engeller 3, 5ve 15. Bu nedenle, geçerli ve gerçekten kısa bir çözüm.

Scala, 295 karakter

object F extends Application{var(f,i,z)=("",('z'/'z'),"FBiuzzzz");while(i<(-'b'+'u'+'z'/'z')*('¥'/'!')){if(i%(-'f'+'i'/('z'/'z'))==0)f+=z.sliding(1,2).mkString;if(i%((-'b'+'u'+'z'/'z')/('f'/'f'+'i'/'i'+'z'/'z'+'z'/'z'))==0)f+=z.drop(1).sliding(1,2).mkString;if(f=="")f+=i;println(f);i+=1;f="";}}

C ( 237 209 karakter)

#include<stdlib.h>
#define e printf  
a=50358598,b=83916098,c=1862302330;_(m,n){return(m%((c&n)>>24))
||!(e(&n)|e(&c));}main(_);(*__[])(_)={main,exit};main(i){_(i,a)
&_(i,b)&&e("%i",i);e("\n");__[i>=100](++i);}

Yine de bunun C standardına uygun olduğundan emin değilim :)
Yine de çalışıyor. Linux’ta GCC’nin kullanılması, yani.

Python 3 - 338

import sys
def fibu():
        (F,I,B,U),i,u,z=sys._getframe(0).f_code.co_name,0xf,0xb,lambda x,y:x%((i//u)+(i^u))==u>>i if y>u else x%(((u<<(u>>2))&i)>>(u>>2))==i>>u
        A,RP = "",chr(ord(U)+((i//u)+(i^u)))*2
        for x in range(100):print(x if not (z(x,u)or z(x,i))else A.join((F+I+RP if z(x,u)else A,B+U+RP if z(x,i)else A)))
fibu()

Bu benim ilk golf. En kısa değil, ama oldukça çirkin! Yasaklanan sayıların veya dizi değişmezlerin hiçbiri. Firp, Burp!

Python - 157

from itertools import cycle as r
c=str.replace
[c(c(c(z+y,'x','fix'),'y','bux'),'x','zz').strip() or x for z,y,x in zip(r('  y'),r('    x'),range(1,101))]

Çok kısa değil, ama okuyucunun keyfi olarak uzun sayıma kadar saf işlevsel stil ve genişletilebilirliği takdir edeceğini umuyorum.

K, 155

{m:{x-y*x div y};s:{"c"$(10-!#x)+"i"$x};$[&/0=m[x]'(2+"I"$"c"$49;4+"I"$"c"$49);s"<`rs<pvw";0=m[x;2+"I"$"c"$49];s"<`rs";0=m[x;4+"I"$"c"$49];s"8lrs";x]}'!100

Biraz golf oynayabilirim ama daha fazla şaşırtmayı tercih ederim.

Python 2 - 54 karakter

i=0
while 1:i+=1;print'FizzBuzz'[i%~2&4:12&8+i%~4]or i

Python 3 - 56 karakter

i=0
while 1:i+=1;print('FizzBuzz'[i%~2&4:12&8+i%~4]or i)

'FizzBuzz' ifadesinin görünmesini istemiyorsanız:

Python 2 - 58 karakter

i=0
while 1:i+=1;print' zzuBzziF'[12&8+i%~2:i%~4&4:-1]or i

Python 3 - 60 karakter

i=0
while 1:i+=1;print(' zzuBzziF'[12&8+i%~2:i%~4&4:-1]or i)

Veya GolfScript Python ile nasıl yenilir;)

JavaScript 111 karakter - anahtar numarası yok

a=b=c=0;while(a++<99)document.write((b>1?(b=0,"Fizz"):(b++,""))+(c==4?(c=0,"Buzz"):(c++,""))+(b*c?a:"")+"<br>")

C # - 218 karakter

using System;class D{static void Main(){int l,i,O=1;l++;string c="zz",a="fi",b="bu";l++;l++;i=l;i++;i++;for(;O<101;O++)Console.WriteLine(((O%l)>0&&1>(O%i))?a+c:(1>(O%l)&&(O%i)>0)?b+c:(1>(O%l)&&1>(O%i))?a+c+b+c:O+"");}}

Buna benzer başka numaralar tanıtırsam kısaltılabilir: (toplam 210 karakter)

using System;class D{static void Main(){int l=1,i,O=1;string c="zz",a="fi",b="bu";l+=2;i=l;i+=2;for(;O<101;O++)Console.WriteLine(((O%l)>0&&1>(O%i))?a+c:(1>(O%l)&&(O%i)>0)?b+c:(1>(O%l)&&1>(O%i))?a+c+b+c:O+"");}}

Belli ki fizz ve vızıltı kelimesini kaldırmaya karar verdim ve biraz daha fazla şaşırtmaya gittiniz. İkincisi, birincisinden daha kısadır, ancak ilavede olanlara biraz daha doğrudandır.

Bu tam olarak golf değil, yaklaşık 120 satır.

C ++ bellek yönetimi ile tanımsız davranış için eğlenceli potansiyelden yararlanan bir şey yapacağımı düşündüm.

#include <iostream>
#include <string>

using namespace std;

class Weh;
class HelloWorld;

class Weh
{
public:

    string value1;
    string value2;
    void (*method)(void * obj);

    Weh();

    string getV1();

    static void doNothing(void * obj);
};

class HelloWorld
{
public:
    static const int FOO = 1;
    static const int BAR = 2;
    static const int BAZ = 4;
    static const int WUG = 8;

    string hello;
    string world;
    void (*doHello)(HelloWorld * obj);

    HelloWorld();

    void * operator new(size_t size);

    void tower(int i);
    const char * doTower(int i, int j, int k);

    static void doHe1lo(HelloWorld * obj);
};

Weh::Weh()
{
    method = &doNothing;
}

void Weh::doNothing(void * obj)
{
    string s = ((Weh *) obj)->getV1();
    ((HelloWorld *) obj)->tower(1);
}

string Weh::getV1()
{
    value1[0] += 'h' - 'j' - 32;
    value1[1] += 'k' - 'g';
    value1[2] += 'u' - 'g';
    value1[3] = value1[2];
    value2 = value1 = value1.substr(0, 4);

    value2[0] += 'd' - 'h';
    value2[1] += 'w' - 'k';
    value2[2] = value1[2];
    value2[3] = value1[3];

    return "hello";
}

void * HelloWorld::operator new(size_t size)
{
    return (void *) new Weh;
}

HelloWorld::HelloWorld()
{
    hello = "hello";
    world = "world";
}

void HelloWorld::doHe1lo(HelloWorld * obj)
{
    cout << obj->hello << " " << obj->world << "!" << endl;
}

void HelloWorld::tower(int i)
{
    doTower(0, 0, i);
    tower(i + (FOO | BAR | BAZ | WUG));
}

const char * HelloWorld::doTower(int i, int j, int k)
{
    static const char * NOTHING = "";
    int hello = BAR;
    int world = BAZ;
    int helloworld = FOO | BAR | BAZ | WUG;

    if ((hello & i) && (world & j))
        cout << this->hello << this->world << endl;
    else if (hello & i)
    {
        cout << this->hello << endl;
        cout << doTower(0, j + 1, k + 1);
    }
    else if (world & j)
    {
        cout << this->world << endl;
        cout << doTower(i + 1, 0, k + 1);
    }
    else
    {
        cout << k << endl;
        cout << doTower(i + 1, j + 1, k + 1);
    }

    return NOTHING;
}

int main()
{
    HelloWorld * h = new HelloWorld;
    h->doHello(h);
}

Ruby - 89 karakter

puts (0..99).map{|i|srand(1781773465)if(i%15==0);[i+1,"Fizz","Buzz","FizzBuzz"][rand(4)]}

Bu parlaklık için kredi alamam, ancak en sevdiğim şaşkın uygulamadan bu soruyu bırakamam :)

Yukarıdaki uygulama David Brady tarafından yazılmıştır ve fizzbuzz yakut mücevherindendir. Kaynak kodun açıklaması:

Ruby'nin rand'ındaki 1781773465 numaralı tohumun FizzBuzz ilerlemesinde tekrarlayan 15 basamaklı diziyi üreteceği gerçeğini kullanır. Buradaki öncül, zekice randevuyu tahmin edilebilir bir sıraya sokmak için kandırmak istiyoruz. (Bilgi boyutunda gerçekte bir azalma elde etmediğimizi not etmek ilginçtir. 15 basamaklı dizi, bit çiftleri olarak kodlanabilir ve 30 bitlik bir sayı olarak saklanabilir. 1781773465 31 bit depolama gerektirdiğinden aslında bize biraz depolama verimliliğine mal oldu.

Ruby - 87 karakter

puts (0..99).map{|i|srand(46308667)if(i%15==0);["FizzBuzz","Buzz",i+1,"Fizz"][rand(4)]}

İşte daha kısa tohum kullanan farklı bir versiyon var ama arama tablosu farklı bir düzende. Kaynak kodun açıklaması:

İlk uygulama (89 karakter) 0 = int, 1 = Fizz, 2 = Buzz, 3 = FizzBuzz'ın belirli sırasına bağlıdır. Sipariş değişirse daha küçük bir anahtar bulmak mümkün olabilir. 24 olası permütasyon vardır. Eğer permütasyonların 2 * 31 uzaya eşit dağıldığını ve bunun "yaklaşık yarısı" olma ihtimalinin yaklaşık% 50 olasılığını varsayarsak, o zaman iyi bir güvence (% 20-50) olduğunu varsayabiliriz. 1.4e + 9 (2 * 28 altında ) civarında bir yere Çok fazla bir kazanç değil, ancak 30 bitlik alandan daha az bir sürede 30 bit bilgiyi "gizlemek" için rand'ın önceden tanımlanmış sırasını güçlendirdiğini gösteriyor.

Sonuç: Permütasyon [3,2,0,1], 26 bit olarak depolanabilen 46308667 numaralı tohumda görülür.

Python, 1 satır, 376 karakter

pep8-E501 ihmal edildi. Sadece python3 ile çalışır.

print(*((lambda x=x: ''.join(chr(c) for c in (102, 105)) + (2 * chr(122)) + ''.join(chr(c) for c in (98, 117)) + (2 * chr(122)) + '\n' if x % (30 >> 1) == 0 else ''.join(chr(c) for c in (102, 105)) + (2 * chr(122)) + '\n' if x % (6 >> 1) == 0 else ''.join(chr(c) for c in (98, 117)) + (2 * chr(122)) + '\n' if x % (10 >> 1) == 0 else str(x) + '\n')() for x in range(1, 101)))

Alternatif Yakut (126 karakter)

(1..100).map{|i|(x="\xF\3\5\1Rml6ekJ1eno=".unpack('C4m'))[-1]=~/(.*)(B.*)/
[*$~,i].zip(x).map{|o,d|i%d>0||(break $><<o<<?\n)}}

Kısa ve belirsiz, nasıl sevdiğimiz. 3 ve 5 aslında oradalar ancak tamsayı değişmezleri değil, bu yüzden hala önemli olduğunu düşünüyorum.

Bunun, kelimenin tam anlamıyla 'Fizz', 'Buzz', 'FizzBuzz' olmayan en kısa Ruby sürümü olduğunu unutmayın.

Gıcırtı (4.4) Smalltalk 206 bytes

|f i zz b u z|z:=''.b:=28r1J8D0LK. 1to:100do:[:o|0<(f:=(i:=(zz:=b\\4)//2*4)+(u:=zz\\2*4))or:[z:=z,o].b:=zz<<28+(b//4).z:=z,((z first:f)replaceFrom:1to:f with:28r1A041FHQIC7EJI>>(4-i*u*2)startingAt:1),'
'].z

Veya daha az belirgin mesajlarla aynı algoritma, aynı sayıda karakter

|l f i zz b u z|z:=#[].b:=36rDEB30W. 1to:100do:[:o|0<(f:=(i:=(zz:=b\\4)//2)+(u:=zz\\2)*4)or:[z:=z,('',o)].b:=zz<<28+(b//4).l:=36r2JUQE92ONA>>(1-u*i*24).1to:f do:[:k|z:=z,{l-((l:=l>>6)-1<<6)}].z:=z,'
'].'',z

Smalltalk'a yaptıklarım için Alan Kay'dan özür dilerim.
Bu kesmelerin bazıları Smalltalk lehçelerinde taşınabilir, bazıları Squeak uyum katmanı gerektirir ...

Bir Çalışma Alanında yürütürseniz, bildirimleri çıkartabileceğinizi unutmayın. Fi zz buz | ve 14 karakter kazanın.

357 karaktere ulaşabilirsek (tek harfle 315), o zaman önemsiz #to: do: loop:

|fizz buzz if f fi zz b u bu z|f:=fizz:=buzz:=0.z:=#[].b:=814090528.if:=[:i|i=0or:[fi:=28.zz:=27<<7+i.u:=26.(fizz:=[zz=0or:[z:=z,{(u:=u//2)\\2+1+(zz+((fi:=fi//2)\\2+2-(zz:=zz//8)*8)*4)}.fizz value]])value]].(buzz:=[(f:=f+1)>100or:[(fi:=(zz:=b\\4)//2*17)+(bu:=zz\\2*40)>0or:[z:=z,('',f)].b:=zz<<28+(b//4).if value:fi;value:bu.z:=z,'
'.buzz value]])value.'',z

Haskell 226 bayt, düzen için boşluk dahil;)

z=[fI$ (++)            \ 
(fi zz 1 "Fi" )        \  
(fi zz 2 "Bu" )        \ 
:[show zz]  | zz<-[1..]]
fI (zZ:zz)  | zZ==[]   \
= concat zz | 1==1=zZ  
fi zZ bu zz | zZ%bu=   \
(zz++"zz")  | 1==1=[] 
bu%zz=mod bu (zz*2+1)==0

'Gerçek' kod 160 bayttır ve sıkıştırılabilir, ancak o zaman fizz-buzz-ness'i kaybeder.

Çalıştır (güzel çıktı için):

putStrLn (unwords (take 20 z ))

Çıktı:

1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz 

Perl

use MIME::Base64;print map{map{(++$i,'Fizz','Buzz','FizzBuzz')[$_]."\n"}(3&ord,3&ord>>2,3&ord>>4,3&ord>>6)}split//,decode_base64"EAZJMIRBEgxhkARDGCTBEAZJMIRBEgxhkA"

2009'da yaptığım bir tane. Yine de çözülmesi oldukça kolay.

Düzenleme: Kahretsin, "Fizz" ve "Buzz!" :( Bunu değiştirdiğimi sanıyordum.

C 216 bayt

#define t(b) putchar(p+=b);
main(p,v,c){p=70;for(v=c=1;v<=p*2-40&&!(c=0);++v){if(!(v%(p/23))){t(0)t(35)t(17)t(0)++c;}if(!(v%(p/(14+c*9)))){t(-56+!c*52)t(51)t(5)t(0);++c;}if(c){t(-112)p+=60;}else printf("%i\n",v);}}