Obfuscated FizzBuzz Golf [fermé]


50

Créez l'implémentation FizzBuzz la plus courte possible.

Pour être considéré comme obscurci, il doit satisfaire à au moins l'un des éléments suivants:

  1. Ne contient aucun des mots "Fizz", "Buzz" ou "FizzBuzz"
  2. Ne contient pas les nombres 3, 5 ou 15.
  3. Utilisez l’un des éléments ci-dessus de manière trompeuse.

Rappelez-vous: le but est d’être court et difficile à suivre.

L'exemple de code qui a inspiré cette question est le suivant:

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

Comment connaissez-vous le lien? Dans votre solution, vous avez ms.Length, mais dans certaines solutions, aucun lien de ce type n'existe ...
Labo

Je vote pour clore cette question hors sujet car elle ne comporte pas de critère de validité objective, rendant impossible la décision indiscutable de déterminer si une soumission respecte les règles.
Dennis

Réponses:


25

GolfScript, 75 69 65 60 59 caractères

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

Vous penseriez donc que GolfScript est déjà obscurci, non? Eh bien, juste pour suivre les spécifications, j'ai décidé que le programme ne contienne pas "fizz", "buzz", ni les chiffres 3, 5, ni 15. :-)

Oui, il existe des nombres avec des multiples de 5, tels que 25, 35, 90, 100 et 6875. Sont-ils des harengs rouges? Tu décides. ;-)


2
Bien que j'aie écrit des commentaires pour toutes mes autres soumissions GolfScript, aucun ne sera disponible pour celle-ci. Justification: chat.stackexchange.com/transcript/message/436819#436819 :-D
Chris Jester-Young le

Les chiffres 3 et 5 apparaissent dans votre code, donc ce n'est pas correct !!!
Labo

@Labo Un seul des critères doit être satisfait, pas les trois. Lisez à nouveau la question. :-)
Chris Jester-Young

C'est une blague ? Je passe plusieurs heures à ça! Bien que j'aie quand même réussi à avoir un code Python long de 58 caractères: p codegolf.stackexchange.com/a/63543/47040
Labo

4
@Labo: Je peux voir les chiffres 3 et 5, mais pas les chiffres 3 et 5.
David Ongaro

65

Javascript 97 caractères - pas de chiffres du tout

Nombres ? Qui a besoin d'un numéro quand vous avez Javascript!

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

Remarque: une boucle infinie vous alertera de la séquence.

Bonus (666 caractères)

  • Pas de numéro
  • Aucune lettre (seule zforla totalité du script a été utilisée)

.

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

18
Les vrais programmeurs codent comme le second.

9
@ M28: Oui. C'est un moyen de renforcer la sécurité de l'emploi ... car trouver quelqu'un qui peut gérer ce code ne serait pas chose facile.
Andy

