Discussion :

[jrosenzw]

Bonjour

J'ai du mal à afficher le triangle de Pascal conformement à cet énoncé :

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
 
/* Le triangle de Pascal.
* Le triangle de Pascal est un tableau triangulaire de nombre qui commence comme
* cela 
*              1
*             1 1
*            1 2 1
*           1 3 3 1
*          1 4 6 4 1
*         1 5 10 10 5 1
*        1 6 15 20 15 6 1
*       1 7 21 35 35 21 7 1
*      1 8 28 56 70 56 28 8 1
*
* Chaque nombre du triangle de Pascal est une des combinaisons C(n,k).
* Si on compte les lignes et le colonnes
* diagonales à partir de 0, le nombre de ligne n et de la colonne k est C(n,k). 
* Par exemple, le nombre de la ligne 6 colonne 2 est C(6,2) = 15. Ecrire un 
* programme qui utilise la fonction comb() pour imprimer le triangle de Pascal 
* jusqu'à la douzième ligne. 
*/

J'ai écrit ce code (dans un projet sous l'IDE DevC++) mais qui ne marche bien pour l'affichage.

fichier .h "triangleDePascal.h"

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int comb(int n, int k)
{
    if(n < 0|| k < 0 || n < k )
         return 0;
   int c = 1, m = n + 1;
  // m = n + 1;
 for( int i = 1; i <= k; i++,m--)
 {
	c *= m/i;
 }
 return c;
}

fichier principale "main.cpp"

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
 
 
#include <cstdlib>
#include <iostream>
 
#include "triangleDePascal.h"
 
using namespace std;
 
int main(int argc, char *argv[])
{
  int n, k;
 
  cout << " Entrez deux entiers pour l'impression du triangle de Pascal : ";
  cin >> n >> k;
  for ( int i = 0; i <  n; i++ )
 {
	for ( int j = i; j < k; j++ )
	{
            cout << " ";
            cout << comb( i, j ) << '\n';
        }
  cout << endl;
 cin.ignore(numeric_limits <	streamsize > ::max(), '\n');
 }
}

Est-ce que quelqu'un voit une erreur sur ce code qui fait que j'obtiens un résultat erroné. (Exemple d'affichage pour

Code :

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

1
2
3
 
C(6,2) : 1 0
 1 2 )

Merci d'avance.

[koala01]

Salut,

Avant de voir les commentaires sur ton code proprement dit, quelques remarques "générales":

l'inclusion de cstdlib n'est pas nécessaire, car elle est avantageusement remplacée par celle de iostream.

Par contre, pour pouvoir utiliser numeric_limits, tu devrait inclure <limits>

Ensuite, plutôt qu'une phrase comme "Entrez deux entiers pour l'impression du triangle de Pascal : ", tu devrais être plu précis dans ce que tu souhaites que l'utilisateur introduise, et donc peut être travailler en deux temps:
introduisez la valeur de départ pour votre triangle de pascal" (récupérer cette valeur et la valider)
introduiez le nombre de lignes souhaité" (récupérer cette valeur et la valider)

En outre, si tu tiens à séparer correctement ton code en fichiers d'en-tête et fichiers d'implémentation, sache que le fichier d'en-tête (*.h ou *.hpp) ne devrait contenir que les déclarations de fonction et les définitions de classes.

Ton fichier d'en-tête ressemblerait donc à

Code :

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

int comb(int n, int k);

... tout simplement...
et tu aurais un fichier d'implémentation (triangleDePascal.cpp) qui contiendrait l'implémentation de la fonction sous la forme (non corrigée) de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int comb(int n, int k)
{
    if(n < 0|| k < 0 || n < k )
         return 0;
   int c = 1, m = n + 1;
  // m = n + 1;
 for( int i = 1; i <= k; i++,m--)
 {
	c *= m/i;
 }
 return c;
}

Toute la question étant ici de savoir s'il est intéressant de travailler ainsi pour une seule fonction

