Série de Rentrée N°0 · Révision & Évaluation diagnostique

PHASE A — Diagnostic à froid

Lire, prédire et raisonner avant toute réactivation explicite · 3 exercices · 20 min · Travail sans machine

Exercice 1 — Lire un problème avant de coder

Score interactif : {{ scoreEx1Total }} / 4 pts 4 pts · 6 min

Mise en situation :

Lors d'une expérience de mouvement, on relève une distance $d$ (en mètres) et une durée $t$ (en secondes), avec $t > 0$. On veut calculer puis afficher la vitesse moyenne $v = d / t$.

Q1 1. Indiquer le but du problème en une phrase :

{{ qcmEx1[0].selected === qcmEx1[0].correct ? '+1 pt' : '0 pt' }}

{{ qcmEx1[0].selected === qcmEx1[0].correct ? 'Exact !' : 'Incorrect.' }}

Q2 2. Compléter l'analyse : entrées = … ; sortie = … ; contrainte = …

{{ qcmEx1[1].selected === qcmEx1[1].correct ? '+1 pt' : '0 pt' }}

{{ qcmEx1[1].selected === qcmEx1[1].correct ? 'Exact !' : 'Incorrect.' }}

Q3 3. Proposer le type algorithmique de $d$, $t$ et $v$, puis compléter les trois exemples supplémentaires :

Types validés : {{ scoreTypesEx1 }} / {{ typesEx1Rows.length }}

Sélectionnez le type algorithmique approprié dans la liste déroulante pour chaque élément du tableau :

Objet / information	Exemple	Type (proposer dans la liste)
		Type incorrect pour cet objet. Essayez un autre type de la liste.

Q4 4. Ordonner les quatre actions principales de la solution algorithmique :

{{ isActionsEx1Correct ? 'Ordre exact (+1 pt)' : 'Ordre incorrect (0 pt)' }} {{ slotsEx1FilledCount }} / 4 étapes placées

Glissez et déposez chaque action disponible dans son emplacement chronologique approprié (Étape 1 à Étape 4). Vous pouvez également glisser une action d'une étape à une autre pour intervertir, ou cliquer sur une action pour la placer directement.

Banque d'actions disponibles à ordonner : {{ poolActionsEx1.length }}

{{ poolActionsEx1.length > 0 ? 'Glisser vers une étape ci-dessous (ou cliquer)' : 'Toutes les actions sont placées' }}

Placer

Toutes les actions ont été placées dans les étapes ci-dessous. Cliquez sur Vérifier pour valider l'ordre logique.

Démarche algorithmique ordonnée : {{ slotsEx1FilledCount }} / 4 étapes remplies

{{ slotsEx1FilledCount === 4 ? 'Prêt pour validation' : 'Déposez les 4 actions dans l\'ordre chronologique' }}

Étape {{ slotIdx + 1 }}

{{ slotIdx === 0 ? '1ère action' : slotIdx === 1 ? '2ème action' : slotIdx === 2 ? '3ème action' : '4ème action' }}

Déposer l'action de l'Étape {{ slotIdx + 1 }} ici

Bien placé Mal placé

{{ isActionsEx1Correct ? 'Bravo ! La démarche algorithmique est parfaitement ordonnée.' : 'Attention à l\'enchaînement logique :' }}

Un algorithme respecte le triptyque fondamental : 1. Entrées (acquisition de la distance d et de la durée t > 0) → 2. Traitement (calcul de la vitesse moyenne v ← d / t) → 3. Sortie (affichage du résultat final v).

Ordre chronologique standard :

Étape 1 : Saisir la distance d (en mètres, avec d ≥ 0).
Étape 2 : Saisir la durée t (en secondes, avec t > 0).
Étape 3 : Calculer la vitesse moyenne : v ← d / t.
Étape 4 : Afficher la vitesse moyenne calculée v.

Note : La saisie de la durée peut également précéder celle de la distance (les étapes 1 et 2 sont permutables), l'essentiel étant que les deux données soient acquises avant le calcul.

Validez vos réponses de façon interactive ci-dessus, puis recopiez la synthèse sur votre cahier.

Exercice 2 — Suivre l'état des variables

Score QCM : {{ scoreQcmEx2 }} / {{ qcmEx2.length }} 2 pts · 5 min

Algorithme Etat

ALGORITHME Etat
DEBUT
  a ← 4
  b ← a + 3
  a ← b * 2
  c ← a - b
  Écrire(a, b, c)
