📚 Devoir de Synthèse N°1

Lycée Mahmoud Megdich - Année 2024/2025 - Classe: 2ème Sc 2

✍️ Corrigé par Mr Mesfar Sami - Enseignant d'Informatique - 📞 93725135

📝 Exercice 1 : QCM et Algorithmes (3 points)

Question 1 : QCM

a) Génération de nombre aléatoire :

L'instruction algorithmique permettant de choisir au hasard dans une variable N un entier positif dont le nombre de chiffres est compris entre 3 et 8 est :

  • ☐ N ← aléa(3,8)
  • ☐ N ← aléa(999, 99999999)
  • ☑ N ← aléa(100, 99999999)

b) Extraire l'unité :

L'instruction algorithmique permettant d'obtenir dans une variable U, l'unité de la variable N est :

  • ☐ U ← N div 10
  • ☑ U ← N mod 10
  • ☐ U ← N div 10 mod 10

c) Supprimer l'unité :

L'instruction algorithmique permettant de supprimer de la variable N son chiffre d'unité est :

  • ☑ N ← N div 10
  • ☐ N ← N mod 10
  • ☐ N ← N mod 10 div 10

Question 2 : Algorithme du k-ème chiffre

Écrire une séquence algorithmique permettant de déterminer dans une variable C, le kème chiffre dans N à partir de la droite.

Exemple : Pour N = 452387 et k = 4 ; on obtient C = 2
  • 1er chiffre à droite : 7
  • 2ème chiffre à droite : 8
  • 3ème chiffre à droite : 3
  • 4ème chiffre à droite : 2 ✓

✅ Solution 1 : QCM et Algorithmes

🔍 Explications des réponses du QCM :

a) Bonne réponse : N ← aléa(100, 99999999)

  • Pour avoir un nombre de 3 chiffres minimum : commence à 100
  • Pour avoir un nombre de 8 chiffres maximum : termine à 99999999
  • aléa(3,8) donnerait seulement un nombre entre 3 et 8 ❌
  • aléa(999, 99999999) donnerait un nombre de 3 à 8 chiffres mais commence à 999 ❌

b) Bonne réponse : U ← N mod 10

  • Le modulo 10 donne le reste de la division par 10
  • Le reste = dernier chiffre (unité)
  • Exemple : 452387 mod 10 = 7

c) Bonne réponse : N ← N div 10

  • La division entière par 10 supprime le dernier chiffre
  • Exemple : 452387 div 10 = 45238

📋 Solution Question 2 : Algorithme du k-ème chiffre

// Séquence pour trouver le k-ème chiffre à partir de la droite
Pour i ← 1 à k Faire
C ← N mod 10
N ← N div 10
FinPour

💡 Explication de l'algorithme :

  1. On répète k fois l'extraction du dernier chiffre
  2. C ← N mod 10 : On récupère le dernier chiffre
  3. N ← N div 10 : On supprime le dernier chiffre
  4. Après k itérations, C contient le k-ème chiffre

📊 Exemple d'exécution (N=452387, k=4) :

i N (avant) C = N mod 10 N (après div 10)
1 452387 7 45238
2 45238 8 4523
3 4523 3 452
4 452 2 ✓ 45

📝 Exercice 2 : Multiplication par additions (3 points)

🎯 Objectif :

Écrire l'algorithme du programme permettant de calculer le produit de deux entiers positifs A et B en utilisant des additions successives.

Principe :

A * B = A + A + A + A + ... + A (B fois)

Exemple : Pour A = 5 et B = 7

5 * 7 = 5 + 5 + 5 + 5 + 5 + 5 + 5 = 35

Affichage attendu : 5 * 7 = 35

📋 À compléter :

Algorithme Multiplication
Début
Ecrire("Donner un entier positif A :")
Lire(A)
...........................
...........................
S ← 0
...........................
...........................
...........................
Ecrire(..............................)
Fin

✅ Solution 2 : Multiplication par additions

📋 Algorithme complet :

Algorithme Multiplication
Début
Ecrire("Donner un entier positif A :")
Lire(A)
Ecrire("Donner un entier positif B :")
Lire(B)
S ← 0
Pour i ← 1 à B Faire
S ← S + A
FinPour
Ecrire(A, " * ", B, " = ", S)
Fin

📊 Tableau de Déclaration des Objets (TDO) :

Nom Type Nature Rôle
A Entier Variable Premier nombre (multiplicande)
B Entier Variable Deuxième nombre (multiplicateur)
S Entier Variable Somme / Résultat de la multiplication
i Entier Variable Compteur de boucle

