FizzBuzz Golf ofuscado [fechado]


50

Crie a implementação FizzBuzz ofuscada mais curta possível.

Para ser considerado ofuscado, deve atender a pelo menos um dos seguintes:

  1. Não contém nenhuma das palavras "Fizz", "Buzz" ou "FizzBuzz"
  2. Não contém os números 3, 5 ou 15.
  3. Use qualquer uma das opções acima de maneira enganosa.

Lembre-se: o objetivo é ser curto e difícil de seguir.

O exemplo de código que inspirou essa pergunta é a seguir:

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

Como você conhece o limite? Em sua solução você tem ms.Length mas em algumas soluções não existe tal limite ...
Labo

Estou votando para encerrar esta questão como fora de tópico, porque ela não possui um critério de validade objetivo, tornando impossível decidir indiscutivelmente se uma submissão segue as regras.
Dennis

Respostas:


25

GolfScript, 75 69 65 60 59 caracteres

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

Então, você acha que o GolfScript por si só já está ofuscado, certo? Bem, apenas para seguir as especificações, decidi que o programa não contenha "fizz", "buzz", nem os números 3, 5 ou 15. :-)

Sim, existem alguns números com múltiplos de 5, como 25, 35, 90, 100 e 6875. São arenques vermelhos? Você decide. ;-)


2
Embora eu tenha escrito comentários para todos os meus outros envios de GolfScript, nenhum será publicado para este. Racional: chat.stackexchange.com/transcript/message/436819#436819 :-D
Chris Jester-Young

Os números 3 e 5 aparecem no seu código, então não está correto !!!
Labo

@Labo Apenas um dos critérios precisa ser atendido, não os três. Leia a pergunta novamente. :-)
Chris Jester-Young

Isso é uma piada ? Eu gasto várias horas nisso! Embora eu ainda conseguimos ter um 58 caracteres longo Python código: p codegolf.stackexchange.com/a/63543/47040
Labo

4
@Labo: Eu posso ver os dígitos 3 e 5, mas não os números 3 e 5.
David Ongaro

65

Caracteres Javascript 97 - nenhum número

Números? Quem precisa de número quando você tem 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: Há um loop infinito que alertará a sequência.

Bônus (666 caracteres)

  • Nenhum número
  • Nenhuma carta (apenas zforfoi usada em todo o script)

.

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

18
Programadores reais codificam exatamente como o segundo.

9
@ M28: Sim. Essa é uma maneira de criar segurança no emprego ... porque encontrar alguém que possa manter esse código não seria a coisa mais fácil.
Andy

1
Você pode usar a janela ["eval"] ('"\\' + 1 + 7 + 2 + '"') para z.
Nabb

