Partage
  • Partager sur Facebook
  • Partager sur Twitter

[ zSpirale] Exercice pour débutant

    11 novembre 2010 à 0:30:06

    Salut a tous, ce topic est la pour proposer les réponses de l'exercice proposé ici

    Reprise de l'enonce :


    Titre: zSpirale
    Mois: Novembre
    Sujet: Boucles, manipulation de tableaux à 2 dimensions et allocation dynamique

    zSpirale



    Le but de l'exercice consiste à déclarer un tableau à 2 dimensions et de le remplir en spirale. La spirale peut être faite du bord vers le centre ou du centre vers les bords, c'est vous qui choisissez. Vous pouvez faire les 2, et aussi changer le coin sur lequel on commence. :)

    Voilà un exemple de sortie pour le type 'bord vers centre' :

    00      01      02      03
    11      12      13      04
    10      15      14      05
    09      08      07      06


    *) Dans un premier temps on utilisera un tableau carré (hauteur=largeur) et il sera donc déclaré normalement (tab[10][10]),
    *) Ensuite on utilisera un tableau quelconque (hauteur!=largeur),
    *) Pour terminer, on essayera d'allouer un tableau à 2 dimensions dynamiquement (malloc, ne pas oublier les free).

    Voilà un début de code :

    #include <stdio.h>
    #include <stdlib.h>
    
    /* Défini la taille du tableau */
    #define SZ_TAB  10
    
    void zSpirale(int tableau[SZ_TAB][SZ_TAB]) {
      /* Le code ici */
    }
    
    void afficherTableau(int tableau[SZ_TAB][SZ_TAB]) {
      /* Le code ici */
    }
    
    int main(void) {
      int tableau[SZ_TAB][SZ_TAB];
      
      zSpirale(tableau);
      afficherTableau(tableau);
      return EXIT_SUCCESS;
    }
    


    Bon courage à tous. :)
    • Partager sur Facebook
    • Partager sur Twitter
    Zeste de Savoirbépocode minimal  — Ge0 <3
      11 novembre 2010 à 1:01:55

      Citation : simbilou

      ce topic est la pour proposer les réponses de l'exercice proposé ici


      [Ce serait plus pratique de recopier l'énoncé dans ce fil]




      Ça fait longtemps qu'on n'a pas eu un exo un peu original comme ça. Juste pour dire que le prototype proposé pour la fonction est très contraignant. Ici, notre fonction n'a juste besoin que d'une adresse mémoire qui correspond au début du tableau (je parle pas pas forcément de tableau strict au sens du C) et aux deux dimensions (la largeur et la hauteur), donc pour moi, le bon prototype serait plutôt :

      void zSpirale(int *b, int w, int h);
      /* b pour beginning, w pour width, h pour height */
      



      Après la manière dont la zone mémoire est allouée (tableaux statiques 1D ou 2D, tableaux dynamiques sous une forme ou sous une autre) ne regarde pas la fonction, ce qui lui donne une interface beaucoup plus générique que celle que tu proposes.


      On peut aussi définir une structure remplissage qui prend en compte ce qui précède et d'autres facteur comme le début du remplissage, la direction de remplissage mais bon là c'est des cerises sur le gâteau.

      Bien sûr, on pourrait faire encore plus générique en autorisant des tableaux de types d'objets quelconques mais cela compliquerait l'interface et ce serait assez artificiel.
      • Partager sur Facebook
      • Partager sur Twitter
        11 novembre 2010 à 1:26:31

        Je pense qu'il est plus simple pour un débutant d'avoir tout 'comme dans le cours' et ensuite éventuellement diverger sur quelque chose de plus générique, plutôt que commencer directement avec quelque chose d'inconnu et où ils doivent chercher comment utiliser ce pseudo tableau générique. Ca en dégoutera plus d'un, du moins c'est mon avis.
        Ce serait pas mieux de le mettre dans un nouveau point dans l'exercice ?
        • Partager sur Facebook
        • Partager sur Twitter
          11 novembre 2010 à 1:30:07

          Citation : Pouet_forever

          Je pense qu'il est plus simple pour un débutant d'avoir tout 'comme dans le cours' et ensuite éventuellement diverger sur quelque chose de plus générique, plutôt que commencer directement avec quelque chose d'inconnu et où ils doivent chercher comment utiliser ce pseudo tableau générique. Ca en dégoutera plus d'un, du moins c'est mon avis.



          C'est mon avis aussi et il faut commencer par la méthode traditionnelle. Une fois codée, on se rend mieux compte de ses déficiences.
          • Partager sur Facebook
          • Partager sur Twitter
            11 novembre 2010 à 11:49:30

            Citation : candide


            void zSpirale(int *b, int w, int h);
            /* b pour beginning, w pour width, h pour height */
            




            Je doit avouer que j'ai pense uniquement a une implementation de type tableau 2D. Ce qui donne un prototype de ce style :
            void zSpirale( int **tab, int w, int h)
            


            Mais une fois l'algo trouver, passer d'une structure a une autre ne devrait pas pose trop de probleme.


            • Partager sur Facebook
            • Partager sur Twitter
            Zeste de Savoirbépocode minimal  — Ge0 <3
              11 novembre 2010 à 17:25:26

              Alors j'ai une petite proposition de réponse :


              Je crée d'abord une énumération :
              typedef enum Direction Direction;
              enum Direction
              {
                  DROITE, BAS, GAUCHE, HAUT
              };
              



              main() :
              int main(int argc, char **argv)
              {
                  int j;
                  int **tableau = NULL;
              
                  // Taille du tableau :
                  int w = 3;
                  int h = 5;
              
                  if ((tableau = malloc(h * sizeof(int*))) == NULL)
                  {
                      printf("Erreur lors de l'allocution dynamique 1");
                      exit(EXIT_FAILURE);
                  }
              
                  for (j = 0; j < h; j ++)
                  {
                      if ((tableau[j] = malloc(w * sizeof(int))) == NULL)
                      {
                          printf("Erreur lors de l'allocution dynamique 2");
                          exit(EXIT_FAILURE);
                      }
                  }
              
              
                  inscritTableau(tableau, w, h);
                  afficheTableau(tableau, w, h);
              
              
              
                  printf ("\nLibération du tableau!\n");
              
                  for (j = 0; j < w - 1; j ++)
                  {
                      free(tableau[j]);
                  }
              
                  free(tableau);
              
              
                  return EXIT_SUCCESS;
              }
              



              inscritTableau() :

              void inscritTableau(int **tableau, int w, int h)
              {
              
                  // point de départ :
                  int i = w - 1;
                  int j = h - 1;
                  
                  Direction direction = GAUCHE;
              
                  int z = 1;
                  int nb_case = w * h;
              
              
                  while (z <= nb_case)
                  {
              
                      tableau[j][i] = z;
              
                      switch (direction)
                      {
                          case DROITE:
                              if (i + 1 < w && tableau[j][i+1] == 0)
                                  i ++;
                              else
                              {
                                  direction = BAS;
                                  j ++;
                              }
                              break;
              
                          case BAS:
                              if(j + 1 < h && tableau[j+1][i] == 0)
                                  j ++;
                              else
                              {
                                  direction = GAUCHE;
                                  i --;
                              }
                              break;
              
                          case GAUCHE:
                              if (i - 1 >= 0 && tableau[j][i-1] == 0)
                                  i --;
                              else
                              {
                                  direction = HAUT;
                                  j --;
                              }
                              break;
              
                          case HAUT:
                              if (j - 1 >= 0 && tableau[j-1][i] == 0)
                                  j --;
                              else
                              {
                                  direction = DROITE;
                                  i ++;
                              }
                              break;
                      }
              
                      z ++;
                  }
              }
              


              afficheTableau() :
              void afficheTableau(int **tableau, int w, int h)
              {
                  int i, j;
              
                  printf ("Contenu du tableau spiral de %d lignes et %d colonnes\n", h, w);
                  printf("\n");
              
                  for (j = 0; j < h; j ++)
                  {
                      for (i = 0; i < w; i ++)
                      {
                          printf("%d ", tableau[j][i]);
                      }
                      printf("\n");
                  }
              }
              



              On indique le coin de départ dans la fonction inscritTableau() ainsi que la direction correspondante (droite, bas, gauche, haut). Puis on boucle en incrémentant chaque tour z. Si la case suivante est déjà occupé ou si elle n'existe pas, alors on change de direction.

              Par contre, pour l'allocution dynamique, j'ai essayé de la mettre dans ma fonction inscritTableau() (parce que je trouve ça assez moche de devoir faire l'allocution dans le main()) mais rien à faire, je n'y arrive pas.

              Voilà
              • Partager sur Facebook
              • Partager sur Twitter
                11 novembre 2010 à 18:21:32

                C'est pas mal
                L'affichage peut etre beaucoup optimise par contre. Parce que a premiere vu, tu vas avoir un decalage quand tu vas passer de nombre de 1 a 2 chiffres (ou meme a 3 chiffres si le tableau est grand). Et ce n'est pas tres seyant.

                Maintenant tu peux essayer de faire partir la spirale d'un autre coin, ou meme du milieu.

                Pour l'allocation dynamique (et non pas allocution ;) ), dans le main c'est encore le plus simple. Sinon il faudrait passer a la fonction l'adresse de ton tableau de pointeur. Soit un int*** ! Par contre si la deuxieme allocation plante, il faudrait que tu libere ce que tu peux avant de fermer le programme.
                • Partager sur Facebook
                • Partager sur Twitter
                Zeste de Savoirbépocode minimal  — Ge0 <3
                  11 novembre 2010 à 18:27:35

                  Voilà mon code, ya beaucoup de blabla qui ne sert à rien (malloc et cie), le principal se situe entre les lignes 43 et 60. :)

                  #include <stdio.h>
                  #include <stdlib.h>
                  #include <math.h>
                  #include <string.h>
                  
                  enum {
                    TOP_L, TOP_R,
                    BOT_R, BOT_L
                  };
                  
                  void zSpirale(int ** tab, int h, int w, int corner, int way) {
                    /* { x, y } */
                    int dir[4][2] = {
                      { 1, 0 } , { 0, 1 }, { -1, 0 }, { 0, -1 }
                    };
                    int x, y;
                    int i, j;
                    int n, max;
                    
                    for (i = 0; i < h; i++)
                      memset(tab[i], 0, w * sizeof **tab);
                    
                    x = dir[corner][0] * way;
                    y = dir[corner][1] * way;
                    
                    if (corner == TOP_L) {
                      i = 0;
                      j = 0;
                    }
                    else if (corner == TOP_R) {
                      i = 0;
                      j = w - 1;
                    }
                    else if (corner == BOT_L) {
                      i = h - 1;
                      j = 0;
                    }
                    else if (corner == BOT_R) {
                      i = h - 1;
                      j = w - 1;
                    }
                    
                    n = 2;
                    max = h * w;
                    tab[i][j] = 1;
                    while (n <= max) {
                      int tmpj = j + x;
                      int tmpi = i + y;
                      
                      if (tmpi < 0 || tmpj < 0 || tmpi >= h || tmpj >= w ||
                          tab[tmpi][tmpj] != 0) {
                        corner = (corner + 1) % 4;
                        x = dir[corner][0];
                        y = dir[corner][1];
                      }
                      else {
                        j = tmpj;
                        i = tmpi;
                        tab[i][j] = n;
                        n++;
                      }
                    }
                  }
                  
                  void printTab(int ** tab, int h, int w) {
                    int i, j;
                    char format[25];
                    int sz = log10(h * w) + 1;
                    
                    sprintf(format, "%%-%dd ", sz);
                    
                    for (i = 0; i < h; i++) {
                      for (j = 0; j < w; j++) {
                        printf(format, tab[i][j]);
                      }
                      puts("");
                    }
                  }
                  
                  int ** allocTab(int h, int w) {
                    int ** t;
                    int i;
                    
                    t = malloc(sizeof *t * h);
                    if (!t)
                      return NULL;
                    for (i = 0; i < h; i++) {
                      t[i] = malloc(sizeof **t * w);
                      if (!t)
                        goto error;
                    }
                    
                    return t;
                    
                  error:
                    for (i; i >= 0; i--)
                      free(t[i]);
                    free(t);
                    return NULL;
                  }
                  
                  void freeTab(int ** tab, int h) {
                    int i;
                    
                    for (i = 0; i < h; i++)
                      free(tab[i]);
                    free(tab);
                  }
                  
                  #define W_TAB   4
                  #define H_TAB   4
                  
                  int main(void) {
                    int ** tab;
                    int h = H_TAB;
                    int w = W_TAB;
                    
                    tab = allocTab(h, w);
                    if (!tab) {
                      perror("malloc");
                      return EXIT_FAILURE;
                    }
                    
                    zSpirale(tab, h, w, BOT_R, -1);
                    printTab(tab, h, w);
                    freeTab(tab, h);
                    return EXIT_SUCCESS;
                  }
                  

                  7  6  5  4  
                  8  15 14 3  
                  9  16 13 2  
                  10 11 12 1

                  -
                  Edité par Pouet_forever 17 avril 2018 à 14:57:15

                  • Partager sur Facebook
                  • Partager sur Twitter
                    11 novembre 2010 à 20:19:25

                    Voilà, ce que j'ai fait : je parcours le tableau du bord gauche vers le centre parce que c'est le plus simple :D . Et je n'ai pas ajouté le support de tableau de n'importe quelle taille avec l'allocation dynamique car je trouve que ça n'apporte pas grand chose.
                    Sur ce :
                    #include <stdio.h>
                    #include <stdlib.h>
                    
                    #define COLS 20
                    #define ROWS 23
                    
                    void
                    print_vector (int (*v)[COLS], int rows, int cols) {
                        int i, j;
                    
                        for (i = 0 ; i < rows ; putchar('\n'), ++i)
                            for (j = 0 ; j < cols ; ++j)
                                printf("%s%-.3d", j == 0 ? "" : " ", v[i][j]);
                    }
                    
                    int
                    main (void) {
                        int i, k, size, v[ROWS][COLS] = {{0}};
                        int l, r, b, t;
                    
                        l = t = 0; /* l représente la ligne à gauche du tableau (left) et t celle en haut (top). */
                        b = ROWS; /* b représente la ligne en bas du tableau. */
                        r = COLS; /* r représente la ligne à droite du tableau (right). */
                        size = ROWS*COLS;
                    
                    /* Soit m,n ∈ N tel que m soit le nombre de lignes d'une matrice
                       et n son nombre de colonne.
                       L'algorithme utilisé ici pour remplir la "matrice" en  spirale
                       est en O(m*n), s'il n'y a pas d'erreur. */
                    
                        for (k = 0 ; k < size ; ++l) {
                            for (i = l ; i < r && k < size ; ++i)
                                v[t][i] = k++;
                            for (i = ++t ; i < b && k < size ; ++i)
                                v[i][r-1] = k++;
                            for (i = --r ; i > l && k < size ; --i)
                                v[b-1][i-1] = k++;
                            for (i = --b ; i > t && k < size ; --i)
                                v[i-1][l] = k++;
                        }
                    
                        print_vector(v, ROWS, COLS);
                    
                        return EXIT_SUCCESS;
                    }
                    
                    • Partager sur Facebook
                    • Partager sur Twitter
                      11 novembre 2010 à 20:25:32

                      Y'a pas a dire Lithrein, ta façon de condenser le code me plait beaucoup.
                      • Partager sur Facebook
                      • Partager sur Twitter
                      Zeste de Savoirbépocode minimal  — Ge0 <3
                        11 novembre 2010 à 21:59:28

                        Voilà, j'ai modifié mon allocation dynamique en la mettant dans une fonction.

                        Ce qui donne :

                        allocTableau() :
                        void allocTableau(int ***tableau, int w, int h)
                        {
                            int j = 0;
                        
                            if ((*tableau = malloc(sizeof **tableau * h)) == NULL)
                            {
                                printf("Erreur lors de l'allocution dynamique 1");
                                exit(EXIT_FAILURE);
                            }
                        
                            for (j = 0; j < h; j ++)
                            {
                                if (((*tableau)[j] = malloc(sizeof ***tableau *  w)) == NULL)
                                {
                                    printf("Erreur lors de l'allocution dynamique 2");
                                    goto error;
                                }
                            }
                        
                        error :
                            for (j; j >= 0; j --)
                                free((*tableau)[j]);
                            free(*tableau);
                            exit(EXIT_FAILURE);
                        }
                        


                        Et le main() devient :
                        int main(int argc, char **argv)
                        {
                            int w = 5;
                            int h = 9;
                            int **tableau = NULL;
                            allocTableau(&tableau, w, h);
                        
                              if (!tableau) {
                                perror("malloc");
                                return EXIT_FAILURE;
                              }
                        
                            inscritTableau(tableau, w, h);
                            afficheTableau(tableau, w, h);
                            libereTableau(tableau, h);
                        
                        
                            return EXIT_SUCCESS;
                        }
                        


                        Maintenant, pour ce qui est des autres codes de Lithrein et Pouet, j'ai une ou deux questions :
                        Quel est cette chose :
                        goto error;
                        
                        [...]
                        
                        error :
                        


                        Pour ce qui est de l'espacement, j'ai mis des \t dans mon printf. Mais pourriez vous m'expliquer comment fonctionne ceci :
                        int sz = log10(h * w) + 1;
                          sprintf(format, "%%-%dd ", sz);
                        
                        // Ou
                        
                          printf("%s%-.3d", j == 0 ? "" : " ", v[i][j]);
                        
                        • Partager sur Facebook
                        • Partager sur Twitter
                          11 novembre 2010 à 23:16:18

                          error: crée un 'label', c'est un point dans le code où on peut sauter directement avec goto. A éviter.

                          Le calcul sert en fait à déterminer le nombre maximum de chiffres qu'on aura à afficher. Une fois qu'on a trouvé combien on en avait, je crée le format pour que ça s'affiche correctement.
                          Le %% -> %
                          Le - -> -
                          Le %d -> le nombre sz
                          Le d -> d
                          Ce qui donne à la fin, avec un nombre max de 100 : "%-3d "

                          Pour la deuxième écriture, le but est d'afficher un espace avant chaque nombre si ce n'est pas le premier. Si c'est le premier (justifié à gauche), pas besoin d'espace, sinon on en met un.
                          Le ? : est une condition ternaire, c'est la même chose qu'un if..else, mais condensé.
                          En gros ça fait :
                          Si j == 0 on affiche "" et le reste
                          Si j != 0 on afiche un espace " " et le reste.

                          Ca ne sert à rien de prendre ma fonction d'allocation si tu ne la comprends pas. :euh:
                          • Partager sur Facebook
                          • Partager sur Twitter
                            14 novembre 2010 à 14:10:26

                            Salut tout le monde.

                            Ceci est ma première participation a un zExo, donc je sais pas si il est très bien fait, mais je pense m'être bien débrouiller

                            PS: Pouet Forever, j'ai testé ton code, mais chez moi il ne fonctionne pas, comme si il y avait une boucle infini '-'

                            Enfin bon, voilà mon code :


                            #include <stdio.h>
                            #include <stdlib.h>
                            
                            #define TAILLE1 5
                            #define TAILLE2 4
                            
                            void zSpirale(int *t, int x, int y);
                            void affiche(int *t, int x, int y);
                            void *my_malloc(size_t n);
                            
                            void *my_malloc(size_t n)
                            {
                                void *p = calloc(n, 1);
                            
                                if(!p)
                                {
                                    printf("Erreur malloc");
                                    exit(-1);
                                }
                            
                                return p;
                            }
                            
                            void affiche(int *t, int x, int y)
                            {
                                int i, j;
                            
                                for(j = 0; j < y; j++)
                                {
                                    for(i = 0; i < x; i++)
                                        printf("%3d ", *t++);
                                    printf("\n");
                                }
                            }
                            
                            void zSpirale(int *t, int x, int y)
                            {
                                int xMin = 0, yMin = 0;
                                int xMax = x, yMax = y;
                                int n = 0, size = x * y;
                            
                                while(n < size)
                                {
                                    for(y = yMin, x = xMin; x < xMax; x++)/*On écrit la ligne du haut*/
                                        t[y * TAILLE1 + x] = n++;
                            
                                    x--;
                                    y++;
                            
                                    if(n < size)
                                    {
                                        for(; y < yMax; y++)/*On écrit la colonne de droite*/
                                            t[y * TAILLE1 + x] = n++;
                            
                                        y--;
                                        x--;
                                    }
                            
                                    if(n < size)
                                    {
                                        for(; x >= xMin; x--)/*La ligne du bas*/
                                            t[y * TAILLE1 + x] = n++;
                            
                                        x++;
                                        y--;
                                    }
                            
                                    if(n < size)
                                    {
                                        for(; y  > yMin; y--)/*La colonne de gauche*/
                                            t[y * TAILLE1 + x] = n++;
                            
                                        yMin++;
                                        xMin++;
                                        yMax--;
                                        xMax--;
                                    }
                                }
                            }
                            
                            int main(void)
                            {
                                int *t = my_malloc(TAILLE1 * TAILLE2 * sizeof *t);
                            
                                zSpirale(t, TAILLE1, TAILLE2);
                                affiche(t, TAILLE1, TAILLE2);
                            
                                free(t);
                                t = (int*)0;
                                return 0;
                            }
                            


                            J'ai essayer de faire le plus propre que je le puisse mais bon, je me doute que c'est pas terrible ^^.(Mais au moins j'ai tenter ma chance, on est la pour progresser ;-) )

                            Cordialement Qnope
                            • 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 !
                              14 novembre 2010 à 14:45:28

                              Salut,
                              Simplement pour une spirale commençant au coin supérieur gauche, j'aurais ceci, fais très rapidement.
                              Pour un départ sur un autre coin, ce sera dans le même genre.
                              Par contre, pour une spirale démarrant au centre, ça doit être plus marrant.

                              Désolé, la fonction est une peu noyée dans l'enrobage(alloc, désalloc et affichage.)
                              Pour l'affichage, rien de générique, au contraire des codes de Pouet et de Lithrein.
                              #include <stdio.h>
                              #include <stdlib.h>
                              
                              #define N_ROW   5
                              #define N_COL   7
                              
                              void zSpirale1(int **t, int nr, int nc)
                              {
                                  int n, v;
                              
                                  for(n = 0, v = 0; n < nr * nc; n++)
                                  {
                                      int i;
                                      for(i = n; i < nc - n; i++)
                                          t[n][i] = v++;
                                      for(i = n + 1; i < nr - n; i++)
                                          t[i][nc - n - 1] = v++;
                                      for(i = nc - n - 2; i >= n; i--)
                                          t[nr - n - 1][i] = v++;
                                      for(i = nr - n - 2; i > n; i--)
                                          t[i][n] = v++;
                                  }
                              }
                              
                              
                              void afficherTab(int **t, int nr, int nc)
                              {
                                  int i, j;
                                  for(i = 0; i < N_ROW; i++)
                                  {
                                      for(j = 0; j < N_COL; j++)
                                          printf("%3d ", t[i][j]);
                                      puts("");
                                  }
                              }
                              
                              void deleteMat(int **mat, int nr)
                              {
                                  if(mat != NULL)
                                  {
                                      int i;
                                      for(i = 0; i < nr; i++)
                                          free(mat[i]), mat[i] = NULL;
                              
                                      free(mat);
                                  }
                              }
                              
                              int **createMat(int nr, int nc)
                              {
                                  int err = 0;
                                  int **pnew = malloc(nr * sizeof *pnew);
                                  if(pnew == NULL)
                                      err = 1;
                              
                                  if(!err)
                                  {
                                      int i;
                                      for(i = 0; !err && i < nr; i++)
                                      {
                                          pnew[i] = malloc(nc * sizeof **pnew);
                                          if(pnew[i] == NULL)
                                              err = 1;
                                      }
                                  }
                              
                                  if(err)
                                      deleteMat(pnew, nr), pnew = NULL;
                              
                                  return pnew;
                              }
                              
                              
                              
                              int main(void)
                              {
                                  int **tab = createMat(N_ROW, N_COL);
                                  if(tab == NULL)
                                  {
                                      fprintf(stderr, "Error createMat...");
                                      exit(EXIT_FAILURE);
                                  }
                              
                              
                                  zSpirale1(tab, N_ROW, N_COL);
                                  afficherTab(tab, N_ROW, N_COL);
                              
                                  deleteMat(tab, N_ROW);
                              
                                  return 0;
                              }
                              


                              @pouet:
                              Tu devrais terminer ta série de else if par un else.
                              Au moins tu serais assuré que tous les cas sont traités, il semble qu'il y a bien un problème avec ton code en tous cas. ;)

                              • Partager sur Facebook
                              • Partager sur Twitter
                              Zeste de Savoir, le site qui en a dans le citron !
                                14 novembre 2010 à 14:53:32

                                @qnope : Une petite erreur dans le memset. :-°
                                Corrigé. ;)
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  14 novembre 2010 à 14:55:11

                                  @qnope : C'est bien d'avoir essayer par contre j'ai pas mal de critiques.
                                  * Tu appelles une fonction my_malloc et celle-ci fait appel à la fonction calloc ce qui n'est pas très logique.
                                  * Dans la fonction affiche pour afficher un seul caractère, putchar suffit.
                                  * La fonction zSpirale est un véritable château de cartes qui ne demande qu'à s'écrouler. Par exemple : si la fonction n'est pas appelée avec TAILLE1 et TAILLE2, ça risque de planter car l'utilisation de TAILLE1 pour les calculs d'index ne marche plus. Autrement, ta façon de procéder semble bonne.
                                  * Enfin, t = (int *)0 . Certes ça marche comme tu le veux car NULL est égal à 0 mais c'est se compliquer la vie pour rien. t = NULL marche aussi bien.
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    14 novembre 2010 à 15:05:44

                                    Citation : Lithrein


                                    @GurneyH :



                                    :-°
                                    Je ne sais pas comment je dois le prendre... :p
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    Zeste de Savoir, le site qui en a dans le citron !
                                      14 novembre 2010 à 15:15:22

                                      Citation : GurneyH

                                      Citation : Lithrein


                                      @GurneyH :



                                      :-°
                                      Je ne sais pas comment je dois le prendre... :p



                                      Disons que je voulais faire une remarque mais ne sachant pas si elle était justifiée, je ne l'ai pas faite et j'ai oublié d'enlever le « @GurneyH » :honte:
                                      En fait, je me demandais si tu ne risquais pas de libérer des zones de la mémoire non allouées s'il y avait une erreur dans CreateMat
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        14 novembre 2010 à 15:26:02

                                        Ah d'accord. ;)

                                        Tu as raison, dans mon delete, je peux avoir un problème.

                                        En fait au premier couac j'aurais un pointeur NULL, donc pas de soucis.
                                        Par contre, pour les pointeurs suivants...

                                        Je laisse le code dans l'état pour "le mauvais exemple"...


                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        Zeste de Savoir, le site qui en a dans le citron !
                                          14 novembre 2010 à 15:38:24

                                          Citation : Lithrein

                                          @qnope : C'est bien d'avoir essayer par contre j'ai pas mal de critiques.
                                          * Tu appelles une fonction my_malloc et celle-ci fait appel à la fonction calloc ce qui n'est pas très logique.
                                          * Dans la fonction affiche pour afficher un seul caractère, putchar suffit.
                                          * La fonction zSpirale est un véritable château de cartes qui ne demande qu'à s'écrouler. Par exemple : si la fonction n'est pas appelée avec TAILLE1 et TAILLE2, ça risque de planter car l'utilisation de TAILLE1 pour les calculs d'index ne marche plus. Autrement, ta façon de procéder semble bonne.
                                          * Enfin, t = (int *)0 . Certes ça marche comme tu le veux car NULL est égal à 0 mais c'est se compliquer la vie pour rien. t = NULL marche aussi bien.



                                          Pour le calloc, effectivement, petit oubli, c'était pour les tests, plus simple a voir des 0 que des 125478654 ;-).
                                          Pour le putchar, effectivement, je l'ai corriger ;-)
                                          Pour les taille1 et taille2, effectivement, ^^

                                          je viens de corriger mon code, beaucoup moins de ligne ^^.


                                          #include <stdio.h>
                                          #include <stdlib.h>
                                          
                                          #define TAILLE1 10
                                          #define TAILLE2 5
                                          
                                          void zSpirale(int *t, int x, int y);
                                          void affiche(int *t, int x, int y);
                                          void *my_malloc(size_t n);
                                          
                                          void *my_malloc(size_t n)
                                          {
                                              void *p = malloc(n);
                                          
                                              if(!p)
                                              {
                                                  printf("Erreur malloc");
                                                  exit(-1);
                                              }
                                          
                                              return p;
                                          }
                                          
                                          void affiche(int *t, int x, int y)
                                          {
                                              int i, j;
                                          
                                              for(j = 0; j < y; j++, putchar('\n'))
                                              {
                                                  for(i = 0; i < x; i++)
                                                      printf("%3d ", *t++);
                                              }
                                          }
                                          
                                          void zSpirale(int *t, int x, int y)
                                          {
                                              int xMin = 0, yMin = 0;
                                              int xMax = x, yMax = y;
                                              int n = 0, size = x * y, t1 = x;
                                          
                                              while(n < size)
                                              {
                                                  for(y = yMin, x = xMin; x < xMax; x++)/*Ligne haut*/
                                                      t[y * t1 + x] = n++;
                                          
                                                  if(n < size)
                                                  for(y = yMin + 1, x = xMax - 1; y < yMax; y++)/*Colonne droite*/
                                                      t[y * t1 + x] = n++;
                                          
                                                  if(n < size)
                                                  for(y = yMax - 1, x = --xMax - 1; x >= xMin; x--)/*Ligne bas*/
                                                      t[y * t1 + x] = n++;
                                          
                                                  if(n < size)
                                                  for(y = --yMax - 1, x = xMin++, yMin++; y >= yMin; y--)/*Colonne gauche*/
                                                      t[y * t1 + x] = n++;
                                              }
                                          }
                                          
                                          int main(void)
                                          {
                                              int *t = my_malloc(TAILLE1 * TAILLE2 * sizeof *t);
                                          
                                              zSpirale(t, TAILLE1, TAILLE2);
                                              affiche(t, TAILLE1, TAILLE2);
                                          
                                              free(t);
                                              t = (int*)0;
                                              return 0;
                                          }
                                          
                                          • 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 !
                                            20 novembre 2010 à 19:19:18

                                            Bon je poste ma solution pour ce mois ci:
                                            #include <stdio.h>
                                            
                                            #define SZ_TAB 10
                                            #define Tab tab[Y][X]=i
                                            
                                            
                                            void zSpiral(int tab[][SZ_TAB])
                                            {
                                            
                                            	for(int i = -1, nbT = SZ_TAB, Y=0, X=-1, c=1, I;(Tab)<SZ_TAB*SZ_TAB-1;c*=-1)
                                            	{
                                            		for(I = 0;I<nbT;I++,i++,X+=c)	Tab;
                                            		for(I = 0,(--nbT);I<nbT;I++,i++,Y+=c)	Tab;
                                            	}
                                            }
                                            void afficherTab(int tab[][SZ_TAB])
                                            {
                                            	for(int y = 0;y<SZ_TAB;y++,printf("\n"))
                                            		for(int x = 0;x<SZ_TAB;x++)
                                            			printf("%d\t",tab[y][x]);
                                            }
                                            int main()
                                            {
                                            	int ztab[SZ_TAB][SZ_TAB];
                                            	zSpiral(ztab);
                                            	afficherTab(ztab);
                                            	getchar();
                                            
                                                return 0;
                                            }
                                            


                                            Je suis sûr que l'on peut l'améliorer.
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                            🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                              21 novembre 2010 à 11:04:51

                                              Segfault chez moi.
                                              Et puis, tu pourrais faire un code plus clair (genre éviter la partie C99 et virer ton #define qui masque une affectation).
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                21 novembre 2010 à 11:32:52

                                                Si toi tu trouve que mon code est pas claire c'est plutôt un compliment. (J’avoue que c'était un peu le but :honte: ).

                                                Mais sinon je ne trouve pas le segfault. J'ai tester sur 2 OS différents et je ne le trouve pas.

                                                Et pour la clarté/norme voila le code corrigé :
                                                #include <stdio.h>
                                                
                                                #define SZ_TAB 10
                                                
                                                
                                                void zSpiral(int tab[][SZ_TAB])
                                                {
                                                	int i = -1, nbT = SZ_TAB, Y=0, X=-1, c=1, I; // i 
                                                
                                                	for(;i<SZ_TAB*SZ_TAB-1;c*=-1) // La variable C sert à faire inverser le parcour.
                                                	{
                                                		for(I = 0; I<nbT ;I++,i++,X+=c)	// La je vais vers la droite si c est égale à 1 vers la gauche si c == -1
                                                			tab[Y][(X<0)?0:X]=i;
                                                		for(I = 0,(--nbT); I<nbT ; I++, i++, Y+=c) // La je vais vers le bas si c est égale à 1 vers le heut si c== -1
                                                			tab[Y][X]=i;
                                                	}
                                                	tab[Y][X]=i;
                                                }
                                                
                                                void afficherTab(int tab[][SZ_TAB])
                                                {
                                                	int y,x;
                                                	for(y = 0;y<SZ_TAB;y++,printf("\n"))	// Affichage de le tableau en le parourant
                                                		for(x = 0;x<SZ_TAB;x++)
                                                			printf("%d\t",tab[y][x]);
                                                }
                                                int main()
                                                {
                                                	int ztab[SZ_TAB][SZ_TAB];
                                                	zSpiral(ztab);
                                                	afficherTab(ztab);
                                                	getchar();
                                                
                                                    return 0;
                                                }
                                                
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.
                                                  21 novembre 2010 à 11:44:27

                                                  void zSpiral(int tab[][SZ_TAB])
                                                  {
                                                    /* Y = 0, X = -1 */
                                                    int i = -1, nbT = SZ_TAB, Y = 0, X = -1, c = 1, I; 
                                                  
                                                    /* tab[Y][X] devient tab[0][-1] */
                                                    for(; tab[Y][X] = i < SZ_TAB * SZ_TAB - 1 ; c *= -1)
                                                    {
                                                      for(I = 0; I < nbT ; I++, i++, X+=c)
                                                        tab[Y][X] = i;
                                                  
                                                      for(I = 0, --nbT; I < nbT ; I++, i++, Y += c)
                                                        tab[Y][X] = i;
                                                    }
                                                  }
                                                  


                                                  Je dis ça, je dis rien hein...
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    21 novembre 2010 à 11:48:41

                                                    Tu déclares ton X avec une valeur de -1, mais au premier tour de boucle ton -1 est toujours là, du coup tu accèdes à une valeur de tableau qui ne t'appartient pas. ;)

                                                    Edit: grilled :-°
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      21 novembre 2010 à 12:09:09

                                                      Merci, corrigé. C'est quand même un peu sale.
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                      🍊 - Étudiant - Codeur en C | Zeste de Savoir apprenez avec une communauté | Articles  - ♡ Copying is an act of love.

                                                      [ zSpirale] Exercice pour débutant

                                                      × 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