Exercices : Algorithmes fondamentaux
Cette série d'exercices introduit les concepts de base de la programmation : tests de primalité, calcul de factorielle, moyenne de notes et saisie contrôlée avec validation.
Test de primalité
Écrire un programme qui permet de saisir un entier N et d'afficher s'il est premier ou non. Un nombre est dit premier s'il est divisible uniquement par 1 et par lui-même.
Pour tester si un nombre N est premier, il suffit de tester les diviseurs jusqu'à √N. En effet, si N a un diviseur plus grand que √N, alors il a aussi un diviseur plus petit que √N.
#include <stdio.h>
#include <math.h>
int main(void)
{
int N, vfin;
int etat;
printf("saisir un nombre - ");
scanf("%d", &N);
etat = 1; // 1 True ; 0 False
vfin = (int)sqrt(N) + 1;
for (int i = 2; i < vfin; i++)
{
if (N % i == 0) // si N est divisible par i
{
etat = 0;
break;
}
}
if (etat == 1)
{
printf("%d est un nombre premier\n", N);
}
else
{
printf("%d n'est pas premier\n", N);
}
return 0;
}from math import sqrt, ceil
def est_premier(n):
"""Test de primalité optimisé."""
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(3, ceil(sqrt(n)) + 1, 2):
if n % i == 0:
return False
return True
N = int(input("saisir un nombre - "))
if est_premier(N):
print(N, "est un nombre premier")
else:
print(N, "n'est pas premier")saisir un nombre - 7 7 est un nombre premier saisir un nombre - 12 12 n'est pas premier
7
7 est un nombre premier
Calcul de factorielle
Écrire un programme permettant de lire un nombre entier N puis calcule sa factorielle.
- N! = 1 × 2 × 3 × ... × (N-1) × N
- 0! = 1
En utilisant les boucles suivantes :
- while
- for
// Boucle for
#include <stdio.h>
int main(void)
{
int N, fact;
printf("saisir un nombre - ");
scanf("%d", &N);
fact = 1;
for (int i = 2; i <= N; i++)
{
fact *= i;
}
printf("le factoriel de %d est %d\n", N, fact);
return 0;
}// Boucle while
#include <stdio.h>
int main(void)
{
int N, i, fact;
printf("saisir un nombre - ");
scanf("%d", &N);
fact = 1;
i = 2;
while (i <= N)
{
fact *= i;
i++;
}
printf("le factoriel de %d est %d\n", N, fact);
return 0;
}def factorielle_for(n):
"""Factorielle avec boucle for."""
f = 1
for i in range(2, n + 1):
f *= i
return f
def factorielle_while(n):
"""Factorielle avec boucle while."""
f = 1
i = 2
while i <= n:
f *= i
i += 1
return f
def factorielle_recursive(n):
"""Factorielle récursive."""
if n <= 1:
return 1
return n * factorielle_recursive(n - 1)
# Tests
n = int(input("saisir un nombre - "))
print(f"Factorielle (for) de {n} = {factorielle_for(n)}")
print(f"Factorielle (while) de {n} = {factorielle_while(n)}")
print(f"Factorielle (récursive) de {n} = {factorielle_recursive(n)}")saisir un nombre - 5 le factoriel de 5 est 120 Factorielle (for) de 5 = 120 Factorielle (while) de 5 = 120 Factorielle (récursive) de 5 = 120
Moyenne de notes (nombre inconnu)
Écrire un programme qui permet de calculer la moyenne de notes fournies au clavier avec un dialogue de ce type :
Note 1 : 12 Note 2 : 15.25 Note 3 : 13.5 Note 4 : 8.75 Note 5 : -1 moyenne de ces 4 notes : 12.37
Le nombre des notes n'est pas connu a priori et l'utilisateur peut en fournir autant qu'il le désire. Pour signaler qu'il a terminé, on convient qu'il fournira une note fictive négative. Celle-ci ne devra naturellement pas être prise en compte dans le calcul de la moyenne.
#include <stdio.h>
int main(void)
{
int nb = 0;
float somme = 0, note;
printf("Note 1 : ");
scanf("%f", ¬e);
while (note >= 0)
{
nb++;
somme += note;
printf("Note %d : ", nb + 1);
scanf("%f", ¬e);
}
if (nb > 0)
{
printf("moyenne de ces %d notes : %f\n", nb, somme / nb);
}
else
{
printf("Aucune note valide saisie\n");
}
return 0;
}def calculer_moyenne():
"""
Calcule la moyenne d'une série de notes.
La saisie s'arrête quand l'utilisateur entre une note négative.
"""
notes = []
i = 1
while True:
try:
note = float(input(f"Note {i} : "))
if note < 0:
break
notes.append(note)
i += 1
except ValueError:
print("Veuillez saisir un nombre valide")
if notes:
moyenne = sum(notes) / len(notes)
print(f"moyenne de ces {len(notes)} notes : {moyenne:.2f}")
else:
print("Aucune note valide saisie")
# Version avec compteur explicite
def calculer_moyenne_compteur():
"""Version alternative avec compteur."""
somme = 0
nb = 0
i = 1
while True:
try:
note = float(input(f"Note {i} : "))
if note < 0:
break
somme += note
nb += 1
i += 1
except ValueError:
print("Veuillez saisir un nombre valide")
if nb > 0:
print(f"moyenne de ces {nb} notes : {somme / nb:.2f}")
else:
print("Aucune note valide saisie")
# Test
calculer_moyenne()Note 1 : 12 Note 2 : 15.25 Note 3 : 13.5 Note 4 : 8.75 Note 5 : -1 moyenne de ces 4 notes : 12.38
12, 15.25, 13.5, 8.75, -1
moyenne de ces 4 notes : 12.38
Saisie contrôlée simple
Écrire un programme qui demande à l'utilisateur un nombre compris entre 1 et 3 jusqu'à ce que la réponse convienne.
#include <stdio.h>
int main(void)
{
int Nb;
printf("Saisir un nombre (entre 1 et 3) - ");
scanf("%d", &Nb);
while (Nb < 1 || Nb > 3)
{
printf("Erreur : le nombre doit être entre 1 et 3\n");
printf("Saisir un nombre - ");
scanf("%d", &Nb);
}
printf("Bravo ! Vous avez saisi %d\n", Nb);
return 0;
}def saisie_controlee(min_val=1, max_val=3):
"""
Demande à l'utilisateur un nombre entre min_val et max_val.
Continue jusqu'à ce que la saisie soit valide.
"""
while True:
try:
nb = int(input(f"Saisir un nombre entre {min_val} et {max_val} : "))
if min_val <= nb <= max_val:
print(f"Bravo ! Vous avez saisi {nb}")
return nb
else:
print(f"Erreur : le nombre doit être entre {min_val} et {max_val}")
except ValueError:
print("Veuillez saisir un nombre entier valide")
# Test
saisie_controlee()Saisir un nombre (entre 1 et 3) - 5 Erreur : le nombre doit être entre 1 et 3 Saisir un nombre - 2 Bravo ! Vous avez saisi 2
Saisie contrôlée avec indices
Écrire un programme qui demande un nombre compris entre 10 et 20, jusqu'à ce que la réponse convienne. En cas de réponse supérieure à 20, on fera apparaître un message : "Plus petit !", et inversement, "Plus grand !" si le nombre est inférieur à 10.
#include <stdio.h>
int main(void)
{
int Nb;
printf("Saisir un nombre (entre 10 et 20) - ");
scanf("%d", &Nb);
while (Nb < 10 || Nb > 20)
{
if (Nb < 10)
printf("Plus grand ! ");
else
printf("Plus petit ! ");
printf("- Saisir un nombre - ");
scanf("%d", &Nb);
}
printf("Bravo !\n");
return 0;
}def jeu_devine():
"""
Jeu de devinette : l'utilisateur doit trouver un nombre entre 10 et 20.
Des indices "Plus grand" ou "Plus petit" sont donnés.
"""
while True:
try:
nb = int(input("Saisir un nombre entre 10 et 20 : "))
if 10 <= nb <= 20:
print("Bravo !")
return nb
elif nb < 10:
print("Plus grand !")
else: # nb > 20
print("Plus petit !")
except ValueError:
print("Veuillez saisir un nombre entier valide")
# Version avec nombre mystère (version jeu)
def jeu_mystere():
"""
Version jeu : l'ordinateur choisit un nombre aléatoire
et l'utilisateur doit le trouver.
"""
import random
mystere = random.randint(10, 20)
essais = 0
print("Je pense à un nombre entre 10 et 20...")
while True:
try:
nb = int(input("Votre proposition : "))
essais += 1
if nb == mystere:
print(f"Bravo ! Vous avez trouvé en {essais} essai(s).")
return
elif nb < mystere:
print("Plus grand !")
else:
print("Plus petit !")
except ValueError:
print("Veuillez saisir un nombre entier valide")
# Test
jeu_devine()Saisir un nombre (entre 10 et 20) - 5 Plus grand ! - Saisir un nombre - 25 Plus petit ! - Saisir un nombre - 15 Bravo !
5, 25, 15
Plus grand ! - Plus petit ! - Bravo !
Récapitulatif
| Exercice | Fonctionnalité | Concepts clés |
|---|---|---|
| 1 - Test de primalité | Vérifier si un nombre est premier | Boucle, condition, optimisation √n |
| 2 - Factorielle | Calculer N! = 1×2×...×N | Boucle for, boucle while, récursivité |
| 3 - Moyenne de notes | Calculer la moyenne d'un nombre inconnu de notes | Saisie avec sentinelle, accumulation |
| 4 - Saisie contrôlée | Valider une saisie dans un intervalle | Boucle while, validation |
| 5 - Saisie avec indices | Donner des indices "plus grand/plus petit" | Conditions multiples, interaction utilisateur |
- La validation des saisies est essentielle pour des programmes robustes.
- Les boucles while sont parfaites pour les saisies répétées jusqu'à condition.
- L'optimisation du test de primalité utilise la propriété mathématique √n.
- La sentinelle (valeur négative) permet de gérer un nombre inconnu de données.
- Un même problème peut être résolu avec différentes structures de boucle.
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.