Fonction récursive permettant de calculer et afficher les éléments du triangle de pascal.
Source / Exemple :
/****************************************/
/* trianglepascalrecursif.c
/*
/* v1.0
/*
/* 16 / 12 / 2005
/*
/* maiskisuije@hotmail.com
/*
/****************************************/
#include <stdio.h>
#define DIM 9
typedef enum{OK,ERREUR};
void initialisation (int matrice[DIM][DIM], int *err);
/*
*
void triPascal (int p[DIM][DIM], int i, int j);
/*
*
void affichageMatrice (int matrice[DIM][DIM], int *err);
/*
*
int main (void)
{/*
- Bloc B1 : main
- objectif : calculer et afficher le triangle de pascal
- méthode : additions successives (opérateur arithmétique +), périphérique de sorties
- besoin : mPascal une matrice, x,y deux entiers, DIM
- connu : DIM 8
- entrée : ---
- sortie : ---
- résultat : affichage de la construction du triangle de pascal
- hypothèse : x et y sont deux entiers >=0 */
int x = 0; /* entier pour les lignes de la matrice */
int y = 0; /* entier pour les colonnes de la matrice */
int mPascal[DIM][DIM]; /* une matrice de dimension DIM * DIM */
int erreur; /* pour la gestion des erreurs */
/* initialiser une matrice (void Bloc B2) */
initialisation ( mPascal, &erreur);
/* A : mPascal une matrice de dimension DIM*DIM à été initialisée */
if (erreur == OK)
{
/* calculer les éléments du triangle de pascal (voir Bloc B3) */
triPascal(mPascal, x, y);
/* A : les éléments du triangle de pascal ont été calculés */
/* afficher une matrice (voir Bloc B4) */
affichageMatrice (mPascal, &erreur);
/* A : mPascal une matrice de dimension DIM*DIM a été affichée */
if (erreur != OK)
{
printf("\n! Une erreur s'est produite lors de l'affichage du triangle de pascal.\n");
}
}
else
{
printf("\n! Une erreur s'est produite lors de l'initialisation de la matrice.\n");
}
/* A : le calcul et l' affichage du triangle de pascal à été effectué */
return 0;
}
void initialisation (int matrice[DIM][DIM], int *err)
{/*
- Bloc B2 : initialisation
- objectif : initialiser une matrice
- méthode : en remplissant la diagonale principale avec des 1 et le reste avec des 0
- besoin : matrice une matrice d'entiers >= 0, DIM
- connu : DIM 8
- entrée : matrice une matrice
- sortie : matrice une matrice d'entiers >= 0
- résultat : *err = OK si l'initialisation s'est bien déroulée
- hypothèse : matrice fait référence à une matrice d'entiers */
int lignes; /* entier pour les lignes de la matrice */
int colonnes; /* entier pour les colonnes de la matrice */
for (lignes = 0; lignes < DIM; lignes++)
{
for (colonnes = 0; colonnes < DIM; colonnes++)
{
if (lignes == colonnes)
{
matrice[lignes][colonnes] = 1;
}
else
{
matrice[lignes][colonnes] = 0;
}
}
}
/* A : matrice une matrice d'entiers de dimension DIM * DIM a été initialisée */
}
void triPascal (int p[DIM][DIM], int i, int j)
{/*
- Bloc B3 : triPascal
- objectif : calculer les éléments du triangle de pascal
- méthode : additions successives (opérateur arithmétique +)
- besoin : p une matrice d'entiers >= 0, i, j deux entiers >= 0, DIM 8
- connu : DIM
- entrée : p une matrice, i, j deux entiers >= 0
- sortie : p une matrice contenant des nombres entiers
- résultat : *err = OK si les hypothèses sont réspéctées
- hypothèse : la matrice est intialisée */
/* A : la matrice est initialisée */
if ((i < 0) || (j < 0)) return;
if(i == DIM) return;
if (i != j)
{
if (((i - 1) >= 0) && ((j - 1) >= 0)) p[i][j] = p[i - 1][j] + p[i - 1][j - 1];
else if ((i - 1) >= 0) p[i][j] = p[i - 1][j];
triPascal (p, i, j + 1);
}
triPascal (p, i + 1, 0);
}
void affichageMatrice (int matrice[DIM][DIM], int *err)
{/*
- Bloc B4 : affichageMatrice
- objectif : afficher une matrice
- méthode : périphérique de sortie
- besoin : matrice une matrice d'entiers >= 0, DIM
- connu : DIM 8
- entrée : matrice une matrice
- sortie : ---
- résultat : *err = OK si l'affichage à été bien réalisé
- hypothèse : la matrice est initialisée avec des entiers >= 0 */
int lignes = 0; /* entier pour les lignes de la matrice */
int colonnes = 0; /* entier pour les colonnes de la matrice */
while ((lignes < DIM) && (*err = OK))
{
while ((colonnes < DIM) && (*err = OK))
{
if (matrice[lignes][colonnes] < 0)
{
}
colonnes++;
}
lignes++;
}
/* A : la matrice est initialisée avec des entiers >= 0 */
if (*err == OK)
{
for (lignes = 0; lignes < DIM; lignes++)
{
for (colonnes = 0; colonnes < DIM; colonnes++)
{
printf("%5d", matrice[lignes][colonnes]);
}
printf("\n");
printf("\n");
}
}
/* A : l'affichage de la matrice à été correctement réalisé */
}
Conclusion :
Faites varier DIM pour faire varier le degré du polynome.
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.