Pensée informatique et résolution de problèmes

Un ordinateur peut calculer un itinéraire, jouer un son ou organiser une liste de noms. L’informatique étudie les processus derrière ces tâches : comment l’information est représentée et traitée, quels problèmes peuvent être résolus et comment construire des systèmes qui mettent en œuvre les solutions.

Décrire un calcul

Un modèle de départ utile est entrée → traitement → sortie. Un calculateur d’itinéraire reçoit un point de départ et une destination. Il effectue une recherche dans les informations sur les routes, puis renvoie un itinéraire, une distance en kilomètres et une durée de trajet. Les informations routières sont aussi des données nécessaires au traitement. Le résultat visible ne constitue qu’une partie du calcul.

Énonce un problème informatique avant de choisir sa méthode. Par exemple : « Entrée : une liste de noms. Sortie : les mêmes noms par ordre alphabétique. » Cet énoncé précise à quoi doit ressembler un résultat correct. Il laisse la place à différentes méthodes pour le produire. Si la sortie omet un nom, elle ne résout pas le problème, même si les noms restants sont classés.

Au-delà de l’écriture de code

La programmation consiste à écrire des instructions dans un langage qu’un ordinateur peut exécuter. C’est une activité importante de l’informatique. Ce domaine plus vaste cherche aussi à savoir si une solution existe, quelle quantité de travail elle demande et comment les personnes peuvent l’utiliser facilement et en toute sécurité.

Les frontières entre ces domaines se recoupent. La conception d’un éditeur d’images peut faire intervenir à la fois l’infographie, l’interaction avec l’utilisateur et le génie logiciel. L’informatique contribue aussi à d’autres disciplines : les biologistes comparent des séquences d’ADN, les climatologues modélisent l’atmosphère et les artistes utilisent des logiciels pour créer des images et de la musique.

Disciplines voisines et limites pratiques

L’ingénierie informatique se concentre sur les dispositifs physiques comme les processeurs et les cartes électroniques. Les technologies de l’information se concentrent sur le choix, l’installation et l’exploitation des systèmes d’une organisation. La science des données associe les statistiques et l’informatique pour tirer des conclusions à partir de données. Ces disciplines partagent des méthodes avec l’informatique tout en mettant l’accent sur des activités différentes.

Les ordinateurs exécutent rapidement des instructions précises, souvent à raison de milliards d’opérations simples par seconde. La vitesse ne corrige pas une instruction imprécise. « Ajoute du sel » ne précise pas la quantité ; un processus destiné à une exécution automatique nécessite une action précise.

Il existe aussi des limites qui ne tiennent pas à la vitesse. Certains problèmes énoncés avec précision n’ont pas de solution algorithmique. D’autres ont des solutions qui demandent trop d’étapes pour être réalisables en pratique. Se demander ce qu’un ordinateur peut accomplir fait partie de l’informatique elle-même.

La pensée informatique rend un problème assez clair pour qu’il puisse être résolu étape par étape. Une personne peut exécuter la solution, un ordinateur peut le faire ou les deux peuvent se partager le travail. Cette réflexion consiste notamment à déterminer le sens du problème et la manière de vérifier un résultat.

Quatre techniques qui fonctionnent ensemble

La décomposition divise un problème en parties plus petites. La reconnaissance de motifs trouve des ressemblances ou des tâches répétées. L’abstraction conserve les détails nécessaires à un objectif et écarte les autres. La conception d’algorithmes transforme une solution en étapes précises et ordonnées.

Ces techniques sont des outils auxquels tu peux revenir selon tes besoins. Ce ne sont pas quatre cases à remplir dans un ordre imposé. Un test échoué peut révéler un sous-problème manquant. Un sous-problème répété peut suggérer une procédure réutilisable. Un modèle peut avoir besoin d’un détail supplémentaire avant que l’algorithme fonctionne.

Jeannette Wing a contribué à faire largement connaître le terme « pensée informatique » dans un essai de 2006. Son message central était que cette approche est utile à tous, au-delà des personnes qui travaillent comme programmeurs.

Comprendre, planifier, exécuter et vérifier

Le mathématicien George Pólya a décrit quatre étapes de résolution de problèmes en 1945. En informatique, elles conduisent à des actions concrètes :

1. Comprendre le problème. Identifie les entrées, les sorties, les contraintes et les critères de réussite.
2. Établir un plan. Choisis des tâches plus petites, des motifs utiles et un algorithme.
3. Exécuter le plan. Exprime-le et exécute-le à l’aide de pseudo-code, d’un organigramme ou d’un programme.
4. Revenir sur le résultat. Compare le résultat aux critères de réussite et révise la solution si nécessaire.

Une contrainte est une règle que la solution doit respecter, comme un temps maximal disponible. Un critère de réussite est un moyen de juger le résultat. « Produire une liste de courses regroupée avec les quantités nécessaires » peut être vérifié. « Améliorer les courses » laisse le résultat flou.

Étudier un plan de repas

Supposons que tu doives prévoir les repas du soir pour une semaine. Les entrées comprennent les recettes, le nombre de personnes et les aliments déjà disponibles. La sortie est un plan et une liste de courses. Les besoins alimentaires et le temps disponible pour cuisiner sont des contraintes.

Décompose le travail en trois tâches : choisir les repas, faire la liste et cuisiner. La reconnaissance de motifs montre que plusieurs recettes utilisent du riz et des oignons. L’abstraction représente un ingrédient par son nom et sa quantité, comme « riz, 1 kg », sans conserver la marque lorsque celle-ci n’a pas d’incidence sur le plan.

L’algorithme des courses peut maintenant être ordonné : choisir les repas, lister leurs ingrédients, regrouper les ingrédients répétés, soustraire ce qui se trouve déjà dans les placards et acheter ce qui reste. Regrouper les quantités avant de vérifier les placards évite de soustraire le même stock séparément pour chaque recette.

Vérifie le résultat par rapport aux repas. Chaque ingrédient nécessaire doit être disponible en quantité suffisante. S’il manque un ingrédient, suis la construction de la liste et révise l’étape concernée.