1
Vous pouvez utiliser la fenêtre ["eval"] ('"\\' + 1 + 7 + 2 + '' ') pour z.
Nabb

3
@stevether Il s'agit principalement d'abuser de la conversion de type (ex.: +!![]est identique à 1et ({}+"")[5]identique c) et d'abuser de la notation de tableau pour accéder à une méthode (ex.: window['eval'](identique eval().
HoLyVieR

1
Nombre de caractères approprié si j'en ai jamais vu un.
captncraig

26

Python - 78 caractères

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

1
Cela m'a pris 10 minutes pour comprendre ce que vous avez fait là-bas. Nice et tordu.
Trufa

23

PostScript, 96 octets

Si obscurci, cela ressemble à des ordures aléatoires.

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

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


5
Je parie que ça passe vite .
kaoD

23

C ++: 886 caractères

J'ai essayé de cacher le "fizz" et le "buzz". Pouvez-vous les repérer?

#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
Cela confuse ma brane.
Mateen Ulhaq

2
Je pense que vous vouliez dire membrane
Korvin Szanto

16

DC ( 256 255 octets)

Voilà, j’ai essayé (avec assez de succès, si je puis me le dire moi-même) de cacher quoi que ce soit sauf des lettres et +-[];:=(qui sont vitales et impossibles à masquer). Une erreur de segmentation se produit après avoir atteint environ 8482 unités sur ma machine, mais cela concerne les problèmes de pile liés à la manière dont la récursion est implémentée. La solution elle - même est correcte. 255 octets si vous supprimez les espaces (inclus pour faciliter la lecture)

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 pour dc. Même non dissimulé, bien sûr, ce n'est pas particulièrement lisible .
Jesse Millikan


11

Brainfuck - 626 656

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

Va de 1 à 255


1
En fait, cela fait BuzzFizz. FizzBuzz est correct pour% 15, mais il échange les% 3 et% 5. Je peux essayer de le réparer, mais pour l'instant, mon cerveau est officiellement contrôlé
captncraig

2
Fixé au coût de 30. On aurait pu jouer au golf plus facilement, mais j'ai déjà perdu assez de temps à ce sujet.
captncraig

9
"déchets" est un mot fort ...
Claudiu

10

Brainfuck, 708 personnages

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

Une description de son fonctionnement est disponible dans ma question de révision de code


9

Haskell - 147 142 138 caractères

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

Le code est 19 caractères plus long que nécessaire, mais je pensais que l'esthétique en valait la peine! Je crois que les trois "objectifs" sont satisfaits.

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

Bonjour, j'essaie de comprendre votre code, mais je ne parviens pas à l'exécuter! La fonction zZ' is applied to six arguments, but its type (a0 -> b0 -> c0) -> [a0] -> [b0] -> [c0] 'n'a que trois
RobAu

Et moi, tout en étant capable de le faire, je ne reçois que ["1","2","3","4","5","6"...].
Artyom le

Corrigé - La bonne version était toujours sur mon disque ... il faut avoir collé le texte il y a longtemps!
MtnViewMark

veuillez préciser comment il peut être raccourci de 19 caractères ou afficher le code. Je suis curieux et je n'ai aucune idée
fier haskeller

Il y a 19 occurences de noms 2: lettre bu, fi, zzet zZ. Ceux-ci pourraient être raccourcis à une lettre noms.
MtnViewMark


6

Javascript, 469 octets

C'était probablement le plus amusant que j'ai jamais eu.

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

Essayez-le ici


Dang, je viens de me rendre compte que l'objectif était d'être court et difficile à suivre ... Désolé: P
anOKsquirrel

+1 Peut-être a-t-il manqué la brièveté, mais au moins vous n'avez pas eu le buzz fizz
MickyT

4

Ruby - 165 caractères

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

Ce fut ma première tentative de code de golf. J'ai eu beaucoup de plaisir. =)


4

Perl 6 (52 octets)

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

Permettez-moi de mettre une explication ici. C'est le pire abus de règle que j'ai eu dans une telle tâche. Je sais ce que vous dites - il est évident Fizzet Buzzici. Mais regardons les règles.

Pour être considéré comme obscurci, il doit satisfaire à au moins l'un des éléments suivants:

Cela évite 3, 5et 15. C'est donc une solution valide et très courte.


3

Scala, 295 caractères

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 caractères)

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

Bien que je ne sois pas sûr que cela soit conforme à la norme C :)
Cela fonctionne cependant. Sur Linux utilisant GCC, c’est.


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

C'est mon premier golf. Pas le plus court, mais c'est très moche! Aucun des nombres interdits ou des littéraux de chaîne. 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))]

Pas tout à fait le plus court, mais j'espère que le lecteur appréciera le style purement fonctionnel et l'extensibilité à une longueur arbitrairement longue.


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

Je pourrais jouer un peu au golf mais je préférerais que ce soit plus obscur.


3

Python 2 - 54 caractères

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

Python 3 - 56 caractères

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

Si vous ne voulez pas que "FizzBuzz" apparaisse:

Python 2 - 58 caractères

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

Python 3 - 60 caractères

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

Ou comment battre GolfScript avec Python;)


Les deux premiers semblent ne rien faire car cela i=0signifie que la whileboucle n'est jamais entrée.
xnor

Lol j'ai utilisé ma version de test, dans laquelle la condition est i<20.
Labo

Mais maintenant ça marche :)
Labo

Ne devrait-il pas s’arrêter à 100 selon le problème original de FizzBuzz?
David Ongaro

2

JavaScript 111 caractères - pas de numéro de clé

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 caractères

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

