Exercices Corrigés En C – Les tableaux

#include <stdio.h>

int main()
{
	int tab[10],i; 

	for(i=0; i<10; i++){
		printf("Entrer un nombre:");
		scanf("%d",&tab[i]);
	} 
   
	for(i=0 ; i<10; i++)
		printf("%d ",tab[i]);

	return 0; 
}

#include <stdio.h>

int main()
{
	float notes[10],sum=0; 
	int i;
	
	for(i=0; i<10; i++){ 
		printf("Entrer un nombre:");
		scanf("%f",&notes[i]);
		sum = sum + notes[i];
	} 
   
	printf("La moyenne est:%f", sum/10);

	return 0; 
}

#include <stdio.h>

int main()
{
	int max,i,tab[10];

	printf("Entrer un nombre:");
	scanf("%d",&tab[0]);
	
	max = tab[0];
   
	for(i=1; i<10; i++){ 
		printf("Entrer un nombre:");
		scanf("%d",&tab[i]);
		if(tab[i] > max)
			max = tab[i];
	} 
   
	printf("Le maximum est: %d",max);

	return 0; 
}

#include <stdio.h>

int main()
{
	int tab[10],nbrOcc=0,i,nbrRech;

	for(i=0; i<10; i++){ 
		printf("Entrer un nombre:");
		scanf("%d",&tab[i]);
	} 
   
	printf("Entrer Le nombre recherché:");
	scanf("%d",&nbrRech);
    
	for(i=0; i<10; i++){ 
		if (tab[i] == nbrRech)
			nbrOcc++;
	} 
	printf("Nombre d'occurences de %d est %d",nbrRech,nbrOcc);

	return 0; 
}

#include <stdio.h>

int main()
{
	int tab[10],tmp,i,j;

	for(i=0; i<10; i++){ 
		printf("Entrer un nombre:");
		scanf("%d",&tab[i]);
	} 
   
	for(i=0; i<9; i++){ 
		for(j=i+1; j<10; j++){
			if(tab[j] < tab[i])
			{  
				tmp = tab[i];
				tab[i] = tab[j];
				tab[j] = tmp;
			}
		} 
	} 
	for(i=0; i<10; i++) 
		printf("%d\t",tab[i]);

	return 0; 
}

#include <stdio.h>

int main()
{
	int i,pair=0,impair=0,tab[5]; 

	for(i=0; i<5; i++){
		printf("Entrer un nombre:");
		scanf("%d",&tab[i]);     
	}   

	for(i=0; i<5; i++){
		if(tab[i]%2==0) pair++;
		else impair++;       
	}
  
	printf("Total des éléments pairs: %d\n",pair);
	printf("Total des éléments impaires: %d",impair);
		
	return 0; 
}

#include <stdio.h>

int main()
{
	int tab[10],tab1[10],tab2[10],i,j=0,k=0;
	
	//Stocker les éléments dans le tableau original
	for(i=0; i < 10; i++) {  
		printf("Entrer un nombre:");
		scanf("%d",&tab[i]);
	}  

	for(i=0; i < 10; i++) {  
		if(tab[i]%2 == 0){
			//Stocker les éléments paires
			tab1[j] = tab[i];  
			j++;
		}
		else{
			//Stocker les éléments impaires
			tab2[k] = tab[i]; 
			k++; 
		}
	}
	//Afficher le tableau 1
	for(i=0; i < j ; i++){
		printf("%d ",tab1[i]);
	}  
		
	printf("\t");
	
	//Afficher le tableau 2
	for(i=0; i < k; i++){
		printf("%d ",tab2[i]); 
	}  

	return 0; 
}

#include <stdio.h>

int main()
{
	int i,not_equal=0,tab1[10],tab2[10];
	
	//remplir tab1
	for(i=0; i<10; i++){
		scanf("%d", &tab1[i]);
	}
	printf("\n");
	
	//remplir tab2
	for(i=0; i<10; i++){
		scanf("%d", &tab2[i]);
	}

	for(i=0; i<10; i++) {
		//vérifier l'égalité
		if(tab1[i] != tab2[i]) 
			not_equal = 1;
	}
	
	if (not_equal == 0) 
		printf("TRUE");
	else  
		printf ("FALSE");

	return 0; 
}

#include <stdio.h>

int main()
{
   int i, n, a[100];

   printf("Entrer le nombre d'éléments à stocker dans le tableau:");
   scanf("%d", &n);

   printf("Entrer les %d éléments dans le tableau:\n", n);
   for (i = 0; i < n; i++)
   {
      printf("tab[%d]: ", i);
      scanf("%d", &a[i]);
   }

   printf("\nLes valeurs stockées dans le tableau sont: ");
   for (i = 0; i < n; i++)
   {
       printf("% 5d", a[i]); //Afficher chaque élément du tableau
   }

   printf("\nLes valeurs stockées dans le tableau en sens inverse sont:\n");
   for (i = n - 1; i >= 0; i--)
   {
       printf("% 5d", a[i]); //Afficher chaque élément en ordre inverse
   }

   return 0;
}

#include <stdio.h>

int main()
{
    int tab1[100], tab2[100];
    int i, n;

	
    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);
	
    printf("Entrer les %d éléments dans le tableau: ", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        // Lire l'entrée et la stocker dans le premier tableau
        scanf("%d", &tab1[i]);  
    }
	
    // Copie les éléments du 1er tableau dans le 2éme tableau.
    for (i = 0; i < n; i++)
    {
        tab2[i] = tab1[i];
    }

    printf("\nLes valeurs stockées dans le tableau sont: ");
    for (i = 0; i < n; i++)
    {
        printf("% 5d", tab1[i]); 
    }
	
    printf("\nLes éléments copiés dans le 2ème tableau sont:");
    for (i = 0; i < n; i++)
    {
        printf("% 5d", tab2[i]);
    }
	
    return 0;
}

#include <stdio.h>

int main()
{
    int tab[100]; 
    int n, compteur=0; 
    int i, j; 
	
    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        // Lire l'entrée et la stocker dans le premier tableau
        scanf("%d", &tab[i]); 
    }
	
    // Vérifier les doublons dans le tableau
    for (i = 0; i < n; i++)
    {
        for (j = i + 1; j < n; j++)
        {
            if (tab[i] == tab[j])
            {
                //Incrémenter le compteur de doublons si un doublon est trouvé
                compteur++; 
                //Sortir de la boucle dès qu'un doublon est trouvé				
                break;  
            }
        }
    }

    printf("Le nombre total d'éléments dupliqués trouvés dans le tableau est: %d", compteur);
	
    return 0; 
}

#include <stdio.h>

