Matrices unidimensionnelle: Vecteurs en C - Applications résolues

1) Declaration d’une chaine (tableau or matrice unidimendionnee) avec initialisation des valeurs.

#include<stdio.h>
void main()
{
	int a[]={2,91,0,-45};	/*chaine des elements entiers, variable matrice initialisée à déclaration. 
	Mémoire allouée pour cette matrice provient directement du nombre d'éléments avec qui est initilisée */
 
	// affichage de la chaine qui contient des nombres entiers
	for(int i=0; i<4; i++)
		printf("%d", a[i]);
 
	getchar();
	int k;
	scanf("%d", k);
}

2) La memoire de l’information dans un tableau unidimensionnel, par lecture.

#include<stdio.h>
void main()
{
	int a[20]; /*on declare une chaine de maximum 20 de elements de type int au nom a */
 
	// On introduit des dates dans la chaine
 
	// On introduit le nombre des elements dans la chaine
	int n;
	printf("nombre des elements dans la chaine (<=20): ");
	scanf("%d", &n);
 
	// On introduit les elements dans la chaine
	printf("Entrer les elements: \n");
	for(int i=0; i<n; i++)
	{
		printf("\t elem %d: ", i+1);
		scanf("%d", &a[i]);
	}
 
	//Affichage des elements de la chaine
	printf("Les elements de la chaine sont: ");
	for(int i=0; i<n; i++)
		printf("%d", a[i]);
 	
	getchar();
	int k;
	scanf("%d", k);
}

3) Ecrire des fonctions de lire et d’affichage de la chaine des nombres entiers, apres ce qu’on l’a declaré.

#include<stdio.h>
void lire(int a[], int* n)
{
	printf("Entrer le nombre des elements de la chaine: ");
	scanf("%d",n);
	printf("\nEntrer les elements de la chaine:\n");
	for(int i=0;i<*n;i++)
	{
		printf("\tEntrer les elements%d: ",i+1);
		scanf("%d",&a[i]);
	}
}
void affichage(int a[], int n)
{
	printf("\nLes elements de la chaine sont: ");
	for(int i=0;i<n;i++)
		printf("%d ",a[i]);
	
}
void main()
{
	int a[20],n;
	lire(a,&n);
	affichage(a,n);
 
	getchar();
	int k;
	scanf("%d", &k);
}

4) Ecrire des fonctions de lire et d’affichage de la chaine des nombres entiers, apres ce qu’il a été declaré. On demande la construction d’un type propre pour retenir les chaines des nombres entiers.

#include<stdio.h>
typedef int vecteur[20]; /* vecteur de type propre, cree par retenir les chaines, 
			avec une dimension de maximum 20 elementes*/
void lire(vecteur a, int* n)
{
	printf("Entrer le nombre des elements de la chaine: ");
	scanf("%d",n);
	printf("Entrer les elements de la chine:\n");
	for(int i=0;i<*n;i++)
	{
		printf("\telem %d: ",i+1);
		scanf("%d",&a[i]);
	}
}
void affichage(vecteur a, int n)
{
	printf("Les elements de l chaine sont: ");
	for(int i=0;i<n;i++)
		printf("%d ",a[i]);
}
void main()
{
	vecteur a;
	int n;
	lire(a,&n);
	affichage(a,n);
 
	getchar();
	int k;
	scanf("%d", &k);
}

5) Allocation de memoire dinamique d’une chaine. On doit lire, puis afficher, une chaine des nombres antiers, pour qui l’espace occupé sera à l’execution, non à la compilation.

#include<stdio.h>
#include<stdlib.h> 

//fonction d’alocation de memoire pour le nombre des elements lus dans la chaine

