Algorithmique et programmation par blocs

Un algorithme, c'est une suite finie et ordonnée d'instructions claires et précises qui permet de résoudre un problème ou d'atteindre un objectif. Imagine ça comme une recette de cuisine :

• Exemple 1 : Recette de cuisine (Préparer un gâteau)

  1. Préchauffer le four à 180°C.
  2. Mélanger la farine, le sucre et la levure.
  3. Ajouter les œufs et le lait.
  4. Mélanger jusqu'à obtenir une pâte homogène.
  5. Verser la pâte dans un moule.
  6. Cuire pendant 30 minutes.
  7. Laisser refroidir.

• Exemple 2 : Monter un meuble

  1. Ouvrir le carton.
  2. Identifier toutes les pièces.
  3. Suivre l'ordre des étapes du manuel.
  4. Assembler les pièces avec les vis appropriées.
  5. Vérifier la stabilité du meuble.

Dans ces exemples, chaque étape est une instruction. Si tu suis les instructions dans l'ordre, tu obtiens le résultat attendu !

Pour qu'un algorithme soit efficace, il doit respecter certaines règles :

• Précision : Chaque instruction doit être claire et non ambiguë. Pas de place à l'interprétation !
  • Exemple à éviter : "Mélanger un peu". (Combien ? Avec quoi ?)
  • Exemple correct : "Mélanger 100g de farine avec 50g de sucre."
• Finitude : L'algorithme doit se terminer après un nombre fini d'étapes. Il ne doit pas tourner en boucle indéfiniment.
• Non-ambiguïté : Pour les mêmes données de départ, l'algorithme doit toujours produire le même résultat. Il n'y a qu'une seule façon de l'interpréter.

Les ordinateurs sont des machines très puissantes, mais ils ne peuvent rien faire sans instructions. Un algorithme est exactement ce qu'il faut :

• Il donne à l'ordinateur une séquence d'opérations à effectuer.
• L'ordinateur va alors exécuter automatiquement ces instructions, très rapidement et sans erreur (sauf si l'algorithme lui-même contient des erreurs !).
• C'est grâce aux algorithmes que les ordinateurs peuvent résoudre des problèmes, comme calculer des sommes, afficher une page web, ou faire fonctionner un jeu vidéo.

La programmation par blocs est une méthode pour créer des programmes informatiques sans écrire de code textuel. Au lieu de cela, tu utilises une interface visuelle où tu assemblés des "blocs" graphiques. Chaque bloc représente une instruction ou une partie d'un programme. C'est comme construire avec des LEGO, mais pour les programmes !

• Avantages :
  • Facile à apprendre : Pas besoin de mémoriser des syntaxes compliquées.
  • Visuel : Tu vois directement comment ton programme est construit.
  • Moins d'erreurs : Les blocs s'emboîtent logiquement, ce qui réduit les fautes.

Il existe plusieurs environnements de programmation par blocs. Le plus connu et le plus utilisé en 5ème est Scratch, développé par le MIT.

L'interface de Scratch est divisée en plusieurs zones principales :

Dans Scratch, les personnages sont appelés des sprites. Chaque sprite a une position sur la scène, définie par des coordonnées (x, y).

• L'axe x représente la position horizontale (gauche/droite).
• L'axe y représente la position verticale (haut/bas).

Pour faire bouger un sprite, tu utilises les blocs de mouvement :

• avancer de (10) pas : Déplace le sprite dans la direction où il est orienté.
• aller à x: (0) y: (0) : Place le sprite à une position précise sur la scène (le centre est souvent (0,0)).
• tourner de (15) degrés : Change l'orientation du sprite.

Exemple : Pour faire avancer ton chat Scratch de 50 pas :

quand (drapeau vert) est cliqué
avancer de (50) pas

Les programmes exécutent les instructions dans l'ordre où elles apparaissent. C'est ce qu'on appelle l'exécution séquentielle. Chaque bloc est exécuté l'un après l'autre, du haut vers le bas.

