Erstellen Sie die kürzestmögliche verschleierte FizzBuzz-Implementierung.

Um als verschleiert zu gelten, muss mindestens eine der folgenden Bedingungen erfüllt sein:

1. Enthält keine der Wörter "Fizz", "Buzz" oder "FizzBuzz"
2. Enthält nicht die Nummern 3, 5 oder 15.
3. Verwenden Sie eine der oben genannten Angaben auf irreführende Weise.

Denken Sie daran: Das Ziel ist es, kurz und schwer zu folgen.

Das Codebeispiel, das diese Frage inspiriert hat, sieht folgendermaßen aus:

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 Zeichen

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

Sie würden also denken, GolfScript an sich ist bereits verschleiert, oder? Nun, nur um der Spezifikation zu folgen, habe ich beschlossen, dass das Programm weder "fizz", "buzz" noch die Nummern 3, 5 oder 15 enthält. :-)

Ja, es gibt einige Zahlen mit Vielfachen von 5, wie 25, 35, 90, 100 und 6875. Sind sie rote Heringe? Du entscheidest. ;-)

Javascript 97 Zeichen - überhaupt keine Zahlen

Zahlen? Wer braucht die Nummer, wenn Sie Javascript haben!

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

Hinweis: Es gibt eine Endlosschleife, die Sie auf die Sequenz hinweist.

Bonus (666 Zeichen)

• Keine Nummer
• Kein Buchstabe (wurde nur zforim gesamten Skript verwendet)

.

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

Python - 78 Zeichen

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 Bytes

So verschleiert sieht es aus wie zufälliger Müll.

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

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

C ++: 886 Zeichen

Ich habe versucht, das "Fizz" und das "Buzz" zu verbergen. kannst du sie sehen?

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

Hier habe ich versucht (ziemlich erfolgreich, wenn ich so sagen darf), etwas außer Buchstaben zu verbergen, und +-[];:=(die lebenswichtig und unmöglich zu verschleiern sind). Nachdem ich auf meinem Computer ungefähr 8482 erreicht habe, tritt ein Segfault auf. Dies hat jedoch mit Stack-Problemen zu tun, die sich auf die Art und Weise beziehen, wie die Rekursion implementiert wird. Die Lösung selbst ist richtig. 255 Bytes, wenn Sie das Leerzeichen entfernen (zum leichteren Lesen enthalten)

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

Das Einbetten mit der Einrückung war etwas schwierig.

Rubin, 4312 Zeichen

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

eval("                                                 

















































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

Brainfuck - 626 656

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

Geht von 1 bis 255

Brainfuck, 708 Zeichen

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

Eine Beschreibung der Funktionsweise finden Sie in meiner Frage zur Codeüberprüfung

Haskell - 147 142 138 Zeichen

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

Der Code ist 19 Zeichen länger als nötig, aber die Ästhetik hat sich gelohnt! Ich glaube, dass alle drei "Ziele" erfüllt sind.

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

𝔼𝕊𝕄𝕚𝕟, 33 Zeichen / 92 Byte (nicht konkurrenzfähig)

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

Try it here (Firefox only).

Diese Sprache ist viel zu OP für eingeschränkte Quellcode-Herausforderungen.

Javascript, 469 Bytes

Das war wahrscheinlich der lustigste, den ich je hatte.

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

Probieren Sie es hier aus

Ruby - 165 Zeichen

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

Dies war mein erster Versuch, Code Golf zu spielen. Ich hatte eine Menge Spaß. =)

Perl 6 (52 Bytes)

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

Lassen Sie mich hier eine Erklärung abgeben. Es ist der schlimmste Regelmissbrauch, den ich bei einer solchen Aufgabe begangen habe. Ich weiß, was Sie sagen - es ist offensichtlich Fizzund Buzzhier. Aber schauen wir uns die Regeln an.

Um als verschleiert zu gelten, muss mindestens eine der folgenden Bedingungen erfüllt sein :

Dies vermeidet 3, 5und 15. Daher ist es eine gültige und wirklich kurze Lösung.

Scala, 295 Zeichen

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

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

Obwohl ich nicht sicher bin, ob dies dem C-Standard entspricht :)
Es funktioniert jedoch. Unter Linux mit GCC also.

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

Dies ist mein erster Golf. Nicht die kürzeste, aber es ist ziemlich hässlich! Keine der verbotenen Zahlen oder String-Literale. 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))]

Nicht ganz die kürzeste, aber ich hoffe, der Leser wird den reinen Funktionsstil und die Erweiterbarkeit zu beliebig langen Zählungen zu schätzen wissen.

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

Ich könnte ein bisschen Golf spielen, aber es wäre mir lieber, wenn es etwas verschleierter wäre.

Python 2 - 54 Zeichen

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

Python 3 - 56 Zeichen

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

Wenn Sie nicht möchten, dass "FizzBuzz" angezeigt wird:

Python 2 - 58 Zeichen

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

Python 3 - 60 Zeichen

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

Oder wie man GolfScript mit Python schlägt;)