int* allocation(int* a, int* n)
{
	printf("Entrer le nombre des elements de la chaine: ");
	scanf("%d",n);
	a=(int*)malloc(*n*sizeof(int)); /* l’allocation de la memoire dinamique 
	(dans la zone Heap) pour memorer une chaine en mode dinamique de n elements */
	if(!a)
	{
		printf ("Ereur d’allocation.");
		return 0;
	}
	return a;
} 
//fonction pour introduire des elements dans la chaine
void lire(int* a, int n)
{
	printf("Entrer les elements de la chaine:\n");
	for(int i=0;i<n;i++)
	{
		printf("\telem %d: ",i+1);
		scanf("%d",&a[i]);
	}
} 
//fonction pour l’affichage des elements de la chaine 
void affichage(int* a, int n)
{
	printf("Les elements de la chaine sont: ");
	for(int i=0;i<n;i++)
		printf("%d ",a[i]);
}
void main()
{
	int* a, n;
	a=allocation(a,&n); //appel de la fonction d’allocation de memoire
	lire(a,n); //appel de la fonction de lire
	affichage(a,n); //appel de la fonction d’affichage

	getchar();
	int k;
	scanf("%d", &k);
}

6) Faire une application pour representer les chaines des nombres entiers:
- determiner un type de dates pour de tels representations
- lire une chaine des nombres entiers
- afficher une chaine des nombres entiers
- ajouter les components de la chaine (on va presenter deux methodes: l’une, avec le transfert resulté par le type resulté, et l’autre, avec le transfert par la ligne des parametres)
- realiser l’opperation de multiplication des components de la chaine
- le moyen des elements de la chaine
- le nombre des components negatifs et celui des components positifs de la chaine
- le minimum et le maximum des elements de la chaine
- sortie ascendente de la chaine
- chercher un element dans la chaine avec le retour de la position qu’il trouve; si l’element se trouve plusieurs fois sur des differentes positions, on aura comme resultat la premiere position.
Les fonctions seront décrites avec l'explicite, c'est à dire, le prototype de la fonction.

#include<stdio.h>
#include<stdlib.h>
typedef int* vecteur;
 
//fonction d’allocation de memoire dans la zone Heap pour une chaine declaree
vecteur allocation(vecteur,int*); /*le premier parametre est la chaine, le deuxieme c’est sa dimension 
						(le nombre des elements qui seront lus)*/
	
//la fonction de lire des elements d’une chaine
void lire(vecteur,int);
 
//l'affichage d'une suite de nombres entiers
void affichage(vecteur,int);
 
//somme des elements d’une chaine – avec le transfert par le type resulté
int somme1(vecteur,int);
 
//somme des elements d’une chaine – avec transfert par la ligne des parametres
void somme2(vecteur,int,int*); //le troixieme parametre va retenir le resultat somme
 
//le produit des elements d’une chaine
int produit(vecteur,int);
 
//la moyenne des elements d’une chaine
float media(vecteur,int);
 
//nombres des elements negatives, puis positives, de la chaine
void nr_neg_poz(vecteur,int,int*,int*);
 
//la minimum et le maximum des valeurs de la chaine 
void min_max(vecteur,int,int*,int*);
 
//fonction de triage de la chaine
void triage(vecteur,int);
 
/* chercher un element, avec le retour de la position qu’il occupe dans la chaine 
(s’il se trouve plusieurs fois, on va retourner la premiere position) */
int chercher(vecteur,int,int);
 
