pdf - e-book - archive - github.com

2.6  Fonctions

2.6.1  Géométrie

Ecrire un programme demandant à l’utilisateur de saisir une valeur numérique positive n et affichant un carré, une croix et un losange, tous de coté n. Par exemple, si n = 10, l’exécution donne

Saisissez la taille des figures
10
* * * * * * * * * *
*                 *
*                 *
*                 *
*                 *
*                 *
*                 *
*                 *
*                 *
* * * * * * * * * *
                  *
                *   *
              *       *
            *           *
          *               *
        *                   *
      *                       *
    *                           *
  *                               *
*                                   *
  *                               *
    *                           *
      *                       *
        *                   *
          *               *
            *           *
              *       *
                *   *
                  *
*                                   *
  *                               *
    *                           *
      *                       *
        *                   *
          *               *
            *           *
              *       *
                *   *
                  *
                *   *
              *       *
            *           *
          *               *
        *                   *
      *                       *
    *                           *
  *                               *
*                                   *

Vous définirez des sous-programmes de quelques lignes et au plus deux niveaux d’imbrication. Vous ferez attention à ne jamais écrire deux fois les mêmes instructions. Pour ce faire, complétez le code source suivant :

#include<stdio.h>

/*
  Affiche le caractere c
 */

void afficheCaractere(char c)
{
}

/*****************************************/

/*
  affiche n fois le caractere c, ne revient pas a la ligne 
  apres le dernier caractere.
*/

void ligneSansReturn(int n, char c)
{
}

/*****************************************/

/*
  affiche n fois le caractere c, revient a la ligne apres 
  le dernier caractere.
*/

void ligneAvecReturn(int n, char c)
{
}

/*****************************************/

/*
  Affiche n espaces.
*/

void espaces(int n)
{
}

/*****************************************/

/*
  Affiche le caractere c a la colonne i, 
  ne revient pas a la ligne apres.
*/

void unCaractereSansReturn(int i, char c)
{
}

/*****************************************/

/*
  Affiche le caractere c a la colonne i, 
  revient a la ligne apres.
*/

void unCaractereAvecReturn(int i, char c)
{
}

/*****************************************/

/*
  Affiche le caractere c aux colonnes i et j, 
  revient a la ligne apres.
*/

void deuxCaracteres(int i, int j, char c)
{
}

/*****************************************/

/*
  Affiche un carre de cote n.
*/

void carre(int n)
{
}

/*****************************************/

/*
  Affiche un chapeau dont la pointe - non affichee - est 
  sur la colonne centre, avec les caracteres c.
*/

void chapeau(int centre, char c)
{
}

/*****************************************/

/*
  Affiche un chapeau a l'envers avec des caracteres c, 
  la pointe - non affichee - est a la colonne centre
*/

void chapeauInverse(int centre, char c)
{
}

/*****************************************/

/*
  Affiche un losange de cote n.
*/

void losange(int n)
{
}

/*****************************************/

/*
  Affiche une croix de cote n
*/

void croix(int n)
{
}

/*****************************************/

main()
{
      int taille;
      printf("Saisissez la taille des figures\n");
      scanf("%d", &taille);
      carre(taille);
      losange(taille);
      croix(taille);
}

Télécharger le fichier

fichier source

2.6.2  Arithmétique

Exercice 1 chiffres et nombres

Rapellons que a \% b est le reste de la division entière de a par b.

  1. Ecrire la fonction int unites(int n) retournant le chiffre des unités du nombre n.
  2. Ecrire la fonction int dizaines(int n) retournant le chiffre des dizaines du nombre n.
  3. Ecrire la fonction int extrait(int n, int p) retourant le p-ème chiffre de représentation décimale de n en partant des unités.
  4. Ecrire la fonction int nbChiffres(int n) retournant le nombre de chiffres que comporte la représentation décimale de n.
  5. Ecrire la fonction int sommeChiffres(int n) retournant la somme des chiffres de n.

Exercice 2 Nombres amis

Soient a et b deux entiers strictement positifs. a est un diviseur strict de b si a divise b et a ≠ b. Par exemple, 3 est un diviseur strict de 6. Mais 6 n’est pas un diviseur strict 6. a et b sont des nombres amis si la somme des diviseurs stricts de a est b et si la somme des diviseurs de b est a. Le plus petit couple de nombres amis connu est 220 et 284.

  1. Ecrire une fonction int sommeDiviseursStricts(int n), elle doit renvoyer la somme des diviseurs stricts de n.
  2. Ecrire une fonction int sontAmis(int a, int b), elle doit renvoyer 1 si a et b sont amis, 0 sinon.

Exercice 3 Nombres parfaits

Un nombre parfait est un nombre égal à la somme de ses diviseurs stricts. Par exemple, 6 a pour diviseurs stricts 1, 2 et 3, comme 1 + 2 + 3 = 6, alors 6 est parfait.

  1. Est-ce que 18 est parfait ?
  2. Est-ce que 28 est parfait ?
  3. Que dire d’un nombre ami avec lui-même ?
  4. Ecrire la fonction int estParfait(int n), elle doit retourner 1 si n est un nombre parfait, 0 sinon.

