Gestion d'ensemble (au sens mathematique)

Soyez le premier à donner votre avis sur cette source.

Vue 4 083 fois - Téléchargée 170 fois

Description

ce programme gere des ensemble mathematique.
il effectue les operations suivantes :

- saisie, affichage et gestion d'ensemble
- cardinal d'un ensemble
- union de deux ensembles
- intersections de deux ensembles
- complementaire d'un ensemble
- difference de deux ensembles

Ce programme est codé sous Borland C++ 5.02

Source / Exemple :


#include <stdio.h>
#include <conio.h>

void affich(int[15][100],int[],int);
void supprim_element(int[15][100],int[],int*);
void saisie(int[15][100],int[],int*);
void supprim_ensemble(int[15][100],int[],int*);
void ajout(int[15][100],int[],int*);
void modif(int[15][100],int[],int*);
void gestion(int[15][100],int[],int*);
void cardinal(int[],int*);
int test_pres(int[],int,int);
void affich_intersection(int[],int);
void affich_union(int[],int);
void intersection_ensembles(int[15][100],int[],int,int);
void union_ensembles(int[15][100],int[],int,int);
int test_compl_a(int[15][100],int[],int,int);

void affich_complementaire(int[],int);

void complementaire(int[15][100],int[],int*);
void difference(int[15][100],int[],int,int);
void menu_2(int[15][100],int*,int[]);
void menu_5(int[15][100],int[],int*);
void menu_6(int[15][100],int[],int*);
void menu_8(int[15][100],int[],int*);
void menu_affich();
int menu(int*);
void affich_difference(int[],int);

/******************************************************************************/

/*Fonction permettant de supprimer un element d'un ensemble a condition ke ce
  dernier existe*/

void supprim_element(int t[15][100],int c[],int *n)
{
int i,j;
clrscr();
printf("\t\t\t* Supression d'element *\n\n\n");

do{
printf("Numero de l'ensemble ou se trouve l'element a supprimer :");
scanf("%d",&i);
if((i<=0)||(i>*n)){printf("\a");clrscr();}
}while((i<=0)||(i>*n));

i=i-1;

do{
printf("\n\n");
affich(t,c,i);
printf("Saisir le numero de l'element a effacer :");
scanf("%d",&j);
if((j<=0)||(j>c[i])){printf("\a");clrscr();}
}while((j<=0)||(j>c[i]));

j=j-1;

	while(j<c[i])
	{
	t[i][j]=t[i][j+1];
	j++;
	}

c[i]=c[i]-1;
printf("\n\n");
affich(t,c,i);getch();
}

/******************************************************************************/

/*Fonction de saisie des elements a conditions que le nombre max d'elements (100)
  ne soit pas depassé*/

void saisie(int t[15][100],int c[],int *n)
{
int j;
clrscr();
printf("\t\tElement numero %d\n\n",(*n)+1);

do{
printf("Nombre d'elements a saisir (max 100):");
scanf("%d",&c[*n]);
if((c[*n]>100)||(c[*n]<0)){printf("\a");clrscr();}
}while((c[*n]>100)||(c[*n]<=0));

	for(j=0;j<c[*n];j++)
	{
   do{
	printf("Saisir element n%d :",j+1);
	scanf("%d",&t[*n][j]);
   if((t[*n][j]<=0)||(t[*n][j]>255)){printf("\a");clrscr();}
   }while((t[*n][j]<=0)||(t[*n][j]>255));
	}

(*n)++;
}

/******************************************************************************/

/*Fonction permettant de supprimer un ensemble entier a condition ke ce
  dernier existe*/

void supprim_ensemble(int t[15][100],int c[],int *n)
{
int i,j;
clrscr();
printf("\t\t\t* Supression d'ensembles *\n\n");

do{
printf("Saisir le numero de l'ensemble a supprimer :");
scanf("%d",&i);
if((i<=0)||(i>*n)){printf("\a");clrscr();}
}while((i<=0)||(i>*n));

i=i-1;

	if(i==*n)
	{
	(*n)--;
	}
	else
		{
		  for(j=0;j<c[i+1];j++)
        {
		  t[i][j]=t[i+1][j];
		  }

		while(i<*n)
			{
			c[i]=c[i+1];
			i++;
			}

		(*n)--;
		}
}

