Verschleierter FizzBuzz Golf [geschlossen]


50

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

Woher kennst du die Grenze? In Ihrer Lösung haben Sie ms.Length, aber in einigen Lösungen gibt es keine solche Grenze ...
Labo

Ich stimme dafür, diese Frage als "Off-Topic" zu schließen, da es kein objektives Gültigkeitskriterium gibt, das es unmöglich macht, unbestreitbar zu entscheiden, ob eine Einreichung den Regeln entspricht.
Dennis

Antworten:


25

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


2
Obwohl ich für alle meine anderen GolfScript-Beiträge einen Kommentar verfasst habe, wird für diesen keiner erscheinen. Begründung: chat.stackexchange.com/transcript/message/436819#436819 :-D
Chris Jester-Young

Die Zahlen 3 und 5 erscheinen in Ihrem Code, es ist also nicht korrekt !!!
Labo

@Labo Nur eines der Kriterien muss erfüllt sein, nicht alle drei. Lesen Sie die Frage noch einmal. :-)
Chris Jester-Young

Ist es ein Witz ? Ich verbringe mehrere Stunden damit! Obwohl ich es immer noch geschafft habe, einen 58 Zeichen langen Python-Code zu haben: p codegolf.stackexchange.com/a/63543/47040
Labo

4
@Labo: Ich kann die Ziffern 3 und 5 sehen, aber nicht die Ziffern 3 und 5.
David Ongaro

65

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)

.

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

18
Echte Programmierer codieren genau wie der zweite.

9
@ M28: Ja. Das ist eine Möglichkeit, die Sicherheit von Arbeitsplätzen zu erhöhen. Denn jemanden zu finden, der diesen Code verwalten kann, wäre nicht die einfachste Sache.
Andy

1
Sie können window ["eval"] ('"\\' + 1 + 7 + 2 + '"') für verwenden z.
Nabb

3
@stevether Es geht hauptsächlich darum, die Typkonvertierung zu missbrauchen (Beispiel: +!![]ist dasselbe wie 1und ({}+"")[5]ist dasselbe wie c) und die Array-Notation für die Zugriffsmethode zu missbrauchen (Beispiel: window['eval'](ist dasselbe eval().
HoLyVieR

1
Geeignete Zeichenanzahl, falls ich jemals eines gesehen habe.
Captncraig

26

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

1
Ich habe 10 Minuten gebraucht, um zu verstehen, was Sie dort gemacht haben. Schön und verdreht.
Trufa

23

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


5
Ich wette, das geht kaputt .
KaoD

23

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;

5
Das verwirrt mich.
Mateen Ulhaq

2
Ich denke, Sie meinten Membran
Korvin Szanto

16

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

+1 für dc. Natürlich ist es auch ohne Verschleierung nicht besonders lesbar .
Jesse Millikan


11

Brainfuck - 626 656

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

Geht von 1 bis 255


1
Es stellt sich heraus, dass BuzzFizz dies tatsächlich tut. FizzBuzz wird für% 15 korrekt angezeigt, es werden jedoch% 3 und% 5 ausgetauscht. Ich kann versuchen, es zu beheben, aber im Moment ist mein Gehirn offiziell F'ed
captncraig

2
Zum Preis von 30 repariert. Hätte mit Mühe mehr Golf spielen können, aber ich habe schon genug Zeit damit verschwendet.
captncraig

9
"Waste" ist ein starkes Wort ...
Claudiu

10

Brainfuck, 708 Zeichen

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

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


9

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

Hallo, ich versuche, Ihren Code zu verstehen, kann ihn aber nicht ausführen! Die Funktion zZ' is applied to six arguments, but its type (a0 -> b0 -> c0) -> [a0] -> [b0] -> [c0] 'hat nur drei
RobAu

Und ich bekomme, während ich es ausführen kann, nur ["1","2","3","4","5","6"...].
Artyom

Behoben - Die richtige Version war noch auf meiner Festplatte ... muss den Text vor langer Zeit falsch eingefügt haben!
MtnViewMark

Bitte geben Sie an, wie es um 19 Zeichen gekürzt werden kann, oder geben Sie den Code an. Ich bin neugierig und ich habe keine Ahnung
stolzer Haskeller

Es gibt 19 occurrances von 2 Buchstabenamen: bu, fi, zz, und zZ. Diese können auf einen Buchstaben gekürzt werden.
MtnViewMark

8

𝔼𝕊𝕄𝕚𝕟, 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.


6

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


Verdammt, mir ist gerade klar geworden, dass das Ziel darin bestand, kurz und schwer zu halten ... Entschuldigung: P
anOKsquirrel

+1
Könnte

4

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ß. =)


4

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.


3

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="";}}

3

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.


3

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!


3

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.


3

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.


3

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


Die ersten beiden scheinen nichts zu tun, da i=0die whileSchleife nie betreten wird.
xnor

Lol ich habe meine Testversion benutzt, in der der Zustand ist i<20.
Labo

Aber jetzt funktioniert es :)
Labo

Sollte es nach dem ursprünglichen FizzBuzz-Problem nicht bei 100 enden?
David Ongaro

2

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


2

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.


2

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

2

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.


2
sehr süß, enthält aber ein wörtliches "Fizz", "Buzz" usw. Also nicht gültig nach den Regeln
Arne Brasseur

2

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

2

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.


1

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

1

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 

0

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.


0

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);}}
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.