[F] [mOved] Mon langage est mieux que le tien - Page 30

Son annonce parlait notamment de "frontend development". Donc il faut savoir coder, point. En JS oui, mais il faut savoir coder. Boucler. Conditionner. Quelqu'un qui ne fait que du design sans de l'interaction par le JS n'est pas un frontend dev, c'est un intégrateur, ceux qui transforment une maquette graphique en HTML/CSS/Responsive/Hacks IE. Et encore, les intégrateurs aujourd'hui doivent parfois se mettre au JS.
Le FizzBuzz demande "seulement" d'utiliser une boucle FOR et deux IF à l'intérieur, rien de plus. Merde, c'est à peine plus complexe qu'un Hello World !

(./866 System.out.println("}") ;

 Bof, non, pas vraiment...       System.out.println("#include <stdio.h>") ;
      System.out.print("int main() {") ;
      for ( int i= 1 ; i <= 100 ; ++i ) {
         boolean three= i%3 == 0 ;
         boolean five= i%5 == 0 ;
         System.out.print("   printf(\"%s\", \"") ;
         if ( three ) System.out.print("Fizz") ;
         if ( five ) System.out.print("Buzz") ;
         if ( !three && !five ) System.out.print(i) ;
         System.out.println("\");") ;
      }
    

)

Ton générateur de code est illisible, il est en Java.

Merci Kevin. Je me doutais bien que c'était un truc dans ce genre, mais j'ai l'habitude d'être assez explicite, et je ne lis jamais de code spaghetti comme ça ^^

Ce n'est pas du tout un code spaghetti, au maximum un code spaghetto.

for x in range(1,101):
if (x%3) == 0: print "Fizz",
if (x%5) == 0: print "Buzz",
if not (x%3 == 0) and not (x%5 == 0): print x,
print ""

tellement plus simple

Sinon, j'ai une autre solution intéressante:

#include <stdio.h>

int main(void) {
  char buf[301], *pbuf;
  const char *p[100], **pp;
  int i;
  for (i=1, pbuf=buf, pp=p; i<=100; i++, pbuf+=3, pp++) {
    sprintf(pbuf, "%d", i);
    *pp = pbuf;
  }
  for (i=3, pp=p+2; i<=100; i+=3, pp+=3) *pp = "Fizz";
  for (i=5, pp=p+4; i<=100; i+=5, pp+=5) *pp = (*pp == "Fizz") ? "FizzBuzz" : "Buzz";
  for (i=1, pp=p; i<=100; i++, pp++) printf("%s ", *pp);
  return 0;
}

(Attention, *pp == "Fizz" ne marche que si le compilateur unifie correctement les chaînes de caractères constantes, sinon on peut utiliser un strcmp ou rajouter une troisième boucle de ce type pour les multiples de 15.)

for ($i = 1; $i <= 101; $i++) {
    if ($i%3 == 0) {
        echo "Fizz";
    }
    if ($i % 5 == 0) {
        echo "Buzz";
    }
    if ($i % 3 != 0 && $i % 5 != 0) {
        echo $i;
    }
}

J'aime bien espacer, lisible, et garder les accolades en toutes circonstances.

Kevin c'est simple tu rateras tout entretiens un tant sois peu sérieux

En entretien, je proposerais ma solution du ./866 ou quelque chose qui y ressemble fortement, à moins qu'on ne me demande explicitement d'éviter les modulos. Y a-t'il quelque chose qui ne te va pas dans le ./866?

Pour commencer, je ne vois pas pourquoi il te faut une fonction pour le simple truc qu'il te fait. Tu es sûr de ne pas vouloir remplacer counter++ par une fonction increment_counter(counter) { return counter + 1; } ?

oui, a peu pret tout.
for(x = 1; x < 101; x++} { if ((x %3) == 0) printf("Fizz"); if ((x % 5) == 0) printf("Buzz"); if (((x % 3) != 0) && (x % 5) != 0)) printf("%d%", x); printf("\n"]; }
4 ligne de code ca marche c'est simple et compréhensible par tout le monde et se traduit en code ARM de manière super simple!
Ton code est juste complexe bloaté et plein de truc absolument inutile.