Une erreur courante consiste à commencer à coder avant de déterminer le résultat recherché. Un programme rapide peut résoudre fidèlement le mauvais problème. Ce sont toujours les personnes qui choisissent le modèle, les contraintes et les étapes ; l’ordinateur exécute les instructions qui expriment ces choix.

Il peut être difficile de garder à l’esprit un grand problème dans son ensemble. La décomposition le remplace par des sous-problèmes plus petits que tu peux comprendre, résoudre et vérifier séparément. Les parties doivent néanmoins pouvoir être combinées en une solution au problème initial.

Partir de l’ensemble pour aller vers les détails

Commence par la tâche principale. Divise-la en quelques responsabilités bien définies, puis affine chacune d’elles. C’est la décomposition descendante. Un arbre de décomposition place le problème entier en haut et les tâches plus petites en dessous. Les branches indiquent à quelle tâche appartient une tâche plus petite.

Pour une application de quiz, les parties principales sont le stockage des questions et des réponses, la présentation des questions, la vérification des réponses, puis la tenue et l’affichage du score. La partie « poser une question » peut être divisée en trois : afficher le texte de la question, afficher les choix de réponse et lire le choix de l’apprenant.

Un diagramme de structure textuel pourrait ressembler à ceci :

Run a quiz
    Store questions and answers
    Ask a question
        Show question text
        Show answer options
        Read the choice
    Check the answer
    Keep and show the score

Ces branches décrivent des responsabilités. Leur seule position verticale ne donne pas l’ordre complet d’exécution. Par exemple, l’application répète les questions et les vérifications tant qu’il reste des questions. Un algorithme distinct décrit ce déroulement.

Décider quand arrêter la décomposition

Une partie est assez petite lorsque tu vois comment la résoudre directement ou lorsqu’une méthode ou un outil existant la prend en charge. « Lire le choix » peut être une tâche exploitable une fois que tu sais comment l’interface recueille la saisie. La diviser en mouvements de main individuels ajouterait des détails qui n’aident pas à concevoir l’application.

Effectue d’abord la décomposition principale. Si tu commences par décrire de minuscules actions, tu risques de passer du temps sur un écran tout en oubliant une responsabilité entière, comme décider quand le quiz se termine.

Identifier les dépendances

Une dépendance signifie qu’une tâche a besoin du résultat d’une autre. Le quiz doit obtenir un choix avant de le vérifier, puis le vérifier avant de mettre à jour le score. Note ce que chaque partie reçoit et produit. Cela clarifie les échanges entre elles.

Les parties doivent être aussi indépendantes que possible. Si l’affichage passe de quatre boutons de réponse à une autre méthode de saisie, le calcul du score doit toujours fonctionner avec le résultat vérifié. Des limites claires permettent à plusieurs personnes de construire des parties séparées en même temps et facilitent les modifications ultérieures.

L’indépendance ne signifie pas que les parties n’échangent jamais d’informations. Elles ont besoin d’entrées et de sorties convenues. Une partie chargée du score qui attend TRUE ou FALSE ne peut pas utiliser directement le texte brut d’une partie qui affiche une question sans une étape de vérification de la réponse.

Chercher les lacunes et les chevauchements

Relis le problème initial et demande-toi si l’exécution de toutes les parties permettrait de terminer le travail entier. Le premier arbre ne montre pas quand le quiz s’arrête. Ajoute cette responsabilité au contrôle général du quiz. Demande-toi aussi si deux parties modifient toutes deux le score, ce qui pourrait compter deux fois une bonne réponse.

Vérifie chaque petite partie séparément, puis vérifie le processus assemblé. Un affichage de question correct et un vérificateur de réponse correct peuvent quand même échouer ensemble si l’un envoie un choix dans un format différent de celui attendu par l’autre.

Un travail répété cache souvent une méthode réutilisable. La reconnaissance de motifs consiste à rechercher des ressemblances, des répétitions ou des tendances au sein d’un problème et entre différents problèmes. La question utile est de savoir ce qui reste identique et ce qui change.

Trouver une répétition dans une tâche

Pour dessiner un carré, un stylo en mouvement peut avancer de 100 pas et tourner à droite de 90 degrés, quatre fois. Cette paire d’actions se répète. Une boucle exprime cette paire une seule fois et indique le nombre de répétitions :

REPEAT 4 TIMES
    Move forward 100 steps
    Turn right 90 degrees

Ce motif rend la structure plus facile à voir. Il facilite aussi les modifications : changer la distance parcourue en un seul endroit modifie tous les côtés.

Remplacer les détails changeants par des paramètres

La généralisation permet à une solution de fonctionner pour une famille de cas. Un paramètre est une entrée nommée qui représente un détail susceptible de changer. Pour les polygones réguliers, le nombre et la longueur des côtés peuvent être des paramètres.

Un stylo qui parcourt le contour d’un polygone régulier effectue un tour complet. La rotation à chaque sommet est :

Ici, $n$ est le nombre de côtés. Répète la paire d’actions avancer et tourner $n$ fois, en gardant la même longueur de côté et la même rotation à chaque fois.

La rotation est le changement de direction du stylo, pas l’angle intérieur du polygone. Pour un triangle, une rotation de 60 degrés ne produirait pas le trajet à trois côtés recherché.

Reconnaître la même méthode dans différents problèmes

Trouver le vol le moins cher, l’itinéraire le plus court et la meilleure note demande dans chaque cas de retenir la meilleure possibilité examinée jusque-là. Commence par une possibilité. Examine chacune des suivantes et remplace celle retenue lorsque la nouvelle est meilleure. Le sens de la comparaison change selon qu’on cherche la plus petite ou la plus grande valeur, mais le motif général reste utile.

Les motifs peuvent aussi organiser les données. Regrouper les dépenses en alimentation, transport et logement rend visibles leurs caractéristiques communes. Si les ventes de parapluies augmentent régulièrement lorsque la météo annonce de la pluie, un magasin peut utiliser cette tendance pour l’aider à prévoir son stock. Une tendance est un constat à examiner ; la raison qui l’explique compte lorsqu’on cherche à savoir si elle va se poursuivre.

