Utwórz najkrótszą możliwą zaciemnioną implementację FizzBuzz.

Aby uznać ją za zaciemnioną, powinna spełniać co najmniej jedno z poniższych:

1. Nie zawiera słów „Fizz”, „Buzz” ani „FizzBuzz”
2. Nie zawiera liczb 3, 5 ani 15.
3. Użyj któregokolwiek z powyższych w sposób wprowadzający w błąd.

Pamiętaj: celem jest bycie krótkim i trudnym do naśladowania.

Przykładowy kod, który zainspirował to pytanie:

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 znaków

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

Można by pomyśleć, że sam GolfScript jest już zaciemniony, prawda? Cóż, po prostu podążając za specyfikacją, zdecydowałem, że program nie będzie zawierał „fizz”, „buzz”, ani liczb 3, 5, ani 15. :-)

Tak, istnieją pewne liczby o wielokrotnościach 5, takie jak 25, 35, 90, 100 i 6875. Czy są to czerwone śledzie? Ty decydujesz. ;-)

JavaScript 97 znaków - w ogóle żadnych liczb

Liczby ? Kto potrzebuje numeru, gdy masz Javascript!

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

Uwaga: Istnieje nieskończona pętla, która ostrzega o sekwencji.

Bonus (666 znaków)

• Brak numeru
• Bez litery ( zforzostało użyte tylko w całym skrypcie)

.

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

Python - 78 znaków

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 bajtów

Więc zaciemnione wygląda na przypadkowe śmieci.

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

Stosowanie: $ gs -q -dNODISPLAY -dNOPROMPT file.ps

C ++: 886 znaków

Próbowałem ukryć „szum” i „szum”. Widzisz ich?

#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 ( 256255 bajtów)

Oto on, próbowałem (raczej skutecznie, jeśli sam mogę to powiedzieć) ukryć cokolwiek oprócz listów i +-[];:=(które są niezbędne i niemożliwe do zaciemnienia). Robi się segfault po osiągnięciu około 8482 na moim komputerze, ale ma to związek z problemami stosu związanymi ze sposobem realizacji rekurencji. Rozwiązanie samo jest prawdziwe. 255 bajtów, jeśli usuniesz spację (w celu ułatwienia odczytu). Ciesz się:

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

To było trochę trudne do osadzenia za pomocą wcięcia, więc sedno:

Ruby, 4312 znaków

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

eval("                                                 

















































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

Brainfuck - 626 656

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

Zaczyna od 1 do 255

Brainfuck, 708 znaków

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

Opis tego, jak to działa, jest dostępny w moim pytaniu dotyczącym recenzji kodu

Haskell - 147 142 138 znaków

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 jest o 19 znaków dłuższy, niż powinien, ale myślałem, że estetyka była tego warta! Uważam, że wszystkie trzy „cele” są spełnione.

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

𝔼𝕊𝕄𝕚𝕟, 33 znaki / 92 bajty (niekonkurencyjne)

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

Try it here (Firefox only).

Ten język jest zbyt OP dla ograniczonych źródeł.

JavaScript, 469 bajtów

To była chyba najlepsza zabawa, jaką kiedykolwiek miałem.

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

Wypróbuj tutaj

Rubin - 165 znaków

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

To była moja pierwsza próba golfa kodowego. Dobrze się bawiłem. =)

Perl 6 (52 bajty)

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

Pozwól mi wyjaśnić tutaj. To najgorsze nadużycie zasady, jakie popełniłem w takim zadaniu. Wiem, co mówisz - jest oczywiste Fizzi Buzztutaj. Ale spójrzmy na zasady.

Aby uznać ją za zaciemnioną, powinna spełniać co najmniej jedno z poniższych:

W ten sposób unika 3, 5i 15. Dlatego jest to ważne i bardzo krótkie rozwiązanie.

Scala, 295 znaków

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 znaków)

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

Chociaż nie jestem pewien, czy jest to zgodne ze standardem C :)
Jednak to działa. To znaczy w systemie Linux za pomocą 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()

To jest mój pierwszy golf. Nie najkrótszy, ale jest dość brzydki! Żadna z niedozwolonych liczb lub literałów łańcuchowych. 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))]

Nie do końca najkrótszy, ale mam nadzieję, że czytelnik doceni czysty funkcjonalny styl i możliwość rozszerzenia na dowolnie długie rachunki.

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

Mógłbym trochę zagrać w golfa, ale wolałbym, żeby był bardziej zaciemniony.

Python 2 - 54 znaków

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

Python 3 - 56 znaków

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

Jeśli nie chcesz, aby pojawiał się „FizzBuzz”:

Python 2 - 58 znaków

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

Python 3 - 60 znaków

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