3
@stevether Trata-se principalmente de abusar da conversão de tipos (ex .: +!![]é o mesmo que 1e ({}+"")[5]é o mesmo c) e de abusar da notação de matriz para acessar o método (ex .: window['eval'](é o mesmo eval().
HoLyVieR

1
Contagem de caracteres apropriada, se eu já vi um.
captncraig

26

Python - 78 caracteres

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

1
Levei 10 minutos para entender o que você fez lá. Agradável e distorcido.
precisa

23

PostScript, 96 bytes

Tão ofuscado que parece lixo aleatório.

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
Aposto que isso passa por cima .
6133 kaoD

23

C ++: 886 caracteres

Eu tentei esconder o 'fizz' e o 'buzz'. Você pode identificá-los?

#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
Isso está confundindo minha brana.
Mateen Ulhaq 11/03/11

2
Eu acho que você quis membrana
Korvin Szanto

16

DC ( 256 255 bytes)

Aqui está, tentei (com bastante sucesso, se assim posso dizer) esconder qualquer coisa, exceto as letras, e +-[];:=(que são vitais e impossíveis de ofuscar). Ele falha após ter atingido cerca de 8482 na minha máquina, mas isso tem a ver com problemas de pilha relacionados à maneira como a recursão é implementada. A solução em si está correta. 255 bytes se você remover o espaço em branco (incluído para facilitar a leitura)

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 para dc. Mesmo não ofuscado, é claro, não é especialmente legível .
precisa


11

Brainfuck - 626 656

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

Vai de 1 a 255


1
Acontece que isso realmente faz o BuzzFizz. O FizzBuzz está correto para% 15, mas troca% 3 e% 5. I podem tentar corrigi-lo, mas por enquanto o meu cérebro está f'ed oficialmente
captncraig

2
Fixo no custo de 30. Poderia ter jogado mais com esforço, mas já perdi tempo suficiente nisso.
captncraig

9
"desperdício" é uma palavra forte ...
Claudiu

10

Brainfuck, 708 caracteres

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

A descrição de como funciona está disponível na minha pergunta de Revisão de código.


9

Haskell - 147 142 138 caracteres

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

O código tem 19 caracteres a mais do que precisa, mas achei que a estética valeu a pena! Acredito que todos os três "objetivos" sejam satisfeitos.

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

Olá, tento entender seu código, mas não consigo executá-lo! A função zZ' is applied to six arguments, but its type (a0 -> b0 -> c0) -> [a0] -> [b0] -> [c0] 'possui apenas três
RobAu

E eu, enquanto sou capaz de executá-lo, apenas o recebo ["1","2","3","4","5","6"...].
Artyom

Corrigido - A versão correta ainda estava no meu disco ... deve ter colado incorretamente o texto há muito tempo!
MtnViewMark

especifique como pode ser reduzido por 19 caracteres ou mostre o código. Estou curioso e eu não tenho idéia
haskeller orgulhoso

Existem 19 ocorrências de nomes 2 letra: bu, fi, zz, e zZ. Estes podem ser reduzidos para nomes de uma letra.
MtnViewMark

8

𝔼𝕊𝕄𝕚𝕟, 33 caracteres / 92 bytes (não competitivo)

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

Try it here (Firefox only).

Esse idioma é muito OP para desafios de origem restrita.


6

Javascript, 469 bytes

Esta foi provavelmente a mais divertida que já tive.

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

Experimente aqui


Caramba, acabei de perceber que o objetivo era curto e difícil de seguir ... Desculpe: P
anOKsquirrel

+1 Pode ter falhado a falta, mas pelo menos você não tinha burburinho lá dentro #
MickyT

4

Ruby - 165 caracteres

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

Esta foi a minha primeira tentativa de código de golfe. Eu me diverti muito. =)


4

Perl 6 (52 bytes)

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

Deixe-me colocar uma explicação aqui. É o pior abuso de regra que cometi nessa tarefa. Eu sei o que você está dizendo - é óbvio Fizze Buzzaqui. Mas vamos dar uma olhada nas regras.

Para ser considerado ofuscado, deve atender a pelo menos um dos seguintes:

Isso evita 3, 5e 15. Portanto, é uma solução válida e muito curta.


3

Scala, 295 caracteres

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

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

Embora eu não tenha certeza se isso está de acordo com o padrão C :)
Mas funciona. No Linux usando GCC, é isso.


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

Este é o meu primeiro golfe. Não é o mais curto, mas é muito feio! Nenhum dos números proibidos ou literais de cadeias. 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))]

Não é o mais curto, mas espero que o leitor aprecie o estilo funcional puro e a extensibilidade a contagens arbitrariamente longas.


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

Eu poderia jogar um pouco de golfe, mas prefiro que fique mais ofuscado.


3

Python 2-54 caracteres

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

Python 3-56 caracteres

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

Se você não deseja que o 'FizzBuzz' apareça:

Python 2-58 caracteres

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

Python 3-60 caracteres

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

Ou como vencer o GolfScript com Python;)


Os dois primeiros parecem não fazer nada, pois i=0significa que o whileloop nunca é inserido.
Xnor

Lol Eu usei minha versão de teste, na qual a condição está i<20.
Labo

Mas agora ele funciona :)
Labo

Não deveria parar aos 100, de acordo com o problema original do FizzBuzz?
David Ongaro

2

Caracteres JavaScript 111 - sem números-chave

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 caracteres

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

