Golf offuscato FizzBuzz [chiuso]


50

Crea l'implementazione offuscata più breve possibile di FizzBuzz.

Per essere considerato offuscato, dovrebbe soddisfare almeno una delle seguenti condizioni:

  1. Non contiene nessuna delle parole "Fizz", "Buzz" o "FizzBuzz"
  2. Non contiene i numeri 3, 5 o 15.
  3. Utilizzare uno dei precedenti in modo fuorviante.

Ricorda: l'obiettivo è essere brevi e difficili da seguire.

Segue l'esempio di codice che ha ispirato questa domanda:

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

Come conosci il limite? Nella tua soluzione hai ms.Length ma in alcune soluzioni non esiste tale limite ...
Labo

Sto votando per chiudere questa domanda come fuori tema perché non ha un criterio oggettivo di validità, rendendo impossibile decidere indiscutibilmente se una richiesta segue le regole.
Dennis,

Risposte:


25

GolfScript, 75 69 65 60 59 caratteri

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

Quindi, pensi che GolfScript da solo sia già offuscato, giusto? Bene, solo per seguire le specifiche, ho deciso di non avere il programma "fizz", "buzz", né i numeri 3, 5, né 15. :-)

Sì, ci sono alcuni numeri con multipli di 5, come 25, 35, 90, 100 e 6875. Sono aringhe rosse? Tu decidi. ;-)


2
Anche se ho scritto commenti per tutte le altre mie osservazioni GolfScript, nessuna sarà disponibile per questo. Razionale: chat.stackexchange.com/transcript/message/436819#436819 :-D
Chris Jester-Young

I numeri 3 e 5 compaiono nel tuo codice, quindi non è corretto !!!
Labo,

@Labo Solo uno dei criteri deve essere soddisfatto, non tutti e tre. Leggi di nuovo la domanda. :-)
Chris Jester-Young,

È uno scherzo ? Ci dedico diverse ore! Anche se sono ancora riuscito ad avere un codice Python di 58 caratteri: p codegolf.stackexchange.com/a/63543/47040
Labo,

4
@Labo: vedo le cifre 3 e 5 ma non i numeri 3 e 5.
David Ongaro,

65

Javascript 97 caratteri - nessun numero

Numeri? Chi ha bisogno del numero quando hai Javascript!

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

Nota: esiste un loop infinito che avviserà l'utente della sequenza.