int main()
{
    int tab[100], n, compteur = 0;
    int i, j, k; 

	
    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        // Lire l'entrée et la stocker dans le premier tableau
        scanf("%d", &tab[i]);
    }

    printf("\nLes éléments uniques trouvés dans le tableau sont: ");
    for (i = 0; i < n; i++)
    {
        //Réinitialiser le compteur pour chaque élément
        compteur = 0;
        for (j = 0, k = n; j < k + 1; j++)
        {
            //Incrémenter le compteur lorsque la valeur recherchée est dupliquée
            if (i != j)
            {
                if (tab[i] == tab[j])
                {
                    compteur++;
                }
            }
        }
        if (compteur == 0)
        {
            printf("%d ", tab[i]); //Afficher l'élément unique
        }
    }

    return 0;
}

#include <stdio.h>

int main() {
  int tab1[100], tab2[100], tab3[200];
  int i, j, k;
  int n1, n2, n3;

  printf("Entrer le nombre d'éléments à stocker dans le tableau:");
  scanf("%d", & n1);

  printf("Entrer les %d éléments dans le tableau:\n", n1);
  for (i = 0; i < n1; i++) {
    printf("tab[%d]: ", i);
    scanf("%d", & tab1[i]);
  }

  printf("Entrer le nombre d'éléments à stocker dans le tableau:");
  scanf("%d", & n2);

  printf("Entrer les %d éléments dans le tableau:\n", n2);
  for (i = 0; i < n2; i++) {
    printf("tab[%d]: ", i);
    scanf("%d", & tab2[i]);
  }

  /* Taille du tableau fusionné est égale à la taille du 
	1er tableau + taille du 2éme tableau */
  n3 = n1 + n2;
  //insertion dans le troisième tableau
  for (i = 0; i < n1; i++) {
    tab3[i] = tab1[i];
  }
  for (j = 0; j < n2; j++) {
    tab3[i] = tab2[j];
    i++;
  }
  // trier le tableau par ordre décroissant
  for (i = 0; i < n3; i++) {
    for (k = 0; k < n3 - 1; k++) {

      if (tab3[k] <= tab3[k + 1]) {
        j = tab3[k + 1];
        tab3[k + 1] = tab3[k];
        tab3[k] = j;
      }
    }
  }

  // Affiche le tableau fusionné
  printf("\nLe tableau fusionné par ordre décroissant est: ");
  for (i = 0; i < n3; i++) {
    printf("%d   ", tab3[i]);
  }
  printf("\n\n");
  return 0;
}

#include <stdio.h>

int main()
{
    int tab[100], freq[100];
    int n, i, j, compteur;

    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        scanf("%d", &tab[i]);
        //Initialiser le tableau des fréquences avec -1
        freq[i] = -1; 
    }

    // Compter la fréquence de chaque élément du tableau
    for (i = 0; i < n; i++)
    {
        //Initialiser le compteur pour chaque élément
        compteur = 1; 
        for (j = i + 1; j < n; j++)
        {
            if (tab[i] == tab[j])
            {
                //Incrémenter le compteur pour les éléments correspondants
                compteur++;  
                //Marquer la fréquence de l'élément dupliqué comme 0				
                freq[j] = 0; 
            }
        }

        /* Si la valeur du tableau de fréquences n'est pas marquée 
		comme 0, mettez-la sur le compteur */
        if (freq[i] != 0)
        {
            freq[i] = compteur;
        }
    }

    printf("\nLa fréquence de tous les éléments du tableau: \n");
    for (i = 0; i < n; i++)
    {
        if (freq[i] != 0)
        {
            printf("%d se produit %d fois\n", tab[i], freq[i]);
        }
		return 0;
    }
}

#include <stdio.h>

int main()
{
    int tab[100];
    int i, max, min, n;

    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        scanf("%d", &tab[i]);
    }

    //Initialiser max et min avec le premier élément du tableau
    max = tab[0];
    min = tab[0];

    // Parcourir le tableau pour trouver le maximum et minimum
    for (i = 1; i < n; i++)
    {
        // Actualiser max si l'élément actuel est plus grand
        if (tab[i] > max)
        {
            max = tab[i];
        }

        // Actualiser min si l'élément actuel est plus petit
        if (tab[i] < min)
        {
            min = tab[i];
        }
    }

    printf("Le maximum est: %d\n", max);
    printf("Le minimum est: %d", min);
	
    return 0;
}

#include <stdio.h>

int main()
{
    int tab1[10], tab2[10], tab3[10];
    int i, j = 0, k = 0, n;

    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        scanf("%d", &tab1[i]);
    }

    // Séparer les entiers pairs et impairs dans des tableaux séparés
    for (i = 0; i < n; i++)
    {
        if (tab1[i] % 2 == 0)
        {
            tab2[j] = tab1[i];
            j++;
        }
        else
        {
            tab3[k] = tab1[i];
            k++;
        }
    }

    printf("\nLes éléments pairs sont: ");
    for (i = 0; i < j; i++)
    {
        printf("%d ", tab2[i]);
    }

    printf("\nLes éléments impairs sont: ");
    for (i = 0; i < k; i++)
    {
        printf("%d ", tab3[i]);
    }

    return 0;
}

#include <stdio.h>

int main()
{
	int tab[10],sum,i;

	sum = 0;
	for(i=0; i < 10; i++){
		printf("Entrer un nombre:"); 
		scanf("%d", &tab[i]);
		
		if(tab[i] % 2 == 0)
			sum = sum + tab[i];
		else
			sum = sum - tab[i];
	}
 
	printf("La différence égale à %d", sum);

	return 0; 
}

#include <stdio.h>

int main()
{
	int tab[10],i,j,compteur=0; 
	
	for(i=0; i<10; i++){
		printf("Enter un nombre:");
		scanf("%d",&tab[i]);                
	}

	for(i=0; i<10; i++){
		for(j=i+1; j<10; j++){
			if (tab[i] == tab[j]){
				compteur++;
			}
		} 
	}	
	printf("Nombre total d'éléments dupliqués est: %d",compteur) ;

	return 0; 
}

#include <stdio.h>

int main()
{
	int check=0,i,tab[10];
	
	printf("Entrer un nombre:"); 
	scanf("%d",&tab[0]);

	for(i=1; i<=9; i++){
		printf("Entrer un nombre:"); 
		scanf("%d",&tab[i]);
		
		if (tab[i] < tab[i-1]){
			check=1;
		}
	}
	
	if (check==0)
		printf("Les nombres sont successives");
	else
		printf("Les nombres ne sont pas successives");

	return 0; 
}

#include <stdio.h>

int main()
{
	int tab[10],tmp,i,j;
 
	for(i=0; i<10; i++)
	{ 
		scanf("%d", &tab[i]);
	}
 
	for(i=0; i<10; i++)
		printf("%d  ",tab[i]);
   
	for(i=0; i<9; i++)
	{ 
		if(tab[i]==0) {
			j = i + 1;
			while(tab[j]==0 && j<9) {
				j++;
			}
			tmp = tab[i]; 
			tab[i]= tab[j]; 
			tab[j]= tmp;
		}
	}
 
	printf("\n");
  
	for(i=0; i<10; i++)
		printf("%d  ",tab[i]);

	return 0; 
}

