สร้าง FizzBuzz ที่สั้นที่สุดเท่าที่จะเป็นไปได้

หากต้องการได้รับการพิจารณาว่าสับสนต้องมีสิ่งต่อไปนี้อย่างน้อยหนึ่งอย่าง:

1. ไม่มีคำใด ๆ "Fizz", "Buzz" หรือ "FizzBuzz"
2. ไม่มีตัวเลข 3, 5 หรือ 15
3. ใช้ข้อใดข้อหนึ่งในวิธีที่ทำให้เข้าใจผิด

ข้อควรจำ: เป้าหมายนั้นต้องสั้นและยากที่จะติดตาม

ตัวอย่างโค้ดที่เป็นแรงบันดาลใจของคำถามนี้เป็นดังนี้:

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 ตัวอักษร

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

ดังนั้นคุณคิดว่า GolfScript ด้วยตัวเองนั้นงงงวยใช่ไหม? ดีเพียงทำตามข้อมูลจำเพาะฉันตัดสินใจที่จะให้โปรแกรมไม่มี "fizz", "buzz" หรือหมายเลข 3, 5, หรือ 15 :-)

ใช่มีตัวเลขบางตัวที่มีทวีคูณของ 5 เช่น 25, 35, 90, 100 และ 6875 พวกมันเป็นปลาเฮอริ่งแดงหรือไม่ คุณตัดสินใจ. ;-)

Javascript 97 chars - ไม่มีตัวเลขเลย

ตัวเลขเหรอ ใครต้องการหมายเลขเมื่อคุณมี Javascript!

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

หมายเหตุ: มีการวนซ้ำไม่สิ้นสุดที่จะแจ้งเตือนคุณลำดับ

โบนัส (666 ตัวอักษร)

• ไม่มีหมายเลข
• ไม่มีตัวอักษร(ใช้ได้เฉพาะzforในสคริปต์ทั้งหมด)

.

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

Python - 78 ตัวอักษร

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 ไบต์

งงดังนั้นดูเหมือนขยะสุ่ม

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

การใช้งาน: $ gs -q -dNODISPLAY -dNOPROMPT file.ps

C ++: 886 ตัวอักษร

ฉันพยายามซ่อน 'ฟอง' และ 'Buzz' คุณสามารถมองเห็นพวกเขา?

#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 ไบต์)

ที่นี่คือฉันพยายาม (ค่อนข้างประสบความสำเร็จถ้าฉันพูดด้วยตัวเอง) เพื่อซ่อนอะไรยกเว้นตัวอักษรและ+-[];:=(ซึ่งสำคัญและเป็นไปไม่ได้ที่จะทำให้งงงวย) มันเป็น segfault หลังจากไปถึงประมาณ 8482 หรือมากกว่านั้นบนเครื่องของฉัน แต่นั่นคือสิ่งที่เกี่ยวข้องกับปัญหาสแต็กที่เกี่ยวข้องกับวิธีการเรียกใช้ซ้ำ วิธีแก้ไขนั้นถูกต้อง 255 ไบต์ถ้าคุณลบช่องว่าง (รวมเพื่อความสะดวกในการอ่าน) เพลิดเพลินกับ:

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

นี่เป็นเรื่องยุ่งยากเล็กน้อยที่จะฝังโดยใช้การเยื้องเพื่อส่วนสำคัญ

ทับทิม 4312 ตัวอักษร

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

eval("                                                 

















































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

Brainfuck - 626 656

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

ไปจาก 1 ถึง 255

Brainfuck, 708 ตัวละคร

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

คำอธิบายวิธีการทำงานมีอยู่ในคำถามตรวจสอบโค้ดของฉัน

Haskell - 147 142 138 ตัวอักษร

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..]

รหัสนี้ยาวเกิน 19 ตัวอักษร แต่ฉันคิดว่าความสวยงามนั้นคุ้มค่า! ฉันเชื่อว่า "วัตถุประสงค์" ทั้งสามข้อพอใจ

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

𝔼𝕊𝕄𝕚𝕟, 33 ตัวอักษร / 92 ไบต์ (ไม่มีการแข่งขัน)

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

Try it here (Firefox only).

ภาษานี้เป็นวิธี OP เกินไปสำหรับความท้าทายแหล่งที่ จำกัด

Javascript, 469 ไบต์