Vérifier le motif proposé

Les nombres 1, 2, 4 ne déterminent pas un seul nombre suivant. Doubler donne 8. Augmenter les écarts de un donne 7, puisque les écarts sont jusqu’ici de 1 et 2. Il faut davantage de cas ou une règle expliquant la suite pour décider quel motif convient au problème.

Recherche les différences importantes avant de réutiliser une solution. Partager une addition à parts égales et la partager selon ce que chacun a commandé impliquent tous deux un total commun. La division à parts égales résout la première tâche, mais la seconde nécessite de connaître la commande de chaque personne. Ne réutilise la structure commune qu’après avoir identifié le détail qui modifie le résultat attendu.

Un modèle peut être plus simple que la réalité tout en restant utile. L’abstraction conserve les informations nécessaires à un objectif précis et écarte les autres détails. Sa qualité dépend de sa capacité à répondre aux questions posées par la tâche.

Choisir un modèle adapté à la tâche

Un plan de métro conserve les stations, leur ordre sur chaque ligne et les correspondances. Ces détails aident un voyageur à préparer son trajet. Le plan peut déformer les distances et omettre le tracé des rues, car son objectif principal est de montrer les correspondances.

Ce même plan est un mauvais outil pour déterminer la distance à parcourir à pied entre deux stations. Le modèle a omis un détail nécessaire à ce nouvel objectif. Un détail est pertinent en fonction du problème, et non parce qu’il est intéressant en général.

Considère deux modèles d’une même voiture :

Le jeu de course doit actualiser le mouvement. Le parking doit identifier la voiture et suivre son passage. Aucun des deux modèles n’a besoin de conserver toutes les caractéristiques physiques de la voiture.

Masquer des étapes derrière un nom clair

L’abstraction te permet aussi d’utiliser ce que fait un composant sans avoir à réfléchir à son fonctionnement à chaque fois. Choisir un programme de machine à laver ne t’oblige pas à commander directement son moteur.

Dans un algorithme, une procédure est un groupe d’étapes nommé. L’appel de son nom exécute ces étapes. Un nom comme average(list) indique une tâche tout en masquant le calcul répété. Une procédure qui renvoie un résultat à l’élément qui l’a appelée retourne une valeur. Celui-ci peut stocker cette valeur ou l’utiliser dans un autre calcul.

Un paramètre fournit à une procédure une entrée qui peut changer. drawPolygon(sides, length) possède deux paramètres. L’appel drawPolygon(6, 100) fournit six côtés et une longueur de 100 pas. Cela combine l’abstraction, qui masque les étapes du dessin, et la généralisation, qui permet différentes formes et tailles.

Les limites d’une procédure doivent être claires : quelles entrées accepte-t-elle et quel résultat ou quelle action produit-elle ? Pour une moyenne, une liste vide demande un traitement particulier, car aucun effectif ne permet d’effectuer la division. Masquer les étapes ne dispense pas de définir les entrées utilisables.

Construire des couches de compréhension

Une application de messagerie permet d’envoyer un message. En dessous, le système d’exploitation propose des services que l’application peut utiliser. À un niveau inférieur, le matériel exécute des opérations. Chaque couche s’appuie sur le comportement de la couche suivante sans exposer tous ses détails internes à son utilisateur. Une modification interne peut rester circonscrite tant que le comportement annoncé reste le même.

Les techniques se renforcent mutuellement. La décomposition identifie des parties. La reconnaissance de motifs trouve les parties qui partagent une structure. L’abstraction donne à ces parties des noms et des limites claires afin qu’elles puissent être combinées.

Une erreur d’abstraction courante consiste à supprimer un fait qui détermine si un résultat fonctionne. Un calculateur d’itinéraire qui ignore les rues à sens unique peut proposer un trajet impossible à parcourir. Pour vérifier un modèle, liste les décisions qu’il doit permettre de prendre et confirme que les données conservées suffisent pour chacune.

Un algorithme est un ensemble fini et ordonné d’instructions précises permettant de résoudre un problème ou d’accomplir une tâche. Pour une entrée valide, il produit la sortie attendue après un nombre fini d’étapes. Une recette, une notice de montage et la division posée utilisent toutes cette idée.

Vérifier les propriétés de la méthode

Un algorithme utile possède des entrées et des sorties définies. Chaque étape doit être assez précise pour n’avoir qu’un seul sens et assez effective pour pouvoir être exécutée. Les étapes doivent se terminer et leur résultat doit être correct pour chaque entrée valide.

« Trouver le plus grand nombre » indique un objectif, mais ne précise pas de méthode. « Examiner chaque nombre et retenir le plus grand trouvé jusque-là » donne une méthode qui peut être développée en instructions. Elle soulève aussi une question sur l’entrée : que doit-il se passer si la liste est vide ? Définir les entrées valides évite de laisser la méthode inachevée.

Les instructions de la vie quotidienne peuvent laisser des lacunes que les personnes comblent grâce à leur expérience. « Mets la confiture sur le pain » omet l’ouverture du pot et l’étalement d’une quantité sur une surface. Lorsque tu conçois une méthode destinée à une exécution automatique, indique les actions nécessaires au système qui l’exécute et place-les dans un ordre utilisable.

Séparer la méthode de son expression

Un algorithme est la méthode de résolution. Un programme exprime une méthode dans un langage de programmation afin qu’un ordinateur puisse l’exécuter. Le même algorithme peut apparaître en pseudo-code, dans un organigramme et dans des programmes écrits dans différents langages.

Trois structures de contrôle organisent l’exécution :

Avec des variables, ces structures suffisent à exprimer tout algorithme. C’est l’idée derrière un résultat classique publié par Böhm et Jacopini en 1966. Un algorithme peut les combiner : parcourir une liste en répétant des étapes, tester chaque valeur et mettre à jour un résultat stocké en suivant une séquence.

Comparer des méthodes correctes

Supposons qu’un annuaire classé par ordre alphabétique comporte 1 000 pages. Vérifier les pages une par une peut demander 1 000 vérifications. Tourner deux pages à la fois et ne vérifier qu’une page sur deux demande jusqu’à environ 500 vérifications, plus un retour en arrière si le nom a été dépassé.