void main()
{
	vecteur v;
	int n; 
	v=allocation(v,&n); //appel de la fonction d’allocation

	lire(v,n); //appel de la fonction de lire

	affichage(v,n); 
	int s1=somme1(v,n);
	printf("\n\nSomme des elements: %d",s1); 
	int s2;
	somme2(v,n,&s2);
	printf("\n\nSomme des elements: %d",s2);
	int p=produit(v,n);
	printf("\nProduit des elements: %d",p);
	float m=media(v,n);
	printf("\nMoyenne des elements: %.2f",m); 
	int neg,poz;
	nr_neg_poz(v,n,&neg,&poz);
	printf("\nNombre des elements negatives: %d; Nombre des elements positives: %d",neg,poz);
 	int min,max;
	min_max(v,n,&min,&max);
	printf("\nLe minimum de la chaine: %d; Le maximum de la chaine: %d",min,max);
 	triage(v,n);
	affichage(v,n);
 	int elem;
	printf("\nL’element qu’on veut chercher: ");
	scanf("%d",&elem);
	if(chercher(v,n,elem)) //résultat différent de 0
		printf("\tL’element se trouve sur la position %d", chercher(v,n,elem));
	else
	printf("\tL’element ne se trouve pas dans la chaine");
 
	getchar();
	int k;
	scanf("%d", &k);
}
vecteur allocation(vecteur a, int* n)
{
	printf("Entrer le nombre des elements: ");
	scanf("%d",n);
	a=(int*)malloc(*n*sizeof(int));
	return a;
}
void lire(vecteur a, int n)
{
	printf("Entrer les elements:\n");
	for(int i=0;i<n;i++)
	{
		printf("\telem %d= ",i+1);
		scanf("%d",&a[i]);
	}
}
void affichage(vecteur a, int n)
{
	printf("\nLa chaine est: ");
	for(int i=0;i<n;i++)
	printf("%d ",a[i]);
}
int somme1(vecteur a, int n)
{
	int s=0;
	for(int i=0;i<n;i++)
	s+=a[i]; //s=s+a[i];
	return s;
}
void somme2(vecteur a, int n, int* s)
{
	*s=0;
	for(int i=0;i<n;i++)
	*s+=a[i];
}
int produit(vecteur a, int n)
{
	int p=1;
	for(int i=0;i<n;i++)
	p*=a[i];
	return p;
}
float media(vecteur a, int n)
{
	return (float)somme1(a,n)/n;
}
void nr_neg_poz(vecteur a, int n, int* neg, int* poz)
{
	*neg=*poz=0;
	for(int i=0;i<n;i++)
	if(a[i]>=0)
		(*poz)++;
	else
		(*neg)++;
}
void min_max(vecteur a, int n, int* m, int* M)
{
	*m=*M=a[0]; /* passer de l'hypothèse que le premier élément sera à la fois l'élément
				minimum et maximum de matrice */
	for(int i=1;i<n;i++)
	if(a[i]<*m)
	*m=a[i];
	else
	if(a[i]>*M)
	*M=a[i];
}
void triage(vecteur a, int n)
{
	int aux;
	for(int i=0;i<n-1;i++)
	for(int j=i+1;j<n;j++)
	if(a[i]>a[j]) //triage ascendant
	{
		aux=a[i];
		a[i]=a[j];
		a[j]=aux;
	}
}
int chercher(vecteur a, int n, int e)
{
	for(int i=0;i<n;i++)
	if(a[i]==e)
	return i+1;
	return 0;	
}

7) Lire et affichage d’un chaine des nombres, par construire un type propre pour retenir la chaine des nombre entiers. La fonction sera decrite avec la zone declarative explicite, avec un prototype de fonction.

#include<stdio.h>
#include<malloc.h>
typedef int* vecteur;
vecteur allocation (vecteur a, int* n)
{
  printf("Entrer le nombre des elements: ");
  scanf("%d",n);
  a=(int*)malloc(*n*sizeof(int));
  return a;
}
void lire(vecteur a, int n)
{
 printf("Entrer les elements:\n");
 for(int i=0;i<n;i++)
   {
    printf("\telem %d= ",i+1);
    scanf("%d",&a[i]);
   }
}
void affichage(vecteur a, int n)
{
 printf("\nchaineul este: ");
 for(int i=0;i<n;i++)
   printf("%d ",a[i]);
}
void main()
{
  vecteur x; //la chaine des nombres entiers
  int n;  //nombre des elements qui seront lus dans la chaine
  
  x=allocation(x,&n);
  lire(x,n);
  affichage(x,n);
 
 getchar();
 int k;
 scanf("%d",k);
}

8) Soit les declarations : int a[20]; int n; float e. Determiner la valeur de l’expression e dans chaque cas: e = x1+x2+x3+…+xn;