นี่อาจสนุกที่สุดที่ฉันเคยมีมา

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

ลองที่นี่

Ruby - 165 ตัวอักษร

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

นี่เป็นความพยายามครั้งแรกของฉันที่การตีกอล์ฟ ฉันสนุกมาก. =)

Perl 6 (52 ไบต์)

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

ให้ฉันอธิบายที่นี่ มันเป็นการละเมิดกฎที่แย่ที่สุดที่ฉันเคยทำในงานนี้ ฉันรู้ว่าคุณกำลังพูดอะไร - มีความชัดเจนFizzและBuzzที่นี่ แต่ลองมาดูกฎ

หากต้องการได้รับการพิจารณาว่าสับสนต้องมีสิ่งต่อไปนี้อย่างน้อยหนึ่งข้อ:

นี้หลีกเลี่ยงการ3, และ5 15ดังนั้นจึงเป็นวิธีที่ถูกต้องและสั้นจริง ๆ

สกาลา, 295 ตัวอักษร

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 ตัวอักษร)

#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);}

แม้ว่าฉันไม่แน่ใจว่านี้เป็นไปตามมาตรฐาน C :)
มันใช้งานได้ บน Linux ที่ใช้ GCC นั่นคือ

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

นี่คือสนามกอล์ฟครั้งแรกของฉัน ไม่สั้นที่สุด แต่ก็น่าเกลียดทีเดียว! ไม่มีตัวเลขต้องห้ามหรือตัวอักษรสตริง เฟอร์เรอ!

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

ไม่ใช่เรื่องที่สั้นที่สุด แต่ฉันหวังว่าผู้อ่านจะได้ชื่นชมสไตล์การใช้งานที่บริสุทธิ์และความสามารถในการขยายไปถึงการนับที่มีความยาวโดยพลการ

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

ฉันตีกอล์ฟได้เล็กน้อย แต่ฉันค่อนข้างจะสับสนมากกว่า

Python 2 - 54 ตัวอักษร

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

Python 3 - 56 ตัวอักษร

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

หากคุณไม่ต้องการให้ 'FizzBuzz' ปรากฏ:

Python 2 - 58 ตัวอักษร

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

Python 3 - 60 ตัวอักษร

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

หรือวิธีเอาชนะ GolfScript ด้วย Python;)

จาวาสคริปต์ 111 ตัวอักษร - ไม่มีหมายเลขสำคัญ

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 ตัวอักษร

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+"");}}

อาจสั้นลงถ้าฉันแนะนำหมายเลขอื่นเช่น: (ทั้งหมด 210 ตัวอักษร)

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+"");}}

ตัดสินใจที่จะลบคำที่ชัดเจนฟองและฉวัดเฉวียนและไปสำหรับความสับสนมากขึ้นเล็กน้อย อันที่สองนั้นสั้นกว่าอันแรก แต่จะตรงกับสิ่งที่เกิดขึ้นเพิ่มเติมเล็กน้อย

นี่ไม่ใช่สนามกอล์ฟที่แน่นอนมีประมาณ 120 บรรทัด

ฉันคิดว่าฉันจะทำสิ่งที่ใช้ประโยชน์จากความสนุกที่อาจเกิดขึ้นสำหรับพฤติกรรมที่ไม่ได้กำหนดด้วยการจัดการหน่วยความจำ C ++

#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 ตัวอักษร

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

ฉันไม่สามารถรับเครดิตสำหรับความสามารถนี้ได้ แต่ฉันไม่สามารถทิ้งคำถามนี้ไว้ได้หากไม่มีการใช้งานที่ฉันชื่นชอบ :)

การดำเนินการข้างต้นถูกเขียนขึ้นโดย David Brady และมาจากอัญมณีทับทิมfizzbuzz นี่คือคำอธิบายจากซอร์สโค้ด:

ใช้ความจริงที่ว่าเมล็ด 1781773465 ในแรนด์ของรูบี้จะสร้างลำดับ 15 หลักที่ซ้ำกันในการก้าวหน้าของ FizzBuzz หลักฐานที่นี่คือว่าเราต้องการหลอก rand อย่างชาญฉลาดในการส่งมอบลำดับที่คาดเดาได้ (เป็นที่น่าสนใจที่จะทราบว่าเราไม่ได้ลดขนาดข้อมูลลงไปจริง ๆ แล้วลำดับ 15 หลักสามารถเข้ารหัสเป็นบิตคู่และเก็บไว้ในจำนวน 30 บิตเนื่องจาก 1781773465 ต้องใช้พื้นที่จัดเก็บ 31 บิตความฉลาดของเรามี อันที่จริงเราเสียค่าใช้จ่ายเล็กน้อยของประสิทธิภาพการจัดเก็บ แต่นั่นไม่ใช่จุด!

Ruby - 87 ตัวอักษร

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

นี่คือเวอร์ชันอื่นที่ใช้เมล็ดสั้นกว่า แต่ตารางค้นหาอยู่ในลำดับที่แตกต่างกัน นี่คือคำอธิบายจากซอร์สโค้ด:

การใช้งานครั้งแรก (89 ตัวอักษร) ปฏิบัติตามคำสั่งเฉพาะของ 0 = int, 1 = Fizz, 2 = Buzz, 3 = FizzBuzz อาจเป็นไปได้ที่จะหาคีย์ที่เล็กกว่าหากการสั่งซื้อนั้นเปลี่ยนไป มีการเรียงสับเปลี่ยนที่เป็นไปได้ 24 แบบ หากเราสมมติว่าการเรียงสับเปลี่ยนมีการกระจายอย่างสม่ำเสมอทั่วทั้งพื้นที่ 2 * 31 และมีความน่าจะเป็น 50% ที่อันนี้คือ "ประมาณครึ่งทาง" เราก็สามารถสรุปด้วยความมั่นใจที่เหมาะสม (พูด 20-50%) ว่ามี ใส่ที่อื่นประมาณ 1.4e +9 (ต่ำกว่า 2 * 28) มันไม่ได้กำไรมากนัก แต่มันแสดงให้เห็นถึงการใช้ประโยชน์จากลำดับที่กำหนดไว้ล่วงหน้าของ rand เพื่อ "ซ่อน" 30 บิตของข้อมูลในพื้นที่น้อยกว่า 30 บิต

ผลลัพธ์: การเรียงสับเปลี่ยน [3,2,0,1] ปรากฏที่เมล็ด 46308667 ซึ่งสามารถเก็บไว้ใน 26 บิต

Python 1 บรรทัด, 376 ตัวอักษร

pep8-E501 ถูกละเว้น ใช้งานได้ใน python3 เท่านั้น

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

Ruby สำรอง (126 ตัวอักษร)

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

สั้นและคลุมเครือเพียงแค่เราชอบมัน 3 และ 5 นั้นมีอยู่ในนั้นจริง ๆ แต่ไม่ได้เป็นตัวอักษรจำนวนเต็มดังนั้นฉันคิดว่ามันยังคงนับ

โปรดทราบว่านี่เป็นรุ่น Ruby ที่สั้นที่สุดโดยไม่มี 'Fizz', 'Buzz', 'FizzBuzz' ที่แท้จริงที่นี่

Squeak (4.4) Smalltalk 206 ไบต์

|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

หรืออัลกอริทึมเดียวกันกับข้อความที่ชัดเจนน้อยกว่าจำนวนตัวอักษร

|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 บางคนอาจต้องการเลเยอร์ความเข้ากันได้ของสารภาพ ...

โปรดทราบว่าถ้าคุณดำเนินการในพื้นที่ทำงานคุณสามารถละเว้นการประกาศ | fi zz buz | และได้รับ 14 ตัวอักษร

หากเราสามารถจ่ายได้ 357 ตัวอักษร (315 กับตัวอักษรเดี่ยว vars) ดังนั้นจะเป็นการดีกว่าที่จะหลีกเลี่ยงการ #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 ไบต์รวมถึงช่องว่างสำหรับการจัดวาง;)

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

รหัส 'ของจริง' คือ 160 ไบต์และสามารถบีบอัดได้ แต่จะสูญเสีย fizz-buzz-ness แล้ว

เรียกใช้ (สำหรับผลลัพธ์ที่ดี):

putStrLn (unwords (take 20 z ))

เอาท์พุท:

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 มันค่อนข้างง่ายที่จะคิดออก

แก้ไข: Darn ใช้ "Fizz" และ "Buzz!" :( ฉันคิดว่าฉันเปลี่ยนสิ่งนั้นไม่เป็นไรแล้ว

C 216 ไบต์

#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);}}