Une autre méthode ouvre la partie restante au milieu et conserve la moitié qui peut contenir le nom. Au plus 10 divisions par deux réduisent les 1 000 pages possibles à une seule :

1000 → 500 → 250 → 125 → 63 → 32
     → 16 → 8 → 4 → 2 → 1

Le classement permet d’écarter une moitié sans risque. Sans cet ordre, la moitié écartée pourrait contenir le nom. Cette hypothèse sur l’entrée fait partie de la méthode.

Pour 2 000 pages, vérifier chaque page peut demander deux fois plus de vérifications, tandis que la méthode par divisions successives n’en demande qu’une de plus : 11. Comparer la croissance du nombre d’étapes en dit plus que chronométrer une exécution sur une seule machine.

Vérifie la correction avant de vanter la vitesse. Une méthode qui examine seulement le premier et le dernier nombre d’une liste trouve par hasard 12 dans [7, 3, 12]. Elle manque le 12 dans [7, 12, 3]. Un exemple réussi ne suffit pas à établir que la méthode traite toute la plage d’entrées.

Le pseudo-code décrit un algorithme à l’aide d’instructions structurées et lisibles. Il n’est pas lié à un langage de programmation particulier. Il permet de travailler sur la logique avant de s’occuper de la ponctuation et des autres règles d’écriture d’un langage.

Lire la notation

Les mots-clés sont en majuscules : INPUT, OUTPUT, IF, WHILE et FOR. Chaque instruction occupe sa propre ligne. L’indentation montre quelles instructions appartiennent à un bloc. Un commentaire commence par // et explique le code sans ajouter d’action.

La flèche ← signifie affectation. D’autres styles de pseudo-code utilisent = ou SET … TO pour l’affectation. Ici, = compare des valeurs. Lis count ← 0 comme « count reçoit zéro ». Une variable est un emplacement nommé qui stocke une valeur susceptible de changer. Une constante a un nom mais garde la même valeur, comme PASS_MARK ← 50.

Le membre de droite d’une affectation est évalué en premier. Son résultat remplace l’ancienne valeur à gauche. Si count contient 4, count ← count + 1 lit l’ancienne valeur 4, ajoute 1 et stocke 5. C’est une instruction qui modifie une donnée stockée, pas une équation affirmant qu’un nombre est égal à lui-même plus un.

Adapter les opérations aux données

Additionner les nombres 12 et 3 donne 15. Joindre les chaînes « 12 » et « 3 » donne « 123 ». Choisis des noms descriptifs comme temperature et total pour que le rôle d’une valeur reste visible.

Les opérateurs arithmétiques comprennent +, −, * et /. DIV donne le quotient entier, tandis que MOD donne le reste. Ainsi, 17 DIV 5 vaut 3 et 17 MOD 5 vaut 2. Le test n MOD 2 = 0 permet de reconnaître un entier pair. Des comparaisons comme =, ≠, <, >, ≤ et ≥ produisent des valeurs booléennes.

Lire, calculer et afficher

INPUT minutes
hours ← minutes DIV 60
rest ← minutes MOD 60
OUTPUT hours, "h", rest, "min"

Pour 135 minutes, deux groupes complets de 60 utilisent 120 minutes, et il reste 15 minutes. La sortie est « 2 h 15 min ». INPUT reçoit les données, les deux affectations les traitent et OUTPUT envoie le résultat.

Préserver une valeur avant de la remplacer

Supposons que a contienne 5 et b contienne 8. Les instructions a ← b puis b ← a laissent les deux variables avec la valeur 8. La première instruction a écrasé l’unique copie stockée de 5.

Utilise une variable temporaire :

temp ← a
a ← b
b ← temp

Après la première ligne, temp contient 5. La deuxième ligne place 8 dans a. La troisième place le 5 sauvegardé dans b. L’affectation copie une valeur actuelle ; elle ne crée pas de lien permanent entre les variables.

Donne une valeur de départ à chaque variable avant de la lire. Un total cumulé a besoin de total ← 0 avant sa première addition. Placer l’affectation après l’addition laisse la première étape sans valeur de départ définie.

Une structure conditionnelle choisit les instructions à exécuter. Une condition est une expression dont la valeur est TRUE ou FALSE. La comparaison score ≥ 50 vérifie si le score actuel est au moins égal à 50.

Utiliser IF et ELSE

IF score ≥ 50 THEN
    OUTPUT "Pass"
ELSE
    OUTPUT "Fail"
END IF

Une seule branche s’exécute. Pour 50, la condition est vraie et la sortie est « Pass ». Pour 49, elle est fausse et la sortie est « Fail ». Un IF sans ELSE saute simplement son bloc lorsque sa condition est fausse.

La comparaison doit correspondre à la règle. « Au moins 50 » inclut 50 : il faut donc utiliser ≥. Utiliser > rejetterait ce score situé à la limite. Tester des valeurs au seuil est un moyen direct de détecter cette erreur.

Ordonner plusieurs cas

Un enchaînement de conditions ELSE IF vérifie les conditions dans l’ordre et exécute la première branche correspondante :

IF temperature ≥ 30 THEN
    OUTPUT "Hot"
ELSE IF temperature ≥ 20 THEN
    OUTPUT "Warm"
ELSE IF temperature ≥ 10 THEN
    OUTPUT "Mild"
ELSE
    OUTPUT "Cold"
END IF

Pour 24 °C, le premier test échoue et le deuxième réussit. La sortie est « Warm ». Pour 10 °C, la troisième branche s’exécute. Pour −3 °C, c’est le ELSE final qui s’exécute.

Une température de 35 °C satisfait les trois comparaisons écrites, mais seule la première branche correspondante s’exécute. Si temperature ≥ 10 venait en premier, cette condition serait satisfaite pour 35 et la sortie serait « Mild ». Lorsque des seuils « au moins » se chevauchent, teste d’abord le plus élevé. Les branches suivantes traitent alors les valeurs qui n’ont pas satisfait les seuils supérieurs.