FIN

Après l'instruction	a	b	c
`a ← 4`	4	indéfini	indéfini
`b ← a + 3`	4	7 (4 + 3)	indéfini
`a ← b * 2`	14 (7 × 2)	7	indéfini
`c ← a - b`	14	7	7 (14 - 7)

{{ qcmEx2[0].selected === qcmEx2[0].correct ? '+1 pt' : '0 pt' }}

{{ qcmEx2[0].selected === qcmEx2[0].correct ? 'Exact !' : 'Incorrect.' }}

{{ qcmEx2[1].selected === qcmEx2[1].correct ? '+1 pt' : '0 pt' }}

{{ qcmEx2[1].selected === qcmEx2[1].correct ? 'Exact !' : 'Incorrect.' }}

Notion d'affectation et état des variables maîtrisés !

Vous avez identifié l'affichage exact et bien compris le caractère séquentiel et statique de l'affectation en mémoire.

{{ scoreQcmEx2 }} / {{ qcmEx2.length }} réponse(s) exacte(s)

Consultez les explications détaillées ci-dessus ou cliquez sur « Consulter le tableau de trace » pour visualiser l'état de chaque variable ligne par ligne.

Répondez au QCM interactif ci-dessus, puis notez la justification du comportement des variables et le résultat de l'algorithme sur votre cahier.

Exercice 3 — Décider avec une condition et choisir des tests

Score QCM : {{ scoreQcmEx3 }} / {{ qcmEx3.length }} 4 pts · 9 min

On considère comme plage de référence l'intervalle $[10 ; 20]$. Une valeur $x$ est « dans la plage » si elle appartient à cet intervalle, bornes comprises.

Algorithme Condition

Lire(x)
Si (x ≥ 10) Et (x ≤ 20) Alors
  Écrire("Dans la plage")
Sinon
  Écrire("Hors de la plage")
FinSi

Valeur x	Condition	Affichage attendu	Rôle du test
`9,5`	`Faux`	Hors de la plage	Extérieur gauche (< 10)
`10`	`Vrai`	Dans la plage	Borne inférieure (≥ 10)
`20`	`Vrai`	Dans la plage	Borne supérieure (≤ 20)
`20,1`	`Faux`	Hors de la plage	Extérieur droit (> 20)

Q{{ qIdx + 1 }}

{{ q.selected === q.correct ? 'Exact !' : 'Incorrect.' }}

Tests aux limites et condition logique maîtrisés !

Vous avez su analyser la condition composée, identifier les tests frontières et distinguer variables et constantes.

{{ scoreQcmEx3 }} / {{ qcmEx3.length }} réponse(s) exacte(s)

Consultez les explications ou la synthèse des tests pour consolider les notions de bornes d'intervalle.

Validez vos réponses de façon interactive ci-dessus, puis notez les 4 tests de référence sur votre cahier.

PHASE B — Réactivation active

Un rappel express est maintenant autorisé · compléter, corriger et modifier · 4 exercices · 40 min

Rappel express — conventions utilisées dans cette série

Algorithmique : Objet ← Expression ; Si Condition Alors … [Sinon …] FinSi ; Pour i de Début à Fin Faire … Fin Pour.
Python : objet = expression ; if condition: … else: … ; for i in range(Début, Fin+1): ….
Entrée Python : input() retourne une chaîne ; utiliser int(input()) ou float(input()) lorsque la donnée est numérique.

Exercice 4 — Comprendre une boucle Pour

Score QCM : {{ scoreQcmEx4 }} / {{ qcmEx4.length }} 4 pts · 8 min

Algorithme BouclePour

Lire(n)
s ← 0
Pour i de 1 à n Faire
  s ← s + i
Fin Pour
Écrire(s)

Itération (i)	Calcul effectué	Valeur de s
Avant boucle	`s ← 0`	0
`i = 1`	`s ← 0 + 1`	1
`i = 2`	`s ← 1 + 2`	3
`i = 3`	`s ← 3 + 3`	6
`i = 4`	`s ← 6 + 4`	10

Q{{ qIdx + 1 }}

{{ q.selected === q.correct ? 'Exact !' : 'Incorrect.' }}

Mécanisme de la boucle Pour et accumulation maîtrisés !

Vous comprenez parfaitement l'itération à nombre déterminé de tours et le rôle des éléments neutres pour la somme et le produit.