JavaScript 111 Zeichen - keine Schlüsselnummern

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 Zeichen

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

Könnte gekürzt werden, wenn ich andere Zahlen wie folgt einführe: (210 Zeichen insgesamt)

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

Beschlossen, das offensichtliche Wort Fizz und Buzz zu entfernen und für etwas mehr Verschleierung zu gehen. Die zweite ist kürzer als die erste, hängt jedoch etwas direkter von dem ab, was in der Ergänzung vorkommt.

Dies ist nicht gerade Golf, es sind ungefähr 120 Linien.

Ich dachte, ich würde etwas tun, das all das Spaßpotential für undefiniertes Verhalten mit der C ++ - Speicherverwaltung ausnutzt.

#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 Zeichen

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

Ich kann dieses Stück Brillanz nicht würdigen, aber ich konnte diese Frage nicht ohne meine verborgene Lieblingsimplementierung lassen :)

Die obige Implementierung wurde von David Brady geschrieben und stammt aus dem Ruby Gem von Fizzbuzz . Hier ist die Erklärung aus dem Quellcode:

Verwendet die Tatsache, dass der Startwert 1781773465 in Rubys Rand die 15-stellige Sequenz generiert, die sich im Verlauf von FizzBuzz wiederholt. Die Prämisse hier ist, dass wir rand geschickt dazu bringen wollen, eine vorhersehbare Sequenz zu liefern. (Es ist interessant zu bemerken, dass wir tatsächlich keine Verringerung der Informationsgröße erzielen. Die 15-stellige Sequenz kann als Bitpaar codiert und in einer 30-Bit-Zahl gespeichert werden. Da 1781773465 31 Bit Speicher benötigt, hat unsere Klugheit Das hat uns tatsächlich ein bisschen Speichereffizienz gekostet, aber das ist nicht der springende Punkt!

Rubin - 87 Zeichen

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

Hier ist eine andere Version, die einen kürzeren Startwert verwendet, die Nachschlagetabelle jedoch in einer anderen Reihenfolge. Hier ist die Erklärung aus dem Quellcode:

Die erste Implementierung (89 Zeichen) folgt der spezifischen Reihenfolge von 0 = int, 1 = Fizz, 2 = Buzz, 3 = FizzBuzz. Es kann möglich sein, einen kleineren Schlüssel zu finden, wenn die Reihenfolge geändert wird. Es gibt 24 mögliche Permutationen. Wenn wir davon ausgehen, dass die Permutationen gleichmäßig im 2 * 31-Raum verteilt sind und mit einer Wahrscheinlichkeit von etwa 50%, dass diese "etwa zur Hälfte" abgeschlossen ist, können wir mit anständiger Sicherheit (sagen wir 20-50%) davon ausgehen, dass es a gibt Schlüssel irgendwo um 1.4e + 9 (unter 2 * 28). Es ist nicht viel Gewinn, aber es demonstriert, wie man die vordefinierte Sequenz von rand nutzt, um 30 Informationsbits in weniger als 30 Raumbits zu "verstecken".

Ergebnis: Die Permutation [3,2,0,1] wird im Startwert 46308667 angezeigt, der in 26 Bit gespeichert werden kann.

Python, 1 Zeile, 376 Zeichen

pep8-E501 wird ignoriert. Funktioniert nur in 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)))

Alternativer Rubin (126 Zeichen)

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

Kurz und dunkel, wie es uns gefällt. Die 3 und die 5 sind eigentlich drin, aber nicht als Integer-Literale, also denke ich, dass das immer noch zählt.

Beachten Sie, dass dies die kürzeste Ruby-Version ist, bei der es hier kein wörtliches "Fizz", "Buzz" oder "FizzBuzz" gibt.

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

Oder derselbe Algorithmus mit weniger expliziten Nachrichten, die gleiche Anzahl von Zeichen

|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

Ich entschuldige mich bei Alan Kay für das, was ich Smalltalk angetan habe.
Einige dieser Hacks sind für Smalltalk-Dialekte portabel, andere erfordern eine Squeak-Kompatibilitätsebene ...

Beachten Sie, dass Sie bei der Ausführung in einem Arbeitsbereich Deklarationen | fi zz buz | auslassen können und gewinne 14 Zeichen.

Wenn wir uns 357 Zeichen leisten können (315 mit einzelnen Buchstaben), ist es besser, triviale #to: do: loop: zu vermeiden.

|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 Bytes, einschließlich des Leerzeichens für das Layout;)

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

Der 'echte' Code ist 160 Bytes und kann komprimiert werden, verliert dann aber das Summen.

Führen Sie es aus (für eine gute Ausgabe):

putStrLn (unwords (take 20 z ))

Ausgabe:

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"

Eine, die ich 2009 gemacht habe. Es ist jedoch ziemlich einfach herauszufinden.

Edit: Verdammt, es verwendet "Fizz" und "Buzz!" :( Ich dachte, ich hätte das geändert. Na egal.

C 216 Bytes

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