Combiner des conditions

Pour inclure les températures de 10 °C inclus à 20 °C exclu, utilise temperature ≥ 10 AND temperature < 20. Les deux bornes doivent être respectées. Pour 15, les deux conditions sont vraies. Pour 20, la seconde est fausse.

Utiliser OR pour cet intervalle donne temperature ≥ 10 OR temperature < 20. Cette condition accepte tous les nombres : une valeur inférieure à 10 satisfait quand même la seconde partie, tandis que toute valeur supérieure ou égale à 10 satisfait la première. OR est utile lorsqu’un seul des deux cas suffit, mais pas lorsque deux bornes doivent être respectées simultanément.

Placer une décision dans une autre

Un IF imbriqué place une décision dans une branche d’une autre décision. Tu peux d’abord vérifier si un mot de passe est assez long, puis, dans la branche où le test réussit, vérifier s’il contient un chiffre. La décision intérieure n’est atteinte que si la condition extérieure le permet.

Indente le bloc intérieur pour rendre les chemins visibles. Si plusieurs décisions imbriquées rendent une règle simple difficile à lire, envisage de combiner les conditions avec AND ou d’utiliser un enchaînement de conditions ELSE IF. Suis le parcours d’une valeur dans l’ordre réel avant de supposer que tous les tests écrits sont atteints.

L’itération répète un bloc d’instructions. Une boucle permet d’exprimer une seule fois un travail répété, mais tu dois encore décider quand elle commence, quand elle se termine et quelles valeurs changent à chaque passage.

Choisir comment contrôler la répétition

Une boucle FOR convient lorsque le nombre de répétitions est connu. Une boucle conditionnelle convient à une tâche dont le moment d’arrêt dépend de valeurs ou de nouvelles entrées. Le corps d’une boucle WHILE peut ne jamais s’exécuter. Le corps d’une boucle REPEAT … UNTIL à test en fin s’exécute au moins une fois.

Suivre un compte à rebours

n ← 3
WHILE n > 0 DO
    OUTPUT n
    n ← n − 1
END WHILE
OUTPUT "Go!"

Au premier test, n vaut 3. La boucle affiche 3 et donne à n la valeur 2. Les passages suivants affichent 2 et 1. Après le passage de 1 à 0, le test est faux. L’exécution sort de la boucle et affiche « Go! ».

Si l’on retire la mise à jour, n reste égal à 3 et la boucle n’atteint jamais son état d’arrêt. Une boucle destinée à se terminer a besoin d’un moyen de modifier la condition : une mise à jour interne ou une nouvelle entrée peut le fournir.

Cumuler un total et compter les éléments

Un accumulateur construit un résultat au fil de plusieurs passages. Un compteur consigne le nombre de fois qu’un événement se produit. Pour calculer la moyenne des températures quotidiennes 18, 21, 19, 22 et 20 °C :

total ← 0
count ← 0
FOR EACH t IN temperatures
    total ← total + t
    count ← count + 1
END FOR
OUTPUT total / count

Les totaux successifs sont 18, 39, 58, 80 et 100. Le compteur vaut 5 à la fin, donc la moyenne est de 20 °C. Initialise les deux variables avant la boucle. Remettre total à zéro à l’intérieur effacerait les additions précédentes. Une liste vide exige une vérification distincte avant la division, car son nombre d’éléments est nul.

Retenir la meilleure valeur trouvée jusque-là

Pour une liste non vide, initialise largest avec le premier élément. Examine ensuite chaque valeur et remplace largest chaque fois qu’une valeur plus grande apparaît :

largest ← first item of list
FOR EACH value IN list
    IF value > largest THEN
        largest ← value
    END IF
END FOR
OUTPUT largest

Pour [7, 3, 12, 5], la meilleure valeur retenue reste 7, passe à 12 et reste à 12. Commencer à zéro échoue pour une liste comme [−4, −9, −2], dont la plus grande valeur est −2. Zéro n’a jamais été une valeur candidate.

Vérifier le premier et le dernier passage

Une erreur de décalage d’une unité ajoute ou retire une répétition. FOR i ← 0 TO 5 s’exécute six fois. Dans le compte à rebours, n ≥ 0 afficherait aussi zéro. Écris la première et la dernière valeur de la variable de contrôle pour vérifier le nombre de passages.

Les boucles imbriquées répètent une boucle à l’intérieur d’une autre. Pour 3 lignes et 4 colonnes, le bloc intérieur s’exécute quatre fois pour chaque ligne, soit 12 exécutions. La boucle intérieure recommence à chaque passage de la boucle extérieure.

Un organigramme représente un algorithme à l’aide de formes reliées par des flèches. Les formes indiquent les types d’étapes et les flèches montrent quelle étape s’exécute ensuite. Un organigramme court rend un processus visible pour une personne qui ne lit pas nécessairement le code.

Choisir une forme pour chaque rôle

Les principaux symboles suivent la norme ISO 5807. Ils ont des rôles distincts :

Une ligne de liaison possède une flèche qui indique le sens. Le sens habituel de lecture va de haut en bas et de gauche à droite, mais c’est la flèche qui détermine l’étape suivante. Une ligne qui revient à un point antérieur peut représenter une répétition.

Construire une séquence simple

Pour calculer l’aire d’une pièce rectangulaire, utilise ces cinq symboles dans l’ordre :

1. Symbole de début ou de fin : « Début ».
2. Entrée-sortie : « Entrer longueur, largeur ».
3. Traitement : area ← length * width.
4. Entrée-sortie : « Afficher l’aire ».
5. Symbole de début ou de fin : « Fin ».

Relie chaque étape à la suivante par une flèche. Avec une longueur de 4,5 m et une largeur de 3 m, le calcul donne 13,5 mètres carrés. La lecture des entrées ne calcule pas l’aire : ce calcul appartient à son propre rectangle de traitement. L’affichage de l’aire appartient au parallélogramme de sortie.

Cet organigramme ne comporte ni choix ni parcours répété. C’est une séquence pure et sa forme rend l’ordre clair.

Suivre une décision avec les valeurs actuelles