Bonus (666 caratteri)

  • Nessun numero
  • Nessuna lettera ( zforè stata utilizzata solo nell'intero script)

.

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

18
Codice di programmatori reali proprio come il secondo.

9
@ M28: Sì. Questo è un modo per aumentare la sicurezza del lavoro ... perché trovare qualcuno in grado di mantenere questo codice non sarebbe la cosa più semplice.
Andy,

1
Puoi usare window ["eval"] ('"\\' + 1 + 7 + 2 + '"') per z.
Nabb,

3
@stevether Si tratta principalmente di abusare della conversione del tipo (es .: +!![]è uguale 1ed ({}+"")[5]è lo stesso di c) e abuso della notazione di array per accedere al metodo (es .: window['eval'](è lo stesso eval().
HoLyVieR,

1
Conteggio del personaggio appropriato se ne avessi mai visto uno.
captncraig,

26

Python - 78 caratteri

i=0
while 1:i+=1;print"".join("BzuzzizF"[::2*j]for j in(-1,1)if 1>i%(4+j))or i

1
Mi ci sono voluti 10 minuti per capire cosa hai fatto lì. Bello e contorto.
Trufa,

23

PostScript, 96 byte

Così offuscato sembra spazzatura a caso.

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

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


5
Scommetto che passa irriducibile .
Kaao

23

C ++: 886 caratteri

Ho provato a nascondere il "fizz" e il "ronzio". Riesci a individuarli?

#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
Che confonde la mia brane.
Mateen Ulhaq,

2
Penso che volevi dire membrana
Korvin Szanto il

16

DC ( 256 255 byte)

Eccolo, ho provato (piuttosto con successo, se così posso dire io stesso) a nascondere qualsiasi cosa tranne le lettere e +-[];:=(che sono vitali e impossibili da offuscare). Segfault dopo essere arrivato a circa 8482 circa sulla mia macchina, ma ciò ha a che fare con problemi di stack relativi al modo in cui viene implementata la ricorsione. La soluzione stessa è corretta. 255 byte se si rimuove lo spazio bianco (incluso per facilitare la lettura)

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 per dc. Anche se non offuscato, ovviamente, non è particolarmente leggibile .
Jesse Millikan,


11

Brainfuck - 626 656

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

Va da 1 a 255


1
Si scopre che effettivamente BuzzFizz lo fa. Ottiene FizzBuzz corretto per% 15, ma scambia% 3 e% 5. Potrei provare a risolverlo, ma per ora il mio cervello è ufficialmente F'ed
captncraig

2
Risolto al costo di 30. Avrei potuto giocare a golf di più con sforzo, ma ho già perso abbastanza tempo su questo.
captncraig,

9
"spreco" è una parola forte ...
Claudiu,

10

Brainfuck, 708 caratteri

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

La descrizione di come funziona è disponibile nella mia domanda di revisione del codice


9

Haskell - 147 142 138 caratteri

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

Il codice è di 19 caratteri più lungo di quanto deve essere, ma ho pensato che valesse la pena l'estetica! Credo che tutti e tre gli "obiettivi" siano soddisfatti.

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

Ciao, cerco di capire il tuo codice, ma non riesco a eseguirlo! La funzione zZ' is applied to six arguments, but its type (a0 -> b0 -> c0) -> [a0] -> [b0] -> [c0] 'ha solo tre
RobAu

E io, pur essendo in grado di eseguirlo, ottengo solo ["1","2","3","4","5","6"...].
Artyom,

Risolto - La versione giusta era ancora sul mio disco ... deve aver incollato il testo molto tempo fa!
MtnViewMark,

si prega di specificare come può essere abbreviato di 19 caratteri o mostrare il codice. sono curioso e non ne ho idea
orgoglioso haskeller il

Ci sono 19 occorrenze di nomi 2 lettera: bu, fi, zz, e zZ. Questi potrebbero essere abbreviati in nomi di una lettera.
MtnViewMark,

8

𝔼𝕊𝕄𝕚𝕟, 33 caratteri / 92 byte (non competitivo)

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

Try it here (Firefox only).

Questo linguaggio è troppo OP per sfide con risorse limitate.


6

Javascript, 469 byte

Questo è stato probabilmente il più divertente che abbia mai avuto.

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

Provalo qui


Dang, mi sono appena reso conto che l'obiettivo era di essere breve e difficile da seguire ... Scusa: P
anOKsquirrel,

+1 Potresti aver perso la mancanza, ma almeno non hai avuto un ronzio lì
dentro

4

Rubino - 165 caratteri

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

Questo è stato il mio primo tentativo di code golf. Mi sono divertito molto. =)


4

Perl 6 (52 byte)

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

Vorrei mettere una spiegazione qui. È il peggior abuso di regole che ho fatto in questo compito. So cosa stai dicendo - c'è ovvio Fizze Buzzqui. Ma diamo un'occhiata alle regole.

Per essere considerato offuscato, dovrebbe soddisfare almeno una delle seguenti condizioni:

Questo evita 3, 5e 15. Pertanto, è una soluzione valida e molto breve.


3

Scala, 295 caratteri

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

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

Anche se non sono sicuro che sia conforme allo standard C :)
Funziona, comunque. Su Linux usando GCC, cioè.


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

Questo è il mio primo golf. Non il più corto, ma è piuttosto brutto! Nessuno dei numeri proibiti o letterali stringa. 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))]

Non del tutto il più breve, ma spero che il lettore apprezzerà il puro stile funzionale e l'estensibilità a conteggi arbitrariamente lunghi.


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

Potrei giocare a golf un po 'ma preferirei che fosse più offuscato.


3

Python 2 - 54 caratteri

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

Python 3 - 56 caratteri

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

Se non si desidera visualizzare "FizzBuzz":

Python 2 - 58 caratteri

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

Python 3 - 60 caratteri

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

O come battere GolfScript con Python;)


I primi due sembrano non fare nulla, poiché i=0significa che il whileciclo non viene mai inserito.
xnor

Lol ho usato la mia versione di prova, in cui si trova la condizione i<20.
Labo,

Ma ora funziona :)
Labo,

Non dovrebbe fermarsi a 100 secondo il problema originale di FizzBuzz?
David Ongaro,

