Qu'est-ce qu'un algorithme ?

Un algorithme est une suite d'instructions ou d'opérations permettant de résoudre un problème.

Exemple : une recette de crêpes est un algorithme répondant au problème "Comment faire une crêpe ?"

Comment concevoir un algorithme ?

Pour l'instant, nous allons simplifier la syntaxe et nous concentrer uniquement sur la conception d'algorithmes.

Algorithme pour ouvrir une porte :
        Attraper la poignée

        Baisser la poignée

        Tirer la porte
        Relâcher la poignée
 

Petit exercice :

Concevoir un algorithme pour :
        • Allumer un ordinateur
        • Faire du vélo
        • Chauffer un plat au micro-ondes

Les conditions

Reprenons l'exemple de l'algorithme pour ouvrir une porte.

Supposons que la personne n'est pas en face de la porte, elle ne peut donc pas l'ouvrir. Il faut donc le faire déplacer à la porte.

On peut aussi supposer que la personne peut également être assise, et qu'ainsi elle doit se lever avant de se déplacer.

Nouvel algorithme pour ouvrir une porte :

        Si la personne est assise, se lever

        Si la personne est loin de la porte, se déplacer jusqu'à la porte
        Attraper la poignée

        Baisser la poignée

        Tirer la porte
        Relâcher la poignée

Petit exercice :

Concevoir un algorithme de la préparation du parfait petit déjeuner.

Mathématiques

Les algorithmes sont également utilisés pour donner des instructions aux ordinateurs (et autres machines).
Par exemple, c'est ainsi que l'on développe des sites web, des objets connectés, ou même des jeux.

L'on peut aussi désigner un algorithme comme une fonction.

On retrouvera, souvent l'utilisation des mathématiques et d'arithmétique à l'intérieur des algorithmes. Mais nous verrons cela plus tard, restons sur des choses simples !

Les variables

Qu'est-ce qu'une variable ?

Une variable, c'est en quelque sorte une boîte pouvant contenir une valeur.

On s'en sert pour stocker une valeur, et donc une information.

Types de variable

Il existe différent types de variable. Le type d'une variable définira son contenu.

• Variable type String / Alphanumérique / Chaîne de caractères : Chaîne de caractères
• Variable type Numérique : Nombre relatif
• Variable type Boolean : Opérateur logique Vrai / Faux
• Variable type Array : Tableau de variables

Instructions basiques

Afficher :

Afficher "x = " + x

L'instruction Afficher est simple, elle permet d'afficher ce qui suit. En rouge la chaîne de caractères, en bleu la valeur de la variable (ici x), en vert la transition entre chaîne de caractères et valeur.

Affecter :

x ← x+1

Cette instruction sert à affecter à une variable une valeur. En rouge la variable à laquelle on doit affecter la valeur, en bleu la valeur affectée.

On peut également demander à un utilisateur de renseigner la donnée à affecter à une variable de cette manière :

x ← Saisir()

Syntaxe

Comment écrire un algorithme ?

