#include
#include
#include
#include

int ** dectableau ()
{
//dec ress
int i,j,k;
int ** pt;

pt=NULL;

//obtention des valeurs du tableau
printf(”entrez le nombre de cases horizontale”);
scanf(”%d”,&i);
printf(”\nEntrez le nombre de case verticalement”);
scanf(”%d”,&j);

//allocation dynamique du premier tableau de pointeur
pt=(int**) malloc (j * sizeof (int *));
if (pt!= NULL) // si le premier tableau est bien alloué
{
for (k=0;k {
//allocation dynamique du second tableau de valeur
pt[k]=(int *) malloc ( i * sizeof(int));
}

}
else
{
printf(”la mémoire n’a pas été allouée”);
}

return(pt);
}

void remptableau (int ** tab)
{
int * matrice[3];
int i,j,k,alea;

srand(time(NULL)); // initialisation de l’aléatoire

for(i=0;i<3;i++)
{
* matrice[i]=*tab[i];
}

k=strlen(*matrice[0]);

for (i=0;i<3;i++) // boucles de remplissage aléatoire
{
for(j=0;j {
while (matrice[i][j]<0)
{
matrice[i][j]=rand () %256;
}
}
}
}

void afftableau(int ** tab)
{
int i,j;

k=strlen(tab[1]);

for(i=0;i<3;i++) //boucle d’affichage du tableau
{
for(j=0;j {
printf(”%d”,tab[i][j]);
}
printf(”\n”); // permet le retour à la ligne à la fin d’une premiére ligne
}
}

int main()
{
int ** matrice;
int i,j;
int po,iu;

matrice=dectableau(&po,&iu); //récupération de la matrice de la fonction dectableau

afftableau(matrice); // appel de la procédure d’affichage du tableau

return 0;
}

/* ici je n’ai pas fais de bibliothéque.*/

#include
#include
#include

int voyelle (char * tab)
{
int voyelle, taille,i; //dec.ress

taille=strlen(tab);
voyelle=0;

for(i=0;i {
if((tab[i]=='a') || (tab[i]=='e') || (tab[i]=='i') || (tab[i]=='o') || (tab[i]=='u') || (tab[i]=='y'))
{
voyelle ++; //si la lettre est une voyelle, on incrémente voyelle qu'on retournera au main
}
}

return (voyelle);
}

void mirroir(char * tab1)
{
char * tab2;
char * tab3;
short int taille1, i,k;

taille1=strlen(tab1);
tab2=(char *) malloc (taille1 * sizeof(char)); //on alloue la deuxieme chaîne

k=taille1;

for(i=0;i {
tab2[i]=tab1[k]; //on fait l'effet du mirroir
k--;
}

tab3=(char *) malloc (((2*taille1)+3) * sizeof(char));

// on met les deux tableaux dans tab3

strcpy(tab3,tab1);
tab3[taille1+1]=' ';
tab3[taille1+2]=':';
tab3[taille1+3]=' ';
strcat(tab3,tab2);

for(k=0;k<((2*taille1)+3);k++)
{

printf("%c",tab3[k]);
}

}

int consonne(char * tab)
{
int consonne, taille,i;

taille=strlen(tab);
consonne=0;

for(i=0;i {
if((tab[i]!='a') && (tab[i]!='e') && (tab[i]!='i') && (tab[i]!='o') &&(tab[i]!='u') && (tab[i]!='y'))
{
consonne ++; // si la lettre n'est pas une voyelle on incrémente consonne et on le retournera dans le main
}
}

return (consonne);
}

int main()
{

char * matrice;
int k,i,nbvoy,nbcons; //dec.ress. statique
{
char tableau[100]={0};/dec.ress. dynamique

printf("Entrez votre phrase\n");
gets(tableau);
k=strlen(matrice);

matrice=(char*) malloc ((k)*sizeof(char));
strcpy(matrice, tableau);
} /* la fermeture d'accolade permet l'allocation dynamique du tableau

printf("\n\nVotre chaîne est :\n");

puts(matrice); //affichage de la matrice

nbvoy=voyelle(matrice); //appel de la fonction voyelle

if (nbvoy>1) printf(”Il y a %d voyelles\n”,nbvoy);
else printf(”Il y a %d voyelle\n”,nbvoy); //affichage en fonction du nombre de voyelle

mirroir(matrice); //appel de la procédure mirroir

nbcons=consonne(matrice); //appel de la fonction consonne

if(nbcons>1) printf(”\nil y a %d consonnes”,nbcons);
else printf(”\nil y a %d consonne”,nbcons); //affichage en fonction du nombre de consonne

}

/*La bibliothéque*/

#ifndef MABIB_H_INCLUDED
#define MABIB_H_INCLUDED

#include
#include

int * pif(); // récupére les notes dans le tableau

void paf (int* pt);// affiche le tableau

float moy (int * pointab);// calcul la moyenne des notes du tableau

int mini (int * tab);// determine le minimum de la chaîne

int maxi (int * tab);// determine le maximum de la chaîne

int * affichage (int * tab); // affiche le minimum et le maximum

#endif // MABIB_H_INCLUDED

/* Les sous programmes*/

#include “mabib.h”

int * pif() // fonction permettant le remplissage du tableau.
{
int * pointab;
int i,j; //dec ress
pointab=(int *) malloc (10*sizeof(int)); // alloc dynamique de mémoire pour le tableau la 11 case servira pour moyenne

j=0;

for(i=0;i<10;i++) // boucle de remplissage du tableau
{
printf("entrez votre note n: %d\n", j);
scanf("%d",&pointab[i]);// recupération de la note

while ((pointab[i]<0) && (pointab[i]>20)) //blindage des notes entre 0 et 20
{
printf(”votre note n’est pas comprise entre 0 et 20.\nVeuillez recommencer SVP “);
scanf(”%d”,&pointab[i]);
}
j++;
}

return (pointab); // il retourne le pointeur du tableau.
}

void paf( int * pt) //procédure permettant l’affichage du tableau
{
int i; //dec ress

for(i=0;i<10;i++) //affiche le tableau
{
printf("la note n : %d est %d\n",i,pt[i]);
}
}

float moy(int * pointab) //reception du tableau
{
float moyenne;//dec ress
int i;

moyenne=pointab[0]; //la moyenne prend la valeur de la premiére case

for(i=1;i<10;i++)
{
moyenne=moyenne+pointab[i]; // puis on ajoute le reste des cases au fur et à mesure
}

moyenne=moyenne/10; // on sait qu'il y a dix notes donc on divise moyenne par dix pour avoir la valeur moyenne de "moyenne"

return (moyenne); //et on retourne cette variable par le tableau
}

int mini( int * tab)
{
int minimum,i;

minimum=tab[0];//initialisation du minimum sur la premiére valeur

for(i=1;i<10;i++)
{
if (minimum>tab[i]) minimum=tab[i]; //boucle pour chercher le minimum
}

return(minimum);
}

int maxi (int* tab)
{
int maximum,i; //dec.ress
maximum=tab[0];//initialisation du maximum
for(i=1;i<10;i++)
{
if (maximum }

return(maximum);
}

int * affichage(int * tab)
{
int matrice[2];

matrice[0]=mini(tab);
matrice[1]=maxi(tab);

return(matrice);//on renvoie les valeurs qui s’afficheront dans le main
}

/* Le main */

#include “mabib.h”

int main()
{

int * matnot;
int * maximini;
int min,max;
float moyenne; //dec ress

matnot=pif(); // appelle de pif

paf(matnot); // appelle de pif

moyenne=moy(matnot); // appelle de moyenne

printf(”\n la moyenne vaut %2.2f”,moyenne);
maximini=affichage(matnot); //appel de la fonction du minimum et du maximum

printf(”\n\nle maximum des notes est : %d\nLe minimum des notes est : %d”,maximini[1],maximini[0]);

return 0;
}

Bienvenue dans WordPress. Ceci est votre premier article. Modifiez-le ou effacez-le, puis lancez-vous !