Enfin, tu devrais prendre l'habitude d'utiliser des termes "auto commentés" pour tes différents identifiants (noms de fonction, d'arguments, de variables, etc)...

Une fonction représentant une action, tu pourrais envisager de renommer avantageusement comb en... combiner et tes variables n et k en vue de leur donner des noms qui représentent clairement ce à quoi il servent (depart et nombre_ligne )

Ces détails pratiques ayant été abordés, ne crois tu pas que les deux boucles imbriquées font partie de la logique qui permet de créer le triange de pascal

Si oui, il semble logique de les sortir de la fonction main et de les factoriser dans une fonction qui serait - par exemple - nommée AfficherPascal.

Cela "simplifierait" ta fonction main en:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main(/* int argc, char* argv[] ceci n'est nécessaire que si tu veux
         * pouvoir passer des arguments lors de l'appel de l'exécutable...
         * ici, ce n'est pas vraiment utile ;)
         */ )
{
    int depart;
    int nbLignes;
    cout<<"Introduisez la valeur de départ :";
    cin >>depart;
    cout<<"introduisez le nombre de ligne :";
    cin >> nbLignes;
    AfficherPascal(depart, nbLignes);
    return 0;
}

En effet, le nombre de valeurs affichées par le triangle de pascal dépendra directement de la position de la ligne du triangle que l'on affiche:

• 1 pour la première
• 2 pour la deuxième
• 3 pour la troisième
• 4 pour la quatrième
• ...

De plus, nous remarquons que les valeurs affichées pour une ligne donnée dépendent directement... des valeurs affichées pour la ligne précédente.

La première idée qui vient à l'esprit est donc... qu'il serait intéressant de garder ces valeurs "quelque part"...

De cette manière, tu pourrais envisager de créer ton triangle de pascal d'une seule traite (éventuellement de manière récursive) et de l'afficher une fois qu'il a été créé...

En t'y prenant bien, si tu décide de permettre à la personne de demander l'affichage de plusieurs triangles de pascal, tu pourrais même envisager de ne recréer le triangle que si l'utilisateur demande l'affichage d'un triangle plus grand ou dont la valeur de début diffère...

En effet, si l'utilisateur demande la première fois l'affichage d'un triangle commençant à 1 et comprenant 9 lignes, et la deuxième fois celui d'un triangle commençant à 1 mais de 6 lignes à peine, tout ce que tu as à faire, c'est de n'afficher que les 6 premières lignes du triangle déjà calculé la première fois ...

Évidemment, si l'utilisateur demande la deuxième fois l'affichage d'un triangle de 10 ou 11 lignes ou dont la valeur de départ est 5, il faudra le recalculer

Mais cela peut te permettre de gagner énormément de temps

Je vais te laisser "cogiter" un peu sur la manière d'arriver à ces résultats, mais je vais te mettre sur la voie pour t'aider dans ta conception

Un triangle est composé de lignes, il te faut donc une "collection" dynamique de lignes.

Chaque ligne est de son coté... une "collection" dynamique de valeurs entières.

L'idéal est d'utiliser les conteneurs de la STL, tels que vector ou list.

Tu pourrais donc déclarer une ligne du triangle de pascal sous la forme de

Code :

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

std::vector<int> lignePascal;

et ton triangle de pascal sous la forme de

Code :

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

std::vector<lignePascal> triangePascal;

(les deux se satisferaient très bien d'utiliser std::list )

L'idéal serait alors de partir sur une structure qui contienne le triangle de pascal et qui soit en mesure de te rappeler le nombre de lignes et la valeur de départ utilisée, voire sur une classe qui "encapsulerait" toutes ces informations et qui fournirait les comportements adéquats

[jrosenzw]

Merci Koala01.

Je vais mettre en oeuvre cet algorithme. Je sais que ça me prendra bien du temps. Mais je produirais un effort personnel là-dessus.

Je ne crois pas que j'ai suffisamment avancé pour réaliser ce code avec les collections dynamiques( c'est ça les pointeurs? J'aborderai ce chapitre après les tableaux! J'étudie en fait dans un livre ("Serie Schaum"). Là j'en suis encore aux fonctions).

J'ai aussi bien pris en compte vos remarques sur les règles de bonne pratique de programmation(que je connais mais dont je ne me sers pas toujours).

Je vous renouvelle mes remerciements pour votre contribution.

[koala01]

Mon dieu, il ne s'agit absolument pas de te conseiller de manipuler des pointeurs

Il est vrai que les pointeurs sont une des solutions envisageables pour créer des structures à taille dynamique, mais, dans l'ensemble, les cas dans lesquels il est utile (indispensable ) de les utiliser sont finalement très rares

Ici, il s'agit d'utiliser des conteneurs qui, bien qu'utilisant des pointeurs en internes, présentent un ensemble de comportements qui te permettent de gérer plusieurs objets d'un même type de manière bien plus sécurisante que ce que tu serais tenté de faire en utilisant les pointeurs toi-même...

Le plus souvent, ces conteneurs te permettront d'ajouter un élément à la fin avec un code aussi simple que (si tab est un std::vector<int>)

Code :

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

tab.push_back(2);

J'admets peut etre avoir mal choisi le terme de "collection dynamique", qui peut prêter à confusion avec l'allocation dynamique de la mémoire...

Ici, l'idée était surtout de parler de conteneur qui adaptent "dynamiquement" leur taille aux besoin de stockage

[JolyLoic]

L'intérêt du triangle de pascal est d'utiliser les valeurs d'une ligne pour calculer la suivante. Ce qui impose de les stocker quelque part.

J'ai l'impression par contre que l'exercice en question te demande de ne pas utiliser cette méthode, mais de recalculer chaque valeur de manière lourde, mais sans donc avoir besoin de rien stocker.

Peut-être la méthode plus classique viendra-t-elle dans un prochain chapitre, une fois que tu auras vu les tableaux (j'espère sous la forme vector, qui est de loin la plus simple et la plus utile) ?

[jrosenzw]

Merci à tous les deux JolyLoic et Koala01.

Effectivement je suis un débutant en C++. Dans la mesure que je suis à la lettre un livre d'apprentissage dont je veille à faire tous les exercices et dans l'ordre.

A partir des indications reçues j'ai structuré mon programme comme suit:

fichier .h : pascalTriangle.h

Code :

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

1
2
3
4
 
int combination(int value, int line_number);
// void displayPascalTriangl(int , int );
void displayPascalTriangl(int value, int line_number);

fichiers .cpp
1) pascalTriangle.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int combination(int value, int line_number)
{
    if(value < 0|| line_number < 0 || value < line_number )
         return 0;
	int comb = 1, m = value + 1;
	for( int i = 1; i <= line_number; i++,m--)
	{
		comb *= m/i;
	}
    return comb;
}

2) displayPascalTriangle.cpp

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
 
#include <iostream>
#include "pascalTriangl.h"
 
void displayPascalTriangl(int value, int line_number)
{
     for (int i = -1; i <  value; i++)
	 {
		cout << " ";
        for (int j = i + 1; j < line_number; j++)
		{
            //cout << " ";
            // cout << combination(i, j) << '\n';
            cout << combination(i, j) << " ";
        }
		cout << endl;
     }
     cout << endl;	
}

3) mainPascalTriangle.cpp

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
 