Test(x : entier ; y : entier ; tab : tableau ) : entier
Donnée modifiée (si tableau dans ARG) : tab, le tableau
Données (rentrées par l'utilisateur, si arguments) : x, y
Variables locales (les variables utilisées dans l'algorithme) : i, j
début

     |i ← 0

     |j ← 1

     |Si i < j alors retourner i

     |Sinon

          |j ← i*j

          |Retourner j

     |Fin Si
fin

Légende :

Orange : nom de l'algorithme
Rouge : Données qui seront modifiées (le tableau se trouve dedans s'il est dans les arguments, sinon on le met dans les variables locales)
Vert : Ce sont les données rentrées par l'utilisateur, c'est-à-dire les arguments
Bleu : Ce sont les variables qui seront utilisées durant l'algorithme
Cyan : Marque le début et la fin de l'algorithme

Ici, cet algorithme se nomme Test. Il a besoin de 2 entiers et d'un tableau pour arguments et renvoie également 1 entier.

Quelques exemples

SayGoodbye()
début
    | Afficher "Au revoir"
fin

Somme()
début
    | Afficher "Saisissez deux entiers"
    | x <- Saisir()
    | y <- Saisir()
    | Afficher x + y
fin

Comparaison
Si / Sinon

Si

L'instruction Si exprime une condition qui doit être respectée pour que la suite de l'algorithme opère. Elle peut-être considérée comme la vérification de cette condition (un booléen).

Exemple :

début
    | x <- Alea( )
    | Si x = 1 ou x > 10 alors afficher "Test réussi"
fin

Sinon

Sinon est la condition englobant le reste des conditions de Si.
Sinon va désigner toutes les autres conditions qui ne sont pas comprises dans le Si, cela signifie qu'il ne peut pas y avoir de Sinon sans Si.

Exemple :

début
    | x <- Alea( )
    | Si x = 1 ou x > 10 alors afficher "Test réussi"
    | Sinon afficher "Test échoué"
fin

Simples exercices récapitulatifs

Exercice 1 :

Concevoir un algorithme qui stock dans une variable une phrase, puis l'afficher en rajoutant "Merci" à la fin.

Exercice 2 :

Concevoir un algorithme qui prend deux entiers a et b en argument et retourne leur produit.

Exercice 3 :

Concevoir un algorithme qui prend deux entiers a et b, retourne leur somme si b est supérieur à a, et leur différence si a et supérieur à b.

Exercice 4 :

Un magasin de photos propose le développement au tarif de 0,16 € l’unité ; le tarif est de 0,12 € pour une
commande d’au moins 75 photos.
 

Ecrire un algorithme qui demande le nombre de photos à développer et qui affiche le prix à payer.

Les boucles

Une boucle est un bloc d'instructions qui a pour but de se répêter.

Pourquoi utiliser une boucle ?

Si par exemple, on veut afficher 15 fois "Bonjour", au lieu de l'écrire 15 fois, il nous suffira d'écrire une boucle affichant "Bonjour" qui se répête 15 fois.

Il existe deux types de boucle :

    • Dans le premier cas, on sait exactement combien de fois on souhaite que la boucle se répête ; dans ce cas-là on utilisera une boucle Pour

    • Dans le deuxième cas, on ne sait pas combien de fois la boucle doit se répêter, on répête la boucle tant que la condition est respectée ; dans ce cas-là on utilisera une boucle Tant que... faire (ou Faire tant que)

Comme indiqué ci-dessus, cette boucle est utilisée pour être répêtée un nombre de fois précis.

Pour

début
    | Pour i <- 0 à 9 afficher i
fin

Résultat : 0123456789

début
    | Pour i <- 0 à 9 par pas de 2 afficher i
fin

Résultat : 02468

Exemple 1 :

Exemple 2 :

La boucle Tant que... faire est utilisée pour répêter une boucle tant qu'une condition n'est pas respectée.

Exemple :

Tant que... faire

Ici, on ne sait pas précisément combien de fois va la boucle va s'exécuter.

début
     |x <- 5
     |Tant que x < 100 faire
          |Si x impair alors x <- x + 3
          |Sinon x <- x - 1
     |fin Tant que
fin

Cette boucle est similaire à la boucle précédente, sauf qu'elle va s'exécuter une première fois avant de vérifier la condition, même si celle-ci n'est pas respectée.

Exemple :

Faire... tant que

début
    | x <- 5
    | Faire
        | x <- x + 1
    | Tant que x < 3
    | Afficher x
fin
Résultat : 6

Les tableaux

Tableau à 1 dimension

Il s'agit d'un simple tableau dans lequel l'on peut placer des éléments.

Pour créer un tableau dans un algorithme, il suffit de préciser dans les variables locales qu'une variable est un tableau.

Ainsi, on pourra également accéder au contenu des cellules grâce à leur emplacement.

tab[0] <- 5

Exemple :

RemplirTableau(tab : tableau) : tableau
Donnée modifiée : tab, le tableau
Variables locales : i, l'index des cellules
début
    | Pour i <- 0 à 8
        | tab[i] <- i + 1
    | fin Pour
    | Retourner tab
fin

Cet algorithme va prendre un tableau en argument, et remplir les 9 premières cases par la valeur de leur emplacement (de 0 à 8) en ajoutant 1, puis le retournera.

En supposant que le tableau en argument est vide, voici le tableau qui sera retourné :

Tableaux à 2 dimensions :

En réalité, il s'agit d'un tableau de tableaux.

Comme un tableau à 1 dimension, il suffit de préciser que c'est un tableau à 2 dimensions dans les arguments / variables locales pour que ça en soit un.

0

1

2

3

4

5

CréerTableau()
Variables locales : tab, le tableau 2 dimensions
                    i et j, les index des cellules
début
    | Pour i <- 0 à 5
        | Pour j <- 0 à 6
            | tab[i ; j] <- i * j
        | fin Pour
    | fin Pour
    | Afficher tab
fin

Ainsi, pour accéder à une cellule du tableau, on utilise tab[i ; j], avec i et j les coordonnées de la cellule.
Attention, dans le tableau ci-dessus, i représente y et j représente x. On peut voir que tab[4 ; 3] = 32.

Cet algorithme créera et affichera le tableau 2 dimensions vu au-dessus.

Le modulo

Le modulo est le reste de la division euclidienne d'un nombre par la valeur du modulo. Il est utilisé en algorithmique pour définir l'intervalle d'un nombre.

Exemple

5 ≡ 2 (mod 3)

On lit "5 est congru à 2 modulo 3".
"≡", étant un terme un peu trop mathématique, il sera remplacé par "=" par la suite.

Autres exemples :

11 = 1 (mod 2)
30 = 0 (mod 30)
29 = 9 (mod 10)

On lit "5 est congru à 2 modulo 3".
"≡", étant un terme un peu trop mathématique, il sera remplacé par "=" par la suite.

Exercices récapitulatifs

Exercice 1 :

Concevoir un algorithme qui mélange aléatoirement un tableau.

Exercice 2 :

Concevoir un algorithme qui demande à l'utilisateur de rentrer deux nombres tant que leur somme n'est pas paire.

Exercice 3 :

Concevoir un algorithme qui demande à l'utilisateur s'il souhaite jouer ou passer son tour. Dans le cas où il joue, l'utilisateur lance deux dés "aléatoires". L'algorithme devra donner les jets de l'utilisateur.