{{ scoreQcmEx4 }} / {{ qcmEx4.length }} réponse(s) exacte(s)

Consultez la trace détaillée pas à pas ci-contre pour bien suivre la mise à jour de la variable accumulateur.

Répondez au QCM interactif ci-dessus, puis recopiez la trace et la variante du produit sur votre cahier.

Exercice 5 — Compléter une solution : moyenne de mesures

Score QCM : {{ scoreQcmEx5 }} / {{ qcmEx5.length }} 4 pts · 10 min

On saisit $n$ mesures réelles ($n \ge 1$). On veut calculer et afficher leur moyenne arithmétique. Compléter uniquement les éléments manquants.

Algorithme MoyenneMesures

ALGORITHME MoyenneMesures
DEBUT
  Lire(n)
  s ← [ A ]
  Pour i de 1 à n Faire
    Lire(x)
    [ B ]
  Fin Pour
  m ← [ C ]
  Écrire(m)
FIN

Objet	Type / Nature	Rôle
`n`	Entier	Nombre de mesures à traiter (≥ 1)
`i`	Entier	Indice de la boucle Pour
`x`	Réel	Mesure saisie à chaque répétition
`s`	Réel	Somme cumulée des mesures (init. 0)
`m`	Réel	Moyenne arithmétique calculée (s / n)

Q{{ qIdx + 1 }}

{{ q.selected === q.correct ? 'Exact !' : 'Incorrect.' }}

Calcul de moyenne et typage TDO parfaitement validés !

Vous maîtrisez le schéma classique d'accumulation d'une somme puis de division finale par le nombre d'éléments.

{{ scoreQcmEx5 }} / {{ qcmEx5.length }} réponse(s) exacte(s)

Vérifiez les explications et le TDO complété pour vous assurer des types et des opérations manquantes.

Validez le QCM ci-dessus, puis notez les instructions A, B, C et le TDO dans votre cahier.

Exercice 6 — Déboguer : compter les valeurs strictement positives

Score QCM : {{ scoreQcmEx6 }} / {{ qcmEx6.length }} 4 pts · 12 min

Objectif : parmi $n$ valeurs réelles saisies, afficher le nombre de valeurs strictement positives ($x > 0$). La solution initiale contient deux erreurs logiques.

Code à déboguer

Lire(n)
nbPos ← 1
Pour i de 1 à n Faire
  Lire(x)
  Si x ≥ 0 Alors
    nbPos ← nbPos + 1
  FinSi
Fin Pour
Écrire(nbPos)

Algorithme Corrigé

Lire(n)
nbPos ← 0       // Correction 1 : init à 0
Pour i de 1 à n Faire
  Lire(x)
  Si x > 0 Alors // Correction 2 : strictement > 0
    nbPos ← nbPos + 1
  FinSi
Fin Pour
Écrire(nbPos)

Q{{ qIdx + 1 }}

{{ q.selected === q.correct ? 'Exact !' : 'Incorrect.' }}

Débogage logique et analyse des compteurs réussis !

Vous avez su repérer l'erreur d'initialisation et la nuance fondamentale entre inégalité large et stricte.

{{ scoreQcmEx6 }} / {{ qcmEx6.length }} réponse(s) exacte(s)

Consultez l'algorithme corrigé pour visualiser les deux rectifications en surbrillance.

Notez l'attendu, les deux erreurs logiques et le code corrigé sur votre cahier.

Exercice 7 — Modifier une solution existante

Score QCM : {{ scoreQcmEx7 }} / {{ qcmEx7.length }} 4 pts · 10 min

La solution initiale calcule la somme de tous les $n$ entiers saisis. On veut la modifier pour sommer uniquement les valeurs multiples de 3.

Algorithme Initial

Lire(n)
s ← 0
Pour i de 1 à n Faire
  Lire(x)
  s ← s + x
Fin Pour
Écrire(s)

Python 3 (Somme multiples de 3)

n = int(input("Donner n : "))
s = 0
for i in range(1, n + 1):
    x = int(input(f"Valeur {i} : "))
    if x % 3 == 0:
        s = s + x
print("Somme multiples de 3 =", s)

Q{{ qIdx + 1 }}

{{ q.selected === q.correct ? 'Exact !' : 'Incorrect.' }}

Filtrage conditionnel et opérateur Modulo validés !

