Obfuscated FizzBuzz Golf [zamknięte]

50

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);
        }
}
mootinator
źródło
Skąd znasz granicę? W swoim rozwiązaniu masz ms.Length, ale w niektórych rozwiązaniach nie ma takiego ograniczenia ...
Labo
Głosuję za zamknięciem tego pytania jako nie na temat, ponieważ nie ma ono obiektywnego kryterium ważności, co uniemożliwia bezdyskusyjne rozstrzygnięcie, czy zgłoszenie jest zgodne z zasadami.
Dennis,

Odpowiedzi:

25

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

Chris Jester-Young
źródło
2
Mimo że napisałem komentarz do wszystkich innych zgłoszeń GolfScript, żadne z nich nie będzie dostępne w tym przypadku. Uzasadnienie: chat.stackexchange.com/transcript/message/436819#436819 :-D
Chris Jester-Young
Cyfry 3 i 5 pojawiają się w kodzie, więc nie są poprawne !!!
Labo,
@Labo Tylko jedno kryterium musi być spełnione, nie wszystkie trzy. Przeczytaj pytanie jeszcze raz. :-)
Chris Jester-Young,
To żart ? Spędzam nad tym kilka godzin! Chociaż nadal udało mi się mieć 58- znakowy
Labo
4
@Labo: Widzę cyfry 3 i 5, ale nie cyfry 3 i 5.
David Ongaro
65

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)

.