#include <iostream>
#include <limits>
#include "pascalTriangl.h"
using namespace std;
 
// int main(int argc, char *argv[])
int main()
{
	int value, line_number;
	cout << " Introduisez un entier pour l'affichage du triangle de Pascal : ";
	cin >> value;
    cout << " Introduisez le nombre de ligne : ";
	cin >> line_number;  
    cin.ignore(numeric_limits <	streamsize > ::max(), '\n');
    displayPascalTriangl(value, line_number);
}

Le problème auquel je suis confronté à ce niveau est ce message d'erreur :

displayPascalTriangl.cpp: In function `void displayPascalTriangl(int, int)':
displayPascalTriangl.cpp:8: error: `cout' undeclared (first use this function)
displayPascalTriangl.cpp:8: error: (Each undeclared identifier is reported only once for each function it appears in.)
displayPascalTriangl.cpp:15: error: `endl' undeclared (first use this function)

make.exe: *** [displayPascalTriangl.o] Error 1

Exécution terminée


Pourtant j'ai bien utilisé la directive <iostream> et mon fichier .h

Est-ce que j'ai omis d'inclure une librairie dont je n'ai pas connaissnace? J'utilise DEVC++ come Environement de Developement!.

Merci de votre disponibilité pour le temps consacré.

[white_tentacle]

cout est dans le namespace std.

C'est à dire que pour l'utiliser, tu dois taper

Code :

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

std::cout

Dans ton main, tu as choisi l'autre option, à savoir :

Code :

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

using namespace std

Qui fait que le compilateur va rechercher le symbole cout (tous les symboles en fait) dans l'espace de nom global, mais aussi dans l'espace de nom std. Le problème de cette solution, c'est que si un symbole est défini à la fois dans l'espace de nom global et dans l'espace std, tu as toutes les chances de croire en utiliser un, alors que tu utilises l'autre, avec à la clé des bugs parfois subtils à trouver.

[jrosenzw]

Merci à tous.

J'ai ajouté la directive

Code :

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

using namespace std;

dans tous les fichiers où j'utilise cin et cout et remplacé leur occurrence par std::cin, std::cout

Il se fait que je n'ai plus d'erreur. Cependant je n'ai plus ma fenêtre résultat(elle disparaît aussitôt qu'elle apparaît ) malgré l'instruction :

Code :

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

1
2
 
std::cin.ignore(numeric_limits < streamsize > ::max(), '\n');

Est-ce la bonne manière d'utilisation de std:: que je trouve pourtant pas pratique car il faut écrire autant de std:: qu'il y a aurait de cin, cout. A moins que je n'en saisis pas encore bien l'utilisation.

Comment puis-je garder la visualisation de l'affichage? Mon code est-il adapté pour l'affichage de ce que je voudrais obtenir vu que je ne peux voir ce qui est calculé par mon programme?

Je vous renouvelle mes gratitudes pour votre disponibilité et votre précieuse contribution.

[Goten]

numeric_limits et streamsize font aussi parti du namespace std

[white_tentacle]

Le fait que la fenêtre se ferme, c'est un paramètre de ton environnement de développement.

Une solution nulle mais pas chère pour contourner cela est l'ajout du code suivant en fin de programme (fin du main, juste avant le return 0):

Code :

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

1
2
3
std::cout << std::endl << "Taper un caractère et valider pour sortir du programme : ";
char c;
std::cin >> c;

Une meilleure solution consiste à paramétrer ton IDE .

[koala01]

Ce qui se passe, c'est que tu dois effectuer ta pause... après avoir affiché ton triangle

Ta fonction main() devient donc

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
#include <iostream>
#include <limits>
#include "pascalTriangl.h"
using namespace std;
 
// int main(int argc, char *argv[])
int main()
{
    int value, line_number;
    cout << " Introduisez un entier pour l'affichage du triangle de Pascal : ";
    cin >> value;
    cout << " Introduisez le nombre de ligne : ";
    cin >> line_number;  
    /* il fal
    displayPascalTriangl(value, line_number);
    cout << "Appuyez sur entrée pour continuer...";
    cin.ignore(numeric_limits <	streamsize > ::max(), '\n');
    return 0;
}

Je vais en profiter pour te faire d'autres remarques tout à fait générales:
L'idéal est de se limiter à une instruction par ligne.

Ainsi, s'il n'est pas "incorrect" de déclarer deux variables sous la forme de int i, j; il faut avouer que l'idéal reste... de les déclarer en deux temps sous la forme de

Code :

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

1
2
int i;
int j;

Cela ne devrait pas te prendre plus d'une demi seconde d'aller à la ligne et de réécrire le mot clé int, mais, d'un autre coté, cela t'évite les problèmes qui pourraient survenir avec un code proche de

Code :

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

int *i, j, k, l, m, n, o;

où tu risque de "zapper" la déclaration d'une des variables et où, contrairement aux apparences, seul i est un pointeur

Si une instruction est "complexe", rien ne t'empêche de de l'écrire en plusieurs lignes (en respectant les règles qui le régissent) et de "ventiler" le code sous une forme proche de

Code :

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

1
2
3
double hypotenuse = sqrt(
                         ( cote1 * cote1 ) +
                         ( cote2 * cote2 ));

Ensuite, tu devrais adopter une politique d'indentation stricte: à l'intérieur d'une paire d'accolades, chaque instruction devrait commencer sur la même colonne.

L'idéal est d'éviter le caractère de tabulation, car il peut être représenté par un nombre d'espaces différent selon l'éditeur utilisé.

Ce qui est "correctement indenté" sur un éditeur particulier peut sembler particulièrement mal mis en forme sur un autre

Si je te fais ces remarques, c'est parce qu'un code est beaucoup plus souvent lu ou étudié qu'il n'est écrit ou compilé... surtout lorsqu'il est fourni sur un forum

Et quand bien même il ne serait pas destiné à être présenté sur un forum, pense au fait que, si tu viens à laisser ton code de coté pendant "un certain temps" et que tu dois revenir dessus, alors qu'il te semble si clair aujourd'hui, il risque de te paraitre bien bien plus ténébreux dans trois ou six mois, alors que tu aura eu l'occasion d'oublier jusqu'au but du code écrit...

C'est pourquoi je n'hésite pas à dire que, la première qualité d'un code, avant même de faire ce que l'on attend de lui, est d'être facilement lisible et compréhensible

L'indentation stricte, l'utilisation d'identifiants auto-commentés et celle de commentaires utiles (plutôt que de dire "j'ajoute 10 à i", essayer d'expliquer pourquoi on le fait sera bien plus utile ) sont les meilleurs moyen d'y arriver

[jrosenzw]

Bonjour à tous

Je me suis pas mal occupé à mon exercice sur le triangle de Pascal. Je suis parvenu à faire marcher le code mais avec un résultat non conforme à ce qui serait attendu. J'ai beaucoup réfléchi sur ma solution et envisagé pas mal de cas. Mais j'arrive pas à obtenir un triangle de pascal tel que ça devrait l'être . Par ailleurs mes coefficients sont faux alors que je pense avoir bien tenu compte de la formule(prière de voir à cet effet l'énoncé en début de discussion...). Je me suis appliqué à calculer à la main quelques valeurs de combinaison à travers mon code.Mais à l'exécution, j'obtiens autre chose.

Je vous remercie d'avance de bien vouloir m'éclairer sur cette question. Pensez-vous que mon code correspond à l'algorithme énoncé antérieurement. Encore une fois mes gratitudes pour votre bien aimable attention .

Code complet :

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
63
64
65
// Fichier main.cpp

#include <iostream>
#include <limits>
#include "pascalTriangl.h"
using namespace std;
int main()
{     
    int value, line_number;
    std::cout << " Introduisez un entier pour l'affichage du triangle de Pascal : ";
    std::cin >> value;
    std::cout << " Introduisez le nombre de ligne : ";
    std::cin >> line_number;
    if(value < 0 || line_number < 0 || value < line_number )
    {
        std::cout << " Verifiez les valeurs : ";
    }
    displayPascalTriangl(value, line_number);
    std::cin >> value;
    /*Ne marche ... : //std::cout << "Appuyez sur entrée pour continuer...";
     //std::cin.ignore(numeric_limits <	streamsize > ::max(), '\n');
    // return 0; ... pas la fenêtre d'affichage disparaît malgré cette partie du code */
}

// Fichier affichage.cpp

#include <iostream>
#include "pascalTriangl.h"
using namespace std;

void displayPascalTriangl(int value, int line_number)
{             
    for (int i = 1; i <= value; i++)
    {
        std::cout << " ";
        
        for (int j = 1; j <= i + 1; j++) 
        {
            std::cout << " " << combination(i, j);
        }
        std::cout << endl;
    }  
    std::cout << endl;	
}

// Fichier combinaison.cpp

void combination(int value, int line_number)
{
    int comb = 1;
    if(value < 0 || line_number < 0 || value < line_number)
    comb = 0;
    if(value == 0 && line_number == 0)
    comb = 1;
    for( int k = 0; k < line_number; k++)
    {
        comb *= (value - k)/(k + 1);
    }
}
// Fichier .h

int combination(int value, int line_number);
// void combination(int value, int line_number);
void displayPascalTriangl(int value, int line_number);