💡 Explication de l'algorithme :

  1. On lit les deux nombres A et B
  2. On initialise la somme S à 0
  3. On répète B fois : S ← S + A
  4. On affiche le résultat sous la forme "A * B = S"

📊 Exemple d'exécution (A=5, B=7) :

i S (avant) S ← S + A S (après)
100 + 55
255 + 510
31010 + 515
41515 + 520
52020 + 525
62525 + 530
73030 + 535

🐍 Code Python :

A = int(input("Donner un entier positif A : "))
B = int(input("Donner un entier positif B : "))
S = 0
for i in range(1, B+1):
S = S + A
print(A, " * ", B, " = ", S)

📝 Exercice 3 : Analyse d'algorithme (3 points)

Séquence algorithmique donnée :

C ← N
Pour i de 1 à N Faire
Si N mod i ≠ 0 Alors
C ← C - 1
FinSi
FinPour

Questions :

  1. Exécuter manuellement cette séquence pour N = 12
  2. En déduire le rôle de cette séquence
  3. Écrire une séquence algorithmique équivalente donnant le même résultat

Tableau d'exécution à compléter :

N 12
i
C

✅ Solution 3 : Analyse d'algorithme

1️⃣ Exécution manuelle pour N = 12 :

N 12
i Init123456 789101112
12 mod i -000020 543210
C 12121212121111 1098766

Résultat final : C = 6

🐍 Code Python pour tester :

# Solution Exercice 1 - Question 2
# Trouver le k-ème chiffre à partir de la droite
N = int(input("Entrez N : "))
k = int(input("Entrez k : "))
for i in range(1, k+1):
C = N % 10
N = N // 10
print(f"Le {k}-ème chiffre est : {C}")

2️⃣ Rôle de cette séquence :

Cette séquence calcule le nombre de diviseurs de N.

  • On commence avec C = N (12)
  • Pour chaque i de 1 à N, si i ne divise pas N, on décrémente C
  • Les diviseurs de 12 sont : 1, 2, 3, 4, 6, 12 → 6 diviseurs
  • C = N - (nombre de non-diviseurs) = nombre de diviseurs

3️⃣ Séquence algorithmique équivalente :

// Méthode directe : compter les diviseurs
C ← 0
Pour i de 1 à N Faire
Si N mod i = 0 Alors
C ← C + 1
FinSi
FinPour

Différence : Au lieu de décrémenter pour chaque non-diviseur, on incrémente pour chaque diviseur.

🐍 Code Python pour tester :

# Solution Exercice 3 - Compter les diviseurs
N = int(input("Entrez N : "))
C = 0
for i in range(1, N+1):
if N % i == 0:
C = C + 1
print(f"Nombre de diviseurs de {N} : {C}")

📝 Exercice 4 : Nombres Parfaits (4 points)

🎯 Définition :

Un nombre parfait est un nombre égal à la somme de ses diviseurs propres (diviseurs autres que lui-même).

Exemples :
  • 6 est parfait : diviseurs propres = {1, 2, 3} → 1+2+3 = 6 ✓
  • 28 est parfait : diviseurs propres = {1, 2, 4, 7, 14} → 1+2+4+7+14 = 28 ✓
  • 496 est parfait
  • 8128 est parfait

📋 Travail demandé :

Écrire un algorithme qui permet de :

  • Saisir un entier strictement positif N
  • Vérifier s'il est parfait ou non
  • Afficher le résultat
Affichages attendus :
  • Pour N = 28 : "28 est un nombre parfait"
  • Pour N = 10 : "10 n'est pas un nombre parfait"

✅ Solution 4 : Nombres Parfaits

📋 Algorithme complet :

Algorithme NombreParfait
Début
// Saisie du nombre
Ecrire("Donner un entier positif N :")
Lire(N)
// Calcul de la somme des diviseurs propres
somme ← 0
Pour i de 1 à N-1 Faire
Si N mod i = 0 Alors
somme ← somme + i
FinSi
FinPour
// Vérification et affichage
Si somme = N Alors
Ecrire(N, " est un nombre parfait")
Sinon
Ecrire(N, " n'est pas un nombre parfait")
FinSi
Fin

💡 Explication de l'algorithme :

  1. On saisit le nombre N
  2. On initialise la somme à 0
  3. On parcourt tous les nombres de 1 à N-1 (diviseurs propres)
  4. Si i divise N, on l'ajoute à la somme
  5. Si la somme égale N, le nombre est parfait

📊 Exemple d'exécution pour N = 28 :