Exercice 4 Nombres de Kaprekar

Un nombre n est un nombre de Kaprekar en base 10, si la représentation décimale de n2 peut être séparée en une partie gauche u et une partie droite v tel que u + v = n. 452 = 2025, comme 20 + 25 = 45, 45 est aussi un nombre de Kaprekar. 48792 = 23804641, comme 238 + 04641 = 4879 (le 0 de 046641 est inutile, je l’ai juste placé pour éviter toute confusion), alors 4879 est encore un nombre de Kaprekar.

  1. Est-ce que 9 est un nombre de Kaprekar ?
  2. Ecrire la fonction int sommeParties(int n, int p) qui découpe n est deux nombres dont le deuxième comporte p chiffres, et aui retourne leur somme. Par exemple,
    sommeParties(12540, 2) = 125 + 40 = 165
  3. Ecrire la fonction int estKaprekar(int n)

2.6.3  Passage de tableaux en paramètre

Exercice 5 Somme

Ecrire une fonction int somme(int T[], int n) retournant la somme des n éléments du tableau T.

Exercice 6 Minimum

Ecrire une fonction int min(int T[], int n) retournant la valeur du plus petit élément du tableau T.

Exercice 7 Recherche

Ecrire une fonction int existe(int T[], int n, int k) retournant 1 si k est un des n éléments du tableau T, 0 sinon.

Exercice 8 Somme des éléments pairs

Ecrivez le corps de la fonction int sommePairs(int T[], int n), sommePairs(T, n) retourne la somme des éléments pairs du tableau T à n éléments. N’oubliez pas que a%b est le reste de la division entière de a par b, et que vous êtes tenu d’utiliser au mieux les booléens.

Exercice 9 Vérification

Ecrivez le corps de la fonction int estTrie(int T[], int n), estTrie(T, n) retourne vrai si et seulement si le tableau T, à n éléments, est trié dans l’ordre croissant.

Exercice 10 Permutation circulaire

Ecrire une fonction void permutation(int T[], int n) effectuant une permutation circulaire vers la droite des éléments de T.

Exercice 11 Miroir

Ecrire une fonction void miroir(int T[], int n) inversant l’ordre des éléments de T.

2.6.4  Décomposition en facteurs premiers

On pose ici N = 25, vous utiliserez un \#define N 25 dans toute cette partie. On rappelle qu’un nombre est premier s’il n’est divisible que par 1 et par lui-même. Par convention, 1 n’est pas premier.

  1. Ecrivez une fonction int estPremier(int n, int T[], int k) retournant 1 si n est premier, 0 sinon. Vous vérifierez la primarité de n en examinant les restes des divisions de n par les k premiers éléments de T. On suppose que k est toujours supérieur ou égal à 1.

  2. Modifiez la fonction précédente en tenant compte du fait que si aucun diviseur premier de n inférieur à √n n’a été trouvé, alors n est premier

  3. Ecrivez une fonction void trouvePremiers(int T[], int n) plaçant dans le tableau T les n premiers nombres premiers.

  4. Ecrivez une fonction void décompose(int n, int T[], int K[]) plaçant dans le tableau K la décomposition en facteurs premiers du nombre n, sachant que T contient les N premiers nombres premiers. Par exemple, si n = 108108, alors on décompose n en produit de facteurs premiers de la sorte

    108108 = 2*2*3*3*3*7*11*13 = 22*33*50*71*111*131*170*190* … *Z0

    (où Z est le N-ième nombre premier). On représente donc n de façon unique par le tableau K à N éléments

    {2, 3, 0, 1, 1, 1, 0, 0, 0, …, 0}

  5. Ecrivez une fonction int recompose(int T[], int K[]) effectuant l’opération réciproque de celle décrite ci-dessus.

  6. Ecrivez une fonction void pgcd(int T[], int K[], int P[]) prenant en paramètre les décompositions en facteurs premiers T et K de deux nombres, et plaçant dans P la décomposition en facteurs premiers du plus grand commun diviseur de ces deux nombres.

  7. Ecrivez une fonction int pgcd(int i, int j) prenant en paramètres deux nombres i et j, et combinant les fonctions précédentes pour retourner le pgcd de i et j.

2.6.5  Statistiques