#include <stdio.h>
#include <stdbool.h> 

//Fonction qui renvoie l'index de la ligne avec le plus grand nombre de 1
int indexLigneAvecUn(bool matrice[4][4]) {
	int index = -1 ;
	int maxCount = 0 ;
	 
	/* Visitez chaque ligne. Compter le nombre de 1. Si le nombre est 
	supérieur au maxCount, actualiser le maxCount et stocker l'index 
	de la ligne actuelle dans la variable index. */
	for(int i = 0; i < 4; i++){
		int count = 0;
		for(int j = 0; j < 4; j++){
			if(matrice[i][j] == 1){
				count++ ;
			}
		}
		if(count > maxCount){
			maxCount = count;
			index = i ;
		}
	}                                                                                          
	return index;
}

int main()
{
	bool matrice[4][4] = {{0, 0, 1, 1},
					      {0, 1, 1, 1},
					      {1, 1, 1, 1},
					      {0, 0, 0, 0}};

	int index = indexLigneAvecUn(matrice);
	printf("L'index de la ligne avec le maximum de 1 est: %d",index);

	return 0;
}

#include <stdio.h>

int main() {
    int tab[] = {2, 1, 7, 3, 7, 3, 2, 4, 2, 6, 2};
    int n = sizeof(tab) / sizeof(int);
    int i, j;

    // Afficher le tableau d'origine
    printf("Le tableau donné est: ");
    for (i = 0; i < n; i++) {
        printf("%d  ", tab[i]);
    }
    printf("\n");

    printf("Les éléments uniques du tableau donné sont: ");
    for (i = 0; i < n; i++) {
        // Itérer dans le tableau pour trouver les éléments uniques
        for (j = 0; j < i; j++) {
            // Si un doublon est trouvé, quitter la boucle
            if (tab[i] == tab[j])
                break;
        }

        // Si 'i' atteint 'j', l'élément courant est unique, il faut donc l'afficher.
        if (i == j) {
            printf("%d ", tab[i]);
        }
    }

    return 0;
}

#include <stdio.h>

int main() {
    int L, C, n, i, j, s = 0;
    int matrice[3][3] = {{1, 2, 3},
                         {4, 5, 6},
                         {7, 8, 9}};
    L = C = n = 3;
    int i, j;

    // Afficher le tableau original
    printf("Le tableau donné est : \n");
    for (i = 0; i < L; i++) {
        for (j = 0; j < C; j++) {
            printf("%d  ", matrice[i][j]);
        }
        printf("\n");
    }

    printf("Les éléments à additionner de la matrice triangulaire supérieure sont:");
    for (i = 0; i < L; i++) {
        for (j = 0; j < C; j++) {
            if (i < j) {
                printf("%d  ", matrice[i][j]);
                // Additionner les éléments de la matrice triangulaire supérieure
                s += matrice[i][j]; 
            }
        }
    }
    printf("\nLa somme des éléments de la matrice triangulaire supérieure est: %d", s);
    return 0;
}

#include <stdio.h>

int main() {
    int L, C, n, i, j, s = 0;
    int matrice[3][3] = {{1, 2, 3},
                         {4, 5, 6},
                         {7, 8, 9}};
    L = C = n = 3;
    int i, j;

    // Afficher le tableau original
    printf("Le tableau donné est : \n");
    for (i = 0; i < L; i++) {
        for (j = 0; j < C; j++) {
            printf("%d  ", matrice[i][j]);
        }
        printf("\n");
    }

    printf("Les éléments à additionner de la matrice triangulaire inférieur sont:");
    for (i = 0; i < L; i++) {
        for (j = 0; j < C; j++) {
            if (i > j) {
                printf("%d  ", matrice[i][j]);
                // Additionner les éléments de la matrice triangulaire inférieur
                s += matrice[i][j]; 
            }
        }
    }
    printf("\nLa somme des éléments de la matrice triangulaire inférieur est: %d", s);
    return 0;
}

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

// mélanger le tableau
void rand_tab(int *tab, size_t n)
{
    if (n > 1) 
    {
        size_t i;
        for (i = 0; i < n - 1; i++) 
        {
          size_t j = i + rand() / (RAND_MAX / (n - i) + 1);
          int t = tab[j];
          tab[j] = tab[i];
          tab[i] = t;
        }
    }
}
// afficher les éléments du tableau
void afficher_tab(int *tab, size_t n){
    for (int i = 0; i < n; i++)
        printf("%d ", tab[i]);
}

