400 Exercices Corrigés En C – Partie 16

#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;
}