Discussion :

[mariesauveur]

Bonjour je débute en info et donc en C et C++, poursuivant une formation TSAII.

Je travaille actuellement sur le passage de l'algorithme au programme. L'un des exercices est sur l'affichage du triangle de Pascal.
J'ai réussi à le faire mais l'affichage est loin d'être satisfaisant. Pourriez vous m'orienter svp. Voici le code:

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
 
#include <iostream>
#include <stdio.h>
#include <conio.h>
 
 
int main (void)
{
//Title
    printf("\n ********** TRIANGLE DE PASCAL********** \n");
    //Declaration des Valeurs
    int Redo,i,j,N;
    int TabPas[10][10];
    //Execution
    Redo=0; //Initialisation de la boucle
    do
    {
        printf("\n Entrer un exposant N: ");
        scanf("%i",&N);
        for (i=0; i<=N-1; i++)
        {
            for (j=0; j<=N-1; j++)
            {
                TabPas[i][j]=0;
                TabPas[i][0]=1;
            }
        }
 
        for (i=1; i<=N-1; i++)
        {
            for (j=1; j<=N-1; j++)
            {
                TabPas[i][j]=TabPas[i-1][j-1]+TabPas[i-1][j];
            }
        }
        for (i=0; i<=N-1; i++)
        {
            for (j=0; j<=N-1; j++)
            {
                printf("%i",TabPas[i][j]);
 
            }
            printf("\n");
        }
 
        printf("\n Voulez vous recommencer? (1/0) \n");
        scanf("%i",&Redo);
    }
    while(Redo!=0);
    return 0;
}

J'ai aussi voulu optimiser le programme, en faisant en sorte que la taille du tableau soit variable pour entrer un entier N variable positif sans limite supérieur. Je me sert, du moins j'essaye de me servir du malloc mais là sa bloc. je crois que je ne le déclare pas correctement. voici le code:

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
#include <iostream>
#include <stdio.h>
#include <conio.h>
 
 
int main (void)
{
//Title
    printf("\n ********** TRIANGLE DE PASCAL********** \n");
    //Declaration des Valeurs
    int Redo,i,j,N;
    int* TabPas[N]=NULL;
    //Execution
    Redo=0; //Initialisation de la boucle
    do
    {
        printf("\n Entrer un exposant N: ");
        scanf("%i",&N);
 
        TabPas[i][j]={malloc(N*sizeof(int))};
 
        for (i=0; i<=N-1; i++)
        {
            for (j=0; j<=N-1; j++)
            {
                TabPas[i][j]=0;
                TabPas[i][0]=1;
            }
        }
 
        for (i=1; i<=N-1; i++)
        {
            for (j=1; j<=N-1; j++)
            {
                TabPas[i][j]=TabPas[i-1][j-1]+TabPas[i-1][j];
            }
        }
        for (i=0; i<=N-1; i++)
        {
            for (j=0; j<=N-1; j++)
            {
                printf("%i",TabPas[i][j]);
 
            }
            printf("\n");
        }
 
        printf("\n Voulez vous recommencer? (1/0) \n");
        scanf("%i",&Redo);
    }
    while(Redo!=0);
    return 0;
}

Merci d'avance.
MS

[Sunsawe]

Salut,

Je ne suis pas vraiment certain de ce que tu cherches à faire.
Toute fois, en regardant le premier morceau de code que tu fournis, je remarque ça:
Tu déclares

Code :

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

 int TabPas[10][10];

puis le programme effectue des boucles de N itérations sans que tu ne controle la valeur de N.

Dans ce code:

Code :

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

1
2
3
4
5
6
7
8
9
 
for (i=0; i<=N-1; i++)
{
   for (j=0; j<=N-1; j++)
   {
       TabPas[i][j]=0;
        TabPas[i][0]=1;
    }
}

L'instruction

Code :

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

TabPas[i][0]=1;

est effectué autant de fois que de j alors qu'une suffirait puisqu'elle ne dépend pas de j. Je pense donc que tu pourrais la déplacer pour la mettre dans le corps de la première boucle.

Ensuite au premier tour de la boucle intérieur, le programme effectuera:

Code :

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

1
2
TabPas[i][0]=0;
TabPas[i][0]=1;

Alors 0 ou 1? La seconde instruction annule la première.

[mariesauveur]

Bonsoir,
Quand j'insère la ligne suivant:

TabPas[i][0]=1;