int main() {
    int tab[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    
    printf("Le tableau donné est:");
    afficher_tab(tab, 10);
    rand_tab(tab, 10); 
    printf("\nLes éléments du tableau sont mélangés:");
    afficher_tab(tab, 10);

    return 0;
}

#include <stdio.h>

int repNbr(int tab[], int n) 
{
    int i, j, max, count, maxCount = 0;
    /* La fréquence de chaque élément est calculée et vérifiée. Si elle 
	est supérieure au nombre maximal d'éléments trouvés jusque-là, 
	elle est mise à jour. */  
    for(i = 0; i< n; i++)
    {
        count = 1;
		//Boucle For pour vérifier les éléments dupliqués
        for(j = i+1; j < n; j++)  
        {
            if(tab[j] == tab[i])
            {
                count++; //Incrémenter le compteur
                /* Si le nombre d'éléments actuels est supérieur à maxCount, 
				alors actualiser max */
                if(count > maxCount)
                {
                    max = tab[j];
                }
            }
        }
    }
    return max;
}


int main() {
    int tab[] = {2, 3, 3, 5, 3, 4, 1, 7, 7, 7, 7};
    int n = sizeof(tab) / sizeof(tab[0]);
    int i;

    // Afficher le tableau d'origine
    printf("Le tableau donné est: \n");
    for (i = 0; i < n; i++) {
        printf("%d  ", tab[i]);
    }
    printf("\n");

    printf("Le nombre qui se répète le plus est: %d", repNbr(tab, n));
    return 0;
}

#include <stdio.h>
#include <stdbool.h>

// Fonction pour trouver la paire avec la différence donnée
bool findPair(int tab[], int size, int diff) {
    int i = 0;  
    int j = 1;

    while (i < size && j < size) {
        if (i != j && tab[j] - tab[i] == diff) {
            printf("La paire est: (%d, %d)", tab[i], tab[j]);
            return true;
        } else if (tab[j] - tab[i] < diff) {
            j++; // Incrémenter j pour vérifier l'élément suivant
        } else {
            i++; // Incrémenter i pour vérifier l'élément suivant
        }
    }

    printf("Aucune paire n'a été trouvée dans le tableau donné.");
    return false;
}

int main() {
    int tab[] = {1, 8, 2, 3, 4};
    // Calculer la taille du tableau
    int size = sizeof(tab) / sizeof(tab[0]);
    int diff = 4;
    int i;

    // Afficher le tableau original
    printf("Le tableau donné est: \n");
    for(i = 0; i < size; i++) {
        printf("%d  ", tab[i]);
    }
    printf("\n");

    printf("La différence donnée est: %d\n", diff);
    findPair(tab, size, diff);
    return 0;
}

#include <stdio.h>

void sep0et1(int tab[], int size)
{
    int gauche = 0, droite = size-1;

    while (gauche < droite)
    {
        /* Incrémenter l'index de gauche tant que l'on voit 0 à gauche */
        while (tab[gauche] == 0 && gauche < droite)
            gauche++;

        /* Décrémenter l'index de droite tant que l'on voit 1 à droite */
        while (tab[droite] == 1 && gauche < droite)
            droite--;

        /* Si la gauche est plus petite que la droite, il y a un 
        1 à gauche et un 0 à droite. Échangez-les. */
        if (gauche < droite)
        {
            tab[gauche] = 0;
            tab[droite] = 1;
            gauche++;
            droite--;
        }
    }
}
 
int main(){
    int tab[] = {0, 1, 0, 1, 1, 0};
    int tab_size = 6, i = 0;

    sep0et1(tab, tab_size);
    printf("Le tableau séparé est: ");

    for (i = 0; i < 6; i++)
        printf("%d ", tab[i]);

    getchar();
    return 0;
}

#include <stdio.h>

// Fonction permettant d'échanger deux éléments
void swap(int *a, int *b) 
{ 
    int tmp = *a; 
    *a = *b; 
    *b = tmp; 
} 

// Fonction pour séparer les nombres pairs et impairs dans un tableau
void paireImpaire(int tab[], int size) 
{ 
    int gauche = 0, droite = size - 1; 

    // Séparation des nombres pairs et impairs
    while (gauche < droite) 
    { 
        // Déplacer l'index gauche jusqu'à ce qu'un nombre impair soit trouvé
        while (tab[gauche] % 2 == 0 && gauche < droite) 
            gauche++; 

        // Déplacer l'indice_droit jusqu'à ce qu'un nombre pair soit trouvé
        while (tab[droite] % 2 == 1 && gauche < droite) 
            droite--; 

        // Échanger les éléments pairs et impairs trouvés
        if (gauche < droite) 
        { 
            swap(&tab[gauche], &tab[droite]); 
            gauche++; 
            droite--; 
        } 
    } 
} 

int main() 
{ 
    int tab[] = {3, 4, 5, 2, 1, 6, 8}; 
    int tab_size = sizeof(tab) / sizeof(tab[0]); 
    int i = 0; 

    // Afficher le tableau original
    printf("Le tableau donné est: \n");
    for(i = 0; i < tab_size; i++)
    {
        printf("%d  ", tab[i]);
    }
    printf("\n");

    paireImpaire(tab, tab_size); 

    printf("Le tableau après séparation est: "); 
    for (i = 0; i < tab_size; i++) 
        printf("%d ", tab[i]); 

    return 0; 
}

#include <stdio.h>

int main()
{
    int tab3_size, i, j, tab1_size = 5, tab2_size = 5;
    int tab1[5] = { 1, 2, 3, 4, 5 };
    int tab2[5] = { 6, 7, 8, 9, 10 };
 
    // Déclaration de la taille du tableau 3
    tab3_size = tab1_size + tab2_size;
    int tab3[tab3_size];
 
    // copier les éléments du tableau 1 dans le tableau 3
    for (i = 0; i < tab1_size; i++) {
        tab3[i] = tab1[i];
    }
 
    // copier les éléments du tableau 2 dans le tableau 3
    for (i = 0, j = tab1_size;
         j < tab3_size && i < tab2_size; i++, j++) {
        tab3[j] = tab2[i];
    }
 
    // Éléments du tableau après merge
    for (i = 0; i < tab3_size; i++) {
        printf("%d ", tab3[i]);
    }
    return 0;
}

#include <stdio.h>

void main()
{
    int tab[100];
    int n, i, j, tmp;

    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        scanf("%d", &tab[i]);
    }

    //Trier les éléments par ordre croissant en utilisant le tri à bulles
    for (i = 0; i < n; i++)
    {
        for (j = i + 1; j < n; j++)
        {
            if (tab[j] < tab[i])
            {
                //Échanger des éléments s'ils sont mal ordonnés
                tmp = tab[i];
                tab[i] = tab[j];
                tab[j] = tmp;
            }
        }
    }

    printf("\nÉléments du tableau triés par ordre croissant: ");
    for (i = 0; i < n; i++)
    {
        printf("%d  ", tab[i]);
    }
    printf("\n\n");
}

#include <stdio.h>

void main()
{
    int tab[100];
    int n, i, j, tmp;

    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        scanf("%d", &tab[i]);
    }

    //Trier les éléments par ordre croissant en utilisant le tri à bulles
    for (i = 0; i < n; i++)
    {
        for (j = i + 1; j < n; j++)
        {
            if (tab[i] < tab[j])
            {
                //Échanger des éléments s'ils sont mal ordonnés
                tmp = tab[i];
                tab[i] = tab[j];
                tab[j] = tmp;
            }
        }
    }

    printf("\nÉléments du tableau triés par ordre décroissant: ");
    for (i = 0; i < n; i++)
    {
        printf("%d  ", tab[i]);
    }
    printf("\n\n");
}

#include <stdio.h>

int main()
{
    int tab[100], i, n, p, nbr;

    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        scanf("%d", &tab[i]);
    }

    printf("Saisir la valeur à insérer: ");
    scanf("%d", &nbr);

    // Déterminer la position où la nouvelle valeur sera insérée
    for (i = 0; i < n; i++)
    {
        if (nbr < tab[i])
        {
            p = i;
            break;
        }
        else
        {
            p = i + 1;
        }
    }

    //Déplacer toutes les données à droite du tableau pour faire de la place
    for (i = n + 1; i >= p; i--)
        tab[i] = tab[i - 1];

    // Insérer la nouvelle valeur à l'endroit approprié
    tab[p] = nbr;

    // Afficher le tableau après l'insertion
    printf("\nAprès l'insertion, le tableau est: ");
    for (i = 0; i <= n; i++)
        printf("% 4d", tab[i]);

    return 0;
}

#include <stdio.h>

void main()
{
    int tab[100], i, n, pos, nbr;

    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++)
    {
        printf("tab[%d]: ", i);
        scanf("%d", &tab[i]);
    }

    // Saisir la valeur à insérer et sa position
    printf("Saisir la valeur à insérer: ");
    scanf("%d", &nbr);
    printf("Saisir la position où la valeur doit être insérée: ");
    scanf("%d", &pos);

    //Déplacer toutes les données à droite du tableau pour faire de la place
    for (i = n; i >= pos; i--)
        tab[i] = tab[i - 1];

    // Insérer la nouvelle valeur à la position donnée
    tab[pos - 1] = nbr;

    // Afficher le tableau après l'insertion
    printf("\nAprès l'insertion, le tableau est: ");
    for (i = 0; i <= n; i++)
        printf("% 4d", tab[i]);
}