Un losange pose une question ou teste une valeur. Pour une question oui/non comme score ≥ 50?, indique « Oui » et « Non » sur les sorties. Évalue la condition avec le score actuel et suis exactement une flèche, celle qui correspond au résultat.

Une décision peut avoir plus de deux sorties possibles lorsqu’elle teste plusieurs valeurs distinctes. Indique sur chaque sortie la valeur ou le cas qu’elle représente. Ces indications servent à rendre l’étape suivante non ambiguë.

Une action comme count ← count + 1 appartient à un rectangle de traitement. Une question comme count < 5? appartient à un losange de décision. Mélanger ces rôles masque si une valeur est modifiée ou testée.

Vérifier les liaisons

Un organigramme clair comporte un seul début et au moins une fin. Chaque symbole de traitement et d’entrée-sortie possède une ligne de liaison sortante. Chaque décision oui/non possède deux sorties portant une indication. Suis chaque chemin pour vérifier qu’il atteint une étape suivante prévue ou la fin.

Évite de laisser une branche sans suite après sa sortie. Si les deux branches doivent se poursuivre par la même étape, dessine leur jonction avant cette étape. Utilise des connecteurs portant une indication lorsque des lignes longues ou croisées rendraient la page difficile à suivre. Un symbole de traitement prédéfini permet de garder une grande procédure sur un organigramme séparé tout en conservant la structure générale de l’organigramme principal.

Le pseudo-code et les organigrammes peuvent exprimer le même algorithme. Passer de l’un à l’autre implique de conserver l’ordre des actions, les conditions et tous les chemins du processus. Un schéma soigné dont le test est placé ailleurs décrit un algorithme différent.

Montrer un choix et réunir les chemins

Pour un seuil de réussite de 50, dessine un losange portant score ≥ 50?. Sa sortie Oui mène à un parallélogramme de sortie portant « Pass ». Sa sortie Non mène à un parallélogramme portant « Fail ». Réunis les chemins avant la fin.

En pseudo-code, ces chemins deviennent les branches IF et ELSE. Leur point de jonction correspond à la première instruction après END IF. L’organigramme ne doit pas envoyer le flux de la sortie Pass vers la sortie Fail : une seule des deux intervient lors d’une exécution donnée.

Placer le test au bon endroit

Une boucle possède un chemin qui revient à une étape antérieure et une décision qui détermine si la répétition continue. Pour une boucle WHILE, place la décision avant le corps de la boucle. La sortie correspondant à une condition fausse contourne le corps : il peut donc y avoir zéro passage.

Pour une boucle REPEAT … UNTIL à test en fin, place la décision après le corps. Sa sortie correspondant à une condition fausse revient au corps et sa sortie correspondant à une condition vraie quitte la boucle. Le corps s’exécute au moins une fois, car l’exécution l’atteint avant le premier test.

Étudier une connexion en trois tentatives

attempts ← 0
REPEAT
    INPUT password
    attempts ← attempts + 1
UNTIL password = storedPassword OR attempts = 3
IF password = storedPassword THEN
    OUTPUT "Welcome"
ELSE
    OUTPUT "Account locked"
END IF

Commence l’organigramme par le début et un rectangle de traitement pour attempts ← 0. Dessine ensuite le parallélogramme de saisie du mot de passe, puis le rectangle d’incrémentation. Le losange de la boucle demande « Mot de passe correct OU attempts = 3 ? ». Sa sortie Non revient à la saisie du mot de passe. Sa sortie Oui quitte la boucle.

La condition de sortie donne deux raisons possibles de s’arrêter : elle ne peut donc pas choisir à elle seule le message final. Ajoute un deuxième losange qui demande si le mot de passe est correct. Oui mène à « Welcome » ; Non mène à « Account locked ». Si la troisième tentative est correcte, la boucle s’arrête et la branche du mot de passe correct accueille bien l’utilisateur.

Convertir en suivant les chemins

Pour passer du pseudo-code à un organigramme, transforme chaque affectation en rectangle et chaque entrée ou sortie en parallélogramme. Transforme les tests des branches et des boucles en losanges. Relie le corps à sa décision de contrôle en plaçant correctement la flèche de retour.

Pour passer d’un organigramme au pseudo-code, examine où mènent les chemins de chaque losange. Des chemins qui réalisent des actions différentes puis se rejoignent indiquent une structure conditionnelle. Un chemin qui revient à une étape antérieure indique une itération. Indente chaque corps pour en montrer les limites.

Vérifie la destination de chaque flèche de retour. Revenir après la décision de contrôle ferait sauter le test suivant. Revenir avant une initialisation unique pourrait remettre un compteur à zéro à chaque passage et empêcher la boucle de se terminer.

Un algorithme peut sembler raisonnable tout en faisant ce qu’il ne faut pas. Le suivi d’exécution consiste à suivre exactement ses instructions et à consigner ce qui se produit. Les tests l’exécutent avec des entrées choisies et vérifient les résultats. Le débogage trouve et corrige la cause d’un échec.

Rendre l’état visible

Un tableau de suivi d’exécution consigne les variables et les sorties pendant une exécution à la main. Utilise les valeurs actuelles, pas celles que tu penses que l’auteur avait prévues. Par exemple :

total ← 0
FOR i ← 1 TO 4
    total ← total + i
END FOR
OUTPUT total

Ce tableau compact montre l’état après chaque addition. Pour un bogue difficile, ajoute des lignes après chaque instruction et une colonne pour les résultats des conditions. Un test de boucle faux a aussi sa place dans un suivi détaillé : il explique pourquoi l’exécution quitte la boucle.

Choisir les tests à partir des règles

Détermine le résultat attendu avant d’exécuter chaque test. Sinon, il est facile d’accepter la sortie du programme simplement parce qu’elle est apparue. Certains tests vérifient une propriété, comme le maintien de l’ordre dans la sortie, plutôt qu’un résultat exact.

Pour des scores valides de 0 à 100 avec un seuil de réussite de 50 :