_=$=+!![];$__=((_$={})+'')[_+$+_+$+_];__$=((![])+'')[$];_$_=((_$={})+'')
[_+$+_+$+_+$];____=[][$__+((_$={})+'')[$]+(($)/(![])+'')[$]+$__+__$+_$_];$__$=(!![]+"")
[$+$+$]+([][(![]+"")[$+$+$]+(+[]+{})[$+$]+(!![]+"")[$]+(!![]+"")[+[]]]+"")[($+$)+""+
($+$+$)]+(![]+"")[$]+(![]+"")[$+$];$_$_=____()[$-$][$__$]("\"\\"+($)+($+$+$+$+$+$+$)+
($+$)+"\"");_$=(![]+'')[$-$]+([][[]]+[])[$+$+$+$+$]+$_$_+$_$_;$_=(_+{})[$+$+$]+(!![]+'')
[_+$]+$_$_+$_$_;_--,$$=$+$;____()[$-$][$__$]((![]+"")[+[]]+(+[]+{})[$+$]+(!![]+"")[$]+
"(;++_;)$$$=!(_%("+($$+$$+$)+")),____()[+[]][__$+((![])+'')["+($+$)+"]+((!![])+'')["+
($+$+$)+"]+((!![])+'')[+!![]]+_$_](!(_%("+($$+$)+"))?$$$?_$+$_:_$:$$$?$_:_);");
HoLyVieR
źródło
18
Prawdziwi programiści kodują tak jak drugi.
9
@ M28: Tak. To jeden ze sposobów budowania bezpieczeństwa pracy ... ponieważ znalezienie kogoś, kto będzie w stanie utrzymać ten kod, nie będzie najłatwiejsze.
Andy
1
Możesz użyć okna [„eval”] („” \\ '+ 1 + 7 + 2 +' ”) dla z.
Nabb
3
@stevether Chodzi przede wszystkim o nadużywanie konwersji typu (np .: +!![]jest taki sam 1i ({}+"")[5]jest taki sam jak c) oraz nadużywanie notacji tablicowej w celu uzyskania dostępu do metody (np .: window['eval'](jest taki sam eval().
HoLyVieR,
1
Odpowiednia liczba postaci, jeśli kiedykolwiek ją widziałem.
captncraig
26

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
gnibbler
źródło
1
Zajęło mi 10 minut, aby zrozumieć, co tam zrobiłeś. Ładne i pokręcone.
Trufa,
23

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

KirarinSnow
źródło
5
Założę się, że przeszedł ciężki .
kaoD,
23

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;
Skizz
źródło
5
To wprawia mnie w zakłopotanie.
Mateen Ulhaq,
2
Myślę, że miałeś na myśli membranę
Korvin Szanto,
16

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
Hiato
źródło
+1 za sł. Oczywiście nawet nieudostępnione, nie jest to szczególnie czytelne .
Jesse Millikan
12

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*"))
dzuc
źródło
Jak to w ogóle działa?
addison
._. Jak to działa ...
TuxCrafting
„ciąg programu” .unpack („C *”). map {| x | "" * x} .join ("\ n")
dzuc
11

Brainfuck - 626 656

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

Zaczyna od 1 do 255

captncraig
źródło
1
Okazuje się, że tak naprawdę robi BuzzFizz. Dostaje FizzBuzz poprawny dla% 15, ale zamienia% 3 i% 5. Mogę spróbować to naprawić, ale na razie mój mózg jest oficjalnie F'ed
captncraig
2
Naprawiono kosztem 30. Mogłem bardziej grać w golfa z wysiłkiem, ale zmarnowałem już wystarczająco dużo czasu na to.
captncraig,
9
„marnotrawstwo” to mocne słowo ...
Claudiu
10

Brainfuck, 708 znaków

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

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

Simon Forsberg
źródło
9

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"]
MtnViewMark
źródło
Cześć, próbuję zrozumieć Twój kod, ale nie jestem w stanie go uruchomić! Funkcja zZ' is applied to six arguments, but its type (a0 -> b0 -> c0) -> [a0] -> [b0] -> [c0] 'ma tylko trzy
RobAu
A ja, będąc w stanie go uruchomić, dostaję tylko ["1","2","3","4","5","6"...].
Artyom
Naprawiono - odpowiednia wersja wciąż znajdowała się na moim dysku ... dawno temu źle wkleiłem tekst!
MtnViewMark
określ, w jaki sposób można go skrócić o 19 znaków, lub pokaż kod. jestem ciekawy i nie mam pojęcia
dumny haskeller
Istnieje 19 occurrances z 2 nazw literowych: bu, fi, zzi zZ. Można je skrócić do nazw zawierających jedną literę.
MtnViewMark
8

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

Mama Fun Roll
źródło
6

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

anOKsquirrel
źródło
Cholera, właśnie zdałem sobie sprawę, że cel miał być krótki i trudny do zrealizowania ... Przepraszam: P
anOKsquirrel
+1 Może brakowało z powodu krótkości, ale przynajmniej nie było tam
głośnego
4

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

Splendor
źródło
4

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.

Konrad Borowski
źródło
3

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="";}}
Gareth
źródło
3

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.

marinus
źródło
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()

To jest mój pierwszy golf. Nie najkrótszy, ale jest dość brzydki! Żadna z niedozwolonych liczb lub literałów łańcuchowych. Firp, Burp!

LexyStardust
źródło
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))]

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

Marcin
źródło
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

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

tartin
źródło
3

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

Labo
źródło
Pierwsze dwa wydają się nic nie robić, ponieważ i=0oznacza to, że whilepętla nigdy nie jest wprowadzana.
xnor
Lol Użyłem mojej wersji testowej, w której jest warunek i<20.
Labo,
Ale teraz działa :)
Labo
Czy nie powinno to kończyć się na 100 zgodnie z pierwotnym problemem FizzBuzz?
David Ongaro
2

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

aaaaaaaaaaaa
źródło
2

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.

jcolebrand
źródło
2

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);
}
Wug
źródło
2

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.

Jacob Stanley
źródło
2
bardzo słodki, ale zawiera dosłowne „Fizz”, „Buzz” itp., więc nie obowiązuje zgodnie z zasadami
Arne Brasseur
2

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)))
David Watson
źródło
2

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

Arne Brasseur
źródło
1

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
aka.nice
źródło
1

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 
RobAu
źródło
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"

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.

Ry-
źródło
0

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);}}
Kaslai
źródło