/*******************************************************************************/

/*fonction permettant d'ajouter un element a un ensemble existant*/

void ajout(int t[15][100],int c[],int *n)
{
int i;
clrscr();
printf("\t\t\t* Ajout d'elements *\n\n\n");

do{
printf("Numero de l'ensemble ou vous desirez ajouter un element :");
scanf("%d",&i);
if((i<=0)||(i>*n)){printf("\a");clrscr();}
}while((i<=0)||(i>*n));

i=i-1;

do{
printf("\n\n");
affich(t,c,i);
printf("Entrer l'element n%d :",c[i]+1);
scanf("%d",&t[i][c[i]]);
if((t[i][c[i]]<0)||(t[i][c[i]]>255)){printf("\a");clrscr();}
}while((t[i][c[i]]<0)||(t[i][c[i]]>255));

printf("\n\n");
affich(t,c,i);
c[i]++;
}

/*******************************************************************************/

/*Fonction permettant de modifier la valeur d'un element existant*/

void modif(int t[15][100],int c[],int *n)
{
int i,j;
clrscr();
printf("\t\t\t* Modification d'elements *\n\n\n");

do{
printf("Numero de l'ensemble ou vous desirez modifier la valeur d'un element :");
scanf("%d",&i);
if((i<=0)||(i>*n)){printf("\a");clrscr();}
}while((i<=0)||(i>*n));

i=i-1;

do{
printf("\n\n");
affich(t,c,i);
printf("\nNumero de l'element que vous desirez modifier :");
scanf("%d",&j);
if((j<=0)||(j>c[i])){printf("\a");clrscr();}
}while((j<=0)||(j>c[i]));
j=j-1;
do{
printf("Entrer la nouvelle valeur :");
scanf("%d",&t[i][j]);
if((t[i][j]<0)||(t[i][j]>255)){printf("\a");clrscr();}
}while((t[i][j]<0)||(t[i][j]>255));
}

/*******************************************************************************/
 /*foncton affichant le menude l'option de gestion des ensembles*/

void gestion(int t[15][100],int c[],int *n)
{
clrscr();
printf("\t\t\t* Gestion des ensembles *\n\n\n");
printf("1 : Supprimer tout un ensemble\n\n");
printf("2 : Supprimer un element d'un ensemble\n\n");
printf("3 : Ajouter un element a un ensemble existant\n\n");
printf("4 : Modifier la valeur d'un ensemble");

	switch(getch())
	{
	case'1':supprim_ensemble(t,c,n);break;
	case'2':supprim_element(t,c,n);break;
	case'3':ajout(t,c,n);break;
	case'4':modif(t,c,n);break;
   default:printf("\a");
	}
}

/*******************************************************************************/
     /*fonction calculant le cardinal d'un ensemble*/

void cardinal(int c[],int *n)
{
int i;
clrscr();
printf("\t\t\t* Cardinal d'un ensemble * \n\n\n");
do{
printf("Numero de l'ensemble dont vous voulez calculer le cardinal :");
scanf("%d",&i);
if((i<=0)||(i>*n)){printf("\a");clrscr();}
}while((i<=0)||(i>*n));
i=i-1;
printf("\n\n Le cardinal de l'ensemble %d est : %d",i+1,c[i]);
}

/*******************************************************************************/
     /*foncton testant la presence d'unr certaine valeur dans un tableau de
     stockage, elle retourne 1 si la valeur se touve dans la tableau sinon
     elle retourne 0*/

int test_pres(int u[],int k,int n)
{
int i;

for(i=0;i<k;i++)
{
if(u[i]==n){return 1;}
}
return 0;
}

/*******************************************************************************/
    /*foncton affichant l'intersecton de 2 ensembles*/

void affich_intersection(int in[],int k)
{
int i;

printf("{");

	for(i=0;i<k;i++)
	{
	printf("%d",in[i]);
	if(i!=k-1){printf(",");}
	}
printf("}");
}