#include <stdio.h>

int main() {
    int tab[50], i, pos, n;

    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++) {
        printf("tab[%d]: ", i);
        scanf("%d", &tab[i]);
    }

    printf("\nSaisir la position à supprimer: ");
    scanf("%d", &pos);

    // Localiser la position dans le tableau
    i = 0;
    while (i != pos - 1)
        i++;

    // Décaler les éléments vers la gauche pour remplacer l'élément supprimé
    while (i < n) {
        tab[i] = tab[i + 1];
        i++;
    }
    n--;

    // Afficher le tableau après suppression
    printf("\nAprès la suppression, le tableau est: ");
    for (i = 0; i < n; i++) {
        printf("  %d", tab[i]);
    }

    return 0; 
}

#include <stdio.h>

void main() {
    int tab[50], i, j=0, n, max1, max2;

    printf("Entrer le nombre d'éléments à stocker dans le tableau: ");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++) {
        printf("tab[%d]: ", i);
        scanf("%d", &tab[i]);
    }

    //Trouver la position de l'élément le plus grand dans le tableau
    max1 = 0;
    for (i = 0; i < n; i++) {
        if (max1 < tab[i]) {
            max1 = tab[i];
            j = i;
        }
    }

    /* Ignorer l'élément le plus grand et trouver le deuxième 
	élément le plus grand du tableau */
    max2 = 0;
    for (i = 0; i < n; i++) {
        if (i == j) {
            i++;  //Ignorer l'élément le plus grand
            i--;
        } else {
            if (max2 < tab[i]) {
                max2 = tab[i];
            }
        }
    }

    printf("Le deuxième élément le plus grand du tableau est: %d", max2);
}

#include <stdio.h>

void main() {
    int tab[50], i, j=0, n, min1, min2;

    printf("Entrer le nombre d'éléments à stocker dans le tableau:");
    scanf("%d", &n);

    printf("Entrer les %d éléments dans le tableau:\n", n);
    for (i = 0; i < n; i++) {
        printf("tab[%d]: ", i);
        scanf("%d", &tab[i]);
    }

    // Trouver la position du plus petit élément du tableau
    min1 = tab[0];
    for (i = 0; i < n; i++) {
        if (min1 > tab[i]) {
            min1 = tab[i];
            j = i;
        }
    }

    /* Ignorer l'élément le plus petit et trouver le deuxième élément
	le plus petit du tableau */
    min2 = 999999;
    for (i = 0; i < n; i++) {
        if (i == j) {
            i++;  //Ignorer le plus petit élément
            i--;
        } else {
            if (min2 > tab[i]) {
                min2 = tab[i];
            }
        }
    }

    printf("Le deuxième élément le plus petit du tableau est: %d", min2);
}

#include <stdio.h>

void main() {
    int matrice[3][3], i, j;

    printf("Entrer les éléments de la matrice: \n");
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            printf("matrice[%d][%d]: ", i, j);
            scanf("%d", &matrice[i][j]);
        }
    }

    // Afficher la matrice
    printf("\nLa matrice est : \n");
    for (i = 0; i < 3; i++) {
        printf("\n");
        for (j = 0; j < 3; j++)
            printf("%d\t", matrice[i][j]);
    }
}

#include <stdio.h>

void main() {
    int matriceA[50][50], matriceB[50][50], somme[50][50], i, j, n;

    printf("Entrer la taille de la matrice: ");
    scanf("%d", &n);

    printf("Entrer les éléments de la première matrice: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("matriceA[%d][%d] : ", i, j);
            scanf("%d", &matriceA[i][j]);
        }
    }

    printf("Entrer les éléments de la deuxième matrice: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("matriceB[%d][%d] : ", i, j);
            scanf("%d", &matriceB[i][j]);
        }
    }

    // Afficher la première matrice
    printf("\nLa première matrice est: \n");
    for (i = 0; i < n; i++) {
        printf("\n");
        for (j = 0; j < n; j++)
            printf("%d\t", matriceA[i][j]);
    }

    // Afficher la première matrice
    printf("\nLa deuxième matrice est: \n");
    for (i = 0; i < n; i++) {
        printf("\n");
        for (j = 0; j < n; j++)
            printf("%d\t", matriceB[i][j]);
    }

    // Calculer la somme des matrices
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            somme[i][j] = matriceA[i][j] + matriceB[i][j];

    // Afficher la somme de deux matrices
    printf("\nLa somme des deux matrices est: \n");
    for (i = 0; i < n; i++) {
        printf("\n");
        for (j = 0; j < n; j++)
            printf("%d\t", somme[i][j]);
    }
}

#include <stdio.h>

void main() {
    int matriceA[50][50], matriceB[50][50], soustraction[50][50],i,j,n;

    printf("Entrer la taille de la matrice: ");
    scanf("%d", &n);

    printf("Entrer les éléments de la première matrice: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("matriceA[%d][%d] : ", i, j);
            scanf("%d", &matriceA[i][j]);
        }
    }

    printf("Entrer les éléments de la deuxième matrice: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("matriceB[%d][%d] : ", i, j);
            scanf("%d", &matriceB[i][j]);
        }
    }

    // Afficher la première matrice
    printf("\nLa première matrice est: \n");
    for (i = 0; i < n; i++) {
        printf("\n");
        for (j = 0; j < n; j++)
            printf("%d\t", matriceA[i][j]);
    }

    // Afficher la première matrice
    printf("\nLa deuxième matrice est: \n");
    for (i = 0; i < n; i++) {
        printf("\n");
        for (j = 0; j < n; j++)
            printf("%d\t", matriceB[i][j]);
    }

    // Calculer la soustraction des matrices
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            soustraction[i][j] = matriceA[i][j] - matriceB[i][j];

    // Afficher la soustraction de deux matrices
    printf("\nLa soustraction des deux matrices est: \n");
    for (i = 0; i < n; i++) {
        printf("\n");
        for (j = 0; j < n; j++)
            printf("%d\t", soustraction[i][j]);
    }
}

#include <stdio.h>

int main() {
    int i, j, matrice[50][50], n, s=0;

    printf("Entrer la taille de la matrice: ");
    scanf("%d", &n);

    printf("Entrer les éléments de la matrice: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("matrice[%d][%d] : ", i, j);
            scanf("%d", &matrice[i][j]);
            // Calculer la somme des éléments de la diagonale droite
            if (i == j) {
                s = s + matrice[i][j];
            }
        }
    }

    // Afficher la matrice
    printf("La matrice est: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("% 4d", matrice[i][j]);
        }
        printf("\n");
    }

    // Afficher la somme des éléments de la diagonale droite
    printf("La somme des éléments de la diagonale droite est: %d", s);

    return 0;
}