i 28 mod i Diviseur ? somme
10✓1
20✓3
31✗3
40✓7
53✗7
64✗7
70✓14
............
140✓28

somme = 28 = N → 28 est un nombre parfait ✓

🐍 Code Python :

N = int(input("Donner un entier positif N : "))
somme = 0
for i in range(1, N):
if N % i == 0:
somme = somme + i
if somme == N:
print(N, "est un nombre parfait")
else:
print(N, "n'est pas un nombre parfait")

📝 Exercice 5 : Programme d'entraînement (7 points)

🎯 Objectif :

Créer un programme d'entraînement aux opérations (addition et multiplication) pour des élèves de première année primaire.

📋 Consignes :

  • Générer 20 opérations : 10 additions et 10 multiplications
  • Les opérations sont affichées par alternance (addition, multiplication, addition...)
  • Tirer au hasard deux nombres X et Y entre 2 et 9
  • L'utilisateur saisit sa réponse
  • Afficher "Réponse valide" ou "Réponse invalide"
  • Compter les bonnes réponses pour chaque type d'opération
  • Afficher les scores finaux

Exemple d'exécution :

N° opération Opération affichée Réponse saisie Message
1 3+5 = ? 8 Réponse valide
2 4*7 = ? 18 Réponse invalide
3 2+8 = ? 10 Réponse valide
4 2*6 = ? 12 Réponse valide
... (jusqu'à 20 opérations)

⚠️ Points importants :

  • La première opération est une addition
  • Alterner : addition (impair), multiplication (pair)
  • Nombres aléatoires entre 2 et 9
  • Deux scores distincts : score_addition et score_multiplication

✅ Solution 5 : Programme d'entraînement

📋 Algorithme complet :

Algorithme EntrainementOperations
Début
// Initialisation des scores
score_addition ← 0
score_multiplication ← 0
// Boucle pour 20 opérations
Pour i de 1 à 20 Faire
// Générer deux nombres aléatoires
X ← alea(2, 9)
Y ← alea(2, 9)
// Vérifier si c'est une addition ou multiplication
Si i mod 2 = 1 Alors // Opération impaire = addition
Ecrire(X, "+", Y, " = ?")
Lire(rep)
Si rep = X + Y Alors
Ecrire("Réponse valide")
score_addition ← score_addition + 1
Sinon
Ecrire("Réponse invalide")
FinSi
Sinon // Opération paire = multiplication
Ecrire(X, "*", Y, " = ?")
Lire(rep)
Si rep = X * Y Alors
Ecrire("Réponse valide")
score_multiplication ← score_multiplication + 1
Sinon
Ecrire("Réponse invalide")
FinSi
FinSi
FinPour
// Affichage des résultats finaux
Ecrire("Score additions : ", score_addition, " / 10")
Ecrire("Score multiplications : ", score_multiplication, " / 10")
Fin

💡 Explication de l'algorithme :

  1. Initialiser deux scores à 0 (un pour chaque opération)
  2. Pour chaque opération de 1 à 20 :
    • Générer X et Y entre 2 et 9
    • Si i est impair (i mod 2 = 1) → addition
    • Si i est pair (i mod 2 = 0) → multiplication
    • Vérifier la réponse et incrémenter le score correspondant
  3. Afficher les deux scores finaux

🔑 Points clés :

  • i mod 2 = 1 : opérations 1, 3, 5, ... (additions)
  • i mod 2 = 0 : opérations 2, 4, 6, ... (multiplications)
  • Deux variables de score distinctes
  • Vérification différente selon le type d'opération

🐍 Code Python :

import random
score_addition = 0
score_multiplication = 0
for i in range(1, 21):
X = random.randint(2, 9)
Y = random.randint(2, 9)
if i % 2 == 1: # Addition
rep = int(input(f"{X}+{Y} = ? "))
if rep == X + Y:
print("Réponse valide")
score_addition = score_addition + 1
else:
print("Réponse invalide")
else: # Multiplication
rep = int(input(f"{X}*{Y} = ? "))
if rep == X * Y:
print("Réponse valide")
score_multiplication = score_multiplication + 1
else:
print("Réponse invalide")
print(f"Score additions : {score_addition} / 10")
print(f"Score multiplications : {score_multiplication} / 10")

📊 Tableau de Déclaration des Objets (TDO) :

Nom Type Rôle
score_addition Entier Nombre de bonnes réponses en addition
score_multiplication Entier Nombre de bonnes réponses en multiplication
i Entier Compteur d'opérations (1 à 20)
X, Y Entier Nombres aléatoires (2 à 9)
rep Entier Réponse de l'utilisateur