/*******************************************************************************/
       /*foncton affichant l'union de 2 ensembles*/

void affich_union(int u[],int k)
{
int i;

printf("{");

	for(i=0;i<k;i++)
	{
	printf("%d",u[i]);
	if(i!=k-1){printf(",");}
	}
printf("}");
}

/*******************************************************************************/
            /*fonction calculant et affichant l'intersection de 2 ensembles*/

void intersection_ensembles(int t[15][100],int c[],int a,int b)
{
int k=0,i,j,in[100];

for(i=0;i<c[b];i++)
{
 for(j=0;j<c[a];j++)
 {
 if((t[a][j]==t[b][i])&&(test_pres(in,k,t[a][j])==0)){in[k]=t[a][j];k++;}
 }
}

affich_intersection(in,k);
}

/*******************************************************************************/
               /*fonction calculant et affichant l'union de 2 ensembles*/

void union_ensembles(int t[15][100],int c[],int a,int b)
{
int u[100],k=0,i,j;

for(i=0;i<c[b];i++)
{
	for(j=0;j<c[a];j++)
   {
   if(test_pres(u,k,t[a][j])==0){u[k]=t[a][j];k++;}
   }
}

for(i=0;i<c[b];i++)
{
	for(j=0;j<c[a];j++)
   {
   if(test_pres(u,k,t[b][i])==0){u[k]=t[b][i];k++;}
   }
}

affich_union(u,k);
}

/*******************************************************************************/

/*******************************************************************************/
             /*affich le complementaire d'un ensemble dans un autre*/

void affich_complementaire(int comp[],int k)
{
int i;

printf("{");

	for(i=0;i<k;i++)
	{
	printf("%d",comp[i]);
	if(i!=k-1){printf(",");}
	}
	printf("}");
}

/******************************************************************************/

/*******************************************************************************/
         /*menu du calcul du complemetaire, ce menu verifie tte les conditins
         avant de calculer le complementaire*/

void complementaire(int t[15][100],int c[],int *n)
{
int a,b,comp[100],i,j,k=0,ok;
clrscr();

do{
printf("\t\t\t* Complementaire de A dans B *\n\n");
printf("le Complementaire de A dans B est l'ensemble formé des elements de B qui ne sont pas dans A\n\n");
printf("Numero de l'ensemble A :");
scanf("%d",&a);
if((a<=0)||(a>*n)){printf("\a");clrscr();}
}while((a<=0)||(a>*n));
a=a-1;

do{
printf("Numero de l'ensemble B :");
scanf("%d",&b);
if((b<=0)||(b>*n)||(b==a)){printf("\a");clrscr();}
}while((b<=0)||(b>*n)||(b==a));
b=b-1;

for(i=0;i<c[b];i++)
{ok=1;
	for(j=0;j<c[a];j++)
   {
   if(t[b][i]==t[a][j]){ok=0;}
   }
if((ok==1)&&(test_pres(comp,k,t[b][i])==0)){comp[k]=t[b][i];k++;}
}
printf("\n\nVoici le complementaire de A dans B : ");
affich_complementaire(comp,k);getch();
}

/******************************************************************************/
            /*fonction calculant la difference de 2 ensembles*/

void difference(int t[15][100],int c[],int a,int b)
{
int i,j,ba[100],k=0,ok;

for(i=0;i<c[a];i++)
{ok=1;
	for(j=0;j<c[b];j++)
   {
   if(t[a][i]==t[b][j]){ok=0;}
   }
if((ok==1)&&(test_pres(ba,k,t[a][i])==0)){ba[k]=t[a][i];k++;}
}
affich_difference(ba,k);
}

void affich_difference(int b[],int k)
{int i;

printf(" {");
for(i=0;i<k;i++)
{
printf("%d",b[i]);
if(i!=k-1)printf(",");
}
printf("}");

}

/*******************************************************************************/
                /*menu2 = affichage d'un ensemble*/