#include <stdio.h>

int main() {
    int matrice[50][50], i, j, s=0, n, t=0;

    printf("Entrer la taille de la matrice: ");
    scanf("%d", &n);

    /* Stocker la taille de la matrice pour le parcours 
    de la diagonale gauche */
    t = n; 

    printf("Entrer les éléments de la matrice: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("matrice[%d][%d] : ", i, j);
            scanf("%d", &matrice[i][j]);
        }
    }

    // Afficher la matrice
    printf("La matrice est: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("% 4d", matrice[i][j]);
        }
        printf("\n");
    }

    // Calculer la somme de la diagonale gauche
    for (i = 0; i < n; i++) {
        //Décrémenter pour accéder aux éléments de la diagonale gauche
        t = t - 1; 
        for (j = 0; j < n; j++) {
            if (j == t) {
                // Addition d'éléments sur la diagonale gauche
                s = s + matrice[i][j]; 
            }
        }
    }

    printf("La somme des éléments de la diagonale gauche est: %d", s);

    return 0;
}

#include <stdio.h>

int main() {
    int i, j, k, n, matrice[10][10], lsum[10], csum[10];

    printf("Entrer la taille de la matrice: ");
    scanf("%d", &n);

    printf("Entrer les éléments de la matrice:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("matrice[%d][%d] : ", i, j);
            scanf("%d", &matrice[i][j]);
        }
    }

    // Afficher la matrice
    printf("La matrice est: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("% 4d", matrice[i][j]);
        }
        printf("\n");
    }

    // Calculer la somme des lignes
    for (i = 0; i < n; i++) {
        lsum[i] = 0;
        for (j = 0; j < n; j++) {
            lsum[i] = lsum[i] + matrice[i][j];
        }
    }

    // Calculer la somme des colonnes
    for (i = 0; i < n; i++) {
        csum[i] = 0;
        for (j = 0; j < n; j++) {
            csum[i] = csum[i] + matrice[j][i];
        }
    }

    // Afficher la matrice avec les sommes des lignes
    printf("La somme des lignes et des colonnes de la matrice est:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("% 4d", matrice[i][j]);
        }
        // Afficher la somme de chaque ligne
        printf("% 8d", lsum[i]); 
        printf("\n");
    }
    printf("\n");
    for (j = 0; j < n; j++) {
        // Afficher la somme de chaque colonne
        printf("% 4d", csum[j]); 
    }

    return 0;
}

#include <stdio.h>

int main() {
    int matrice[10][10], n, i, j;
    float determinant = 0;

    printf("Entrer la taille de la matrice: ");
    scanf("%d", &n);

    printf("Entrer les éléments de la matrice: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("matrice[%d][%d] : ", i, j);
            scanf("%d", &matrice[i][j]);
        }
    }

    // Afficher la matrice originale
    printf("La matrice est:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("% 4d", matrice[i][j]);
        }
        printf("\n");
    }

    /* Afficher une matrice triangulaire supérieur en mettant à zéro 
	les éléments triangulaires inférieures */
    printf("\nMettre des zéros dans la matrice triangulaire inférieure:\n");
    for (i = 0; i < n; i++) {
        printf("\n");
        for (j = 0; j < n; j++) {
            if (i <= j) {
                // Afficher les éléments originaux si i <= j (triangle supérieur)
                printf("% 4d", matrice[i][j]); 
            } else {
                printf("% 4d", 0); // Afficher zéro si i > j (triangle inférieur)
            }
        }
    }

    return 0;
}

#include <stdio.h>

int main() {
    int matrice[10][10], n, i, j;
    float determinant = 0;

    printf("Entrer la taille de la matrice: ");
    scanf("%d", &n);

    printf("Entrer les éléments de la matrice: \n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("matrice[%d][%d] : ", i, j);
            scanf("%d", &matrice[i][j]);
        }
    }

    // Afficher la matrice originale
    printf("La matrice est:\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("% 4d", matrice[i][j]);
        }
        printf("\n");
    }

    /* Afficher une matrice triangulaire supérieur en mettant à zéro 
	les éléments triangulaires inférieures */
    printf("\nMettre des zéros dans la matrice triangulaire inférieure:\n");
    for (i = 0; i < n; i++) {
        printf("\n");
        for (j = 0; j < n; j++) {
            if (i >= j) {
                // Afficher les éléments originaux si i <= j (triangle supérieur)
                printf("% 4d", matrice[i][j]); 
            } else {
                printf("% 4d", 0); // Afficher zéro si i > j (triangle inférieur)
            }
        }
    }

    return 0;
}

#include <stdio.h>

int main() {
    int matrice[10][10], i, j, n;
    int det = 0;

    printf("Entrer les éléments de la matrice:\n");
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            printf("matrice[%d][%d] : ", i, j);
            scanf("%d", &matrice[i][j]);
        }
    }

    // Afficher la matrice
    printf("La matrice est: \n");
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 3; j++) {
            printf("% 4d", matrice[i][j]);
        }
        printf("\n");
    }

    // Calculer le déterminant de la matrice 3x3
    for (i = 0; i < 3; i++) {
        det = det + (matrice[0][i] * (matrice[1][(i + 1) % 3] * matrice[2][(i + 2) % 3] - matrice[1][(i + 2) % 3] * matrice[2][(i + 1) % 3]));
    }

    // Afficher le déterminant de la matrice
    printf("\nLe déterminant de la matrice est : %d", det);

    return 0;
}

#include <stdio.h>

int main() {
    int matrice[10][10], i, j, l, c, compteur=0;

    printf("Entrer le nombre de lignes de la matrice:");
    scanf("%d", &l);

    printf("Entrer le nombre de colonnes de la matrice:");
    scanf("%d", &c);

    printf("Entrer les éléments de la matrice:\n");
    for (i = 0; i < l; i++) {
        for (j = 0; j < c; j++) {
            printf("matrice[%d][%d] : ", i, j);
            scanf("%d", &matrice[i][j]);
            if (matrice[i][j] == 0) {
                //Incrémenter le compteur pour les éléments nuls
                ++compteur; 
            }
        }
    }

    /* Vérifier si les zéros représentent plus de la moitié 
	des éléments totaux pour déterminer si la densité est faible. */
    if (compteur > ((l * c) / 2)) {
        printf("La matrice donnée est une matrice creuse.\n");
    } else {
        printf("La matrice donnée n'est pas une matrice creuse.\n");
    }

    printf("Il y a %d nombres de zéros dans la matrice.", compteur);

    return 0;
}

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