Pourrait être raccourci si j'introduisais d'autres nombres comme ceci: (210 caractères au total)

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

Décidé de supprimer le mot évident fizz et buzz et d'aller légèrement plus obscurcissant. La seconde est plus courte que la première mais est légèrement plus directe sur ce qui se passe dans l'addition.


2

Ce n'est pas exactement le golf, c'est environ 120 lignes.

Je pensais que je ferais quelque chose qui tirerait parti de tout le potentiel amusant d'un comportement non défini avec la gestion de la mémoire 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 caractères

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

Je ne peux pas prendre le crédit de cette pièce brillante, mais je ne pourrais pas laisser cette question sans ma mise en œuvre obscure préférée :)

L’implémentation ci-dessus a été écrite par David Brady et provient du joyau rubis de fizzbuzz . Voici l'explication du code source:

Utilise le fait que la graine 1781773465 dans le rand de Ruby générera la séquence de 15 chiffres qui se répète dans la progression de FizzBuzz. La prémisse ici est que nous voulons tromper intelligemment Rand afin de fournir une séquence prévisible. (Il est intéressant de noter que nous n’obtenons pas de réduction de la taille de l’information. La séquence de 15 chiffres peut être codée sous forme de paires de bits et stockée dans un nombre de 30 bits. nous a effectivement coûté un peu d’efficacité de stockage, MAIS CE N'EST PAS LE POINT!

Ruby - 87 caractères

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

Voici une version différente qui utilise une valeur de départ plus courte mais la table de recherche est dans un ordre différent. Voici l'explication du code source:

La première mise en oeuvre (89 caractères) respecte l'ordre spécifique 0 = int, 1 = Fizz, 2 = Buzz, 3 = FizzBuzz. Il peut être possible de trouver une clé plus petite si la commande est modifiée. Il y a 24 permutations possibles. Si nous supposons que les permutations sont équitablement réparties sur 2 * 31 espaces et qu’une probabilité d'environ 50% que celle-ci se situe "à mi-chemin", nous pouvons supposer avec une confiance décente (par exemple 20-50%) qu'il existe une touche quelque part autour de 1.4e + 9 (en dessous de 2 * 28). Ce n'est pas très rentable, mais cela démontre en exploitant la séquence prédéfinie de rand pour "masquer" 30 bits d'information en moins de 30 bits d'espace.

Résultat: La permutation [3,2,0,1] apparaît à la graine 46308667, qui peut être stockée sur 26 bits.


2
très doux, mais contient un "Fizz", "Buzz", etc., donc non valide selon les règles
Arne Brasseur

2

Python, 1 ligne, 376 caractères

pep8-E501 ignoré. Ne fonctionne que dans 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

Rubis alternatif (126 caractères)

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

Bref et obscur, comme nous l’aimons. Le 3 et le 5 sont en réalité là-dedans mais pas en tant que littéraux entiers, donc je pense que cela compte toujours.

Notez que ceci est la version la plus courte de Ruby sans littéralement 'Fizz', 'Buzz', 'FizzBuzz' ici.


1

Squeak (4.4) Smalltalk 206 octets

|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 même algorithme avec des messages moins explicites, même nombre de caractères

|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

Je présente mes excuses à Alan Kay pour ce que j'ai fait à Smalltalk.
Certains de ces hacks sont portables sur les dialectes Smalltalk, d'autres nécessiteraient un calque de compatibilité Squeak ...

Notez que si vous exécutez dans un espace de travail, vous pouvez omettre des déclarations | fi zz buz | et gagnez 14 caractères.

Si nous pouvons nous permettre 357 caractères (315 avec des lettres simples), il vaut mieux éviter la triviale boucle #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 octets, y compris les espaces pour la mise en page;)

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

Le «vrai» code est de 160 octets et peut être compressé, mais perd alors son fizz-buzz-ness.

Exécutez-le (pour une sortie agréable):

putStrLn (unwords (take 20 z ))

Sortie:

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"

Je l'ai fait en 2009. C'est assez facile à comprendre, cependant.

Edit: Darn, il utilise "Fizz" et "Buzz!" :( Je pensais avoir changé cela. Tant pis alors.


0

C 216 octets

#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);}}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.