Vous maîtrisez l'utilisation de l'opérateur modulo en algorithmique et sa syntaxe Python % avec == 0.

{{ scoreQcmEx7 }} / {{ qcmEx7.length }} réponse(s) exacte(s)

Consultez la solution Python ci-contre pour revoir la combinaison de for et if %.

Notez le bloc d'accumulation conditionnelle et la condition Python sur votre cahier.

PHASE C — Synthèse et transfert

Le rappel détaillé disparaît : comparer, traduire, construire et tester · 3 exercices · 30 min

Exercice 8 — Comparer deux solutions

Score QCM : {{ scoreQcmEx8 }} / {{ qcmEx8.length }} 3 pts · 7 min

On dispose de trois réels $a$, $b$ et $c$. On souhaite afficher leur maximum. Deux approches algorithmiques distinctes sont proposées :

Solution A (Initialisation par défaut)

maxi ← a
Si b > maxi Alors
  maxi ← b
FinSi
Si c > maxi Alors
  maxi ← c
FinSi
Écrire(maxi)

Solution B (Alternative initiale Si/Sinon)

Si a > b Alors
  maxi ← a
Sinon
  maxi ← b
FinSi
Si c > maxi Alors
  maxi ← c
FinSi
Écrire(maxi)

Jeu d'essai (a, b, c)	Cas testé	Sortie Solution A	Sortie Solution B	Verdict
`(10, 3, 7)`	Premier élément maximal	10	10	Conforme
`(4, 9, 2)`	Deuxième élément maximal	9	9	Conforme
`(5, 5, 2)`	Égalité sur le maximum ($a = b$)	5	5	Conforme
`(-8, -2, -1)`	Valeurs toutes négatives	-1	-1	Conforme

Q{{ qIdx + 1 }}

{{ q.selected === q.correct ? 'Exact !' : 'Incorrect.' }}

Comparaison et équivalence algorithmique maîtrisées !

Vous avez su analyser deux structures de contrôle différentes et démontrer leur parfaite équivalence fonctionnelle.

{{ scoreQcmEx8 }} / {{ qcmEx8.length }} réponse(s) exacte(s)

Consultez le tableau comparatif pour revoir le comportement sur les différents cas limites.

Rédigez vos 3 jeux d'essais et la justification de l'équivalence des deux solutions sur votre cahier.

Exercice 9 — Passer de l'algorithme à Python

4 pts · 9 min

Traduire fidèlement l'algorithme suivant en Python.

Lire(n)
nbPairs ← 0
Pour i de 1 à n Faire
  Lire(x)
  Si x Mod 2 = 0 Alors
    nbPairs ← nbPairs + 1
  FinSi
Fin Pour
Écrire(nbPairs)

Programme Python :

Écrivez le script complet sur votre cahier en respectant l'indentation, les conversions numériques explicites et la fonction range().

Test : Pour $n = 5$ et les valeurs $4$ ; $7$ ; $0$ ; $-2$ ; $9$, quel résultat doit être affiché ?

Écrivez le code Python et la réponse au test sur votre cahier.

Exercice 10 — Synthèse finale autonome : campagne de mesures

6 pts · 14 min

Dans un laboratoire scolaire, on effectue $n$ mesures de température, avec $n \ge 1$. Pour cet exercice, la plage de référence est $[18 ; 25] \ ^\circ\text{C}$. Les mesures sont saisies une à une. On veut : (1) calculer la moyenne des $n$ températures ; (2) compter combien de mesures sont hors de la plage de référence ; (3) afficher la moyenne et ce nombre.

Identifier les entrées, les sorties et la contrainte principale.
Écrire un algorithme complet respectant les conventions étudiées. Ne pas utiliser de tableau.

Ajouter le TDO après FIN :

Objet	Type / Nature	Rôle
.....	.....	.....
.....	.....	.....
.....	.....	.....
.....	.....	.....
.....	.....	.....
.....	.....	.....

Écrire ensuite le programme Python correspondant.

Proposer trois jeux d'essai avec résultats attendus : (a) toutes les mesures dans la plage ; (b) au moins une mesure hors plage ; (c) valeurs exactement égales à 18 et 25 :

Jeu d'essai	Moyenne attendue	Nombre hors plage
.....	.....	.....
.....	.....	.....
.....	.....	.....

Rédigez l'algorithme complet, le TDO, le programme Python et les 3 jeux d'essais sur votre cahier.