Les catégories des données aux limites et invalides peuvent se chevaucher : −1 est à la fois proche d’une borne et invalide. La catégorie explique pourquoi le test est utile. Une règle utilisant score > 50 réussit les tests normaux avec 73 et 49, mais échoue avec exactement 50.

Teste aussi des structures d’entrée inhabituelles. Une liste vide, un seul élément, des valeurs toutes égales et des valeurs négatives révèlent des hypothèses différentes. Un algorithme de calcul de la moyenne doit traiter une liste vide avant de diviser par son nombre d’éléments. Un algorithme de recherche de la plus grande valeur initialisé à zéro peut échouer sur une liste entièrement négative.

Identifier l’erreur à corriger

Une erreur de syntaxe enfreint les règles d’écriture d’un langage, par exemple l’absence d’une parenthèse fermante. Une erreur d’exécution se produit pendant l’exécution, par exemple une division par zéro. Une erreur de logique permet l’exécution mais donne un résultat faux, par exemple en excluant le seuil de réussite avec >.

Ces catégories t’aident à choisir une vérification. La vérification syntaxique détecte les formes qui enfreignent les règles du langage. Un suivi d’exécution peut révéler le premier état erroné dans une erreur de logique. Des données de test peuvent déclencher une erreur d’exécution qu’une entrée habituelle ne provoquerait jamais.

Déboguer à partir du premier écart

Reproduis l’échec avec une entrée précise. Suis l’exécution ou affiche les valeurs intermédiaires et trouve la première étape où l’état réel diffère de l’état attendu. Corrige la cause, puis exécute à nouveau le test qui échouait et les tests précédents. Une correction dans une branche peut en perturber une autre.

La réussite de tests choisis fournit des éléments sur ces entrées. La correction exige toujours que la méthode traite chaque entrée valide : associe donc les tests à un raisonnement sur les instructions et leurs hypothèses.

En programmation par blocs, des blocs graphiques représentent des instructions et des valeurs. Tu les fais glisser dans un espace de travail et tu les assembles. Leurs formes évitent une grande partie du travail de mémorisation de la syntaxe et te permettent de te concentrer sur la logique du programme.

Connaître les éléments d’un projet

Scratch a été créé au MIT Media Lab. Parmi les autres environnements par blocs figurent Snap!, développé à l’University of California, Berkeley, Microsoft MakeCode et Blockly. Blockly est une bibliothèque permettant de construire des interfaces par blocs ; elle a été créée chez Google et transférée à la Raspberry Pi Foundation en 2025.

Dans Scratch, la scène est l’espace où l’exécution du projet est visible. Les lutins sont les personnages ou objets qui y agissent. Un lutin peut avoir des scripts, des costumes et des sons. Un script est une pile de blocs ; un costume est une image que le lutin peut afficher.

La scène mesure 480 unités Scratch sur 360. Son centre est le point de coordonnées (0 ; 0). Les coordonnées horizontales x vont de −240 à 240 et les coordonnées verticales y de −180 à 180. Les pas de déplacement dans Scratch sont des unités de la scène, pas des mètres.

Se laisser guider par la forme des blocs

Un bloc de valeur s’insère dans un emplacement d’entrée d’un autre bloc. Une commande s’insère dans une pile d’actions. Un bloc booléen s’insère dans un emplacement de condition. La forme aide à distinguer la fourniture d’une valeur de l’exécution d’une commande.

Trouver les blocs par catégorie

Scratch 3 possède neuf catégories principales repérées par des couleurs : Mouvement, Apparence, Son, Événements, Contrôle, Capteurs, Opérateurs, Variables et Mes blocs. Mouvement change la position ; Apparence gère l’aspect visible et les paroles ; Capteurs reçoit des informations ; Opérateurs effectue des calculs ou des comparaisons. L’extension Stylo s’ajoute séparément lorsqu’un projet doit tracer des lignes pendant le déplacement d’un lutin.

Exécuter une courte séquence

Sélectionne un lutin et place ces blocs sous un bloc de tête « quand le drapeau vert est cliqué » :

1. « aller à x : 0 y : 0 »
2. « dire Bonjour ! pendant 2 secondes »
3. « avancer de 100 pas »

Clique sur le drapeau vert. Le lutin va d’abord au centre, puis affiche « Bonjour ! » pendant deux secondes, puis avance de 100 pas dans sa direction actuelle. Le bloc de parole avec durée rend la pause visible. La pile s’exécute de haut en bas.

Une pile isolée peut s’exécuter si l’on clique directement dessus dans l’espace de travail, mais elle ne démarrera pas avec le drapeau vert si elle ne possède pas le bloc de tête correspondant. Vérifie l’ordre de la pile et son événement de démarrage lorsque le projet semble ne pas réagir.

Des blocs correctement assemblés nécessitent toujours un plan correct. Un déplacement peut avoir lieu avant une remise en position prévue, ou une question peut être posée après l’affichage du résultat. Les formes aident à construire un assemblage valide ; le suivi d’exécution révèle si cet assemblage accomplit le travail prévu.

Scratch utilise les mêmes idées que le pseudo-code : stocker une valeur, tester une condition et répéter des étapes. Les blocs rendent la structure visible, mais leur place détermine toujours quand chaque action se produit.

Choisir une boucle adaptée à la tâche

« Répéter 10 fois » exécute son corps dix fois. « Répéter indéfiniment » continue jusqu’à l’arrêt du programme et convient à un jeu qui vérifie continuellement les entrées. « Répéter jusqu’à ce que  » teste avant chaque passage et s’arrête lorsque la condition est vraie. Son corps peut donc ne jamais s’exécuter, contrairement à REPEAT … UNTIL en pseudo-code, qui teste à la fin.

Avec l’extension Stylo et le stylo en position d’écriture, « répéter 4 fois » contenant « avancer de 100 pas » et « tourner à droite de 90 degrés » dessine un carré. Pour un hexagone régulier, utilise six répétitions et une rotation de 60 degrés. Les changements de direction totalisent 360 degrés autour de la figure.

Stocker une valeur et choisir une branche

