Discussion :

[zinjulio]

Je travaille sur un programme qui travaille sur cette suite logique :
1
11
21
1211
.....
Bref une suite assez simple où la ligne suivante renseigne sur la quantité d'un certain nombre en les prenants à la suite (ex : 21=> il y a un 2 et un 1 donc on écrit 1211)

Donc j'ai conçu ce programme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <stdio.h>
void main(void)
{
   char T[100][255];
   long i,k,j;
   T[0][0]=49;
   for (i=1;i<=253;i++) T[0][i]=48;
   k=0;
   i=0;
   for (j=0;j<=98;j++)
      {
          while (T[j][i]!=48)
             {
                 if (T[j][i]!=T[j][i+1])
                     {
                 	     T[j+1][k]=49;
                 	     T[j+1][k+1]=T[j][i];
                 	     i=i+1;
                 	     k=k+2;
                 	 }
                 else if (T[j][i]==T[j][i+1]&&T[j][i]!=T[j][i+2])
                 	 {
                 	     T[j+1][k]=50;
                 	     T[j+1][k+1]=T[j][i];
                 	     i=i+2;
                 	     k=k+2;
                 	 }
                 else 
                     {
                 	     T[j+1][k]=51;
                 	     T[j+1][k+1]=T[j][i];
                 	     i=i+3;
                 	     k=k+2;
                 	 }
             }
          i=0;
          for (i=k;i<=253;i++) T[j+1][k]=48;
          k=0;
      }
   for (j=0;j<=99;j++) 
      {
          for (i=0;i<=253;i++)
              {
                  while (T[j][i+1]!=48) printf("%c",T[j][i]);
              }
          printf("\n");
      }
   getchar();
}

mais à chaque fois lorsque je compile, il ne m'affiche aucune erreur mais lors du run, j'ai ce message

NO-FATAL RUN-TIME ERROR
"défi.c", line 12, col 18, thread is 0x00000B8C
Local "T" is referenced before being initialized

Mais pas moyen de trouver une solution, pouvez m'aider s'il vous plait?
Merci d'avance de vos réponses!

[homeostasie]

Bonjour et bienvenue,

Perso, je pense fortement à un débordement mémoire. A savoir où, c'est autre chose!

Va falloir bien débugger et aussi rendre ton code plus lisible, mettre des commentaires pour expliquer ce que tu fais.

Le mieux serait que tu fasses au préalable un travail de conception en mettant au point ton algorithme, ensuite tu codes.

[diogene]

Bonjour et bienvenue
il semble qu'il y ait une erreur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 ...          
 i=0;
 for (i=k;i<=253;i++) T[j+1][k]=48;
 k=0;

Plutôt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 ...          

 for (i=k;i<=253;i++) T[j+1][i]=48;
 i=0;
 k=0;

De plus, au dela de j = 18 environ, le tableau de 255 char sera trop petit pour contenir le résultat. Il faut modifier le test d'arrêt de la boucle for en fonction de la capacité du tableau

[Emmanuel Delahaye]

Donc j'ai conçu ce programme

J'ai un peu instrumenté le code. Ca a craqué assez vite...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
#include <stdio.h>
#include <assert.h>
 
