TRIANGLE DE PASCAL RÉCURSIF

/****************************************/
/* 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;
			}
		}
	}
	*err = OK;
	/* 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 */

	*err = OK;

	while ((lignes < DIM) && (*err = OK))
	{
		while ((colonnes < DIM) && (*err = OK))
		{
			if (matrice[lignes][colonnes] < 0)
			{
				*err = ERREUR;
			}
			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é */
}

• PRÉDICTION ET MODELISATION DE SERIES TEMPORELLES PAR RESEAUX DE NEURONES ARTIFICIELS MULTICOUCHES(PARTIE 1)
• COLORATION SYNTAXIQUE
• ALGORITHME GÉNÉTIQUE RCPSP
• CALCULETTE (PEUT ÊTRE GRAPHIQUE UN JOURS ^^)
• ENSEMBLE DISJOINT

• TRIANGLE DE PASCAL ET DEVELLOPEMENT DE POLYNOME
• FRACTALE DE SIERPINSKI
• [C - ANSI] - EXEMPLE D'UTILISATION DES POINTEURS DE FONCTIONS DANS LE CADRE D'UN TRI A BULLE RECURSIF
• TRADUCTEUR SIMPLIFIÉ DU PASCAL VERS LE C - LEX ET YACC (FLEX ET BISON)
• RÉSOLUTION DU PROBLÈME DES 8 DAMES