(c'est quand même pas terrible de multiplier vos modulos, et je parle bien de la maintenabilité , et introduire 101 n'est pas très intuitif à la lecture, et le post fixé sans raison c'est mal )

Rhianafoot
#define ULTRA5(_x) (((_x)%5) == 0) #define ULTRA3(_x) (((_x)%3) == 0) for(x = 1; x < 101; x++) { if (ULTRA3(x)) printf("Fizz"); if (ULTRA5(x)) printf("Buzz"); if (!ULTRA3(x) && !ULTRA5(x)) printf("%d", x); printf("\n"); }

Content ?

C'est mieux mais niveau performances c'est toujours moisi

bof

En fait il faut un generateur de code tu as raison:
#define ULTRA5(_x) (((_x)%5) == 0) #define ULTRA3(_x) (((_x)%3) == 0) int main() { int x; printf("int main() { printf(\""); for(x = 1; x < 101; x++) { if (ULTRA3(x)) printf("Fizz"); if (ULTRA5(x)) printf("Buzz"); if (!ULTRA3(x) && !ULTRA5(x)) printf("%d", x); printf("\\n"); } printf("\"); }\n"); }

Voila !

Apres on compile ca on execute et ca nous genere un code parfaitement optimisé !

Pen^2 (./885) :
C'est mieux mais niveau performances c'est toujours moisi

Ouais enfin, de la part d'un mec qui code en Java...

Meowcate (./881) :
Pour commencer, je ne vois pas pourquoi il te faut une fonction pour le simple truc qu'il te fait.

Vous vouliez un truc lisible, donc c'est du self-documenting.

Godzil (./882) :
4 ligne de code

Si c'est ça ton critère, ma première version (./860) fait la même chose que tes 7 lignes (parce qu'il y a aussi la boucle) en 1 ligne.

ca marche

Non, il y a au moins 2 erreurs de syntaxe.

c'est simple

Ton 101 sort de nulle part.

et compréhensible par tout le monde

Seulement ceux qui connaissent les modulos.

et se traduit en code ARM de manière super simple!

Non, le compilateur doit faire une common subexpression elimination pour éliminer les modulos redondants.

Ton code est juste complexe bloaté et plein de truc absolument inutile.

C'est le code fait pour être lisible, pas pour être minimal. Le ./860, en revanche, n'est pas du tout bloaté, mais personne n'en voulait.

Sinon, je peux aussi vous proposer le ./866 sans le self-documenting:

#include <stdio.h>

int main(void) {
  int i;
  for (i = 1; i <= 100; i++) {
    if ((i % 3) == 0) {
      if ((i % 5) == 0) {
        fputs("FizzBuzz ", stdout);
      } else {
        fputs("Fizz ", stdout);
      }
    } else {
      if ((i % 5) == 0) {
        fputs("Buzz ", stdout);
      } else {
        printf("%d ", i);
      }
    }
  }
  return 0;
}

(J'ai remplacé counter par i et inliné les 2 fonctions.)

Zerosquare> la moindre des choses c'est de ne faire les choses qu'une fois

Kevin Kofler (./888) :
Vous vouliez un truc lisible, donc c'est du self-documenting.

Sauf que comme toujours tout est une question de mesure entre le code tellement compact qu'il devient illisible et le code tellement verbeux qu'il devient indigeste. Tu es juste passé d'un extrême à l'autre.

Kevin Kofler (./888) :

Godzil (./882) :
4 ligne de code

Si c'est ça ton critère, ma première version (./860) fait la même chose que tes 7 lignes (parce qu'il y a aussi la boucle) en 1 ligne.

On parle en ligne intelligibles. Pour comprendre ce que faisait ton code j'ai du le ré-indenter et le résultat faisait 12 lignes

Kevin Kofler (./888) :
Seulement ceux qui connaissent les modulos.

ça fait quand même partie de ce que l'on peut attendre d'un professionnel.

Oui, les modulos n'importe quel cours de programmation tu vois ca tres vite ^^

Folco and GT style (Et sans les mains !!!)


move.w #100-1,d0
Connerie_de_boucle:

J'embete le java, le php, les tortues ninjas etc...

dbra d0,Connerie_de_boucle

(Pour evitez l'espionnage industriel nous avons décidez de pas publier la 'powerfull pleine de technique de 'oufs' partie principale !!)


GT et Folco

Le 101 est plutot clair pourtant, mais tu prefere tu peux ecrire (100 + 1), mais bon

Si tu ne sais pas que si tu ecrit x < 100 tu ne vas pas jusqu'a 100 alors que l'enoncé demande d'aller de 1 a 100.

et ecrire x <= Y c'est juste moche.

Kevin: tu semble bien mal connaitre le boulot fait par un optimisateur. plus ton code est complexe, moins il a de chance d'etre correctement optimisé, et non tu ne ferra pas mieux dans 99% des cas que l'optimisateur du language.