Crée score dans Variables. « Mettre score à 0 » affecte sa valeur de départ. « Ajouter 1 à score » ajoute à sa valeur actuelle. Place la remise à zéro avant une boucle de calcul du score ; à l’intérieur, elle effacerait le score précédent à chaque fois.

Le bloc de valeur arrondi score fournit la valeur actuelle aux autres blocs. Cocher sa case affiche un indicateur sur la scène, ce qui aide au suivi d’exécution.

Un bloc « si … alors … sinon » exécute l’un de ses deux corps. Son emplacement de condition à six côtés accepte un booléen comme « (score) > (9) » ou « souris touchée ? ». Les opérateurs « et », « ou » et « non » combinent des conditions avec le même sens qu’en pseudo-code.

Recevoir une entrée, construire du texte et l’afficher

Le bloc « demander [Comment t’appelles-tu ?] et attendre » attend une saisie et la stocke dans « réponse ». Le bloc « regrouper [Bonjour, ] et (réponse) » construit un texte. Place ce bloc de valeur dans « dire … pendant 2 secondes » pour afficher la salutation. Si l’entrée est « Amara », la sortie est « Bonjour, Amara ».

Les trois rôles sont distincts : demander reçoit les données, regrouper traite le texte et dire l’affiche. Un bloc de valeur peut calculer une valeur utile sans rien afficher par lui-même.

Construire un jeu de devinette

Utilise cet ordre de blocs, chaque partie indentée étant placée dans le bloc qui la contient :

"when green flag clicked"
"set secret to (pick random 1 to 10)"
"ask [Guess a number from 1 to 10] and wait"
"repeat until <(answer) = (secret)>"
    "if <(answer) > (secret)> then"
        "say [Too high] for 2 seconds"
    "else"
        "say [Too low] for 2 seconds"
    "ask [Guess a number from 1 to 10] and wait"
"say [Correct!] for 2 seconds"

Une bonne réponse dès le premier essai saute la boucle. Pour le nombre secret 6 et les propositions 3, 8 et 6, les messages sont « Too low », « Too high », puis « Correct! ». La nouvelle demande dans la boucle fournit une valeur qui peut rendre sa condition vraie.

La durée des messages compte. La question posée par un lutin visible utilise sa bulle de dialogue : la demande suivante remplace donc immédiatement une bulle dire sans durée. Un bloc dire de deux secondes permet à l’apprenant de lire d’abord le message.

Lis la boucle comme WHILE answer ≠ secret pour la vérifier en pseudo-code. Omettre la demande répétée bloque le jeu avec l’ancienne réponse incorrecte ; placer le message final de réussite à l’intérieur de la boucle le met sur le mauvais chemin.

Un projet Scratch comporte souvent plusieurs scripts qui attendent différents événements. La programmation événementielle démarre un script lorsqu’un événement se produit. Un bloc personnalisé permet ensuite à un script d’appeler une tâche réutilisable nommée.

Démarrer le bon script

Les blocs de tête comprennent « quand le drapeau vert est cliqué », « quand ce lutin est cliqué », « quand la touche espace est pressée » et « quand je reçois [message] ». Chacun décrit ce qui démarre la pile qui lui est attachée.

Plusieurs scripts peuvent réagir au même événement. Deux lutins peuvent tous deux démarrer lorsque le drapeau vert est cliqué, puis s’exécuter simultanément. La position de leurs piles dans l’espace de travail ne fixe pas d’ordre d’exécution entre elles.

À l’intérieur d’un script, les actions restent ordonnées de haut en bas. Entre les scripts, le moment de leur exécution peut compter. Si deux scripts déplacent le même lutin dans des directions opposées, leur résultat combiné dépend du moment où leurs actions s’exécutent. Donne aux scripts des responsabilités claires et coordonne le travail lorsqu’une tâche a besoin du résultat d’une autre.

Envoyer un message entre scripts

« Envoyer à tous [fin du jeu] » transmet un message à tous les lutins et à la scène. Les scripts correspondants « quand je reçois [fin du jeu] » démarrent en réponse. Le nom du message doit correspondre : il identifie l’événement traité par les destinataires.

« Envoyer à tous et attendre » met aussi l’émetteur en pause jusqu’à la fin des scripts destinataires. Utilise ce bloc lorsque l’action suivante dépend de leur achèvement. Par exemple, un contrôleur peut diffuser un message de préparation et attendre que les lutins rejoignent leurs positions de départ, puis commencer le jeu.

L’attente ne fixe pas d’ordre entre les destinataires. Si deux scripts de préparation destinataires écrasent tous deux la même valeur, ils ont toujours besoin d’un plan qui évite les responsabilités contradictoires. Un script destinataire qui s’exécute indéfiniment empêche aussi l’émetteur en attente de poursuivre.

Donner un nom et une entrée à un travail répété

Dans Mes blocs, crée un bloc personnalisé avec une entrée appelée size. Sa définition peut être décrite ainsi :

"define square (size)"
    "repeat 4"
        "move (size) steps"
        "turn right 90 degrees"

Avec le stylo en position d’écriture, appeler « square (100) » dessine des côtés de 100 pas. Appeler « square (60) » utilise les mêmes instructions avec des côtés plus courts. Le bloc personnalisé fournit une abstraction en masquant les étapes derrière un nom et une généralisation en laissant l’élément qui l’appelle fournir la taille.

L’appel exécute la définition ; il ne copie pas dans le script une deuxième version à maintenir manuellement. Modifier la définition change le travail effectué par les appels ultérieurs. Cela facilite la maintenance d’une méthode répétée.

Transposer les idées au texte

Dans un langage textuel, tu saisis les instructions et respectes les règles de ponctuation et d’espacement du langage. Le raisonnement sous-jacent sur l’état, les conditions et les répétitions reste valable.

Les blocs éliminent de nombreuses erreurs de syntaxe, mais une mauvaise condition peut toujours choisir le mauvais chemin. Les suivis d’exécution et les tests restent utiles. Les grands projets par blocs peuvent aussi devenir difficiles à parcourir et à comparer parce que leurs scripts occupent beaucoup d’espace à l’écran ; le texte est plus facile à parcourir et à gérer pour les grands projets logiciels.