Tạo triển khai FizzBuzz khó hiểu nhất có thể.

Để được coi là bị xáo trộn, nó cần đáp ứng ít nhất một trong những điều sau đây:

1. Không chứa bất kỳ từ nào "Fizz", "Buzz" hoặc "FizzBuzz"
2. Không chứa các số 3, 5 hoặc 15.
3. Sử dụng bất kỳ điều nào ở trên một cách sai lệch.

Hãy nhớ rằng: Mục tiêu là ngắn và khó theo dõi.

Mẫu mã đã truyền cảm hứng cho câu hỏi này như sau:

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 ký tự

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

Vì vậy, bạn nghĩ rằng bản thân GolfScript đã bị xáo trộn, phải không? Chà, chỉ để làm theo thông số kỹ thuật, tôi quyết định chương trình không chứa "fizz", "buzz", cũng không phải các số 3, 5, cũng không phải 15. :-)

Vâng, có một số số có bội số của 5, như 25, 35, 90, 100 và 6875. Chúng có phải là cá trích đỏ không? Bạn quyết định. ;-)

Ký tự Javascript 97 - không có số nào cả

Số? Ai cần số khi bạn có Javascript!

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

Lưu ý: Có một vòng lặp vô hạn sẽ cảnh báo bạn trình tự.

Tiền thưởng (666 ký tự)

• Không có số
• Không có chữ cái (chỉ zforđược sử dụng trong toàn bộ tập lệnh)

.

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

Python - 78 ký tự

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 byte

Vì vậy, obfuscated nó trông giống như rác ngẫu nhiên.

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

Sử dụng: $ gs -q -dNODISPLAY -dNOPROMPT file.ps

C ++: 886 ký tự

Tôi đã cố gắng để ẩn 'fizz' và 'buzz'. Bạn có thể nhận ra chúng không?

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

Đây là, tôi đã cố gắng (khá thành công, nếu tôi có thể tự nói như vậy) để che giấu bất cứ điều gì ngoại trừ các chữ cái, và +-[];:=(điều này rất quan trọng và không thể che giấu ). Nó thực hiện segfault sau khi nhận được khoảng 8482 hoặc hơn trên máy của tôi, nhưng đó là để thực hiện với các vấn đề ngăn xếp liên quan đến cách thực hiện đệ quy. Các giải pháp chính nó là chính xác. 255 byte nếu bạn xóa khoảng trắng (bao gồm để dễ đọc) Thưởng thức:

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

Đây là một chút khó khăn để nhúng bằng cách sử dụng thụt đầu dòng nên một ý chính:

Ruby, 4312 ký tự

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

eval("                                                 

















































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

Brainfuck - 626 656

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

Đi từ 1 đến 255

Brainfuck, 708 ký tự

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

Mô tả về cách thức hoạt động có sẵn trong câu hỏi Đánh giá mã của tôi

Haskell - 147 142 138 ký tự

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

Mã dài hơn 19 ký tự cần thiết, nhưng tôi nghĩ tính thẩm mỹ là xứng đáng! Tôi tin rằng cả ba "mục tiêu" đều hài lòng.

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

, 33 ký tự / 92 byte (không cạnh tranh)

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

Try it here (Firefox only).

Ngôn ngữ này quá OP cho các thách thức nguồn bị hạn chế.

Javascript, 469 byte

Đây có lẽ là niềm vui nhất tôi từng có.

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

Hãy thử nó ở đây

Ruby - 165 ký tự

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

Đây là nỗ lực đầu tiên của tôi tại mã golf. Tôi đã có rất nhiều niềm vui. =)

Perl 6 (52 byte)

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

Hãy để tôi đặt một lời giải thích ở đây. Đó là sự lạm dụng quy tắc tồi tệ nhất mà tôi đã thực hiện trong nhiệm vụ đó. Tôi biết những gì bạn đang nói - có rõ ràng Fizzvà Buzzở đây. Nhưng hãy xem các quy tắc.

Để được coi là bị xáo trộn, cần đáp ứng ít nhất một trong những điều sau đây:

Điều này tránh 3, 5và 15. Vì vậy, đó là giải pháp hợp lệ và thực sự ngắn.

Scala, 295 ký tự

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 ký tự)

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

Mặc dù tôi không chắc điều này phù hợp với tiêu chuẩn C :)
Mặc dù vậy nó vẫn hoạt động. Trên Linux sử dụng GCC, đó là.

Con trăn 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()

Đây là sân golf đầu tiên của tôi. Không phải là ngắn nhất, nhưng nó khá xấu xí! Không có số bị cấm hoặc chuỗi ký tự. Firp, ợ!

Con trăn - 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))]

Không hoàn toàn ngắn nhất, nhưng tôi hy vọng người đọc sẽ đánh giá cao phong cách chức năng thuần túy và khả năng mở rộng để đếm dài tùy ý.

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

Tôi có thể chơi golf khá nhiều nhưng tôi thích nó hơn.

Python 2 - 54 ký tự

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

Python 3 - 56 ký tự

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

Nếu bạn không muốn 'FizzBuzz' xuất hiện:

Python 2 - 58 ký tự

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