int main() {
    int matriceA[50][50], matriceB[50][50];
    int i, j, l1, c1, l2, c2, equal = 1;

    printf("Entrer le nombre de lignes et colonnes de la 1ère matrice:");
    scanf("%d %d", &l1, &c1);

    printf("Entrer le nombre de lignes et colonnes de la 2ème matrice:");
    scanf("%d %d", &l2, &c2);

    printf("Entrer les éléments de la première matrice:\n");
    for(i = 0; i < l1; i++) {
        for(j = 0; j < c1; j++) {
            printf("matriceA[%d][%d] : ", i, j);
            scanf("%d", &matriceA[i][j]);
        }
    } 

    printf("Entrer les éléments de la deuxième matrice:\n");
    for(i = 0; i < l2; i++) {
        for(j = 0; j < c2; j++) {
            printf("matriceB[%d][%d] : ", i, j);
            scanf("%d", &matriceB[i][j]);
        }
    }   

    printf("La première matrice est: \n");
    for(i = 0; i < l1; i++) {
        for(j = 0; j < c1; j++) {
            printf("% 4d", matriceA[i][j]);
        }
        printf("\n");
    }

    printf("La deuxième matrice est: \n");
    for(i = 0; i < l2; i++) {
        for(j = 0; j < c2; j++) {
            printf("% 4d", matriceB[i][j]);
        }
        printf("\n");
    }

    // Comparer l'égalité de deux matrices
    if(l1 == l2 && c1 == c2) {
        printf("Les matrices peuvent être comparées.\n");
        for(i = 0; i < l1; i++) {
            for(j = 0; j < c2; j++) {
                if(matriceA[i][j] != matriceB[i][j]) {
                    equal = 0;
                    break;
                }
            }
        }
    } else {
        printf("Les matrices ne peuvent pas être comparées.\n");
        exit(1);
    }

    // Afficher si les matrices sont égales ou non
    if(equal == 1)
        printf("Les deux matrices sont égales.");
    else
        printf("Les deux matrices ne sont pas égales.");

    return 0;
}

#include <stdio.h>

int main() {
    int matrice[10][10], l1, c1, i, j, ident = 1;

    printf("Entrer le nombre de lignes de la matrice:");
    scanf("%d", &l1);

    printf("Entrer le nombre de colonnes de la matrice:");
    scanf("%d", &c1);
	
    printf("Entrer les éléments de la matrice: \n");
    for(i = 0; i < l1; i++) {
        for(j = 0; j < c1; j++) {
            printf("matrice[%d][%d] : ", i, j);
            scanf("%d", &matrice[i][j]);
        }
    }

    printf("La matrice est: \n");
    for(i = 0; i < l1; i++) {
        for(j = 0; j < c1 ;j++) {
            printf("% 4d", matrice[i][j]);
        }
        printf("\n");
    }
	
    // Vérifier si la matrice est une matrice identité ou non
    for(i = 0; i < l1; i++) {
        for(j = 0; j < c1; j++) {
            if ((i == j && matrice[i][j] != 1) || (i != j && matrice[i][j] != 0)) {
                ident = 0;
                break;
            }
        }
        if (ident == 0) {
            break;
        }
    }

    if(ident == 1) {
        printf("La matrice est une matrice d'identité.");
    } else {
        printf("La matrice n'est pas une matrice d'identité.");
    }
    return 0;
}

#include <stdio.h>

/* Fonction permettant de vérifier s'il existe une paire d'éléments 
dans le tableau dont la somme est égale à une valeur donnée. */
void paireSomme(int tab[], int n, int sum) {
    // Itère dans les éléments du tableau jusqu'à l'avant-dernier élément
    for (int i = 0; i < n - 1; i++) {
        // Itère dans les éléments du tableau du (i + 1)ème élément au dernier élément
        for (int j = i + 1; j < n; j++) {
            // Vérifie si la somme de la paire d'éléments en cours est égale à la somme donnée
            if (tab[i] + tab[j] == sum) {
                printf("Une paire d'éléments peut faire la somme donnée par la valeur des indices %d et %d.", i, j);
                return; // Quitter la fonction si la paire est trouvée
            }
        }
    }
    printf("Aucune paire ne peut faire la somme donnée.");
}

int main() {
    int tab[] = {4, 5, 2, 9, 7, 6};
    int sum = 6;

    // Affiche le tableau donné
    printf("Le tableau donné: ");
    int n = sizeof(tab) / sizeof(tab[0]);
    for (int i = 0; i < n; i++) {
        printf("%d  ", tab[i]);
    }
    printf("\nLa somme donnée: %d", sum);

    paireSomme(tab, n, sum);

    return 0;
}

#include <stdio.h>

/* Trouver l'élément apparaissant un nombre impair de fois 
dans le tableau en utilisant l'opération XOR */
int impaireElem(int *tab, int s) {
    int i, res = 0;

    // Effectuer une opération XOR sur tous les éléments du tableau
    for (i = 0; i < s; i++) {
        res = res ^ tab[i];
    }
	//Renvoie l'élément apparaissant un nombre impair de fois
    return res;
}

int main() {
    int i, tab[] = {1, 2, 1, 6, 6, 2, 7, 2, 7};
    int s = sizeof(tab) / sizeof(tab[0]);

    // Affiche le tableau donné
    printf("Le tableau donné est: ");
    for (i = 0; i < s; i++) {
        printf("%d  ", tab[i]);
    }
    printf("\n");

    printf("L'élément apparaissant un nombre impair de fois est: %d", impaireElem(tab, s));

    return 0;
}

#include <stdio.h>

/* Trouver l'élément apparaissant un nombre impair de fois 
dans le tableau en utilisant l'opération XOR */
int impaireElem(int *tab, int s) {
    int i, res = 0;

    // Effectuer une opération XOR sur tous les éléments du tableau
    for (i = 0; i < s; i++) {
        res = res ^ tab[i];
    }
	//Renvoie l'élément apparaissant un nombre impair de fois
    return res;
}

int main() {
    int i, tab[] = {1, 2, 1, 6, 6, 2, 7, 2, 7};
    int s = sizeof(tab) / sizeof(tab[0]);

    // Affiche le tableau donné
    printf("Le tableau donné est: ");
    for (i = 0; i < s; i++) {
        printf("%d  ", tab[i]);
    }
    printf("\n");

    printf("L'élément apparaissant un nombre impair de fois est: %d", impaireElem(tab, s));

    return 0;
}

#include <stdio.h>

int petitEl(int tab[], int indice_bas, int indice_haut) {
    // Vérifier si indice_bas est supérieur à indice_haut, ce qui indique la fin de la recherche.
    if (indice_bas > indice_haut)
        return indice_bas; // Renvoyer l'indice le plus petit, car il représente l'élément manquant le plus petit.

    // Calculer l'indice moyen entre indice_bas et indice_haut
    int mid_index = indice_bas + (indice_haut - indice_bas) / 2;

    // Si l'élément à mid_index est égal à mid_index, la non-concordance se situe dans la moitié droite.
    if (tab[mid_index] == mid_index)
        return petitEl(tab, mid_index + 1, indice_haut);
    else // Si ce n'est pas le cas, la discordance se situe dans la moitié gauche
        return petitEl(tab, indice_bas, mid_index - 1);
}

