TP Semaine 4 : Algorithmique avec Boucles

TP Semaine 4 : Algorithmique avec Boucles
Master GMA - FST Béni Mellal
⚠ TP NOTÉ - 10% de la note finale
Durée : 3 heures
Type : Évaluation
Mode : Travail individuel
Barème : 20 points
⚡ Instructions Importantes
•
•
•
•
•
Ce TP compte pour 10% de votre note finale
Travail strictement individuel
Testez votre code avec plusieurs valeurs
Commentez votre code pour expliquer votre raisonnement
Gérez les cas particuliers et les erreurs
📝 Questions/Clarifications (15 min)
Profitez de ce temps pour poser des questions sur :
•
•
•
La syntaxe des boucles
Les méthodes des listes
La logique des algorithmes
🎯 PARTIE 1 : Exercices Guidés (1h)
Ces exercices ont des étapes détaillées. Suivez les instructions.
Exercice 1 : Manipulation de Listes (15 min - 2 points)
Objectif : Créer et manipuler une liste avec les méthodes vues en cours.
Étapes :
1. Créer une liste initiale
o
liste = [1, 2, 3, 4, 5]
2. Ajouter des éléments
o Ajouter 6 à la fin (append)
o Ajouter 0 au début (insert)
3. Supprimer des éléments
o Supprimer le premier élément
o Afficher la liste
4. Inverser la liste
o Utiliser la méthode reverse()
o Afficher la liste inversée
5. Trier la liste
o Utiliser sort()
o Afficher la liste triée
Exemple de sortie :
Liste initiale : [1, 2, 3, 4, 5]
Après ajouts : [0, 1, 2, 3, 4, 5, 6]
Après suppression : [1, 2, 3, 4, 5, 6]
Liste inversée : [6, 5, 4, 3, 2, 1]
Liste triée : [1, 2, 3, 4, 5, 6]
Exercice 2 : Statistiques sur une Liste (20 min)
Objectif : Créer une liste de nombres et calculer des statistiques.
Étapes :
1. Créer une liste de 10 nombres
o Soit en saisissant les nombres un par un
o Soit en utilisant une liste prédéfinie
2. Calculer la somme
o Utiliser une boucle for
o Cumuler dans une variable somme
3. Calculer la moyenne
o Diviser la somme par le nombre d'éléments
4. Trouver le maximum et le minimum
o Parcourir la liste
o Comparer chaque élément
5. Compter les nombres pairs
o Tester avec % 2 == 0
o Compter dans une variable
6. Afficher tous les résultats
o Format clair et lisible
Exemple de sortie :
Liste : [12, 45, 7, 23, 56, 34, 89, 15, 67, 8]
Somme : 356
Moyenne : 35.6
Maximum : 89
Minimum : 7
Nombres pairs : 6
Exercice 2 : Nombres Premiers (25 min)
Objectif : Tester si des nombres sont premiers et lister tous les premiers jusqu'à N.
Principe : Un nombre n est premier si il n'est divisible que par 1 et lui-même.
Étapes :
1. Tester si un nombre est premier
o Demander un nombre n à l'utilisateur
o Logique du test :
§ Si n < 2 : pas premier
§ Tester tous les diviseurs de 2 à √n
§ Si n est divisible par au moins un diviseur : pas premier
§ Sinon : premier
o Afficher le résultat
2. Tester plusieurs nombres
o Tester avec : 2, 7, 15, 17, 20
o Afficher pour chacun s'il est premier ou non
3. Lister tous les premiers jusqu'à N
o N = 50
o Créer une liste vide premiers = []
o Pour chaque nombre de 2 à N :
§ Tester s'il est premier (avec la même logique)
§ Si oui : ajouter à la liste
o Afficher la liste complète
Exemple de sortie :
Test des nombres :
2 est premier
7 est premier
15 n'est pas premier
17 est premier
20 n'est pas premier
Nombres premiers jusqu'à 50 :
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
Total : 15 nombres premiers
🚀 PARTIE 2 : Exercices Semi-Ouverts (1h30 - 12 points)
Ces exercices sont notés. Vous avez la liberté sur l'implémentation.
Exercice 1 : Calculateur de Séries Mathématiques (35 min - 6 points)
Objectif : Calculer des sommes de séries avec précision configurable.
Fonctionnalités à implémenter :
1. Somme harmonique
o Formule : H(n) = 1 + 1/2 + 1/3 + ... + 1/n
o Demander n à l'utilisateur
o Calculer et afficher le résultat
2. Somme alternée
o Formule : S(n) = 1 - 1/2 + 1/3 - 1/4 + ... ± 1/n
o Demander n
o Calculer et afficher
3. Approximation de π (série de Leibniz)
o Formule : π/4 = 1 - 1/3 + 1/5 - 1/7 + ...
o Demander le nombre de termes
o Calculer π approximatif
o Afficher l'approximation et l'erreur par rapport à 3.14159
Contraintes :
•
•
•
Utiliser des boucles for
Afficher le nombre de termes utilisés
Formater les résultats avec 6 décimales
Exemple de sortie :
=== Calculateur de Séries ===
1. Somme harmonique
2. Somme alternée
3. Approximation de π
Votre choix : 3
Nombre de termes : 100000
π ≈ 3.141583 (100000 termes)
Erreur : 0.000010
Exercice 2 : Méthode de Dichotomie (35 min - 8 points)
Objectif : Trouver le zéro d'une fonction f(x) sur un intervalle [a, b] par dichotomie.
Principe de la méthode :
•
•
•
•
•
Si f(a) × f(b) < 0, il existe une racine dans [a, b]
On coupe l'intervalle en deux : c = (a + b) / 2
Si f(c) ≈ 0 : c est la solution
Sinon, on garde l'intervalle où f change de signe
On répète jusqu'à convergence
Fonctionnalités :
1. Définir la fonction
o Utiliser : f(x) = x³ - 2x - 5
o (Vous pouvez coder d'autres fonctions en bonus)
2. Demander les entrées
o Intervalle [a, b]
o Précision ε (ex: 0.000001)
3. Vérifier la condition
o f(a) × f(b) < 0
o Sinon, afficher une erreur
4. Algorithme de dichotomie
o Initialiser compteur d'itérations
o Tant que |b - a| > ε :
§ c = (a + b) / 2
§ Si |f(c)| < ε : solution trouvée
§ Sinon : remplacer a ou b
§ Incrémenter compteur
5. Afficher le résultat
o Solution approchée
o Nombre d'itérations
o Vérification : f(solution)
Exemple de sortie :
=== Méthode de Dichotomie ===
Fonction : f(x) = x³ - 2x - 5
Intervalle [a, b] :
a = 2
b = 3
Précision ε = 0.000001
Vérification : f(2) = -1.0, f(3) = 16.0
f(a) × f(b) < 0 ✓ Il existe une racine
Itération 1 : x = 2.5, f(x) = 5.625
Itération 2 : x = 2.25, f(x) = 1.890625
...
Itération 20 : x = 2.094551, f(x) = -0.000001
Solution trouvée : x ≈ 2.094551
Nombre d'itérations : 20
Vérification : f(2.094551) ≈ 0.000000
Contraintes :
•
•
•
Utiliser une boucle while
Limiter à 1000 itérations maximum (éviter boucle infinie)
Gérer le cas où f(a) × f(b) ≥ 0
Barème :
•
•
•
•
•
Fonction et vérification (1.5 pts)
Algorithme de dichotomie correct (3.5 pts)
Gestion des cas particuliers (1 pt)
Affichage et présentation (1 pt)
Compteur d'itérations (1 pt)
Exercice 3 : Triangle de Pascal (20 min - 6 points)
Objectif : Générer et afficher les n premières lignes du triangle de Pascal.
Principe :
Ligne 0 :
1
Ligne 1 :
1
1
Ligne 2 :
1
2
1
Ligne 3 :
1
3
3
1
Ligne 4 :
1
4
6
4
1
Ligne 5 : 1
5 10 10
5
1
Chaque nombre est la somme des deux au-dessus.
Contraintes :
•
•
•
Utiliser une liste de listes
Ne pas utiliser de formule directe (binomiale)
Construire ligne par ligne
Algorithme suggéré :
1. Créer triangle = [[1]] (première ligne)
2. Pour chaque ligne i de 1 à n-1 :
o
o
o
o
Créer ligne = [1]
Pour j de 1 à i-1 :
§ ligne.append(triangle[i-1][j-1] + triangle[i-1][j])
ligne.append(1)
triangle.append(ligne)
3. Afficher avec formatage
Exemple de sortie :
Triangle de Pascal (6 lignes) :
1
1
1
1
1
3
1
2
1
3
1
1
4
6
4
1
5 10 10
5
1
Exercices Bonus (facultatifs)
Si vous finissez en avance, essayez ces défis:
Bonus 1 : Racine carrée par Newton-Raphson
Implémenter la méthode de Newton-Raphson pour calculer √n.
Bonus 2 : Suite de Fibonacci optimisée
Calculer le n-ième terme de Fibonacci sans générer toute la liste.
Bon courage !