void menu_2(int t[15][100],int *n,int c[])
{int i;

			 do{
			printf("\n\n\nSaisir le numero de l'ensemble a afficher :");
         scanf("%d",&i);
         if((i<=0)||(i>*n)){printf("\a");clrscr();}
        	}while((i<=0)||(i>*n));
         i=i-1;
        printf("\n\n");
        affich(t,c,i);getch();
}

/*******************************************************************************/
             /*menu5= union de 2 ensembles*/

void menu_5(int t[15][100],int c[],int *n)
{int a,b;

			clrscr();
        do{
        printf("\t\t\t* Union de deux ensembles *\n\n");
		  printf("Numero de l'ensemble A :");
		  scanf("%d",&a);
        if((a<=0)||(a>*n)){printf("\a");clrscr();}
        }while((a<=0)||(a>*n));
        a=a-1;
        do{
		  printf("Numero de l'ensemble B :");
		  scanf("%d",&b);
        if((b<=0)||(b>*n)){printf("\a");clrscr();}
        }while((b<=0)||(b>*n));
        b=b-1;
        printf("\n\nVoici A U B : ");
        union_ensembles(t,c,a,b);getch();
}

/*******************************************************************************/
           /*menu6 = intersection de 2 ensembles*/

void menu_6(int t[15][100],int c[],int *n)
{int a,b;

			clrscr();
        do{
        printf("\t\t\* Intersection de deux ensembles *\n\n");
		  printf("Numero de l'ensemble A :");
		  scanf("%d",&a);
        if((a<=0)||(a>*n)){printf("\a");clrscr();}
        }while((a<=0)||(a>*n));
        a=a-1;
        do{
		  printf("Numero de l'ensemble B :");
		  scanf("%d",&b);
        if((b<=0)||(b>*n)){printf("\a");clrscr();}
        }while((b<=0)||(b>*n));
        b=b-1;
        printf("\n\nVoici A inter B : ");
		  intersection_ensembles(t,c,a,b);getch();
}

/******************************************************************************/

/******************************************************************************/
            /*menu 8 = difference de 2 ensembles*/

void menu_8(int t[15][100],int c[],int *n)
{int a,b;

        do{
        printf("\t\t\t* Difference de deux ensembles A et B*\n\n");
        printf("La difference des ensembles A et B est l'ensemble des elements de A qui ne sont pas dans B\n\n");
        clrscr();
		  printf("Numero de l'ensemble A :");
		  scanf("%d",&a);
        if((a<=0)||(a>*n)){printf("\a");clrscr();}
        }while((a<=0)||(a>*n));
        a=a-1;
        do{
		  printf("Numero de l'ensemble B :");
		  scanf("%d",&b);
        if((b<=0)||(b>*n)){printf("\a");clrscr();}
        }while((b<=0)||(b>*n));
        b=b-1;
        printf("voici la difference de A et B :");

        difference(t,c,a,b);getch();
}

/******************************************************************************/
            /*affichage d'un ensemble*/

void affich(int t[15][100],int c[],int i)
{
int j;
clrscr();
printf("\n Ensemble numero %d = ",i+1);

printf("{");
	for(j=0;j<c[i];j++)
	{
	printf("%d",t[i][j]);
   if(j!=(c[i])-1){printf(",");}
	}
printf("}\n\n");
	for(j=0;j<c[i];j++)
	{
	printf("Element n%d : %d\n",j+1,t[i][j]);
	}
}

/*******************************************************************************/

               /*affichage du menu general*/

void menu_affich()
{
clrscr();
printf("\t\t\t* Gestion d'ensembles *\n\n\n");
printf(" 1 : Saisie d'un ensemble\n");
printf(" 2 : Affichage d'un ensemble\n");
printf(" 3 : Gestion des ensembles\n\n");

printf(" 4 : Cardinal d'un ensemble\n");
printf(" 5 : L'union de deux ensembles\n");
printf(" 6 : L'intersection de deux ensembles\n");
printf(" 7 : Le complementaire d'un ensemble\n");
printf(" 8 : La difference de deux ensembles\n\n");
printf(" esc : Quitter le programme");
printf("\n\n\n\t\t\tFaites votre choix...\n");
textcolor(12);
cprintf("\n\n\n\n                  Realise par 2PAC esgi (2pac 4 ever!!)");
}