int main() {
    int i, tab[] = {0, 1, 2, 4, 5, 6, 7, 9};
    int size = sizeof(tab) / sizeof(tab[0]);

    // Afficher le tableau d'origine
    printf("Le tableau donné est:");
    for(i = 0; i < size; i++) {
        printf("%d  ", tab[i]);
    } 

    int indice_bas = 0, indice_haut = size - 1;
	
    int res = petitEl(tab, indice_bas, indice_haut);

    printf("\nLe plus petit élément manquant est: %d", res);
    return 0;
}

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

void sommeMinimale(int *tab, int tab_size) {
    int i, j, sum, min1, min2, minS;

    /* Initialiser les variables pour déterminer la somme minimale 
	et les paires d'éléments correspondantes */
    min1 = tab[0];
    min2 = tab[1];
    minS = min1 + min2;

    // Itérer dans le tableau pour trouver la paire dont la somme est la plus faible
    for (i = 0; i < tab_size - 1; i++) {
        for (j = i + 1; j < tab_size; j++) {
            sum = tab[i] + tab[j];
            // Actualiser la somme minimale et les éléments de la paire si la somme actuelle est plus petite
            if (abs(sum) < abs(minS)) {
                minS = sum;
                min1 = tab[i];
                min2 = tab[j];
            }
        }
    }
    // Afficher la paire d'éléments dont la somme est minimale
    printf("[%d, %d]\n", min1, min2);
}

int main() {
    int tab[] = {55, 42, 75, -52, -89, 23, 80, -99, 2, -44}; 
    int size = sizeof(tab) / sizeof(tab[0]);
    int i;  

    // Afficher le tableau d'origine
    printf("Le tableau donné est: ");
    for (i = 0; i < size; i++) {
        printf("%d  ", tab[i]);
    } 

    printf("\nLa paire d'éléments dont la somme est minimale est: ");
    sommeMinimale(tab, size);
    return 0;
}

#include <stdio.h>
#include <stdbool.h>

int petitNbrPositifManq(int tab[], int n)
{

    // Pour marquer l'occurrence d'éléments
    bool present[n + 1];
    for (int i = 0; i < n; i++)
        present[i] = false;

    for (int i = 0; i < n; i++) {
        /* Ne marquer que les éléments obligatoires.
         Tous les éléments non positifs et les éléments
         supérieurs à n + 1 ne seront jamais considérés comme
         une réponse. Par exemple, le tableau sera {1, 2, 3} dans le 
         pire des cas et le résultat sera 4, ce qui correspond à n + 1.*/
        if (tab[i] > 0 && tab[i] <= n)
            present[tab[i]] = true;
    }

    // Trouver le premier élément qui n'apparaît pas dans le tableau original
    for (int i = 1; i <= n; i++)
        if (!present[i])
            return i;

    return n + 1;
}

int main()
{
    int tab[] = { 3, 1, 2, -5, 5, -23, 10, 6, 8, -7 };
    int size = sizeof(tab) / sizeof(tab[0]);
    printf("Le plus petit nombre positif manquant est: %d", petitNbrPositifManq(tab, size));
}

#include <stdio.h>

void getMaj(int tab[], int n)
{
    int max = 0;
    int index = -1;
    for (int i = 0; i < n; i++) {
        int compteur = 0;
        for (int j = 0; j < n; j++) {
            if (tab[i] == tab[j])
                compteur++;
        }
  
        // Actualiser max si le compteur de l'élément 
        // actuel est plus grand
        if (compteur > max) {
            max = compteur;
            index = i;
        }
    }
  
    // si max est supérieur à n/2
    // retourner l'élément correspondant
    if (max > n / 2)
        printf("L'élément majoritaire est: %d\n", tab[index]);
  
    else
        printf("Pas d'élément majoritaire\n");
}

int main()
{
    int tab[] = { 4, 1, 2, 4, 4, 5, 4, 6, 8, 4 };
    int n = sizeof(tab) / sizeof(tab[0]);
  
    getMaj(tab, n);
  
    return 0;
}

#include <stdio.h>

void swap(int tab[], int i, int j) {
    int tmp = tab[i];
    tab[i] = tab[j];
    tab[j] = tmp;
}

int sortElements(int tab[], int end) {
    int start = 0, milieu = 0;
    int pivot = 1;

    while (milieu <= end) {
        if (tab[milieu] < pivot) {
            swap(tab, start, milieu);
            ++start, ++milieu;
        } else if (tab[milieu] > pivot) {
            swap(tab, milieu, end);
            --end;
        } else {
            ++milieu;
        }
    }
}

int main() {
    int tab[] = { 0, 1, 1, 2, 2, 1, 0, 1, 2, 0, 2, 0 };
    int n = sizeof(tab) / sizeof(tab[0]);
    int i;

    printf("Le tableau donné est: ");
    for (i = 0; i < n; i++) {
        printf("%d ", tab[i]);
    }

    printf("Après le tri, les éléments du tableau sont: ");
    sortElements(tab, n - 1);
    for (int i = 0 ; i < n; i++) {
        printf("%d ", tab[i]);
    }
    return 0;
}

#include <stdio.h>

// Fonction permettant de vérifier si tab2[] est un sous-ensemble de tab1[]
int tabSousEnsemble(int *tab1, int tab1_size, int *tab2, int tab2_size) {
    int i, j;
    // Parcourir les éléments de tab2[]
    for (i = 0; i < tab2_size; i++) {
        // Recherche de l'élément tab2[] courant dans tab1[]
        for (j = 0; j < tab1_size; j++) {
            // Si un élément est trouvé dans tab1[], arrêter la boucle
            if (tab2[i] == tab1[j])
                break;
        }
        // Si la boucle se termine sans trouver d'élément, 
        // tab2[] n'est pas un sous-ensemble
        if (j == tab1_size)
            return 0; // Pas un sous-ensemble
    }
    return 1; // tab2[] est un sous-ensemble de tab1[]
}

int main() {

    int tab1[] = {3, 8, 7, 12, 6, 9, 1, 0, 5};
    int tab2[] = {1, 3, 7, 6, 0};
    int i;
    int n1 = sizeof(tab1) / sizeof(tab1[0]);
    int n2 = sizeof(tab2) / sizeof(tab2[0]);
    
    printf("Le premier tableau donné est: ");
    for (i = 0; i < n1; i++) {
        printf("%d ", tab1[i]);
    }
    printf("\n");

    printf("Le deuxième tableau est: ");
    for (i = 0; i < n2; i++) {
        printf("%d ", tab2[i]);
    }
    printf("\n");

    // Vérifier si tab2[] est un sous-ensemble de tab1[]
    if (tabSousEnsemble(tab1, n1, tab2, n2))
        printf("Le deuxième tableau est un sous-ensemble du premier tableau.");
    else
        printf("Le deuxième tableau n'est pas un sous-ensemble du premier tableau.");

    return 0;
}