Pen²: je ne suis pas d'accord sur la "répétition" du code, le compilateur est loin d'etre idiot et est tout a fait capable de detecter ce genre de choses, et au contraire ca rends le code plus limite.

Apres libre a toi de faire un truc comme:
#define HIGH_LIMIT (100) for(x=0; x < (HIGH_LIMIT + 1); x++) { bool isMul3 = ( x == ((x / 3) * 3) ); bool isMul5 = ( x == ((x / 5) * 5) ); if (isMul3) printf("Fizz"); if (isMul5) printf("Buzz"); if (!isMul3 && !isMul5) printf("%d", x); printf("\n"); }

mais tu sais, ton compilateur a 99.9999% de chance de generer un code identique a ce que je viens de faire la. Alors pourquoi se faire chier a ecrire du code plus complexe pour, par grand chose?

Edit: ajout du printf("\n"); manquant

Juste pour m'amuser, j'ai compilé les version des posts 866, 882 et 886 (celui la en deux version, une avec la division entiere, l'autre avec le modulo)

Tout compilé en gcc -O3 fizz_xxx.c -o fizz_xxx

Premier constat:
[godzil@jiji Code]$ ls -l fizz_*
-rwxr-xr-x 1 godzil godzil 5227 May 14 12:22 fizz_882
-rwxr-xr-x 1 godzil godzil 5211 May 14 12:23 fizz_886
-rwxr-xr-x 1 godzil godzil 5613 May 14 12:04 fizz_kevin866
-rwxr-xr-x 1 godzil godzil 5211 May 14 12:23 fizz_modulo886

Kevin je peux t'appeler l'optimisateur humain!
On vois aussi que utiliser une division entiere + multiplication n'a pas d'impact sur la taille du code generé.

On remarquera aussi que la difference entre la version du 882 qui fait plusieurs fois le meem calcul est pas enorme comparé a la version du 886.

Essayont de voir ce qu'il se passe. Un coup de objdump -d fizz_XXX > fizz_XXX.s:

Fichier joint : fizz_882.s
Fichier joint : fizz_886.s
Fichier joint : fizz_kevin866.s
Fichier joint : fizz_modulo886.s

un peu d'explication plus tard dans la matinée

Pen^2 (./885) :
C'est mieux mais niveau performances c'est toujours moisi

Je ne suis pas spécialiste en compilo, mais j'imagine comme Godzil que c'est optimisé par le compilo, non ?

Comme bien sur le compilateur n'optimise pas, la seule difference que genere cette difference de code:
bool isMul3 = ( x == ((x / 3) * 3) ); bool isMul5 = ( x == ((x / 5) * 5) );

vs bool isMul3 = ( (x % 3) == 0 ); bool isMul5 = ( (x % 5) == 0 );

C'est l'ordre des registres sur deux cmp 804838c: 39 d8 cmp %ebx,%eax 804838e: 0f 94 c0 sete %al 8048391: 89 c7 mov %eax,%edi 8048393: b8 56 55 55 55 mov $0x55555556,%eax 8048398: f7 eb imul %ebx 804839a: 29 ca sub %ecx,%edx 804839c: 8d 04 52 lea (%edx,%edx,2),%eax 804839f: 39 d8 cmp %ebx,%eax
VS 804838c: 39 c3 cmp %eax,%ebx 804838e: 0f 94 c0 sete %al 8048391: 89 c7 mov %eax,%edi 8048393: b8 56 55 55 55 mov $0x55555556,%eax 8048398: f7 eb imul %ebx 804839a: 29 ca sub %ecx,%edx 804839c: 8d 04 52 lea (%edx,%edx,2),%eax 804839f: 39 c3 cmp %eax,%ebx

l'asm x86 est vraiment moche, illisibile, etc...

La on comprend pourquoi il y a plus 'd'asmeux' 68000 que x86.


GT Lisible

Du temps que j'y pense:

Kevin Kofler (./888) :
C'est le code fait pour être lisible, pas pour être minimal. Le ./860, en revanche, n'est pas du tout bloaté, mais personne n'en voulait.

Je vois un truc comme ça dans un code review, ou même commite dans un dépôt, et je peux te dire que la personne va passer un sale quart d'heure.

C'est EXACTEMENT le genre de code qui n'est ni clair ni maintenable, et que toutes personne un tant soit peu sérieuse cherche a surtout ne jamais produire, tant que ce n'est pas STRICTEMENT nécessaire (et donc fortement documente du pourquoi c'est comme ça et pas autrement.

(euh, c'est pas toi qui t'éclate en postant régulièrement du code absolument imbitable ? )