#include<stdio.h>
void lire(int a[], int* n)
{
	printf("\nEntrer le nombre des elements: ");
	scanf("%d", n);
	printf("\nEntrer les elements: ");
	for(int i=0; i<*n; i++)
	{
		printf("\nElem %d: ", i+1);
		scanf("%d", &a[i]);
	}
}
int expression(int a[20],int n)
{	
	int e=0;
	for(int i=0; i<n; i++)
	{
	e=e+a[i];
	}
	return e;
}
void main()
{
	int a[20], n, e;
 
	lire(a, &n);
	printf("\nLe resultat est: %d", expression(a,n));
 
	getchar();
	int var;
	scanf("%d", &var);
}

9) Alloction dinamique chaine.

#include <stdio.h>
#include <stdlib.h>
void main()
{
    int n , *a, i;
    printf ("Entrer le nombre des elements de la chaine: ");
    scanf ("%d", &n); 
    //allocation de mémoire pour la memorisation d’une chaine dinamique de n elements
    a=(int*) malloc(n*sizeof(int));  
    //introduire les elements dans la chaine
    printf ("Entrer les elements dans la chaine: \n"); 
    for (i=0; i<n; i++)
	{
        printf ("element %d: ", i+1);
		scanf ("%d", &a[i]);
	} 
	//affichagea elementelor
    printf ("Les elements entiers de la chaine sont: \n");
    for (i=0; i<n; i++)
	{
       	printf ("element %d = %d\n", i+1, a[i]);
	}
 
	int j;
	scanf("%d", &j);
}

10) Soit les declarations : int a[20]; int n; float e; Determiner la valeur d’une expression e dans chaque cas:
a) e = x1+x2+x3+…+xn;
b) e = x1*x2*x3*…*xn;
c) e = la moyenne aritmetique des composants du vecteur;
d) e = somme des carrés des composantes de vecteur;
e) e = somme des cubes des composants negatives;
f) e = x1-x2+x3-x4+…±xn

#include<stdio.h>

//introducere date in chaine
void lire(int b[], int* n)
{
	printf("\nEntroduire le nombre des components du vecteur: ");
	scanf("%d", n);
 
	printf("\Entrer les elements:\n ");
	for(int i=0; i<*n; i++)
	{
		printf("\nElem %d:", i+1);
		scanf("%d", &b[i]);
	}
}
int expression1 (int a[20], int n)
{
	int e=0;
	for(int i=0; i<n; i++)
	e=e+a[i];
	return e;
}
int expression2 (int a[20], int n)
{
	int e=1;
	for(int i=0; i<n; i++)
	e=e*a[i];
	return e;
}
float expression3 (int a[20], int n)
{
	float e=0;
	for(int i=0; i<n; i++)
		e=e+a[i]/(float)n;
	return e;
}
int expression4 (int a[20], int n)
{
	int e=0;
	for(int i=0; i<n; i++)
	e=e+a[i]*a[i];
	return e;
}
int expression5 (int a[20], int n)
{
	int e=0;
	for(int i=0;i<n;i++)
	{
		if(a[i]<0)
		e=e+a[i]*a[i]*a[i];
	}
	return e;
}
int expression6 (int a[20], int n)
{
	int e=0,semn=1;
	for(int i=0;i<n;i++)
	{
		if (i%2==0)
			semn=1;
		else 
			semn=-1;
 		e=e+a[i]*semn;
	}
	return e;
}
void main()
{
	int b[20], n, i;
	float e; 
	lire(b, &n); 
	printf("\n\tLa somme des elements est: %d",expression1(b,n));
	printf("\n\tLe produit est: %d",expression2(b,n));
	printf("\n\tLa moyenne aritmetique est: %.2f",expression3(b,n));
	printf("\n\tLa somme des carees est: %d",expression4(b,n));
	printf("\n\tLa somme des cubes negatifs est: %d",expression5(b,n));
	printf("\n\tL’expression est: %d",expression6(b,n));
 
	getchar();
	int var;
	scanf("%d", &var);
}

11) A élaborer un programme qui entrelace deux vecteurs dans un troisième vecteur. Les deux premiers seront d'abord triés.