int main (void)
{
   char T[100][255];
   size_t i, k, j;
   T[0][0] = 49;
   for (i = 1; i <= 253; i++)
   {
      assert (i < sizeof *T / sizeof **T);
      T[0][i] = 48;
   }
   k = 0;
   i = 0;
   for (j = 0; j <= 98; j++)
   {
      while (T[j][i] != 48)
      {
         if (T[j][i] != T[j][i + 1])
         {
            assert (j + 1 < sizeof T / sizeof *T);
            assert (j < sizeof T / sizeof *T);
            assert (k + 1 < sizeof *T / sizeof **T);
 
            T[j + 1][k] = 49;
            T[j + 1][k + 1] = T[j][i];
            i = i + 1;
            k = k + 2;
         }
         else if (T[j][i] == T[j][i + 1] && T[j][i] != T[j][i + 2])
         {
            T[j + 1][k] = 50;
            T[j + 1][k + 1] = T[j][i];
            i = i + 2;
            k = k + 2;
         }
         else
         {
            T[j + 1][k] = 51;
            T[j + 1][k + 1] = T[j][i];
            i = i + 3;
            k = k + 2;
         }
      }
      i = 0;
      for (i = k; i <= 253; i++)
         T[j + 1][k] = 48;
      k = 0;
   }
   for (j = 0; j <= 99; j++)
   {
      for (i = 0; i <= 253; i++)
      {
         while (T[j][i + 1] != 48)
            printf ("%c", T[j][i]);
      }
      printf ("\n");
   }
   return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Assertion failed: k + 1 < sizeof *T / sizeof **T, file main.c, line 24
 
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
 
Press ENTER to continue.

Débordement, de tableau, comportement indéfini...

[Fred83]

Une solution simple serait peut être de faire une fonction prenant en paramètre une chaîne a analyser et retournant un pointeur sur char contenant la chaîne résultante.

Dans la fonction,

- Tu alloue une chaîne de longueur égale a deux fois celle à analyser + 1 pour le zéro terminal (Dans le pire des cas, si tous les caractères sont différents, ta ligne de sortie est deux fois plus longue que la ligne d'entrée).

- Tu parcours avec un pointeur la chaîne d'entrée jusqu'à la fin.
A chaque caractère, s'il est égal au précédent, tu incrémente un compteur
Sinon, tu ajoute ton compteur et le caractère précédent à la fin de ta chaîne de sortie.

Tu n'a plus qu'a rappeler ta chaîne autant de fois que tu le désire avec en entrée la chaine retournée par l'appel précédent.

Ne pas oublier de libérer les chaines allouées en fin de programme.

Bon courage

[zinjulio]

J'ai commencé à modifier mon programme et voici ce que cela donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <stdio.h>
char calcul(char T[]);
void main(void)
{
   char T[2];
   int i;
   T[0]=49;
   printf("%c",T[0]);
   for (i=1;i<=99;i++) 
   {
       printf("%c",calcul(T[]));
       T[]=calcul(T);
   getchar();
}
 
char calcul(char T[])
{
   int i=0,j,k=1,l=0;
   while (T[i]!==00) i++;
   char U[(i*2)+1];
   for (j=0;j<=i*2;j++)
      {
          if (T[j]==T[j+1]) k++;
          else
               {
                   U[l]=k+48;
                   U[l+1]=T[j];
                   l=l+2;
                   k=1;
               }
   return U[];
}

La fonction calcul permet de calculer la ligne suivante à partir de la précèdente.
Je me doute que ce programme comporte des erreurs j'ai donc plusieurs questions pour vous :
-Comment on appelle une fonction qui renvoie comme résultat un tableau? j'ai lu la faq mais je n'ai pas tout compris!
-Aussi j'aimerais savoir comment fait-on un tableau à itération variable? car dans la fonction calcul le tableau U doit être au maximun deux fois plus grand que le tableau T mais je ne sais pas exactement comment l'on traduit cela en language c!

merci de vos réponses

[Fred83]

Il y a du pain sur la planche,

-Comment on appelle une fonction qui renvoie comme résultat un tableau? j'ai lu la faq mais je n'ai pas tout compris!

Actuellement ta fonction calcul retourne un caractère et non un pointeur sur une chaîne de caractère. Pour retourner un pointeur, ta fonction devrait plutôt ressemble a ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
char *calcul(char *T)

Pour connaître la taille d'une chaîne de caractères, utilise la fonction strlen().

Dans la construction de ta chaîne, pour plus de clarté, au lieu d'écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
U[l]=k+48;

écris donc

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
U[l]=k+'0';

pour faire ce que tu appelles un tableau à itération variable, utilise malloc().
Donc pour réserver une chaîne de longueur double de celle passée en paramètre, ta fonction calcul devient :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
char *calcul(char *LigneIn)
{
char *Retour;       // Chaine retournee
Retour=malloc(2*strlen(LigneIn)+1);
if(Retour!=NULL)
  {
  //Remplir ici la chaîne Retour
  }
return(Retour);

Tu n'as plus qu'a remplir correctement ta chaîne Retour et a appeler autant de fois que tu veux ta fonction depuis un main() similaire a celui ci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#include <stdio.h>
#include <stdlib.h>
 
// Nombre de chaines a generer
#define NB_CHAINES 10
 
int main(void)
{
char *Tmp[NB_CHAINES];  // Declare NB_CHAINES pointeurs sur char
int ii;
 
// alloue et initialise la premiere chaine
Tmp[0]=malloc(2);
strcpy(Tmp[0],"1");
 
// Appelle la fonction de création d'une chaîne a partir de la précédente
for(ii=1;ii<NB_CHAINES;ii++)
  {
  Tmp[ii]=Calcul(Tmp[ii-1]);
  printf("Tmp[%d]=%s\n",ii,Tmp[ii]);
  }
 
// Libére les chaines allouées
for(ii=0;ii<NB_CHAINES;ii++)
  free(Tmp[ii]);
 
return(0);
}

La balle est dans ton camps.

[Emmanuel Delahaye]

Pour connaître la taille d'une chaîne de caractères, utilise la fonction strlen().

Pour être précis, strlen(), comme son nom l'indique, donne la longueur de la chaine (length) sans le 0 final...