← Toutes les ressources pour les enseignants

Imprimer la fiche de l’élève Voir le corrigé

Corrigé pour l’enseignant

Construire de petits programmes

Recueillez quatre types d’indices : prédiction de l’état pertinent ; comportement dans des cas variés, y compris aux limites ; explication fondée sur la trace et l’état ; correction justifiée d’un écart. Évaluez chacun comme en développement, avec soutien ou autonome, sur papier ou selon la procédure approuvée de votre école. Réussir un défi prouve un comportement de la machine, pas la paternité du code ni une maîtrise complète. Acceptez les programmes équivalents corrects : le corrigé public est un modèle, pas l’unique réponse possible.

Matériel pédagogique public. Les solutions sont des exemples ; des programmes équivalents corrects peuvent aussi réussir les vérifications réelles.

28. Un petit jeu de cible

Construisez un jeu de trois tours avec un état enregistré et un score.

Ouvrir cette leçon →

1. Prévoir et tracer

Avant d’exécuter le programme d’essai, prévoyez sa sortie et tracez les trois premières instructions exécutées. Suivez les registres, les indicateurs ou la mémoire pertinents, selon le besoin. Avancez ensuite pas à pas pour comparer.

STORE 5 200
LOAD [200] R1
LOAD 0 R2
LOOP 3
INPUT
CMP R1
JUMP_IF_ZERO hit
JUMP next
hit: LOAD R2
ADD 1
COPY R0 R2
next: NOP
RETURN
LOAD R2
STORE 201
PRINT
HALT

Ajouter les entrées à la file: 5, 2, 5

Initialiser la mémoire: 200: 5

Corrigé de la prédiction d’essai

Sortie: 2