Dans la boucle primaire, sous le "do", le programme ne répond plus après avoir entré une valeur de N.

En fait dans mon algorithme, cette ligne est le remplissage de la j=0 de 1, N-1 fois.

La commande:

Code :

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

1
2
 
TabPas[i][j]=0;

est le remplissage du tableau de zéros sur chaque ligne après la diagonale de 1.

Je ne suis pas sur de m'expliquer clairement... En fait, si je ne met pas cette commande j'obtiens un résultat complètement délirant.

Le premier programme est pour faire un premier affichage du triangle avec N<=10, je n'est pas mi de condition sur N car la taille du tableau délimite par elle même le champ d'application de N. Ce n'est pas très pro, mais j'ai sauté l'étape étant donner que ce n'est qu'un affichage et remplissage de tableau. Je vais essayer. En fait j'aimerai bien ne pas avoir de 0 après la diagonale de 1 et avoir un alignement vertical des nombres dans le tableau.

Enfin, dans le deuxième code, j'essaye de créer un tableau dynamique quelque soit la valeur de N...

[Sunsawe]

Concernant la ligne qui s'execute de multiple fois, je pensais plus à ça:

Code :

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

1
2
3
4
5
6
7
8
for (i=0; i<=N-1; i++)
{
   for (j=0; j<=N-1; j++)
   {
       TabPas[i][j]=0;
   }
   TabPas[i][0]=1;
}

De cette façon, l'initialisation de la première colonne à 1 ne se fait qu'une fois par ligne (effaçant au passage la valeur 0 insérée par la boucle intérieure). Dans les faits, ça ne change rien au résultat que tu obtenais avant.

Par contre là,

est le remplissage du tableau de zéros sur chaque ligne après la diagonale de 1.

je ne te suis plus.
Avec la précédente construction, tu ne fais qu'initialiser la première colonne à 1, pas la diagonale.
tu obtiens donc en fin de boucle quelque chose comme:

1 0 0 0 ... 0
1 0 0 0 ... 0
...
1 0 0 0 ... 0

Et si je lis bien (il est tard quand même...) la boucle suivante

Code :

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

1
2
3
4
5
6
7
for (i=1; i<=N-1; i++)
{
     for (j=1; j<=N-1; j++)
        {
            TabPas[i][j]=TabPas[i-1][j-1]+TabPas[i-1][j];
        }
}

va construire quelque chose comme ça:

1 0 0 0 0 ... 0
1 1 0 0 0 ... 0
1 2 1 0 0 ... 0
1 3 2 1 0 ... 0
...
1 9 8 7 6 ... 1

Est ce vraiment ce que tu obtiens? veux obtenir?

[mariesauveur]

Oui il se fait tard, merci de votre patience.

Pour le première boucle, j'ai compris mon erreur d'interprétation de l'algorithme.

Pour le résultat oui c'est ce que j'obtiens, sans alignement vertical des colonnes, car quand la valeur devient à deux chiffre puis trois, il y a un décalage du nombre par rapport à celui du dessus.

En suite, j'aimerai ne pas avoir la suite de zéros après la diagonale de 1. mais là je crois qu'il faut que je revois mon algorithme de remplissage.

[Sunsawe]

ok, je crois voir ce que tu veux obtenir:
- Initilisation d'une matrice 10x10 à 0 mis à part la première colonne à 1
- Remplissage de la matrice avec, à partir de x=1 et y=1, f(x,y)=f(x-1,y-1)+f(x-1,y)
- Affichage du contenu de la matrice jusqu'à la diagonale

Tout d'abord, tu devrais regarder sur google comment initialiser un tableau à plusieurs dimensions. Tu verras qu'il y a des moyens beaucoup plus simple qu'une boucle sur l'ensemble des valeurs. Par exemple,

Code :

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

 int TabPas[10][10]={0};

suffit à initialiser l'intégralité de la matrice à 0. Mais regarde, tu trouveras surement un moyen d'initialiser la première colonne à 1 et le reste à 0 en une seule instruction

Ensuite, tu dis ne pas te soucier de ce qui vient après la diagonale. En effet, il n'y a que des 0 et peu importe de toute façon. As tu remarqué que tous les éléments de la diagonale ont une propriété particulière qui permet de les reconnaitre?