Pode ser abreviado se eu apresentei outros números da seguinte forma: (total de 210 caracteres)

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

Decidiu remover a palavra óbvia chiar e zumbir e procurar um pouco mais de ofuscação. O segundo é mais curto que o primeiro, mas é um pouco mais direto sobre o que está ocorrendo na adição.


2

Isso não é exatamente um jogo de golfe, são cerca de 120 linhas.

Eu pensei em fazer algo que aproveitasse todo o potencial divertido de comportamento indefinido com o gerenciamento de memória 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

Ruby - 89 caracteres

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

Não posso me responsabilizar por esse pedaço de brilho, mas não poderia deixar essa pergunta sem minha implementação ofuscada favorita :)

A implementação acima foi escrita por David Brady e é da gema fizzbuzz ruby. Aqui está a explicação do código fonte:

Usa o fato de a semente 1781773465 no rand de Ruby gerar a sequência de 15 dígitos que se repete na progressão do FizzBuzz. A premissa aqui é que queremos enganar inteligentemente o rand para fornecer uma sequência previsível. (É interessante notar que na verdade não obtemos uma redução no tamanho da informação. A sequência de 15 dígitos pode ser codificada como pares de bits e armazenada em um número de 30 bits. Como 1781773465 requer 31 bits de armazenamento, nossa inteligência realmente nos custou um pouco de eficiência de armazenamento, mas esse não é o ponto!

Ruby - 87 caracteres

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

Aqui está uma versão diferente que usa uma semente mais curta, mas a tabela de pesquisa está em uma ordem diferente. Aqui está a explicação do código fonte:

A primeira implementação (89 caracteres) segue a ordem específica de 0 = int, 1 = Fizz, 2 = Buzz, 3 = FizzBuzz. Pode ser possível encontrar uma chave menor se a ordem for alterada. Existem 24 permutações possíveis. Se assumirmos que as permutações estão distribuídas igualmente por todo o espaço 2 * 31, e cerca de 50% de probabilidade de que este esteja "na metade do caminho", podemos assumir com uma confiança decente (digamos 20-50%) que existe um em algum lugar em torno de 1.4e + 9 (abaixo de 2 * 28). Não é muito ganho, mas demonstra alavancar a sequência predefinida de rand para "ocultar" 30 bits de informação em menos de 30 bits de espaço.

Resultado: a permutação [3,2,0,1] aparece na semente 46308667, que pode ser armazenada em 26 bits.


2
muito doce, mas contém um literal "Fizz", "Buzz" etc, portanto, não válido de acordo com as regras
Arne Brasseur

2

Python, 1 linha, 376 caracteres

pep8-E501 ignorado. Só funciona em 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

Ruby alternativo (126 caracteres)

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

Curto e obscuro, exatamente como gostamos. O 3 e o 5 estão realmente lá, mas não como literais inteiros, então eu acho que ainda conta.

Observe que esta é a versão mais curta do Ruby, sem literal 'Fizz', 'Buzz', 'FizzBuzz' aqui.


1

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

Ou mesmo algoritmo com menos mensagens explícitas, mesmo número de caracteres

|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

Peço desculpas a Alan Kay pelo que fiz com Smalltalk.
Alguns desses hacks são portáteis em dialetos Smalltalk, alguns exigiriam uma camada de compatibilidade Squeak ...

Observe que, se você executar em uma área de trabalho, poderá omitir declarações | fi zz buz | e ganhe 14 caracteres.

Se pudermos pagar 357 caracteres (315 com vars de uma letra), é melhor evitar #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 bytes, incluindo o espaço em branco para o 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

O código 'real' tem 160 bytes e pode ser compactado, mas perde o tempo de ebulição.

Execute-o (para obter uma saída agradável):

putStrLn (unwords (take 20 z ))

Resultado:

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"

Um que eu fiz em 2009. No entanto, é bem fácil descobrir.

Edit: Droga, ele usa "Fizz" e "Buzz!" :( Eu pensei que tinha mudado isso. Deixa pra lá então.


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);}}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.