Partage
  • Partager sur Facebook
  • Partager sur Twitter

[Concours]Le code le plus sale

Laissez sortir le programmeur sale qui est en vous

    26 novembre 2010 à 17:10:11

    Citation : artificier59


    <troll>Si on veut du code illisible, c'est facile, suffit d'indenter au style gnu ^^ </troll>



    +1 :p

    Sinon, j'ai retrouver un de mes vieux code lorsque j'apprenais GTK+, il était destiné a crée un afficheur d'image simple. Il ne vaut pas tous les codes montrer jusqu'à présent mais je le trouve relativement sale et alambiqué. Je précise que j'ai abandonné le style GNU depuis :-°


    #include <stdio.h>
    #include <errno.h>
    #include <stdlib.h>
    #include <string.h>
    #include <gtk/gtk.h>
    #include <glib.h>
    #include <ctype.h>
    
    #if ! defined (WIN32)
    #	include <sys/types.h>
    #endif
    
    
    static struct SimpleViewer
    {
      gchar *pathFile;
      gchar *pathDirectory;
        
      GDir *currentDirectory;
      gint currentFile;
        
      GPtrArray *liste;
      GtkWidget *statusBar;
    } this;
    
    
    
    gint compare(gconstpointer a, gconstpointer b)
    {
      gchar **c = (gchar **)a;
      gchar **d = (gchar **)b;
        
      gchar *chaine1 = *c;
      gchar *chaine2 = *d;
    
      for(; tolower(*chaine1) == tolower(*chaine2); chaine1++, chaine2++)
        if(*chaine1 == '\0')
          return 0;
       
      return tolower(*chaine1) - tolower(*chaine2);    
    }
    
    
    gboolean isImage(gchar const *img)
    {
      if(g_str_has_suffix(img, ".gif") || g_str_has_suffix(img, ".jpg") || g_str_has_suffix(img, ".png") || g_str_has_suffix(img, ".bmp") || g_str_has_suffix(img, "svg"))
        {
          return 1;
        }
      else
        {
          return 0;
        }
    }
    
    
    void showFileName(void)
    {
      guint contextID;
        
      contextID = gtk_statusbar_get_context_id(GTK_STATUSBAR(this.statusBar), "Current file name");
      gtk_statusbar_push(GTK_STATUSBAR(this.statusBar), contextID, g_ptr_array_index(this.liste, this.currentFile));
    }
    
    
    GtkWidget* loadDir(gchar const *path)
    {
      guint i = 0;
      gchar *tmp = NULL;
      GtkWidget *image;
        
      this.pathFile = strrchr(path, '/');
        
      if(this.pathFile)
        {
          *this.pathFile++ = '\0';
          this.pathDirectory = (gchar *)path;
            
          this.currentDirectory = g_dir_open(this.pathDirectory, 0, NULL);
          this.liste = g_ptr_array_new();
            
          if(!this.currentDirectory || !this.liste)
    	return NULL;
            
          while((tmp = (gchar *)g_dir_read_name(this.currentDirectory)) != NULL)
    	if(isImage(tmp))
    	  g_ptr_array_add(this.liste, tmp);
            
          g_ptr_array_sort(this.liste, compare);
            
          for(i = 0; i < this.liste->len; i++)
            {
    	  if(!strcmp(this.pathFile, g_ptr_array_index(this.liste, i)))
                {
    	      this.currentFile = i;
    	      break;
                }
            }
            
          tmp = g_strconcat(this.pathDirectory, "/", this.pathFile, NULL);
          image = gtk_image_new_from_file(tmp);
          g_free(tmp);
            
          showFileName();
        }
      else
        {
          image = gtk_image_new_from_file(path);
        }
        
        
      if(!image)
        return NULL;
      else
        return image;
    }
    
    
    void nextImage(GtkWidget *image)
    {
      gchar *tmp;
        
      if(++this.currentFile >= this.liste->len)
        this.currentFile = 0;
        
      if(image)
        {
          tmp = g_strconcat(this.pathDirectory, "/", g_ptr_array_index(this.liste, this.currentFile), NULL);
          gtk_image_set_from_file(GTK_IMAGE(image), tmp);
          g_free(tmp);
        }
        
      showFileName();
    }
    
    
    void previousImage(GtkWidget *image)
    {
      gchar *tmp;
        
      if(--this.currentFile < 0)
        this.currentFile = this.liste->len - 1;
        
      if(image)
        {
          tmp = g_strconcat(this.pathDirectory, "/", g_ptr_array_index(this.liste, this.currentFile), NULL);
          gtk_image_set_from_file(GTK_IMAGE(image), tmp);
          g_free(tmp);
        }
        
      showFileName();
    }
    
    
    
    
    
    int main(int argc, char *argv[])
    {
      GtkWidget *window;
      GtkWidget *vbox;
      GtkWidget *hbox;
      GtkWidget *imageBox;
      GtkWidget *previous, *next;
        
      GtkWidget *image = NULL;
        
      GtkWidget *menuBar;
      GtkWidget *fileMenu, *fileMenuOpen, *fileMenuQuit, *fileMenuName;
    	
      gtk_init(&argc, &argv);
    	
      window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      gtk_window_set_title(GTK_WINDOW(window), "Simple Viewer");
      gtk_window_set_default_size(GTK_WINDOW(window), 640, 480);
    	
      vbox = gtk_vbox_new(FALSE, 2);
      gtk_container_add(GTK_CONTAINER(window), vbox);
        
      hbox = gtk_hbox_new(FALSE, 2);
        
      menuBar = gtk_menu_bar_new();
      fileMenu = gtk_menu_new();
        
      fileMenuName = gtk_menu_item_new_with_label("File");
      fileMenuOpen = gtk_menu_item_new_with_label("Open");
      fileMenuQuit = gtk_menu_item_new_with_label("Quit");
        
      gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileMenuName), fileMenu);
      gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), fileMenuOpen);
      gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), fileMenuQuit);
      gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), fileMenuName);
      gtk_box_pack_start(GTK_BOX(vbox), menuBar, FALSE, FALSE, 3);
    	
      previous = gtk_button_new_from_stock(GTK_STOCK_UNDO);
      next = gtk_button_new_from_stock(GTK_STOCK_REDO);
      imageBox = gtk_scrolled_window_new(NULL, NULL);
        
      this.statusBar = gtk_statusbar_new();
    	
      gtk_box_pack_start(GTK_BOX(hbox), previous, FALSE, FALSE, 5);
      gtk_box_pack_start(GTK_BOX(vbox), imageBox, TRUE, TRUE, 5);
      gtk_box_pack_start(GTK_BOX(hbox), next, FALSE, FALSE, 5);
      gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
        
      gtk_box_pack_start(GTK_BOX(vbox), this.statusBar, FALSE, FALSE, 5);
        
      if(argc > 1)
        image = loadDir(argv[1]);
        
      if(image)
        gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(imageBox), image);
        
      g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
      g_signal_connect(G_OBJECT(fileMenuQuit), "activate", G_CALLBACK(gtk_main_quit), NULL);
        
      g_signal_connect_swapped(G_OBJECT(next), "clicked", G_CALLBACK(nextImage), image);
      g_signal_connect_swapped(G_OBJECT(previous), "clicked", G_CALLBACK(previousImage), image);
        
      gtk_widget_show_all(window);
      gtk_main();
        
      if(this.liste)
        {
          g_ptr_array_free(this.liste, TRUE);
          g_dir_close(this.currentDirectory);
        }
      return EXIT_SUCCESS;
    }
    

    • Partager sur Facebook
    • Partager sur Twitter
      28 novembre 2010 à 11:33:06

      J'en profite pour publier un nouveau code:
      #include<stdio.h>
      
      int main(void)
      {
      
      int _ = 0;printf("Rectangle?(y ou n)");if(getchar()-'n')_ |=1;getchar();
      printf("Triangle?");if(getchar()-'n')_ |=2;getchar();printf("Losange?");if(getchar()-'n')_ |=4;getchar();
      printf("\n");if(_&2)
      for(int __ = 6;__;__--,printf("\n"))for(int i = 0;i<7;i++)printf("%c",(!i??!??!!(i-6)??!??!(!(__-6)||__==1))?'??=':' ');// Triangle
      if(_&1)??<for(int __ = 6;__;__--,printf("\n"))for(int i = 0;i<7;i++)printf("%c",(!i??!??!!(i-__)??!??!!(__-6))?'??=':' ');printf("#");??>// rectangle
      printf("\n");
      if(_&4)for(int i = 0;i<10;i++,printf("%c",(i-5)?'\n':0))for(int __ = 9;__;__--)//Cercle
      if(i-5)printf("%c",__<=(5+((i/5)?9-i:i))&&__>=(5-((i/5)?9-i:i))?'??=':' ');return 0;??>
      


      Compile en C99 seulement, il propose plusieurs forme et les dessines.

      Je l'améliorerais dans la journée.
      • Partager sur Facebook
      • Partager sur Twitter

      🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.

        28 novembre 2010 à 11:58:29

        Citation : Smil

        Une version qui combine illisibilité, mauvaise indentation, langage sms et inutilité d'un programme qui vous fait entrer dix nombres et vous les affiches :

        #include "defines.h"
        
        bof chutjecode debutgood fingood
        cparti
        bof useless debutplein BOCOU finplein finligne
        bof truc quivaut riendutout vIrGuLe kikoo quivaut cvrai finligne
        tarretespas debutgood kikoo fingood cparti
        lismoica debutgood "ecri 1 nb!!!" fingood finligne
        vazytupeuxecrire debutgood "%d" vIrGuLe dans useless debutplein truc finplein fingood finligne
        truc quivaut truc ogmente finligne
        siparhasard debutgood truc estpareil nbmagik fingood
        kikoo quivaut riendutout finligne dejalafin
        lismoica debutgood "ta ecri\n" fingood finligne
        tarretespas debutgood truc paspareilque riendutout fingood cparti
        truc quivaut truc diminu finligne
        lismoica debutgood "%d\n" vIrGuLe useless debutplein truc finplein fingood finligne dejalafin
        dejalafin
        



        Et le header, avec tous les defines :
        <secret>

        #include <stdio.h>
        #include <stdlib.h>
        #define bof int
        #define debutplein [
        #define finplein ]
        #define debutgood (
        #define fingood )
        #define cparti {
        #define dejalafin }
        #define BOCOU 111111
        #define chutjecode main
        #define finligne ;
        #define vazytupeuxecrire scanf
        #define lismoica printf
        #define tarretespas while
        #define cvrai 1
        #define riendutout 0
        #define quivaut =
        #define vIrGuLe ,
        #define dans &
        #define ogmente +1
        #define siparhasard if
        #define nbmagik 11
        #define paspareilque !=
        #define diminu -1
        #define estpareil ==
        

        </secret>

        La puissance des defines dans sa splendeur !! :p

        Citation : Loadware

        Pas mal comme concours, ça me rappelle le code de Nanoc posté dans un topic récent :
        <secret>

        #include <stdio.h>
        
        #define      M 002354l 
        #define     A   000644l 
        #define    G     000132l 
        #define     I   000322l 
        #define      C 000374l 
        
        #define                a ; 
        #define               b for 
        #define              c    ++ 
        #define             d       % 
        #define            e       int 
        #define           f           , 
        #define          g             - 
        #define         h             011 
        #define        i                 = 
        #define       j                   { 
        #define      k                     ) 
        #define     l                    '\n' 
        #define    m                      main 
        #define    n                         < 
        #define     o                       } 
        #define      p                     > 
        #define       q                  && 
        #define        r                 ( 
        #define         s              || 
        #define          t             ? 
        #define           u     putchar 
        #define            v      void 
        #define             w     '*' 
        #define              x     : 
        #define               y ' ' 
        #define                _ / 
        #define           C_O_O_L return 
        
                           e u r e k a 
                                 e 
                                m r 
                               v k j 
                              j j j j 
                             j j j j j 
                            j j j j j j 
                           j j j j j j j 
                          j e z a b r z i 
                         M _ A _ G _ I _ C 
                        a z n G a u r z d h 
                       + z _ h p M _ A q z d 
                      h + z _ h n M _ G q z _ 
                     h n z d h + M _ I q z _ h 
                    p z d h g M _ C t w x y k f 
                   z d h g h + 1 s u r l k f z c 
                  k a u r l k a j j j j j j j j j 
                 j j C_O_O_L M _ A _ G _ I _ C a o 
                o o o o o o o o o o o o o o o o o o 
                              o o o o 
                              o o o o 
                              o o o o 
                              o o o o
        

        </secret>

        Ce code n'est pas de moi, je ne participe pas :-°

        </span>

        Citation : Pouet_forever

        Aller, histoire de s'amuser. :lol:

        <secret>

        #include <stdio.h>
        #include <stdlib.h>
        #include <time.h>
        
        #define T 
        #define   L                       goto
        #define     D                   int
        #define       F               rand
        #define         Z           while
        #define           J       scanf
        #define             xD  gmtime
        #define               Z_
        #define             P   )
        #define           A       "%d"
        #define         U           puts
        #define       K              }
        #define     G                 srand
        #define   W                     return
        #define _S
        #define   H                   time
        #define     _M_             main
        #define         X         =
        #define           C     i
        #define             _D_
        #define           I     do
        #define         Q         if
        #define       B             %d
        #define     O                 {
        #define   Y                     %
        #define S                         break
        #define   E                      (
        #define     R                   else
        #define       V                ;
        #define         _W            printf
        #define                  qsort
        #define               L_O_L
        
        _S _D_ Z_ D _M_ E P O D C, n, r V G E H E NULL P P V C X F E P Y 100 V r X
        _S _D_ Z_ 10 V I SDZ : O Q E r <= 0   P O U E T   "Perdu !" P V L POUET V K J E
        _S _D_ Z_ A, &n P V r-- V Q E n > C _S _D_ Z_   P O U E T   "-" P V L SDZ V _S _D_ Z_
        _S _D_ Z_ K R Q E n < C   P O U E T   "+" P V L SDZ V K T R O U E  _S _D_ Z_
        _S _D_ Z_ "Trouvé !" P V S V K K Z E ~0 P V   POUET   : W 0 V K _S _D_ Z_
        

        </secret>
        Edit : Petit oubli. :-°
        Re-édit: Bug sur l'indentation. :D

        J'adore ce topic! :waw: ! Je participerais quand j'aurais le temps! ;)
        • Partager sur Facebook
        • Partager sur Twitter
          28 novembre 2010 à 14:21:51

          J'ai remarqué ce concours y a 2 secondes, voila ma petite participation:

          [Code candidat]


          [Obfusc]


          //le fichier DEFINE.h 
          #include<stdio.h>
          #include<stdlib.h>
          #include<time.h>
          #define jeSuiUnPoint ;
          #define jeSuisUnMsg printf("PERDU !\n")
          #define jeSuisUnEntier int
          #define jeSuisUnMSG printf("GAGNE !\n");
          #define jeSuisUnFou srand(time(NULL))
          #define __ (rand() - 10)
          #define jeSuisUnVide void
          #define jeSuisUnMain main
          #define jeSuisUnPO (
          #define jeSuisUnPF )
          //le fichier source.c
          #include"DEFINE.h"
          jeSuisUnVide jeSuisUnMain jeSuisUnPO jeSuisUnVide jeSuisUnPF
          {
          jeSuisUnEntier nbMyst jeSuisUnPoint
          jeSuisUnEntier nbEnter jeSuisUnPoint
          jeSuisUnFou jeSuisUnPoint
          nbMyst = __ jeSuisUnPoint
          printf("Entrez nbMyst: ");
          scanf("%d", &nbEnter) jeSuisUnPoint
          while jeSuisUnPO nbMyst != nbEnter jeSuisUnPF
          {
          if jeSuisUnPO nbMyst > nbEnter jeSuisUnPF
          {
          printf("plus !\nnbMyst: ") jeSuisUnPoint
          scanf("%d",&nbEnter) jeSuisUnPoint
          }
          else 
          {
          printf("moins !\nnbMyst: ") jeSuisUnPoint
          scanf("%d",&nbEnter) jeSuisUnPoint
          }
          }
          jeSuisUnMSG jeSuisUnPoint
          }
          

          Voila !
          EDIT: Oups ! j'ai mis un retour a une fonction sur void :p
          • Partager sur Facebook
          • Partager sur Twitter
          "Il est impossible pour un homme d'apprendre ce qu'il croit déjà connaître"
            28 novembre 2010 à 14:28:46

            C'est un peu facile de ne "salir" que grâce au prépro, non? ;)
            • Partager sur Facebook
            • Partager sur Twitter
            Zeste de Savoir, le site qui en a dans le citron !
            Anonyme
              28 novembre 2010 à 14:31:08

              void main(void) !?
              • Partager sur Facebook
              • Partager sur Twitter
                28 novembre 2010 à 14:32:21

                Je trouve aussi GurneyH :) .
                • Partager sur Facebook
                • Partager sur Twitter
                  28 novembre 2010 à 14:33:45

                  Oui, c'est un code un peu bof...

                  Citation : Bart Simpson

                  On me dit toujours d'aller a l'église et maintenant que j'y vais c'est pas la bonne !


                  Chui dans le même cas ^^
                  • Partager sur Facebook
                  • Partager sur Twitter
                  "Il est impossible pour un homme d'apprendre ce qu'il croit déjà connaître"
                    28 novembre 2010 à 14:55:49

                    Pour résumer tous ces codes, je n'utiliserai qu'un mot: IGNOBLE o_O
                    • Partager sur Facebook
                    • Partager sur Twitter
                    Anonyme
                      28 novembre 2010 à 14:57:41

                      Citation : lepetitzero

                      Pour résumer tous ces codes, je n'utiliserai qu'un mot: IGNOBLE o_O


                      Oui, c'est le but \o/
                      • Partager sur Facebook
                      • Partager sur Twitter
                        28 novembre 2010 à 14:59:34

                        Jusque la j'ai principalement vu des codes moches, mais pas des codes sales ;)
                        • Partager sur Facebook
                        • Partager sur Twitter
                          28 novembre 2010 à 15:03:05

                          Idem. Rendre un code illisible n'est pas le but du topic, il faut le rendre bête.
                          • Partager sur Facebook
                          • Partager sur Twitter
                          Je suis professeur de mathématiques sur LiveMentor, pour niveaux collège/lycée/prépa MPSI :)
                            28 novembre 2010 à 15:05:07

                            Pourtant, Uknow parle d’offuscation dans son premier post.

                            Et je trouve que c'est un exercice bien plus intéressant que de faire un code dégueulasse. :)
                            • Partager sur Facebook
                            • Partager sur Twitter
                              28 novembre 2010 à 15:05:39

                              Participation sans indentation, illisible, useless, avec comments inutiles, SMS, et débile :

                              [Code candidat]


                              [Obfuscer]



                              main.c


                              #include "directives.h"
                              
                              entier programme_useless debut_kikoo rien_a_dire fin_kikoo youpii
                              entier nbm kikoo 0 et_puis nbe kikoo 0 fin_instruct   bougera_pas
                              entier maria kikoo 100 et_puis mario kikoo 1 fin_instruct //C tro
                              /*kikoo c truk!*/ INITHASARD() fin_instruct nbm kikoo debut_kikoo
                              HASARD()  sboub_useless  debut_kikoo  maria  unmore  mario   more
                              1 fin_kikoo fin_kikoo more mario fin_instruct /*C de plu  en  plu
                              kool ceu truk! */ fais_le youpii IMPRIMER("nonbr? ") fin_instruct
                              DEMANDER("%d", &nbe);  zeppo  debut_kikoo  nbm  sup nbe fin_kikoo
                              youpii  IMPRIMER("plusse!")  fin_instruct  EnOfLi()  fin_instruct
                              EnOfLi() fin_instruct finifini re zeppo debut_kikoo nbm  inf  nbe
                              fin_kikoo    youpii    IMPRIMER("moin!")  fin_instruct   EnOfLi()
                              fin_instruct   EnOfLi()   fin_instruct   finifini    re    youpii
                              IMPRIMER("braveau!") fin_instruct EnOfLi() fin_instruct  EnOfLi()
                              fin_instruct finifini  finifini   boucle_la    debut_kikoo    nbe
                              pas_chance nbm fin_kikoo   fin_instruct   FINIR(0)   fin_instruct
                              finifini //Oua cez tro kikoo ceu truke j'ai fait un super pavé:)!
                              

                              directives.h


                              #include<stdio.h>
                              #include<stdlib.h>
                              #include<time.h>
                              #define entier int
                              #define lentier long
                              #define caractere char
                              #define programme_useless main
                              #define debut_kikoo (
                              #define fin_kikoo )
                              #define rien_a_dire void
                              #define youpii {
                              #define finifini }
                              #define fin_instruct ;
                              #define debut_using [
                              #define fin_using ]
                              #define alors ||
                              #define aussi &&
                              #define rageux !
                              #define sup >
                              #define inf <
                              #define supe >=
                              #define infe <=
                              #define chance ==
                              #define pas_chance !=
                              #define boucle_la while
                              #define fais_le do
                              #define etoile *
                              #define et_puis ,
                              #define bougera_pas const
                              #define kikoo =
                              #define more +
                              #define unmore -
                              #define fricote *
                              #define unfricote /
                              #define sboub_useless %
                              #define zeppo if
                              #define re else
                              #define IMPRIMER(feuille) printf("%s", feuille)
                              #define DEMANDER scanf
                              #define EnOfLi() printf("\n")
                              #define INITHASARD() srand(time(NULL))
                              #define HASARD() rand()
                              #define FINIR(retour) return retour
                              

                              Résultat


                              nonbr? 2
                              plusse!
                              
                              nonbr? 5
                              plusse!
                              
                              nonbr? 80
                              plusse!
                              
                              nonbr? 90
                              moin!
                              
                              nonbr? 85
                              moin!
                              
                              nonbr? 83
                              braveau!
                              • Partager sur Facebook
                              • Partager sur Twitter
                                28 novembre 2010 à 15:08:10

                                Citation : Tosh

                                Pourtant, Uknow parle d’offuscation dans son premier post.

                                Et je trouve que c'est un exercice bien plus intéressant que de faire un code dégueulasse. :)


                                Dans ce cas faut changer le titre, a vrai dire, je n'ai lu aucun post, je n'ai que parcouru les codes ;)
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  28 novembre 2010 à 15:17:13

                                  Faut pas forcément rendre le code 'bête'? S'il est 'intelligent' mais compliquer à comprendre çà marche aussi. Enfin c'est ce que je pense.
                                  • Partager sur Facebook
                                  • Partager sur Twitter

                                  🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.

                                    28 novembre 2010 à 15:32:22

                                    C'est sûr qu'il ya des choses à dire sur le rapport du titre avec les codes qui sont présentés. Mon but était de pousser les gens à poster leur codes les plus "répugnants".

                                    Et parmi les règles qu'il fallait enfreindre c'était l'indentation, donc je pense que les catégories de codes "obfusqués" rentre dans ce principe. Je propose donc que nous votons plutôt un gagnant dans chaque catégorie (obfuscation, code plutôt sale et code illisible). Qu'en dites-vous ?
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      28 novembre 2010 à 15:35:28

                                      C'est une bonne idée ^^, mais pourquoi ne pas rajouter un gagnant toutes catégorie aussi ^^?

                                      PS: La date du concours reste jusque quand?
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                      http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                        28 novembre 2010 à 15:38:00

                                        Citation : qnope

                                        C'est une bonne idée ^^, mais pourquoi ne pas rajouter un gagnant toutes catégorie aussi ^^?

                                        PS: La date du concours reste jusque quand?



                                        Allé je propose le weekend prochain.

                                        12 décembre 2010 à minuit.
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          28 novembre 2010 à 15:39:14

                                          Il faut présenter un seul code ?
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            28 novembre 2010 à 15:41:43

                                            Et pour les catégories moi je dis ok. Mais à ce moment la on peux proposer plusieurs codes ?

                                            edit grilled.
                                            • Partager sur Facebook
                                            • Partager sur Twitter

                                            🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.

                                              28 novembre 2010 à 15:45:30

                                              Bonjour,

                                              voilà le code source que je propose:

                                              #include <stdio.h>
                                              #include <stdlib.h>
                                              #include <time.h>
                                              #define _gukzmu                                                                                                                                                                                 int main(){srand(time(NULL));int _=0,__=(rand()%100);printf("Bienvenue dans le jeu du Plus ou Moins\n\n");while (_ != __){printf("Entrer un nombre > ");scanf("%d", &_);if (_ > __)printf("C'est moins !\n");else if (_ < __)printf("C'est plus !\n");else printf("Gagn%c !", 130);}}
                                              _gukzmu
                                              
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                28 novembre 2010 à 15:46:26

                                                Je vais essayer de faire un code multiple alors ^^

                                                Ne pas mélanger les déclarations de variables avec le code.

                                                Ca signifie que les variables G doivent pas avoir le même nom que les variables "normal"?
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                http://cpp-rendering.io : Vous trouverez tout ce dont vous avez besoin sur Vulkan / OpenGL et le rendu 3D !
                                                  28 novembre 2010 à 15:46:52

                                                  Citation : Tosh

                                                  Il faut présenter un seul code ?



                                                  Vu le changement de la donne, chacun peut présenter un code de chaque catégorie.

                                                  PS : éditez vos anciens post marqués en vert et mettez une en-tête du genre

                                                  [Code candidat]

                                                  de façon à ce que je puisse repérer facilement les codes. Et bien évidemment indiquez à quelle catégorie le code appartient.

                                                  Exemple :

                                                  [Code candidat]



                                                  [Obfusc]


                                                  //code
                                                  

                                                  [Code sale]


                                                  //code
                                                  

                                                  [Code illisible]


                                                  //code
                                                  


                                                  Merci.
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    28 novembre 2010 à 15:47:50

                                                    Mais si on rentre dans plusieurs catégories ?
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                                                      28 novembre 2010 à 16:00:02

                                                      Citation : schadocalex

                                                      Mais si on rentre dans plusieurs catégories ?



                                                      Tu peux participer avec un code par catégorie. Ou ne participer qu'à une catégorie ou deux comme tu veux.
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        28 novembre 2010 à 16:13:56

                                                        Juste une précision:

                                                        Sale, c'est mal pensé.
                                                        Illisible, c'est pas lisible. // La je risque pas de me tromper
                                                        Obfuscer, c'est illisible et mal pensé.

                                                        Je me trompe ?
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter

                                                        🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.

                                                          28 novembre 2010 à 16:15:49

                                                          Je pense pas, sale comprend aussi la pertinence des noms des variables, les variables globales, mais ça peut être bien pensé quand même.
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                          "If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)
                                                            28 novembre 2010 à 16:18:44

                                                            Citation : @che


                                                            Sale, c'est mal pensé.
                                                            Illisible, c'est pas lisible. // La je risque pas de me tromper
                                                            Obfuscer, c'est illisible et mal pensé.



                                                            Sale : mal pensé si tu veux, mal indenté avec des noms de variables bidons (pas des __ mais des nom genre 'n' ou 'i' qui ne veulent rien dire...
                                                            Illisible : les codes de pouet_forever (je ne trouve pas de description meilleur :p DSL).
                                                            Obfusc : plutôt des codes qui montrent une figure de style (un objet, un OVNI...) fais travailler ton imagination ;) .
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              28 novembre 2010 à 16:18:44

                                                              Sale, c'est pour moi inefficace, mal indenté, peu élégant, lourd...

                                                              Illisible, c'est qu'il peut être efficace, mais reste très dur à relire.

                                                              Offusquer, c'est l'art de cacher complétement le fonctionnement du programme, pas diverses méthodes.

                                                              (Bon, en général, le résultat n'est pas forcément efficace, mais ce n'est pas forcé)
                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              [Concours]Le code le plus sale

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                              • Editeur
                                                              • Markdown