#include<stdio.h>
#include<stdlib.h>
void main()
{ 
 int n , m, *a, *b, i, j, gasit, aux, k, *c; 
//---------------------------------------------------------------------------------
    printf ("Entrer le nombre des elements de la chaine1: ");
    scanf ("%d", &n);
	//allocation de memoire pour la memorisation dynamique d’une chaine de n elements
	a=(int*) malloc(n*sizeof(int));
   //l’introduction des elements dans la chaine
	printf ("Entrer les elements dans la chaine1: \n"); 
	for (i=0; i<n; i++)
	{
        printf ("element %d: ", i+1);
		scanf ("%d", &a[i]);
	}
//---------------------------------------------------------------------------------

    printf ("Entrer le nombre des elements de la chaine2: ");
    scanf ("%d", &m); 
	//allocation de memoire pour la memorisation dynamique d’une chaine de n elements
	b=(int*) malloc(m*sizeof(int));
   //introducere elementelor in chaine
	printf ("Entrer elements dans la chaine2: \n"); 
	for (j=0; j<m; j++)
	{
        printf ("element %d: ", j+1);
		scanf ("%d", &b[j]);
	}
//--------------------------------------------------------------------------------- 
	//l’afichage des elements des deux chaines
	printf ("Les elements entiers de la chaine1 sont: \n");
	for (i=0; i<n; i++)
	{
       printf ("element %d = %d\n", i+1, a[i]);
	} 
	printf ("Les elements entiers de la chaine 2 sont: \n");
	for (j=0; j<m; j++)
	{
       printf ("element %d = %d\n", j+1, b[j]);
	} 
//---------------------------------------------------------------------------------	 
	//triage chaine I

	do
	{
		gasit=0;
		for(i=0;i<n-1;i++)
		if (a[i]>a[i+1])
		{
			aux=a[i];
			a[i]=a[i+1];
			a[i+1]=aux;
			gasit=1;
		}
	} 
	while(gasit); 
	//affichage apres triage de la chaine 1

	printf ("Les elements de la chaine1 apres le triage sont: \n");
	for (i=0; i<n; i++)
	{
       printf ("element %d = %d\n", i+1, a[i]);
	}
//--------------------------------------------------------------------------------- 
	//triage chaine II

	for(i=0;i<m-1;i++)
	for(j=i+1;j<m;j++)
	if(b[i]>b[j])
	{
		aux=b[i];
		b[i]=b[j];
		b[j]=aux;
	}
 
	//affichage apres triage chaine 2

		printf ("Les elements de la chaine2 apres le triage sont: \n");
	for (j=0; j<m; j++)
	{
       printf ("element %d = %d\n", j+1, b[j]);
	}
//---------------------------------------------------------------------------------
	// échange réel
 
	//allocation de memoire pour la memorisation dynamique d’une chaine de n elements
	c=(int*) malloc((n+m)*sizeof(int)); 
	i=j=k=0;
	while(i<m && j<n)
	if (a[i]==b[j])	//si on a des elements communs dans les deux vecteurs,
		elles seront mises une seule fois dansle vecteur  rassemblées
	{
		c[k++]=a[i++];
		j++;
	}
	else 
	if (a[i]<b[j]) c[k++]=a[i++];
	else c[k++]=b[j++]; //sau {c[k]=b[j]; k++; j++;}

	if(i<m) //s’il reste encore des elements non analyses dans a, on ls copie dans c 
		for(j=i;j<n;j++)
			c[k++]=a[j];
	else // s’il reste encore des elements non analyses dans b, on ls copie dans c 

		for(i=j;i<m;i++)
			c[k++]=b[i]; 
	//affichage apres sortage des chaines

		printf ("Les elements de la chaine apres le sortage sont: \n");
	for (k=0; k<(m+n); k++)
	{
       printf ("element %d = %d\n", k+1, c[k]);
	} 
//---------------------------------------------------------------------------------

getchar();
int var;
scanf("%d", &var);
}