• Si tu as trois blocs empilés, le premier sera exécuté, puis le deuxième, puis le troisième.
• L'ordre est crucial ! Changer l'ordre des blocs peut complètement modifier le comportement de ton programme.

Exemple :

quand (drapeau vert) est cliqué
dire [Bonjour !] pendant (2) secondes
avancer de (100) pas
dire [Je suis avancé !] pendant (2) secondes

Le chat dira d'abord "Bonjour !", puis avancera, et enfin dira "Je suis avancé !".

Parfois, tu veux répéter la même série d'instructions plusieurs fois. Au lieu de copier-coller les mêmes blocs, tu utilises une boucle.

Le bloc répéter (10) fois permet d'exécuter une séquence de blocs un nombre de fois déterminé.

• C'est très utile pour optimiser le code et le rendre plus court et plus lisible.
• Exemple : Dessiner un carré. Au lieu de "avancer, tourner, avancer, tourner...", tu fais "répéter 4 fois [avancer, tourner]".

Exemple : Faire un carré

quand (drapeau vert) est cliqué
répéter (4) fois
  avancer de (100) pas
  tourner horaire de (90) degrés

Le chat avancera de 100 pas, tournera de 90°, et répétera cela 4 fois pour former un carré.

Le bloc répéter indéfiniment est une boucle qui, comme son nom l'indique, exécute les instructions à l'intérieur sans jamais s'arrêter, jusqu'à ce que le programme soit arrêté manuellement.

• Utile pour les animations continues, les jeux où un personnage doit toujours écouter les commandes du joueur, ou un fond sonore qui doit jouer en permanence.

Exemple : Un personnage qui marche en continu

quand (drapeau vert) est cliqué
répéter indéfiniment
  avancer de (10) pas
  si (touché le bord ?) alors
    rebondir si le bord est atteint
  fin de si
  attendre (0.1) secondes

Le personnage avancera, rebondira sur les bords et continuera indéfiniment.

Les événements sont des actions qui déclenchent le début d'un script. C'est la façon dont ton programme réagit aux interactions de l'utilisateur ou à d'autres situations.

• Blocs d'événements populaires :
  • quand (drapeau vert) est cliqué : Démarre le programme.
  • quand la touche (espace) est pressée : Déclenche une action quand une touche est enfoncée.
  • quand ce sprite est cliqué : Réagit quand l'utilisateur clique sur le personnage.
  • quand l'arrière-plan bascule à (arrière-plan1) : Déclenche une action quand l'arrière-plan change.

Exemple : Faire sauter un personnage

quand la touche (espace) est pressée
  changer y de (50)
  attendre (0.2) secondes
  changer y de (-50)

Le personnage "sautera" quand tu appuieras sur la touche Espace.

Les conditions permettent à ton programme de prendre des décisions. Le bloc si () alors exécute un ensemble d'instructions seulement si une certaine condition est vraie.

• La condition est une question à laquelle on peut répondre par "vrai" ou "faux".
• Les conditions sont souvent basées sur des capteurs (toucher une couleur, une souris, une touche) ou des opérateurs (comparer des nombres).

Exemple : Réagir si le chat touche un mur

quand (drapeau vert) est cliqué
répéter indéfiniment
  avancer de (5) pas
  si <touché le bord ?> alors
    dire [Aïe, le mur !] pendant (1) secondes
    tourner horaire de (180) degrés // Faire demi-tour
  fin de si

Le chat avancera, et s'il touche le bord, il dira "Aïe, le mur !" et fera demi-tour.

Le bloc si () alors sinon offre deux chemins possibles pour le programme. Si la condition est vraie, les instructions du "alors" sont exécutées. Si la condition est fausse, ce sont les instructions du "sinon" qui sont exécutées.

• C'est très utile pour gérer des cas alternatifs.

Exemple : Un jeu où le personnage change de costume selon la couleur du sol

quand (drapeau vert) est cliqué
répéter indéfiniment
  si <couleur (rouge) est touchée ?> alors
    basculer sur le costume [costume2] // Costume "joyeux"
  sinon
    basculer sur le costume [costume1] // Costume "normal"
  fin de si

