Exercices de programmation en langage C (les fonctions)

Exercice 1

Faire fonctionner l’exemple du cours sur les fonctions :

float calculPrixTTC(float prixHT, float tva);

Rappel : il y a 3 étapes, déclaration de la fonction, définition de la fonction (code) et utilisation dans le programme principal "main()" ou une autre fonction.

Voir le corrigé

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf

// Déclaration de la fonction (prototype)
float calculPrixTTC(float prixHT, float tva);

int main()
{
    float tauxTva = 20.0;
    float pTTC_produit;

    //Utilisation de la fonction
    pTTC_produit = calculPrixTTC(12.50, tauxTva);

    printf("Prix TTC : %f", pTTC_produit);

    return 0;
}

// Définition de la fonction (code)
float calculPrixTTC(float prixHT, float tva) {
    float prixTTC;

    prixTTC = prixHT * (1 + tva / 100);
    return prixTTC;
}

Exercice 2

Écrire une fonction qui renvoie 1 si un nombre entier passé en paramètre est impair, 0 sinon. Son prototype est donc :

int estImpair(int nb);

Écrire également son programme de test (main).

Remarque : prennez l'habitude de mettre un commentaire au format Javadoc avant la déclaration de chaque fonction :

// Déclaration de la fonction (prototype)
/**
 * Teste si un nombre est impair
 * @author SD
 * @param nb (int) : Nombre à tester
 * @return (int) 1 si nb est impair 0 sinon
*/
int estImpair(int nb);

Voir le corrigé

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf

// Déclaration de la fonction (prototype)
/**
 * Teste si un nombre est impair
 * @author SD
 * @param nb (int) : Nombre à tester
 * @return (int) 1 si nb est impair 0 sinon
*/
int estImpair(int nb);

int main()
{
    for(int i=0; i<6 ; i++) {
        if(estImpair(i))
            printf("%d est impair\n", i);
        else
            printf("%d est pair\n", i);
    }

    return 0;
}

// Définition de la fonction (code)
int estImpair(int nb) {
    if(nb % 2 == 0)
        return 0;
    else
        return 1;
}

/* Peut aussi s'écrire simplement :
int estImpair(int nb) {
    return nb % 2;
}
*/

Exercice 3

Nombre de caractères dans une chaîne (reprendre le code de l’exercice 6 sur les tableaux)

Créer une fonction qui renvoie le nombre de caractères d’une chaîne de caractères passée en paramètre. Son prototype sera :
int longueurChaine(char texte[]);
Dans le "main()", demander à l’utilisateur de saisir son nom
Toujours dans le "main()", utiliser la fonction "longueurChaine" pour compter les caractères et afficher leur nombre

Rappel : un tableau de caractère (chaine de caractères), se termine par le caractère spécial : '\0'.

Voir le corrigé

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf

// Déclaration de la fonction (prototype)
/**
 * Renvoie le nombre de caractères d'une chaîne de caractères
 * passée en paramètre
 * @author SD
 * @param texte (char[]) : Chaîne de caractère (terminée par '\0')
 * @return (int) Nombre de caractères qui compose la chaîne 'texte' reçue en paramètre
*/
int longueurChaine(char texte[]);

int main() {
	char tNom[30];
	
	printf("Saisissez votre nom : ");   // Afficher : "Saisissez votre nom : "
	scanf("%s", tNom);                	// Entrer : tNom[]
	
	printf("\nVotre nom compte %d caracteres", longueurChaine(tNom));
	
	return 0;
}

// Définition de la fonction (code)
int longueurChaine(char texte[]) {
	int longueur = 0;                  // longueur <-- 0
	
	while (texte[longueur] != '\0') {  // Tant que(texte[longueur] != '\0')
	    longueur++;                    //      longueur <-- longueur + 1
	}                                  // Fin Tant que
	
	return longueur;
}

Exercice 4

Saisir un mot et l’afficher dans l’ordre inversé (reprendre le code de l’exercice 7 sur les tableaux).

Comme pour l’exercice précédent, créer une fonction qui inverse une chaîne de caractères passée en paramètre (cette fonction pourra elle-même utiliser la fonction "longueurChaine" créée précédemment).

Utiliser ensuite cette fonction dans le "main()" de manière à inverser et afficher une chaîne de caractères saisie par l’utilisateur.

Voir le corrigé

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf

// Déclaration des fonctions
/**
 * Renvoie le nombre de caractères d'une chaîne de caractères
 * passée en paramètre
 * @author SD
 * @param texte (char[]) : Chaîne de caractère (terminée par '\0')
 * @return (int) Nombre de caractères qui compose la chaîne 'texte' reçue en paramètre
*/
int longueurChaine(char texte[]);
/////////////////////////////////////////////////////////////////////////////////////
/**
 * Échange les valeurs de 2 variables de type char passées en paramètres
 * @author SD
 * @param c1 (char*) : Pointeur sur le premier caractère
 * @param c2 (char*) :  Pointeur sur le deuxième caractère
*/
void echange(char* c1, char* c2);
/////////////////////////////////////////////////////////////////////////////////////
/**
 * Inverse une chaîne de caractères passée en paramètre. Ex : ELISA => ASILE
 * @author SD
 * @param texte (char[]) : Chaîne de caractère à inverser
*/
void inverseChaine(char texte[]);

// Utilisation dans main()
int main() { 
  int nbCar;
  char tMot[30];

  printf("Saisissez un mot : ");
  scanf("%s", tMot);

  inverseChaine(tMot);

  printf("\n%s", tMot);
}

// Définition des fonctions (code)
void inverseChaine(char texte[]) {
  int nbCar, i;
  char temp;

  nbCar = longueurChaine(texte);

  for(i = 0; i < nbCar / 2; i++) {
    echange(&texte[i], &texte[nbCar - 1 - i]);
  }
}

void echange(char* c1, char* c2) {
  char temp = *c1;

  *c1 = *c2;
  *c2 = temp;
}

int longueurChaine(char texte[]) {
  int longueur = 0;
  
  while(texte[longueur] != '\0') longueur++;
  
  return longueur;
}

Exercice 5

Écrire une fonction qui remplace les voyelles (minuscules et majuscules) par des espaces dans une chaîne passée en paramètre.

Voir le corrigé

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf

// Déclaration des fonctions
/**
 * Remplace les voyelles (minuscules et majuscules) par des espaces 
 * dans la chaîne text[], renvoie le nombre de caractères remplacés
 * @author SD
 * @param text (char[]) : Chaîne de caractère (terminée par '\0')
 * @return (int) Nombre de caractères qui ont été remplacés dans la chaîne 'text' reçue en paramètre
*/
int remplaceVoyellesParEspaces(char text[]); 
////////////////////////////////////////////////////////////////////////////
/**
 * Détermine si un caractère passé en paramètre est une voyelle. 
 * @author SD
 * @param c (char) : Caractère à tester
 * @return (int) 1 si le caractère reçu en paramètre est une voyelle, 0 sinon
*/
int estUneVoyelle(char c);

int main() {
	char leTexte[50];
	
	printf("Entrez un  mot : ");
	scanf("%s", leTexte);
	
	int n = remplaceVoyellesParEspaces(leTexte);
	
	printf("%d caractères ont été remplacés   %s", n, leTexte);

	return 0;
}

// Définition des fonctions (code)
int remplaceVoyellesParEspaces(char text[]) {
    int i, nbRemplacement = 0;
    
    // parcourir toute la chaine, caractère par caractère
    //  (on sait que le dernier caractère est '')
    i = 0;
    while(text[i] != '') {
    //    Si le caractère est une voyelle (majuscule ou minuscule)    || = OU
        if(estUneVoyelle(text[i])) {
    //      Le remplacer par un espace
            text[i] = ' ';
    //      nbRemplacement++
            nbRemplacement++;
        }
        i++;
    }
    // renvoyer nbRemplacement
    return nbRemplacement;
}

int estUneVoyelle(char c) {
    char tVoyelle[] = "aAeEiIoOUuYy";
    
    for(int i=0 ; i<12 ; i++) {
        if(c == tVoyelle[i])
            return 1;
    }
    return 0;
}

Exercice 6

Écrire une fonction qui cherche combien de fois un caractère est présent dans une chaîne de caractères. Le caractère à chercher et la chaîne seront passés en paramètres.

Voir le corrigé

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf

/**
 * Compte combien de fois un caractère est présent dans une chaîne.
 * La chaîne de caractères et le caractère cherché sont passés en paramètres
 * @author SD
 * @param texte (char[]) : Chaîne de caractère (terminée par '\0')
 * @param car (char) : Caractère à rechercher dans 'texte'
 * @return (int) Nombre de fois que le caractère a été trouvé
*/
int nombreOccurence(char texte[], char car);

int main()
{
    char leTexte[] = "Fonction qui cherche combien de fois un caractère est présent dans une chaîne";
    
    printf("\n%s", leTexte);
    
    printf("\n\nLe caractère 'e' est présent %d fois", nombreOccurence(leTexte, 'e'));
    
    printf("\n\nLe caractère 'Y' est présent %d fois", nombreOccurence(leTexte, 'Y'));
    
    return 0;
}