Lub jak pokonać GolfScript za pomocą Pythona;)

JavaScript 111 znaków - bez kluczowych numerów

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 znaków

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

Mógłbym zostać skrócony, gdybym wprowadził inne liczby takie: (łącznie 210 znaków)

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

Postanowiłem usunąć oczywiste słowo „musować” i „bzyczeć” i wybrać nieco więcej zaciemnienia. Drugi jest krótszy niż pierwszy, ale jest nieco bardziej bezpośredni w stosunku do tego, co dzieje się w dodatku.

To nie jest dokładnie gra w golfa, ma około 120 linii.

Pomyślałem, że zrobię coś, co wykorzysta cały zabawny potencjał nieokreślonego zachowania dzięki zarządzaniu pamięcią 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);
}

Rubin - 89 znaków

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

Nie mogę uwierzyć w ten błyskotliwość, ale nie mogłem zostawić tego pytania bez mojej ulubionej zaciemnionej implementacji :)

Powyższe wdrożenie zostało napisane przez Davida Brady'ego i pochodzi z rubinowego klejnotu fizzbuzz . Oto wyjaśnienie z kodu źródłowego:

Wykorzystuje fakt, że ziarno 1781773465 w randie Ruby wygeneruje 15-cyfrową sekwencję, która powtarza się w trakcie FizzBuzz. Założeniem tutaj jest to, że chcemy sprytnie oszukać Rand w celu zapewnienia przewidywalnej sekwencji. (Warto zauważyć, że tak naprawdę nie uzyskujemy zmniejszenia rozmiaru informacji. 15-cyfrowa sekwencja może być kodowana jako para bitów i przechowywana w 30-bitowej liczbie. Ponieważ 1781773465 wymaga 31 bitów pamięci, nasza sprytność ma faktycznie kosztowało nas trochę wydajności przechowywania. ALE TO NIE PUNKT!

Rubin - 87 znaków

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

Oto inna wersja, która używa krótszego ziarna, ale tabela odnośników jest w innej kolejności. Oto wyjaśnienie z kodu źródłowego:

Pierwsza implementacja (89 znaków) przestrzega określonej kolejności 0 = int, 1 = Fizz, 2 = Buzz, 3 = FizzBuzz. W przypadku zmiany kolejności może być możliwe znalezienie mniejszego klucza. Możliwe są 24 kombinacje. Jeśli założymy, że permutacje są równomiernie rozmieszczone w przestrzeni 2 * 31 i istnieje około 50% prawdopodobieństwa, że ​​ta jest „w połowie drogi”, wówczas możemy założyć z przyzwoitą pewnością (powiedzmy 20-50%), że istnieje klucz gdzieś około 1,4e + 9 (poniżej 2 * 28). To niewiele, ale pokazuje, że wykorzystuje predefiniowaną sekwencję Rand, aby „ukryć” 30 bitów informacji na mniej niż 30 bitach przestrzeni.

Wynik: permutacja [3,2,0,1] pojawia się w ziarnie 46308667, który można zapisać w 26 bitach.

Python, 1 linia, 376 znaków

pep8-E501 zignorowano. Działa tylko w 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)))

Alternatywny Rubin (126 znaków)

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

Krótkie i niejasne, tak jak lubimy. 3 i 5 są w rzeczywistości, ale nie jako literały całkowite, więc myślę, że to wciąż się liczy.

Zauważ, że jest to najkrótsza wersja Rubiego bez dosłownego „Fizz”, „Buzz”, „FizzBuzz”.

Squeak (4.4) Smalltalk 206 bajtów

|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

Lub ten sam algorytm z mniej wyraźnymi komunikatami, taką samą liczbą znaków

|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

Przepraszam Alana Kay za to, co zrobiłem Smalltalk.
Niektóre z tych hacków są przenośne w dialektach Smalltalk, niektóre wymagałyby warstwy kompatybilności Squeak ...

Zauważ, że jeśli wykonujesz w obszarze roboczym, możesz pominąć deklaracje | fi zz buz | i zdobądź 14 znaków.

Jeśli stać nas na 357 znaków (315 z pojedynczymi zmiennymi literowymi), lepiej unikać trywialnego #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 bajtów, w tym spacja dla układu;)

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

„Rzeczywisty” kod ma 160 bajtów i można go skompresować, ale wtedy traci fizyczny szum.

Uruchom (dla dobrego wyniku):

putStrLn (unwords (take 20 z ))

Wynik:

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"

Jeden, który zrobiłem w 2009 roku. Jednak dość łatwo to rozgryźć.

Edycja: Cholera, używa „Fizz” i „Buzz!” :( Myślałem, że to zmieniłem. Nieważne.

C 216 bajtów

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