Séance 3 : Structures itératives (Pour, Tant que, Répéter...Jusqu'à) & TDO

Phase {{ currentPhase === 'all' ? 'Toutes' : currentPhase + ' / ' + phases.length }}

Phase active :

{{ currentPhase === 'all' ? 'Vue complète (Toutes les phases affichées)' : phases[currentPhase - 1].title }}

Étape 1

Situation & Simulateur interactif (Analyse d'un nombre)

15 minutes

Énoncé de la situation-problème : Analyse arithmétique

Dans le cadre de l'étude des nombres entiers (exploitées notamment en cryptographie), on souhaite concevoir un programme automatisé d'analyse d'un entier positif N.

Ce programme doit réaliser les trois opérations suivantes :

Contrôle de saisie sécurisé : Saisir un entier N strictement compris entre 2 et 100 (2 < N < 100).
Recherche des diviseurs stricts & test du nombre parfait : Calculer la somme de tous les diviseurs stricts de N (tous les entiers i de 1 à N div 2 qui divisent N). Un nombre est dit parfait s'il est égal à la somme de ses diviseurs stricts (exemples : 6 car 1 + 2 + 3 = 6 et 28 car 1 + 2 + 4 + 7 + 14 = 28).
Divisions successives par 2 (Réduction binaire) : Compter le nombre de divisions entières successives par 2 que le nombre N puisse subir.

Laboratoire d'Arithmétique et Théorie des Nombres - Analyse d'un nombre et boucles

Laboratoire d'Arithmétique : Analyse de N & Boucles

Travail demandé : Écrire l'algorithme (puis le programme Python correspondant) intitulé AnalyseNombre qui réalise la saisie contrôlée de N, détermine si N est un nombre parfait et calcule le nombre de divisions entières successives par 2.

Boucle 1

Contrôle de saisie

Boucle : Répéter / Jusqu'à

Répéter
  ... 
Jusqu'à (2 < n < 100)

Au moins une saisie avant de tester la condition d'arrêt.

Boucle 2

Somme des diviseurs

Boucle : Pour ... Faire / Fin Pour

Pour i de 1 à n div 2 Faire
  ...
Fin Pour

Exactement n div 2 itérations connues d'avance.

Boucle 3

Divisions par 2

Boucle : Tant Que ... Faire / Fin Tant Que

Tant Que (temp Mod 2 = 0) Faire
  ...
Fin Tant Que

Condition de continuation évaluée avant chaque division.

Démonstration Interactive : Décomposition des 3 Boucles

Cas d'école :

Saisir la valeur de N :

n =

≤ 2 (rejeté) 2 < N < 100 (conforme) ≥ 100 (rejeté)

Contrôle de conformité de saisie :

Boucle 2 (Pour) : Diviseurs stricts de 1 à {{ Math.floor(nVal / 2) }}

{{ d }} Aucun diviseur strict.

Somme des diviseurs stricts :

{{ divisorsList.join(' + ') || '0' }} = {{ sommeDiv }}

{{ isPerfect ? `${nVal} est un nombre parfait.` : `${nVal} n'est pas un nombre parfait.` }}

{{ isPerfect ? (sommeDiv + ' == ' + nVal + ' -> est_parfait = True') : (sommeDiv + ' ≠ ' + nVal + ' -> est_parfait = False') }}

Boucle 3 (Tant que) : Divisions successives par 2 (temp // 2)

{{ nVal }} temp initial

Dernière valeur impaire : {{ lastOddNumber }}

Nombre total de divisions (nb_div2) : {{ nbDiv2 }}

{{ nVal }} supporte {{ nbDiv2 }} divisions par 2, l'entier impair retrouvé est {{ lastOddNumber }}.

Sortie console Python (Terminal)

Questions orales :

Algo :

Python :

Étape 2

Structures itératives & Normes officielles

15 minutes

Structure	Algorithmique (Norme)	Python (Conventions 2024-2025)
Boucle complète Nombre d'itérations connu à l'avance	`Pour i de D à F [Pas = p] Faire Traitement Fin Pour`	`for i in range(D, F + 1, p): Traitement` Borne F+1 exclue en Python
Boucle préalable Test avant d'entrer (0 à N fois)	`Tant que Condition Faire Traitement Fin Tant que`	`while Condition: Traitement` Condition de maintien (True)
Boucle post-test Exécutée au moins une fois (≥ 1)	`Répéter Traitement Jusqu'à Condition`	`while not (Condition): Traitement` Négation de la condition d'arrêt

Consignes officielles :

Interdiction absolue du break : La sortie anticipée d'une boucle par break est strictement prohibée.
Intégrité du compteur Pour : La variable de contrôle ne doit jamais être modifiée manuellement dans le bloc.
Division entière : Utiliser exclusivement l'opérateur euclidien // pour préserver le type int.

Pas négatif dans range

Pour décrémenter, la borne finale passée à range doit être F - 1.

# Décompte décroissant de 10 à 0
for i in range(10, -1, -2):
    print(i)

Inversion de condition

Jusqu'à indique l'arrêt. En Python, while évalue le maintien.

# Répéter ... Jusqu'à (n > 2)
n = int(input("N = "))
while not (n > 2):  # ou while n <= 2:
    n = int(input("N = "))

Prévention de boucle infinie

La variable de condition doit impérativement évoluer vers l'arrêt à chaque tour.

while temp % 2 == 0:
    temp = temp // 2  # Vers l'arrêt
    nb_div2 = nb_div2 + 1

Étape 3

Bilan & Auto-évaluation (Questions flash & Quiz)

15 minutes

Questions Flash de clôture :

Question didactique

Afficher la réponse

Algo : {{ f.resAlgo }}

Quiz d'auto-évaluation

Testez vos compétences sur les boucles Pour, Tant que, Répéter et leur implémentation sans break.

Score : {{ quizScore }} / {{ quizQuestions.length }}

Q{{ idx + 1 }}. {{ q.question }}

Explication : {{ q.explanation }}

Séance 3 terminée !

Entraînez-vous sur les séries d'exercices itératifs pour consolider vos acquis.

Série 3 (15 exercices) Série 4 (5 exercices)