/*******************************************************************************/

              /*fonction executant le choix de l'utilisateur*/

int menu(int *nb)
{
int tab[15][100],card[15],w=0;

switch(getch())
{
case'1':if(*nb<15){saisie(tab,card,nb);}else{printf("\a");}break;

case'2':if(*nb!=0){menu_2(tab,nb,card);}else{printf("\a");}break;

case'3':if(*nb!=0){gestion(tab,card,nb);}else{printf("\a");}break;

case'4':if(*nb!=0){cardinal(card,nb);getch();}else{printf("\a");}break;

case'5':if(*nb>1){menu_5(tab,card,nb);}else{printf("\a");};break;

case'6':if(*nb>1){menu_6(tab,card,nb);}else{printf("\a");};break;

case'7':if(*nb>1){complementaire(tab,card,nb);}else{printf("\a");}break;

case'8':if(*nb>1){menu_8(tab,card,nb);}else{printf("\a");}break;
case 27:w=1;break;
default:printf("\a");
}

return w;
}
/*******************************************************************************/
/*******************************************************************************/
/*******************************************************************************/
/*******************************************************************************/

   /*ici se lance le programme*/

void main()
{
int nb=0;

do
{
menu_affich();
}while(menu(&nb)!=1);

}

Conclusion :


Si vous avez des questions ou des remarques (bonnes ou mauvaises) n'hesitez surtout pas !!!!!!!

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

cs_bouba
Messages postés
518
Date d'inscription
dimanche 2 décembre 2001
Statut
Membre
Dernière intervention
10 novembre 2007
2 -
Le programme est bien mais maintenant il faudrait que tu le modifies afin de gérer les ensembles de façn a ce qu'il n'y ait pas un nombre limité d'éléments a insérer.
Petit indice: utilise les containers de la STL.
Bonne Prog!
bounty_hunter
Messages postés
7
Date d'inscription
mardi 16 novembre 2004
Statut
Membre
Dernière intervention
28 février 2006
-
Ce code est propre, relativement bien structuré.
Cependant, au sens mathématique du terme, un ensemble ne contient que des éléments différents.
C'est à dire que {3,2,7,8,3,7} contient des éléments identiques et ne peut donc pas être considéré comme un ensemble.
Quelques modifications sur des contrôles de redondances seraient donc les bienvenues.
D'autre part, pourquoi ne pas utiliser des listes chainées afin de pouvoir insérer des éléments à la volée? Là, on est obligé de connaitre d'avance le nombre d'éléments de l'ensemble pour l'initialiser. De plus, sa modification est assez fastidieuse (un élément par un).

Sinon, à part ça, le boulot est interessant car batit sur de bonnes bases.
Je vais reprendre la source et faire quelques modifs pour un travail à faire pour mon école.
Donc, si quelqu'un est interessé après ça... :)
Gipsy974
Messages postés
17
Date d'inscription
jeudi 11 décembre 2003
Statut
Membre
Dernière intervention
27 juillet 2005
-
bounty , je serai bien heureux de le voir ce code , comme MCDV je le pense :)
bounty_hunter
Messages postés
7
Date d'inscription
mardi 16 novembre 2004
Statut
Membre
Dernière intervention
28 février 2006
-
Ah oui, mais là, il y a conflit d'interet :)
cs_slayah
Messages postés
1
Date d'inscription
jeudi 24 mai 2007
Statut
Membre
Dernière intervention
31 mai 2007
-
votre travail est intéressant et va me servir énormement vu que je suis débutante mais le problème c'est que j'ai eu lors de la compilation un message affichant les erreurs suivantes ce qui fait que j'ai pas pu exécuter le programme merci donc de m'aider:
Programme 4.cpp(45) : error C2065: 'clrscr' : undeclared identifier
Programme 4.cpp(518) : warning C4129: '*' : unrecognized character escape sequence
Programme 4.cpp(614) : error C2065: 'textcolor' : undeclared identifier
Error executing cl.exe.

Programme 4.obj - 2 error(s), 1 warning(s)

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.