char convertirNote(int note); // Déclaration de la fonction

int main() { int note; char lettre;

while(scanf("%d", &note) != EOF) {
    lettre = convertirNote(note);  // Appel de la fonction
    printf("Note : %d, Lettre : %c\n\n", note, lettre);
}

return 0;

}

// Définition de la fonction char convertirNote(int note) { char resultat;

switch(note/10) {
case 10:
case 9:   resultat = 'A'; break;
case 8:   resultat = 'B'; break;
case 7:   resultat = 'C'; break;
case 6:   resultat = 'D'; break;
default:  resultat = 'E';
}

return resultat;

}

</div>**Question 1** : La fonction convertirNote transforme une note entière en une lettre correspondante (A, B, C, D, E). Le paramètre est de type int et la valeur de retour est de type char.

**Question 2** : Le code exécute toutes les instructions du switch jusqu'à la fin, il ne sort pas immédiatement après le cas correspondent.

### Exercice 2 : Somme des chiffres d'un nombre

<div>```
#include <stdio.h>

int sommeChiffres(int n);  // Déclaration de la fonction

int main() {
    int n;
    int resultat;

    while(printf("Entrez n : "), scanf("%d", &n) != EOF) {
        resultat = sommeChiffres(n);    // Appel de la fonction
        printf("n = %d, resultat = %d\n\n", n, resultat);
    }

    return 0;
}

// Définition de la fonction
int sommeChiffres(int n) {
    int somme = 0;

    while(n != 0) {
        somme += n % 10;
        n /= 10;
    }

    return somme;
}

Question 2 : Oui, l'algoirthme fonctionne. L'approche actuelle utilise une boucle pour extraire chaque chiffre. Une alternative récursive consisterait à séparer le chiffre des unités et de traiter le reste du nombre récursivement.

Exercice 3 : Calcul de puissance

int puissance(int base, int exposant); // Déclaration de la fonction

int main() { int base, exposant; int resultat;

while(printf("Entrez la base et l'exposant : "), scanf("%d%d", &base, &exposant) != EOF) {
    resultat = puissance(base, exposant);  // Appel de la fonction
    printf("%d^%d = %d\n\n", base, exposant, resultat);
}

return 0;

}

// Définition de la fonction int puissance(int base, int exposant) { int temp;

if(exposant == 0)
    return 1;
else if(exposant % 2)
    return base * puissance(base, exposant-1);
else {
    temp = puissance(base, exposant/2);
    return temp*temp;
}

}

</div>**Question 1** : Calcule la puissance d'un nombre (base^exposatn).

**Question 2** : Oui, l'algorithme utilise une méthode efficace de "exponentiation par carrés" pour réduire le nombre d'opérations.

### Exercice 4 : Nombres premiers jumeaux

<div>```
#include <stdio.h>
#include <stdlib.h>
int estPremier(int n);

int main(){
    int i,compteur=0;
    printf("Nombres premiers jumeaux inférieurs à 100 :\n");
    for(i=1;i<=100;++i){
        if (estPremier(i)){
            if (estPremier(i+2)){
                printf("%d %d\n",i,i+2);
                compteur+=1;
            }
        }
    }
    printf("Il y a %d paires de nombres premiers jumeaux sous 100\n",compteur);
    system("pause");
    return 0;
}

int estPremier(int n){
    int i,flag=1;
    if (n==1)
        flag=0;
    for(i=2;i<=n/2;++i){
        if (n%i==0){
            flag=0;
            break;
        }
    }
    return flag;
}

unsigned int n;
while(scanf("%u",&n)!=EOF){ 
    deplacements=0;
    hanoi(n,'A','B','C');
    printf("\n");
    printf("Total des déplacements : %d\n",deplacements);
}

return 0;

} void hanoi(unsigned int n,char depart,char intermediaire,char arrivee){

if(n==1)
deplacerDisque(n,depart,arrivee);
else{
    hanoi(n-1,depart,arrivee,intermediaire);
    deplacerDisque(n,depart,arrivee);
    hanoi(n-1,intermediaire,depart,arrivee);
}

} void deplacerDisque(unsigned int n,char depart,char arrivee){

printf("Déplacer le disque %u de %c vers %c\n",n,depart,arrivee);
deplacements++;

}

</div>### Exercice 6.1 : Calcul de combinaisons (itératif)

<div>```
#include <stdio.h>
#include <stdlib.h>
int combinaison(int n, int p);   // Déclaration de la fonction

int main() {
    int n, p;
    int resultat;

    while(scanf("%d%d", &n, &p) != EOF) {
        resultat = combinaison(n, p);   // Appel de la fonction
        printf("C(%d,%d) = %d\n\n", n, p, resultat);
    }
    system("pause");
    return 0;
}
int combinaison(int n, int p)
{
    int i,j,denominateur=1,numerateur=1;
    for(i=1;i<=p;i++)
        denominateur*=i;
    for(j=n-p+1;j<=n;j++)
        numerateur*=j;
    return numerateur/denominateur;
}

int main() { int n, p; int resultat;

while(scanf("%d%d", &n, &p) != EOF) {
    resultat = combinaison(n, p);   // Appel de la fonction
    printf("C(%d,%d) = %d\n\n", n, p, resultat);
}
system("pause");
return 0;

} int combinaison(int n, int p) { if(n==p) return 1; if(n<p) return 0; if(p==0) return 1; return combinaison(n-1,p)+combinaison(n-1,p-1); }

</div>### Exercice 7 : PGCD de trois nombres

<div>```
#include<stdio.h>

int pgcd(int a,int b,int c);

int main(){
    int a,b,c;
    int resultat;

    while(scanf("%d%d%d",&a,&b,&c)!=EOF){
        resultat=pgcd(a,b,c);
        printf("PGCD : %d\n\n",resultat);
    }

    return 0;
}

int pgcd(int a, int b, int c) {
    int i = a;
    if (i > b)
        i = b;
    if (i > c)
        i = c;
    for (i; i >= 1; --i) {
        if (a % i == 0 && b % i == 0 && c % i == 0)
            return i;

    }return 1;
}