Exercices de programmation en langage C (les tableaux)

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() {
    int tab[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    printf("%d", tab[0]);
    for(int i = 1 ; i < 10 ; i++) printf(", %d", tab[i]);

	return 0;
}

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() {
    const int TAB_SIZE = 100;
    const int LINE_SIZE = 10;
    int tab[TAB_SIZE];
    
    // Remplir le tableau avec les nombres de 0 à TAB_SIZE
    for(int i = 0 ; i < TAB_SIZE ; i++) tab[i] = i;
 
    // Aficher le tableau en limitant à LINE_SIZE valeurs par lignes
    for(int i = 0 ; i < TAB_SIZE ; i++) {
        if((i+1) % LINE_SIZE == 0) { // Si arrivé en fin de ligne
            printf("%2d\n", tab[i]); //    Ajout d'un saut de ligne
        }
        else {                      // Sinon
            printf("%2d,", tab[i]); //    Ajout d'une virgule
        }
    }
    
	return 0;
}

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() {
    const int TAB_SIZE = 10;
    float tDestination[TAB_SIZE];
    float tSource[] = {12.5, -25.4, -78.9, 45.1, 8.6, -1.0, 37.2, -51.3, 88.8, 94.7};
    int iSrc, iDst;
    
    // Recopier les éléments positifs de tSource dans tDestination
    for(iSrc = 0, iDst = 0 ; iSrc < TAB_SIZE ; iSrc++) {
        if(tSource[iSrc] > 0) tDestination[iDst++] = tSource[iSrc];
    }
 
    // Compléter tDestination avec des zéros
    while(iDst < TAB_SIZE) tDestination[iDst++] = 0;
 
    // Aficher les tableaux
    printf("tSource      : %.2f", tSource[0]);
    for(int i = 1 ; i < TAB_SIZE ; i++) printf(", %.2f", tSource[i]);

    printf("\ntDestination : %.2f", tDestination[0]);
    for(int i = 1 ; i < TAB_SIZE ; i++) printf(", %.2f", tDestination[i]);

    return 0;
}

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() {
    const int TAB_SIZE = 10;
    int tNombres[TAB_SIZE];
    
    // Demander les nombres à l'utilisateur
    printf("Entrez les nombres (entiers) du tableau\n");
    for(int i = 0 ; i < TAB_SIZE ; i++) {
        printf("Nombre %d/10 : ", i+1);
        scanf("%d", &tNombres[i]);
    }
 
    // Rechercher le plus petit nombre
    int nbMin = tNombres[0];
    for(int i = 1 ; i < TAB_SIZE ; i++) {
        if(tNombres[i] < nbMin) nbMin = tNombres[i];
    }

    // Rechercher le plus grand nombre
    int nbMax = tNombres[0];
    for(int i = 1 ; i < TAB_SIZE ; i++) {
        if(tNombres[i] > nbMax) nbMax = tNombres[i];
    }
    
    // Aficher le tableau
    printf("\ntNombres : %d", tNombres[0]);
    for(int i = 1 ; i < TAB_SIZE ; i++) printf(", %d", tNombres[i]);
    
    printf("\nLa valeur minimale est : %d", nbMin);
    printf("\nLa valeur maximale est : %d", nbMax);    

	return 0;
}

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() {
	const int NB_MAX_NOTES = 50;
	int nbNotes;
	float note, sommeDesNotes;
	float tabNotes[NB_MAX_NOTES]; // Déclare un tableau de 50 réels
	
	printf("Entrez des notes (entre 0 et 20)\nPour stopper, saisir une note hors de cet interval.\n");
	
	nbNotes = 0;
	// A. Saisir les notes et les mémoriser dans un tableau
	// + B. Compter les notes saisies et afficher leur nombre
	do {
		scanf("%f", &note);
		tabNotes[nbNotes] = note; // tabNotes[nbNotes] <-- note
		nbNotes++;
	} while((note >= 0) && (note <= 20) && (nbNotes < NB_MAX_NOTES));
	
	if((note < 0) || (note > 20)) nbNotes--; // La dernière note saisie n'est pas valide
	else printf("\nVous avez ateint le nombre maximum de notes possible.");

	printf("\nVous avez saisi %d notes", nbNotes);
	
	// C. Calcul et affichage de la moyenne 
	sommeDesNotes = 0;
	int i;
	for(i = 0 ; i < nbNotes ; i++) {
	    sommeDesNotes = sommeDesNotes + tabNotes[i];
	}
	
	float moyenne = sommeDesNotes / nbNotes; 
	printf("\n\nLa moyenne des notes est : %.2f\n", moyenne);
	
	// D. Comparer chaque note à la moyenne et ajouter, dans l’affichage précédent "égal",
	//    "inférieur" ou "supérieur à la moyenne"
	// + E. Compter et afficher combien il y a de notes supérieures à la moyenne
	int nbNotesSupMoy = 0;
	for(i = 0 ; i < nbNotes ; i++) {
	    printf("\n%d : %.2f", i+1, tabNotes[i]);
	    
	    if(tabNotes[i] > moyenne) {
	        printf(" > à la moyenne");
	        nbNotesSupMoy++;
	    }
	    else if(tabNotes[i] < moyenne)
	        printf(" < à la moyenne");
	    else
	        printf(" = à la moyenne");
	}
	
	printf("\n\nIl y a %d notes > à la moyenne.", nbNotesSupMoy);
	
	// F. Dans le tableau de notes, chercher la note la plus petite 
	float noteLaPlusFaible = 21;
	int positionNoteLaPlusFaible;
	for(i = 0 ; i < nbNotes ; i++) {
	    if(tabNotes[i] < noteLaPlusFaible) {
	        noteLaPlusFaible = tabNotes[i];
	        positionNoteLaPlusFaible = i + 1;
	    }
	}
	
	// F. (suite) Afficher cette note et sa position dans le tableau
	printf("\n\nLa note la plus basse est %.2f, sa position est %d", noteLaPlusFaible, positionNoteLaPlusFaible);

	// G. Dans le tableau de notes, chercher la note la plus haute 
	float noteLaPlusHaute = -1;
	int positionNoteLaPlusHaute;
	for(i = 0 ; i < nbNotes ; i++) {
	    if(tabNotes[i] > noteLaPlusHaute) {
	        noteLaPlusHaute = tabNotes[i];
	        positionNoteLaPlusHaute = i + 1;
	    }
	}
	
	// G. (suite) Afficher cette note et sa position dans le tableau
	printf("\n\nLa note la plus haute est %.2f, sa position est %d", noteLaPlusHaute, positionNoteLaPlusHaute);
	
	return 0;
}

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() {
	int nbCar;
	char tNom[30];
	
	printf("Saisissez votre nom : ");   // Afficher : "Saisissez votre nom : "
	scanf("%s", tNom);                	// Entrer : tNom[]
	
	nbCar = 0;                          // nbCar <-- 0
	while (tNom[nbCar] != '\0') {       // Tant que(tNom[nbCar] != '\0')
	    nbCar++;                        //      nbCar <-- nbCar + 1
	}                                   // Fin Tant que
	
	// Afficher : "Votre nom compte nbCar caracteres"
	printf("\nVotre nom compte %d caracteres", nbCar);
	
	return 0;
}

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() 
{
    // Variables :
	int nbCar, i;       // Entier : nbCar, i
	char tMot[30];      // Tableau de caractères : tMot[30]

    printf("Saisissez un mot : ");  // Afficher : "Saisissez un mot : "
    scanf("%s", tMot);              // Entrer : tMot[]

    // Déterminer la longueur du mot
    nbCar = 0;                      // nbCar <-- 0
    while(tMot[nbCar] != '\0') {    // Tant que(tMot[nbCar] != '\0')
	    nbCar = nbCar + 1;          //      nbCar <-- nbCar + 1
    }                               // Fin Tant que
    
    // Affiche le mot caractère par caractère en partant de la fin
    for(i = nbCar -1 ; i >= 0 ; i--) {   // Pour i de nbCar-1 à 0 incrément -1
	    printf("%c", tMot[i]);      //      Afficher : "tMot[i]"
    }                               // Fin Pour
    
    return 0;
}   // Fin

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() 
{
	int position_m,position_s,position;
	char caractere;
	// a.	Initialiser un tableau avec le texte suivant : 	"Quel sinistre mot !"
	char tab[] = {"quel sinistre mot !"};
	
	// b.	Trouver et afficher à quelle position se trouve la lettre 'm' 
	position_m = 0;
	while (tab[position_m] != 'm') position_m++;

	printf("\nLe caractere m est a la position %d",position_m);

    // c.	Même chose pour la première lettre 's'
	position_s = 0;
	while (tab[position_s] != 's') position_s++;
	
	printf("\nLe caractere s est a la position %d",position_s);
	
	// d.	Mettre la lettre 'm' à la place de 's' et vice versa 
	tab[position_m] = 's';
	tab[position_s] = 'm';
	
	// e.	Afficher le texte ainsi modifié 
	printf("\nLa chaine modifiee est : %s",tab);
	
	// f.	Demander à l’utilisateur de saisir une lettre quelconque
	printf("\nSaisir un caractere quelconque : ");
	scanf("%c",&caractere);
	
	// g.	Chercher cette lettre dans le texte et afficher sa position
	//      ou un message d’erreur si elle est absente
	position = 0;
	while ((tab[position] != caractere) && (tab[position] != '\0')) position++;
	
	if (position < 19) { // la chaine "quel sinistre mot !" comporte 19 caractères
		printf("\nLa position de '%c' dans \"%s\" est : %d",caractere,tab,position);
	} else {
		printf("\nLe caractere '%c' n'est pas présent dans '%s'",caractere,tab);
	}
	
	return 0;
}   // Fin

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() 
{
    const int TAB_SIZE = 30;
	int i, nbPatient;
	float tTaille[TAB_SIZE], tMasse[TAB_SIZE], imc, somme;
	
	// A.	Enregistrer la taille t en mètres de tous les patients qui se présentent 
	//		(arrêt par la saisie d’un nombre ≤ 0)
	printf("Entrez la taille des patients (en mètre) :\n");
	i = 0;
	do {
		printf("  Taille du patient %d : ", i + 1);
		scanf("%f", &tTaille[i]);
		i = i + 1;
	} while ((tTaille[i-1] > 0) && (i < TAB_SIZE));
	
	// B.	Après la saisie, afficher le nombre total des patients.
	nbPatient = i;
	if(tTaille[i-1] < 0) nbPatient--; // La dernière taille saisie n'est pas valide
	else printf("\nVous avez ateint le nombre maximum de %d patients possible.", TAB_SIZE);
	
	printf("\nIl y a %d patients.\n\n", nbPatient);
	
	// C.	Pour chaque patient précédemment mesuré, enregistrer la masse m en kilogrammes.
	printf("Entrez la masse des patients (en kg) :\n");
	for(i = 0; i < nbPatient; i++) {
		printf("  Masse du patient %d : ", i + 1);
		scanf("%f", &tMasse[i]);	
	}
	
	// D.	Calculer et afficher la taille et le poids moyens.
	printf("\n");
		// Taille moyenne
	somme = 0;
	for(i = 0 ; i < nbPatient ; i++) {
		somme = somme + tTaille[i];
	}
	printf("\nLa taille moyenne des patients est : %.2f\n", somme / nbPatient);
	    // Poids moyen
	somme = 0;
	for(i = 0; i < nbPatient; i++) {
		somme = somme + tMasse[i];
	}
	printf("\nLa masse moyenne des patients est : %.2f\n", somme / nbPatient);
	
	//	E.	Pour chaque patient, calculer l’indice de masse corporelle : IMC = m/t*t 
	// 		et afficher : pas assez , trop ou normal selon son IMC
	for(i = 0; i < nbPatient; i++) {
		imc = tMasse[i] / (tTaille[i] * tTaille[i]);
		
		printf("\nIMC patient %d : %.2f", i + 1, imc);

		if(imc < 18.5) {
			printf(" => Pas assez");
		} else {
			if(imc > 25) {
				printf(" => Trop");
			} else {
				printf(" => Normal");
			}
		}
	}	
		
	return 0;
}

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf
int main() 
{
    char trame[1000];
    int saisieOk = 0;
    int i, nbCar;
    
    // A. Permet à l'utilisateur de saisir la chaîne de caractères
    printf("Entrer une chaîne de caractères (caractères autorisés : 0-9A-Za-z) : ");
    scanf("%s", trame);
    
    do {
        i = 0;
        while(trame[i] != '\0') {
            if(trame[i] < '0' || (trame[i] > '9' && trame[i] < 'A') || (trame[i] > 'Z' && trame[i] < 'a') || trame[i] > 'z') {
                saisieOk = 0;
                printf("\nErreur : la chaîne de caractères peut contenir uniquement les caractères 0-9A-Za-z.");
                printf("\nSaisissez à nouveau : ");
                scanf("%s", trame);
            }
            else {
                saisieOk = 1;
            }
            i++;
        }
    } while(!saisieOk);
    
    nbCar = i;
    printf("saisie Ok (%d octets) : \n\t%s\n", nbCar, trame);
    
    // B. Calcul le checksum
    unsigned int checksum = 0;
    for(i = 0 ; trame[i] != '\0' ; i++) checksum = (checksum + trame[i]) % 65536;
    printf("Valeur du checksum : \n\t%d\n", checksum);
    
    // C. Affiche la trame à transmettre en hexadécimal 
    printf("\nTrame à tranmettre : ");
    printf("0x%02X ", 0x02); // STX
    printf("0x%02X ", nbCar >> 8);      // Nombre de caractères saisis (poids fort)
    printf("0x%02X ", nbCar & 0xFF);    // Nombre de caractères saisis (poids faible)
    for(i = 0 ; trame[i] != '\0' ; i++) printf("0x%2X ", trame[i]);
    printf("0x%02X ", checksum >> 8);   // checksum (poids fort)
    printf("0x%02X ", checksum & 0xFF); // checksum (poids faible)
    printf("0x%02X", 0x03); // ETX
    
	return 0;
}