Instruction	PC avant	PC après	État pertinent	Sortie
STORE	0	1	`{"registers":[0,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[200]}`	Aucune
LOAD	1	2	`{"registers":[0,5,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[200],"memoryWrites":[]}`	Aucune
LOAD	2	3	`{"registers":[0,5,0,0,0,0,0,0],"flags":{"zero":true,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune

2. Construire et vérifier

La mémoire 200 contient un octet cible. Lisez exactement trois propositions. Comptez celles qui correspondent à la cible, enregistrez le score en mémoire 201 et affichez-le une fois.

Types d’instructions requis: INPUT, CMP, LOOP, STORE, JUMP_IF_ZERO

Exemple de solution du défi

LOAD [200] R1
LOAD 0 R2
LOOP 3
INPUT
CMP R1
JUMP_IF_ZERO hit
JUMP next
hit: LOAD R2
ADD 1
COPY R0 R2
next: NOP
RETURN
LOAD R2
STORE 201
PRINT
HALT

Cas réels du vérificateur

Cas 1

Entrée: 5, 2, 5
Mémoire initiale: 200: 5
Sortie attendue: 2
Mémoire finale attendue: 200: 5, 201: 2
Lectures mémoire requises: 200

Cas 2

Entrée: 1, 2, 3
Mémoire initiale: 200: 9
Sortie attendue: 0
Mémoire finale attendue: 200: 9, 201: 0
Lectures mémoire requises: 200

Cas 3

Entrée: 0, 0, 0
Mémoire initiale: 200: 0
Sortie attendue: 3
Mémoire finale attendue: 200: 0, 201: 3
Lectures mémoire requises: 200

Cas 4

Entrée: 17, 1, 2
Mémoire initiale: 200: 17
Sortie attendue: 1
Mémoire finale attendue: 200: 17, 201: 1
Lectures mémoire requises: 200

3. Expliquer la machine

Quel état change en cas de proposition correcte ou incorrecte ?

Raisonnement et note pédagogique

Le score augmente seulement en cas d’égalité ; la cible reste une donnée enregistrée de la règle. Trois propositions produisent un score numérique.

29. Un utilitaire de tampon utilisant la pile

Combinez entrées, boucles, pile et stockage indexé.

Ouvrir cette leçon →

1. Prévoir et tracer

LOAD 3 R3
LOAD 10
PUSH
LOAD 20
PUSH
LOAD 30
PUSH
LOAD 0 R1
LOOP R3
POP
STORE R1
PRINT
LOAD R1
ADD 1
COPY R0 R1
RETURN
HALT

Ajouter les entrées à la file: Aucune

Initialiser la mémoire: Tous les octets sont initialement nuls

Corrigé de la prédiction d’essai

Sortie: 30, 20, 10

Instruction	PC avant	PC après	R0 avant	R0 après	État pertinent	Sortie
LOAD	0	1	0	0	`{"registers":[0,0,0,3,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune
LOAD	1	2	0	10	`{"registers":[10,0,0,3,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune
PUSH	2	3	10	10	`{"registers":[10,0,0,3,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[10],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune

2. Construire et vérifier

Lisez N (0 à 5), puis exactement N octets. Utilisez la pile de données pour les inverser. Affichez la suite inversée et enregistrez-la à partir de l’adresse mémoire 0.

Types d’instructions requis: INPUT, LOOP, PUSH, POP, STORE

Exemple de solution du défi

INPUT
COPY R0 R3
LOOP R3
INPUT
PUSH
RETURN
LOAD 0 R1
LOOP R3
POP
STORE R1
PRINT
LOAD R1
ADD 1
COPY R0 R1
RETURN
HALT

Cas réels du vérificateur

Cas 1

Entrée: 0
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: Aucune
Mémoire finale attendue: 0: 0

Cas 2

Entrée: 1, 7
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 7
Mémoire finale attendue: 0: 7

Cas 3

Entrée: 4, 1, 2, 3, 4
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 4, 3, 2, 1
Mémoire finale attendue: 0: 4, 1: 3, 2: 2, 3: 1

Cas 4

Entrée: 3, 0, 255, 8
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 8, 255, 0
Mémoire finale attendue: 0: 8, 1: 255, 2: 0

3. Expliquer la machine

Pourquoi utiliser deux phases et que doit faire N = 0 ?

Raisonnement et note pédagogique

Collectez et empilez d’abord ; dépilez, écrivez et affichez ensuite dans l’ordre inverse. Zéro répétition ne produit aucune sortie ni écriture accidentelle.

30. Votre propre mini système d’exploitation

Répartissez des travaux en attente vers des services réutilisables et enregistrez les résultats.

Ouvrir cette leçon →

1. Prévoir et tracer

LOAD 4
CALL double
STORE 64
PRINT
LOAD 3
CALL square
STORE 65
PRINT
HALT
double: MUL 2
RETURN
square: MUL R0
RETURN

Ajouter les entrées à la file: Aucune

Initialiser la mémoire: Tous les octets sont initialement nuls

Corrigé de la prédiction d’essai

Sortie: 8, 9

Instruction	PC avant	PC après	R0 avant	R0 après	État pertinent	Sortie
LOAD	0	1	0	4	`{"registers":[4,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune
CALL	1	9	4	4	`{"registers":[4,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[],"callStack":[2],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune
MUL	9	10	4	8	`{"registers":[8,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[],"callStack":[2],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Aucune

2. Construire et vérifier

Lisez N (0 à 3), puis N paires (opération, valeur). L’opération 0 double, 1 calcule le carré et 2 ajoute un. Répartissez le travail avec des sous-programmes appelés par CALL. Affichez chaque résultat complet et enregistrez son octet aux adresses 64, 65, … dans l’ordre des travaux.

Types d’instructions requis: INPUT, LOOP, CALL, CMP, STORE, RETURN

Exemple de solution du défi

INPUT
COPY R0 R3
LOAD 64 R2
LOOP R3
INPUT
COPY R0 R4
INPUT
COPY R0 R1
LOAD R4
CMP 0
JUMP_IF_ZERO doubleJob
CMP 1
JUMP_IF_ZERO squareJob
LOAD R1
CALL increment
JUMP finish
doubleJob: LOAD R1
CALL double
JUMP finish
squareJob: LOAD R1
CALL square
finish: STORE R2
PRINT
LOAD R2
ADD 1
COPY R0 R2
RETURN
HALT
double: MUL 2
RETURN
square: MUL R0
RETURN
increment: ADD 1
RETURN

Cas réels du vérificateur

Cas 1

Entrée: 3, 0, 4, 1, 3, 2, 9
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 8, 9, 10
Mémoire finale attendue: 64: 8, 65: 9, 66: 10

Cas 2

Entrée: 2, 1, -2, 0, 0
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 4, 0
Mémoire finale attendue: 64: 4, 65: 0

Cas 3

Entrée: 0
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: Aucune
Mémoire finale attendue: 64: 0

Cas 4

Entrée: 3, 2, 255, 0, 130, 1, 16
Mémoire initiale: Tous les octets sont initialement nuls
Sortie attendue: 256, 260, 256
Mémoire finale attendue: 64: 0, 65: 4, 66: 0

3. Expliquer la machine

Pourquoi une sortie de 260 peut-elle coexister avec un octet de journal de 4 ?

Raisonnement et note pédagogique

R0 garde l’entier complet représentable exactement ; STORE garde son octet de poids faible. Les appels de services masquent le calcul, pas la règle de répartition.