Nous souhaitons faire des statistiques sur les connexions des clients d’un site Web. Le tableau C, à n éléments, contient les identifiants des clients qui se sont connectés. Ainsi C[i] contient l’identifiant du i-ème client à s’être connecté, notez bien que si un client se connecte plusieurs fois, son identifiant apparaîtra plusieurs fois dans le tableau C. Le tableau D contient les durées de connexion. Ainsi D[i] est le temps de connexion de la i-ème connexion. Le but est de déterminer, pour chaque, client, son temps total de connexion.

  1. Ecrire le corps du sous-programme void decalageGauche(int T[], int a, int b), ce sous-programme décale la tranche

    T[a]T[a + 1] …T[b]


    d’une case vers la gauche.

  2. Ecrivez le corps de la fonction int calculeTempsTotalConnexionClient(int C[], int D[], int n, int i). calculeTempsTotalConnexionClient(C, D, n, i) retourne le temps total de connexion du client d’identifiant C[i], on suppose que i est l’indice de la première occurence de C[i] dans C.

  3. Ecrivez le corps de la fonction int supprimeDoublons(int C[], int D[], int n, int i). supprimeDoublons(C, D, n, i) supprime toutes les occurences (d’indices strictement supérieurs à i) du client d’identifiant C[i] dans C et D et retourne le nombre d’éléments supprimés. Vous devrez utiliser decalageGauche.

  4. Ecrivez le corps de la fonction int tempsTotalDeConnexion(int C[], int D[], int n, int i). tempsTotalDeConnexion(C, D, n,i) place dans D[i] le temps total de connexion du client C[i] et élimine de C et de D toutes les autres occurences de ce client. Cette fonction doit retourner le nombre d’éléments supprimés. Vous devrez utiliser calculeTempsTotalConnexionClient et supprimeDoublons.

  5. Ecrire le corps du sous-programme inttempsTotauxDeConnexion(int C[], int D[], int n). tempsTotauxDeConnexion(C, D, n) additionne les temps de connexions de chaque visiteur. Vous devrez modifier C et D de sorte que chaque client n’apparaîsse qu’une fois dans C et que D contienne pour chaque client son temps total. Cette fonction retourne le nombre d’éléments significatifs dans C et D. Vous devrez utiliser tempsTotalDeConnexion.

2.6.6  Chaînes de caractères

Exercice 12 affichage

Ecrivez une fonction void afficheChaine(char s[]) qui affiche la chaîne de caractère s sans utiliser de %s.

Exercice 13 longueur

Ecrivez une fonction int longueur(char s[]) qui retourne la longueur de la chaîne de caractère s sans utiliser strlen.

Exercice 14 extraction

Ecrivez une fonction char extrait(char s[], int n) qui retourne le n-ème caractère de s, vous considérerez que les indices commencent à 1.

Exercice 15 substitution

Ecrivez une fonction void subs(char s[], int n, char a) qui remplace le n-ème caractère de s par a, vous considérerez que les indices commencent à 1.

2.6.7  Programmation d’un Pendu

Cette section a pour but la programmation d’un pendu, vous êtes invités à utiliser les fonctions définies ci-dessus.

Exercice 16 initialisation

Ecrire une fonction void initialise(char t[], int n) qui place dans t n caractères '\_'.

Exercice 17 vérification

Ecrire une fonction void verifie(char t[], char k[], char c) qui recherche toutes les occurences du caractère c dans t, soit i l’indice d’une occurrence de c dans t, alors cette fonction remplace le i-ème caractère de k par c. Par exemple, si on invoque verifie(``bonjour", ``b\_\_j\_\_r", 'o'), alors k prendra la valeur "bo\_jo\_r''.

Exercice 18 Le jeu

Programmez un pendu, faites le plus simplement possible, et utilisez les fonctions ci-dessus..

2.6.8  Tris

Exercice 19 Tri à bulle

  1. Ecrivez le corps de la fonction void echange(int T[], int a, int b), echange(T, a, b) échange les éléments T[a] et T[b].
  2. Ecrivez le corps de la fonction void ordonne(int T[], int a, int b), ordonne(T, a, b) échange les éléments T[a] et T[b] si T[a] > T[b]. Vous utliserez le sous-programme echange.
  3. Ecrivez le corps de la fonction void bulle(int T[], int a, int b), bulle(T, a, b) place le plus grand élément de la tranche
    T[a]T[a + 1]…T[b]
    dans T[b]. Vous utiliserez le sous-programme ordonne.
  4. Ecrivez le corps de la fonction void triBulle(int T[], int n), triBulle(T, n) tri le tableau T à n éléments. Vous utiliserez le sous-programme bulle.

Exercice 20 Tri par sélection

  1. Implémentez la fonction int indiceDuMin(int T[], int i, int j) retournant l’indice du plus petit élément de T(i), ..., T(j), c’est-à-dire de tous les éléments du tableau dont l’indice est compris entre i et j.
  2. Implémentez le sous-programme void placeMin(int T[], int i, int j, int k) échangeant avec T(k) le plus petit élément de T dont l’indice est compris entre i et j.
  3. Le tri par sélection est une méthode consistant à rechercher dans un tableau T à n éléments le plus petit élément du tableau et à l’échanger avec le T(1). Puis à chercher dans T(2), …, T(N) le deuxième plus petit élément et à l’échanger avec T(2), etc. Une fois un tri par sélection achevé, les éléments du tableau doivent être disposés par ordre croissant. Ecrivez le sous-programme void triParSelection(int T[], int N).