Si le personnage touche une zone rouge, il mettra le costume 2, sinon il gardera le costume 1.

Une variable est comme une boîte ou un emplacement en mémoire où tu peux stocker des informations (des nombres, du texte...). La valeur d'une variable peut changer pendant l'exécution du programme.

• Utilisations courantes :
  • Score dans un jeu.
  • Compteur (nombre de fois qu'une action se produit).
  • Nom d'un joueur.

Dans Scratch, tu peux "Créer une variable" dans la catégorie "Variables". Tu peux ensuite mettre [ma variable] à (0), ajouter (1) à [ma variable], ou montrer/cacher la variable.

Exemple : Compteur de clics

quand (drapeau vert) est cliqué
  mettre [score] à (0)
quand ce sprite est cliqué
  ajouter (1) à [score]

Chaque fois que tu cliques sur le sprite, la variable "score" augmente de 1.

Les opérateurs arithmétiques permettent de faire des calculs avec des nombres.

• (...) + (...) : Addition
• (...) - (...) : Soustraction
• (...) * (...) : Multiplication
• (...) / (...) : Division

Exemple : Calculer la somme de deux nombres

quand (drapeau vert) est cliqué
  dire (joindre [La somme de 5 et 3 est ] ((5) + (3))) pendant (2) secondes

Le chat dira "La somme de 5 et 3 est 8".

Ces opérateurs sont essentiels pour construire des conditions complexes dans les blocs si... alors.

• Opérateurs de comparaison :

  • (...) = (...) : Est égal à
  • (...) > (...) : Est supérieur à
  • (...) < (...) : Est inférieur à

• Opérateurs logiques :

  • (...) et (...) : Les deux conditions doivent être vraies.
  • (...) ou (...) : Au moins une des conditions doit être vraie.
  • non (...) : Inverse le résultat d'une condition (si elle est vraie, elle devient fausse, et inversement).

Exemple : Vérifier si un score est dans une certaine fourchette

si < <[score] > (10)> et <<[score] < (20)>> alors
  dire [Bon score !]
fin de si

Le chat dira "Bon score !" uniquement si le score est plus grand que 10 ET plus petit que 20.

Crée un jeu où le programme choisit un nombre secret entre 1 et 100, et le joueur doit le deviner.

• Concepts clés :
  • Variable pour stocker le nombre secret et le nombre de tentatives.
  • Boucle répéter indéfiniment (ou répéter jusqu'à ce que) pour que le joueur puisse faire plusieurs essais.
  • Conditions (si...alors...sinon) pour comparer la proposition du joueur avec le nombre secret (plus grand, plus petit, égal).
  • Interaction utilisateur avec le bloc demander [Devine le nombre entre 1 et 100 :] et attendre.
  • Utiliser l'opérateur nombre aléatoire entre (1) et (100) pour le nombre secret.

Anime un personnage qui réagit à des événements et change d'apparence.

• Concepts clés :
  • Mouvement (avancer de, aller à).
  • Apparence (costume suivant, basculer sur le costume).
  • Événements (quand la touche ... est pressée, quand ce sprite est cliqué).
  • Sons (jouer le son ...).
  • Utilise des boucles répéter indéfiniment pour une animation continue.

Une partie très importante de la programmation est le débogage (trouver et corriger les erreurs, ou "bugs").

• Identifier les erreurs : Si ton programme ne fait pas ce que tu attends, examine chaque bloc, un par un, pour comprendre où le problème se situe.
  • Lis ton code à voix haute, comme si tu étais l'ordinateur.
  • Utilise la fonction "pas à pas" de Scratch pour voir l'exécution bloc par bloc.
• Tester son programme : Exécute ton programme plusieurs fois avec différentes entrées pour t'assurer qu'il fonctionne dans tous les cas.
• Ajouter des fonctionnalités : Une fois que ton programme de base fonctionne, tu peux toujours l'améliorer : ajouter des niveaux, des bonus, des graphismes plus jolis, etc. Ne t'arrête jamais d'expérimenter !