2

Caratteri JavaScript 111 - nessun numero chiave

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 caratteri

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

Potrebbe essere abbreviato se avessi introdotto altri numeri in questo modo: (210 caratteri in totale)

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

Ho deciso di rimuovere la parola ovvia fizz e ronzio e andare per un po 'più di offuscamento. Il secondo è più corto del primo ma è leggermente più diretto su ciò che accade nell'aggiunta.


2

Questo non è esattamente golf, è di circa 120 linee.

Ho pensato di fare qualcosa che sfruttasse tutto il potenziale divertente per un comportamento indefinito con la gestione della memoria 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);
}

2

Rubino - 89 caratteri

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

Non posso prendermi il merito per questo pezzo di genialità, ma non potrei lasciare questa domanda senza la mia implementazione offuscata preferita :)

L'implementazione sopra è stata scritta da David Brady e proviene dalla gemma rubino fizzbuzz . Ecco la spiegazione dal codice sorgente:

Usa il fatto che il seme 1781773465 nel rand di Ruby genererà la sequenza di 15 cifre che si ripete nella progressione di FizzBuzz. La premessa qui è che vogliamo ingannare abilmente Rand nel fornire una sequenza prevedibile. (È interessante notare che in realtà non otteniamo una riduzione della dimensione delle informazioni. La sequenza di 15 cifre può essere codificata come coppie di bit e memorizzata in un numero di 30 bit. Poiché 1781773465 richiede 31 bit di memoria, la nostra intelligenza ha in realtà ci è costato un po 'di efficienza di archiviazione. MA NON È IL PUNTO!

Rubino - 87 caratteri

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

Ecco una versione diversa che utilizza un seme più breve ma la tabella di ricerca è in un ordine diverso. Ecco la spiegazione dal codice sorgente:

La prima implementazione (89 caratteri) aderisce all'ordinamento specifico di 0 = int, 1 = Fizz, 2 = Buzz, 3 = FizzBuzz. Potrebbe essere possibile trovare una chiave più piccola se l'ordine è cambiato. Esistono 24 possibili permutazioni. Se assumiamo che le permutazioni siano distribuite uniformemente nello spazio 2 * 31 e circa il 50% di probabilità che questa sia "circa a metà strada", allora possiamo assumere con una discreta sicurezza (diciamo il 20-50%) che esiste un chiave da qualche parte intorno a 1,4e + 9 (sotto 2 * 28). Non è molto utile, ma dimostra di sfruttare la sequenza predefinita di rand per "nascondere" 30 bit di informazioni in meno di 30 bit di spazio.

Risultato: la permutazione [3,2,0,1] appare sul seme 46308667, che può essere memorizzato in 26 bit.


2
molto dolce, ma contiene letteralmente "Fizz", "Buzz" ecc. quindi non valido secondo le regole
Arne Brasseur,

2

Python, 1 riga, 376 caratteri

pep8-E501 ignorato. Funziona solo 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

Alternative Ruby (126 caratteri)

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

Breve e oscuro, proprio come ci piace. Il 3 e il 5 sono in realtà lì, ma non come valori letterali interi, quindi penso che conti ancora.

Si noti che questa è la versione Ruby più corta senza letterale 'Fizz', 'Buzz', 'FizzBuzz' qui.


1

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

O stesso algoritmo con messaggi meno espliciti, stesso numero di caratteri

|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

Mi scuso con Alan Kay per quello che ho fatto a Smalltalk.
Alcuni di questi hack sono portatili nei dialetti Smalltalk, alcuni richiederebbero un livello di compatibilità Squeak ...

Si noti che se si esegue in un'area di lavoro, è possibile omettere le dichiarazioni | fi zz buz | e guadagna 14 personaggi.

Se possiamo permetterci 357 caratteri (315 con lettera singola vars), allora è meglio evitare banali #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

1

Haskell 226 byte, incluso lo spazio bianco per il 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

Il codice "reale" è di 160 byte e può essere compresso, ma perde quindi il brusio.

Eseguilo (per un buon output):

putStrLn (unwords (take 20 z ))

Produzione:

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"

Uno che ho realizzato nel 2009. È abbastanza facile da capire, però.

Modifica: dannazione, usa "Fizz" e "Buzz!" :( Pensavo di averlo cambiato. Allora non importa.


0

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);}}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.