Pour ce qui est de l'affichage je pense que tu pourrais jouer avec les espaces d'autant plus que tu connais des le début le plus grand nombre présent dans la matrice.
Peut être aussi, pour la lisibilité, tu gagnerais à élaborer un peu la séparation à l'affichage. Par exemple utiliser "|" plutot qu'un espace (l'alignement est plus facile à visualiser).

Tu dis que tu débutes en la matière alors je ne veux pas te gacher le plaisir de la découverte mais si tu as besoin de plus de détails, pas de soucis.

[mariesauveur]

Salut Sunsawe.

Merci pour ta réponse.

J'ai revu mon interprétation de mon algorithme et revu la prog.
Oui je connais cette initialisation de Tableau. Je pourrais tout aussi bien l'utiliser. Mais pour l'instant je vais rester sur mon algorithme.

Voila, aujourd'hui avec quelques heure de sommeil j'ai réussi mon affichage et est inclus la positivité et l'infériorité à N comme condition pour N. je suis assez content du résultat pour ce qui est de la porté de l'exercice.

Voici le code:

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 <iostream>
#include <stdio.h>
#include <conio.h>
 
 
int main (void)
{
//Title
    printf("\n ********** TRIANGLE DE PASCAL********** \n");
    //Declaration des Valeurs
    int Redo,i,j,N;
    int TabPas[10][10];
    //Execution
    Redo=0; //Initialisation de la boucle
    do
    {
        printf("\n Entrer un exposant N: ");
        scanf("%i",&N);
        if ((N>0)&&(N<=10))
        {
            for (i=0; i<=N-1; i++)
            {
                TabPas[i][0]=1;
 
                for (j=1; j<=N-1; j++)
                {
                    TabPas[i][j]=0;
                }
            }
 
            for (i=1; i<=N-1; i++)
            {
                for (j=1; j<=N-1; j++)
                {
                    TabPas[i][j]=TabPas[i-1][j-1]+TabPas[i-1][j];
                }
            }
 
            for (i=0; i<=N-1; i++)
            {
                for (j=0; j<=N-1; j++)
                    if (TabPas[i][j]!=0)
                    {
                        {
                            printf("%4i",TabPas[i][j]);
                        }
                    }
                printf("\n");
            }
 
        }
        else
        {
            printf("\n ERREUR, vous devez entrer un entier positif superieur a 0 et inferieur ou egal a 10");
        }
 
        printf("\n Voulez vous recommencer? (1/0) \n");
        scanf("%i",&Redo);
    }
    while(Redo!=0);
    return 0;
}

Je passe maintenant au développement du même programme quelques soit N, donc tableau dynamique... Mais si j'ai bien compris ce que j'ai lu, il faudrait que j'utilise plutôt des chaines variables de caractère, plus adapter au problème en C++.

[Sunsawe]

Salut,

J'ai jeté un oeil à ton code à nouveau. Je suppose que tu conserve les trois boucles for (intialisation, remplissage et affichage) séparément dans un but didactique. Je ne m'étendrai donc pas sur le fait que tu pourrais probablement les rassembler en une seule...

Par contre pour ce qui est de la boucle d'affichage, tu pourrais facilement la rendre plus logique.

Code :

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

1
2
3
4
5
6
7
8
 
for (j=0; j<=N-1; j++)
      if (TabPas[i][j]!=0)
          {
             {
               printf("%4i",TabPas[i][j]);
              }
           }

Bon Il y a une pair d'accolade inutile, mais ça ne dérange que la lisibilité. La condition du if te permet de ne pas avoir les 0 affichés. Bien, mais peu facilement être mieux.
Considère les caractérisques de ton problème. Une fois que tu as atteind un 0, tu sais qu'il n'y aura que des zéros par la suite. Pourquoi continuer à boucler et tester le reste?

Et puisque tu conserves les trois boucles et que rien après la diagonale ne t'intéresse, pourquoi ne t'affranchir des tours de boucle inutiles dans les trois?
(PS: les éléments de la diagonale sont remarquables.)

tableau dynamique... Mais si j'ai bien compris ce que j'ai lu, il faudrait que j'utilise plutôt des chaines variables de caractère, plus adapter au problème en C++.

Euh... oui... mais non.
Il faut que tu choisisses C ou C++. Chacun a ses particularités.
C++ offre certaines possibilités avec la bibliothèque standard (telle que la classe vector) qui ne sont pas disponible en C.
Ce dernier offre certains avantages dans le controle du code à bas niveau mais pour les tableaux dynamiques il faut se débrouiller. les "chaines variables de caractères"sont un moyen.