// Définition de la fonction
int nombreOccurence(char texte[], char car) {
    int nbCar = 0;
    int i;
    
    i = 0;
    while(texte[i] != '\0') {
    //  Si le caractère = car
        if(texte[i] == car) nbCar++;
        
        i++;
    }
    
    return nbCar;
}

Exercice 7

Écrire une fonction qui cherche si une valeur est présente dans un tableau (entiers).

Elle renverra -1 si la valeur n'est pas trouvée et la position de la valeur dans le tableau sinon.

Il faut passer en paramètre la valeur cherchée, le tableau et le nombre d'éléments dans le tableau.

Voir le corrigé

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf

/**
 * Cherche si une valeur est présente dans un tableau (entiers)
 * @author SD
 * @param val (int) : Valeur à rechercher
 * @param tab (int[]) : Tableau de valeurs où se fait la recherche
 * @param size (int) : Nombre d'éléments dans le tableau
 * @return (int) La position de la valeur dans le tableau (-1 si non présent)
*/
int estDansLeTableau(int val, int tab[], int size);

int main()
{
    int tab[] = {99, 45, 85, 10, 25, 65, 45, 100, 78, 11, 0, 5, 55}; // 13 valeurs
    int valeur, position;
    
    valeur = 78;
    position = estDansLeTableau(valeur, tab, 13);
    if(position >= 0)
        printf("\n%d est à la position %d dans le tableau", valeur, position);
    else
        printf("\n%d n'est pas dans le tableau", valeur);
        
    valeur = 79;
    position = estDansLeTableau(valeur, tab, 13);
    if(position >= 0)
        printf("\n%d est à la position %d dans le tableau", valeur, position);
    else
        printf("\n%d n'est pas dans le tableau", valeur);
        
        
    return 0;
}

// Définition de la fonction
int estDansLeTableau(int val, int tab[], int size) {
    // parcourir le tableau à la recherche de val
    for(int i = 0 ; i < size ; i++) {
        if(tab[i] == val)
            return i;
    }
    
    return -1;
}

Exercice 8

Écrire une fonction qui tri par ordre croissant les éléments d'un tableau de nombres entiers.

Pour le tri, utiliser l'algorithme du "tri séléction" donné ci-dessous :

Fonction tri_selection(tableau t, entier n)	// n est le nombre de cases
	pour i de 1 à n-1 par pas de 1
		min <-- i
		pour j de i+1 à n par pas de 1
			si t[j] < t[min]
				min <-- j
			Fin si
		Fin pour
		si min != i
			Echanger t[i] et t[min]
		Fin si
	Fin pour
Fin fonction

Voir le corrigé

#include <stdio.h>  // Inclure la bibliothèque STanDard Input Output
                    // permet d'utiliser, entre autre, printf et scanf

/**
 * Tri un tableau de nombre entiers par ordre croissant
 * @author SD
 * @param leTableau (int[]) : Tableau de nombres entiers à trier
 * @param size (int) : Nombre d'éléments dans le tableau
*/
void tri_selection(int leTableau[], int nbCases);
////////////////////////////////////////////////////////////////////////
/**
 * Échange les valeurs de 2 variables de type int passées en paramètres
 * @author SD
 * @param i (int*) : Pointeur sur le premier nombre entier
 * @param j (int*) :  Pointeur sur le deuxième nombre entier
*/
void echanger(int* i, int* j);

int main() {
    int tab[] = {99, 45, 85, 10, 25, 65, 45, 100, 78, 11, 0, 5, 55};

    // Affichage du tableau non trié    
    printf("%d", tab[0]);
    for(int i=1; i < 13 ; i++) printf(", %d", tab[i]);

    // Tri du tableau
    tri_selection(tab , 13);
    
    // Affichage du tableau trié
    printf("

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

    return 0;
}

// Fonction tri_selection(tableau t, entier n)    // n est le nombre de cases 
void tri_selection(int leTableau[], int nbCases) {
  int i, min;
  // pour i de 1 à n-1 par pas de 1 
  for(i=0; i < nbCases-1 ; i++) {
    min = i;    // min <-- i 
    // pour j de i+1 à n par pas de 1 
    for(int j=i+1; j < nbCases ; j++) {
        if(leTableau[j] < leTableau[min]) {   // si t[j] < t[min] 
            min = j;    // min <-- j 
        } // Fin si 
    } // Fin pour 
    if(min != i) { // si min != i 
        echanger(&leTableau[i], &leTableau[min]); // Echanger t[i] et t[min] 
    } // Fin si 
  } // Fin pour 
} // Fin fonction 

void echanger(int* i, int* j) {
    int temp;
    
    temp = *i;
    *i = *j;
    *j = temp;
}

Articles connexes

Vous avez apprécié cet article ? Partagez le !