Python 3 - 60 ký tự

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

Hoặc cách đánh GolfScript bằng Python;)

Ký tự JavaScript 111 - không có số chính

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 ký tự

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

Có thể rút ngắn nếu tôi giới thiệu các số khác như vậy: (tổng cộng 210 ký tự)

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

Quyết định loại bỏ từ fizz và buzz rõ ràng và đi cho hơi khó hiểu hơn một chút. Cái thứ hai ngắn hơn cái thứ nhất nhưng hơi trực tiếp hơn về những gì xảy ra trong phần bổ sung.

Đây không phải là golf chính xác, khoảng 120 dòng.

Tôi nghĩ rằng tôi đã làm một cái gì đó tận dụng tất cả tiềm năng thú vị cho hành vi không xác định với quản lý bộ nhớ 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 ký tự

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

Tôi không thể tin tưởng vào sự sáng chói này, nhưng tôi không thể để lại câu hỏi này mà không có sự thực hiện khó hiểu yêu thích của mình :)

Việc thực hiện ở trên được viết bởi David Brady và là từ đá quý ruby fizzbuzz . Dưới đây là lời giải thích từ mã nguồn:

Sử dụng thực tế là hạt giống 1781773465 trong rand của Ruby sẽ tạo ra chuỗi 15 chữ số lặp lại trong tiến trình FizzBuzz. Tiền đề ở đây là chúng tôi muốn khéo léo lừa rand để đưa ra một chuỗi dự đoán. (Thật thú vị khi lưu ý rằng chúng tôi thực sự không giảm kích thước thông tin. Chuỗi 15 chữ số có thể được mã hóa dưới dạng các cặp bit và được lưu trữ trong một số 30 bit. Từ 1781773465 cần 31 bit lưu trữ, sự thông minh của chúng tôi có thực sự tiêu tốn của chúng tôi một chút hiệu quả lưu trữ. NHƯNG ĐÓ KHÔNG PHẢI LÀ ĐIỂM!

Ruby - 87 ký tự

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

Đây là một phiên bản khác sử dụng hạt giống ngắn hơn nhưng bảng tra cứu theo thứ tự khác. Dưới đây là lời giải thích từ mã nguồn:

Việc thực hiện đầu tiên (89 ký tự) tuân thủ thứ tự cụ thể là 0 = int, 1 = Fizz, 2 = Buzz, 3 = FizzBuzz. Có thể tìm thấy một khóa nhỏ hơn nếu thứ tự được thay đổi. Có 24 hoán vị có thể. Nếu chúng ta giả sử rằng các hoán vị được phân bổ đều trong không gian 2 * 31 và khoảng 50% xác suất rằng cái này là "khoảng một nửa", thì chúng ta có thể giả định với độ tin cậy khá (giả sử 20-50%) rằng có một phím ở đâu đó khoảng 1,4e + 9 (dưới 2 * 28). Nó không thu được nhiều nhưng nó KHÔNG thể hiện việc tận dụng chuỗi được xác định trước của rand để "ẩn" 30 bit thông tin trong khoảng không gian 30 bit đó.

Kết quả: Hoán vị [3,2,0,1] xuất hiện tại seed 46308667, có thể được lưu trữ trong 26 bit.

Python, 1 dòng, 376 ký tự

pep8-E501 bỏ qua. Chỉ hoạt động trong 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 thay thế (126 ký tự)

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

Ngắn và tối nghĩa, chỉ là cách chúng tôi thích nó. 3 và 5 thực sự nằm trong đó nhưng không phải là số nguyên nên tôi nghĩ rằng vẫn còn tính.

Lưu ý rằng đây là phiên bản Ruby ngắn nhất không có chữ 'Fizz', 'Buzz', 'FizzBuzz' ở đây.

Squeak (4.4) Smalltalk 206 byte

|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

Hoặc cùng một thuật toán với các thông điệp ít rõ ràng hơn, cùng số lượng ký tự

|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

Tôi xin lỗi Alan Kay vì những gì tôi đã làm với Smalltalk.
Một số hack này có thể di động trên các phương ngữ Smalltalk, một số sẽ yêu cầu lớp tương thích Squeak ...

Lưu ý rằng nếu bạn thực thi trong Vùng làm việc, bạn có thể bỏ qua các khai báo | fi zz buz | và đạt được 14 ký tự.

Nếu chúng ta có thể đủ khả năng 357 ký tự (315 với các chữ cái đơn), thì tốt hơn hết là tránh tầm thường #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 byte, bao gồm cả khoảng trắng để bố trí;)

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

Mã 'thực' là 160 byte và có thể được nén, nhưng sau đó mất fizz-buzz-ness.

Chạy nó (cho đầu ra tốt đẹp):

putStrLn (unwords (take 20 z ))

Đầu ra:

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"

Một cái tôi đã làm vào năm 2009. Mặc dù vậy, nó khá dễ để tìm ra.

Chỉnh sửa: Darn, nó sử dụng "Fizz" và "Buzz!" :( Tôi nghĩ rằng tôi đã thay đổi điều đó. Nevermind sau đó.

C 216 byte

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