Algorithmique et structure de données

Présentation du cours

Présentation personnelle

  • Ancien de l'ESGI (Architecture des logiciels)
     
  • Activités pro :
    Développeur mobile (Flutter & Android)
    CTO COMO & Flappy
    Formateur (Flutter, Git, Android, Firebase, Algo)
     
  • Adresse email : thomasecalle+prof@gmail.com

Présentation du cours

Règles générales concernant : 

  • les retards
  • l'attention en cours
  • les supports de cours
  • la notation
  • je prends vos feedback ! (thomasecalle+prof@gmail.com)

Prérequis

Savoir que :

  • 1 + 1 = 2
     
  • 2 - 1 = 1
     
  • 4 / 2 = 2
     
  • 3 * 8 = 24
     
  • si f(x) = 2x
    alors f(3) = ?

Jusqu'où irons-nous ?

Algorithmique de base :

  • types
  • opérateurs
  • variables
  • conditions
  • boucles
  • fonctions
  • tableaux
  • tris
  • récursivité

Pseudo langage !

Introduction à l'algorithmique

Qu'est-ce que c'est, l'algorithmique ?

Exemple : la recette de cuisine

Ingrédients :

  • 4 oeufs
  • 50g de beurre
  • pincée de poivre
  • pincée de sel

Faire une omelette nature

Instructions :

  • battez les oeufs avec une fourchette
  • salez et poivrez
  • faites chauffer le beurre
  • verser les oeufs dans la poêle
  • vérifier la texture souhaitée
  • pliez l'omelette en deux
  • servez

Exemple : le meuble ikéa

Matériel :

  • 4 vis
  • 2 planches de 20 cm
  • etc.

Monter un meuble Ikéa

Instructions :

  • faites quelque chose avec les planches
  • etc.

On aura compris que je ne suis pas bricoleur

Qu'est-ce que l'algorithmique ?

Dans les 2 exemples nous avons eu :

  • des "variables" de base
  • des suites d'instructions à effectuer sans réfléchir
  • un résultat 

Un algorithme est donc une séquence d'instructions exécutées de façon logique (mais non intelligente)

Qu'est-ce que ça donne en  informatique ?

L'algorithmique en informatique

  • un ordinateur est "con comme une chaise"
  • il ne comprend que le binaire : des 0 et des 1
  • il ne fait que suivre des instructions
  • 10101...11  => afficher "bonjour"
  • 01110...01 => afficher "au revoir"
  • les humains ont crée des "langages de programmation" pour s'affranchir du binaire 
  • grâce à ses langages, nous pouvons écrire "du code"
  • le "code" permet d'écrire des algorithmes : des suites d'instructions que l'ordinateur effectuera sans réfléchir

Exemple d'algorithmes 

  • envoyer un mail automatique à tous mes clients avec le texte "babar"
  • à partir d'un poids et d'une taille, calculer l'IMC
  • sauvegarder toutes les touches tapées à l'ordinateur
  • ....
  • faire n'importe quelle application ! (web, mobile, desktop, etc.)

L'algorithmique est la base du développement

 Notion de pseudo langage

Qu'est-ce qu'un langage de programmation ?

On l'a vu, un ordinateur ne comprend que les 0 et les 1 : le binaire

En théorie, on pourrait donc :

  • écrire un fichier rempli de 0 et de 1
  • "éxecuter" le fichier
  • voir le résultat sur l'ordinateur

Qu'est-ce qu'un langage de programmation ?

Sauf qu'écrire en binaire... c'est horrible.

On l'a vu, écrire un algorithme, un programme, permet d'automatiser des tâches

Pourquoi ne pas écrire un programme qui traduit nos intentions en langage binaire ?

Qu'est-ce qu'un langage de programmation ?

Comme l'algorithmique n'est qu'une suite d'instruction logique, les "langages de programmation" ne sont pas de vraies "langues"

Ils ne doivent permettre que d'écrire des instructions logiques qui seront traduites en binaire puis exécutées par l'ordinateur

Qu'est-ce qu'un langage de programmation ?

De quoi a donc besoin un langage de programmation ?

  • un système de "variables"
  • de conditions
  • de boucles
  • de fonctions
  • etc.

Tous autant de concepts communs à TOUS les langages de programmation !

Qu'est-ce qu'un langage de programmation ?

Qu'est-ce qui différencie les langages entre eux alors ?

  • la plateforme ciblée (Web, mobile, etc.)
  • les performances
  • le niveau d'abstraction (bas niveau ou haut niveau)
  • la communauté derrière le langage
  • ...
  • la mode !
  • la syntaxe

Pourquoi faire du pseudo langage ?

 

Et qu'est-ce que c'est ?

Pseudo langage ?

On l'a vu, les logiques des langages de programmations sont toutes les même (variables, conditions, boucles, etc.)

Par contre, leurs syntaxes peuvent être différentes

Pseudo langage ?

def tri_bulle(tab):
    n = len(tab)
    for i in range(n):
        for j in range(0, n-i-1):
            if tab[j] > tab[j+1] :
                tab[j], tab[j+1] = tab[j+1], tab[j]
                
tab = [98, 22, 15, 32, 2, 74, 63, 70]
 
tri_bulle(tab)
 
print ("Le tableau trié est:")
for i in range(len(tab)):
    print ("%d" %tab[i])
void tri_a_bulle(int t[], int const n)
{
	int en_desordre = 1; 
	while (en_desordre)
	{
		en_desordre = 0;
		for (int j = 0; j < n-1; j++)
		{
			if(t[j] > t[j+1])
			{
 				int tmp = t[j+1];
 				t[j+1] = t[j];
 				t[j] = tmp;
				en_desordre = 1;
 			}
		}
	}
}

Python

C

Pseudo langage ?

Un pseudo langage nous permet de créer notre propre langage, un pseudo langage, un qui n'existe pas réellement

Il nous permet de comprendre toute la logique commune à tous les langages de programmations 

Il n'y aura plus ensuite qu'à apprendre la syntaxe propre à un langage, mais vous connaitrez déjà la logique de base !

Pseudo langage ?

Un bon développeur met généralement peu de temps à apprendre un nouveau langage si il connaît déjà la logique algorithmique, il n'a plus qu'à apprendre la syntaxe propre au langage

Outils nécessaires

Outils nécessaires

Les variables

Les variables

Un algorithme se présente comme une suite d'instruction exécutées dans l'ordre

Comme dans une recette de cuisine, il faut toujours avoir en tête que l'ordre des exécutions est très important

Le premier concept à comprendre pour concevoir un algorithme est celui de VARIABLES

Les variables

Dans notre recette de cuisine, nos variables sont nos ingrédients

Nous avons une quantité X d'oeufs, Y de beurre, etc.

Nous les appelons variables car leur valeur est potentiellement amené à être modifiée au cours de l'algorithme (au cours de la recette)

Les variables

En informatique, une variable est un emplacement mémoire dans lequel est stocké une valeur

Une variable :

  • a un nom (doit commencer par une lettre et ne pas comporter d'espaces)
     
  • ne peut contenir qu'une seule valeur à la fois
     
  • son nom permet de lire sa valeur ou de l'afficher

Les variables

Pour notre recette d'omelette, nous pourrions donc imaginer notre première variable

nombreOeufs qui aurait comme valeur 4

Attention, les variables ont aussi un TYPE

Les variables

Le type de la variable correspond au type de la valeur qu'elle stocke

Le type d'une variable peut être soit :

  • un entier (nombre sans virgule, négatif ou positif)
  • un réel (nombre avec virgule, négatif ou positif)

     
  • un caractère (un symbole, comme la lettre 'a' par exemple)
  • une chaîne (zéro ou plusieurs caractères, comme "babar" par exemple)

numérique

alphanumérique

Les variables

Comment déclarer une variable dans un algorithme ?

Nous faisons notre propre pseudo langage et nous pouvons donc mettre la règle que nous voulons, du moment que l'on respecte les principes de bases :

Donner un nom et un type à la variable

Les variables

Nous déclarerons donc nos variables ainsi :

entiers: nombreOeufs, quantiteBeurre
chaine: nomDuClient

Affectation

Affectation

L'affectation est une opération permettant de modifier la valeur d'une variable

nomVariable = valeur;

Ainsi, si on imagine une variable A qui serait un entier, on pourrait écrire

a = 5;

a vaut donc la valeur de 5

Affectation

Si la variable A contenait déjà une valeur, elle serait alors écrasée à  chaque nouvelle affectation

entiers: a

a = 5;
a = 12;

combien vaut a ?

Affectation

Si la variable A contenait déjà une valeur, elle serait alors écrasée à  chaque nouvelle affectation

entiers: a

a = 5;
a = 12;

12 ! la valeur a été écrasée

Affectation

Il est possible d'affecter à une variable le résultat d'une opération arithmétique

entiers: a;

a = 5 + 3 - 1;

La variable a vaudra alors : 

7

Affectation

Il est aussi possible d'affecter à une variable la valeur d'une autre variable !

entiers: a, b

b = 3;
a = b;

La variable a vaudra alors : 

3

les deux variables doivent évidemment être du même type !

La variable b vaudra alors : 

3

Affectation

entiers: a, b

b = 3;
a = b;

zoom sur la seconde instruction

La seconde instruction lit la valeur de b puis l'affecte à a

a et b restent des variables différentes !

Modifier l'une ne modifiera pas l'autre pour autant

Affectation

entiers: a, b

b = 3;
a = b;
b = 42;

Que valent nos variables a et b ?

  • a = 
  • b =

?

?

Affectation

entiers: a, b

b = 3;
a = b;
b = 42;

Que valent nos variables a et b ?

  • a = 
  • b =

3

42

Affectation

entiers: a, b

b = 3;
a = b + 2;

Puisque le nom de la variable correspond à sa valeur, il est tout à fait possible d'écrire ce genre d'instruction :

Affectation

entiers: a

a = 4;
a = a + 1;

Il est aussi possible de faire figurer une variable des 2 côtés d'une affectation !

La seconde instruction lit la valeur de a, lui ajoute 1, puis affecte le résultat à la variable a

ceci s'appelle une incrémentation

Affectation

Passons à un petit exemple pour mieux comprendre :

entiers: a, b, c, d
a = 1;
b = 2;
c = 3;
d = a;
a = c + 1;
b = d + c;
c = d + 2 * a;
  • a =
  • b =
  • c =
  • d =

?

?

?

?

Affectation

Astuce : pour s'aider, il est possible de réfléchir avec un tableau comme celui- ci

Affectation

n.i signifie "Not Initialialized" (ou non initialisée en français)

une variable est "non intialisée" si aucune valeur ne lui a été affectée

Affectation

Passons à un petit exemple pour mieux comprendre :

entiers: a, b, c, d
a = 1;
b = 2;
c = 3;
d = a;
a = c + 1;
b = d + c;
c = d + 2 * a;
  • A =
  • B =
  • C =
  • D =

4

4

9

1

Affectation

Notons qu'il est interdit de faire figurer du côté droit d'une affectation une variable non initialisée !

entiers: a, b

a = 3;
a = b + 2;

interdit !!!

Affectation

Comment représenter les valeurs de nos variables ?

entiers: a
reels: b
caractere: c
chaine: d

a = 3;
b = 3,5;
c = 'A';
d = "toto";

notez le simple quote ('') pour un caractère et le double quotes ("") pour la chaine

Conventions d'écritures

Conventions d'écritures

Un développeur passe 90% de son temps à LIRE des algos, 10% à en écrire

Parce que la majorité du temps nous lisons des algos afin de les comprendre, les mettre à jour, les corriger... nos algorithmes se doivent d'être très propres et agréables à lire !

Conventions d'écritures

Nous allons donc mettre en place des conventions d'écritures

Ce sont des règles d'écritures qui nous permettront d'organiser correctement notre algorithme 

Cela rend :

  • l'algorithme plus lisible
  • le travail d'équipe plus facile (car tout le monde partage les même conventions)

Conventions d'écritures

Voici donc comment devront être écris tous vos algorithmes :

TITRE : Un exemple d'algo super cool
VARIABLES:

entiers: a
chaines: b

DEBUT

a = 5;
// Autres instructions

FIN

Conventions d'écritures

On notera donc les grandes parties :

  • titre (le titre de l'algo)
  • variables (déclaration des variables)
     
  • debut (début des instructions et de l'algo)
     
  • fin (fin des instructions et de l'algo)
TITRE : Un exemple d'algo super cool
VARIABLES:

entiers: a
chaines: b

DEBUT

a = 5;
// Autres instructions

FIN

Conventions d'écritures

On notera enfin la présence d'un ";" à la fin de chaque instruction

En effet, même si pour nous, en tant qu'humains, la fin d'une instruction paraît claire, ça ne l'est pas forcément pour l'ordinateur

Nous placerons donc un ";" à la fin de chaque instruction

Conventions d'écritures

// Autres instructions

Il sera également possible d'ajouter des commentaires à notre code

Les commentaires sont des phrases qui ne seront pas interprétées comme des instructions et servent uniquement à rendre le code plus lisible

Il faudra ajouter "//" au début d'une ligne pour stipuler que c'est un commentaire, comme ici : 

Text

Conventions d'écritures

Comment choisir le nom d'une variable ?

Dans la mesure du possible, donner un nom qui a un sens ! Un nom de variable long mais intelligible est bieeeen plus pertinent qu'un nom de variable 'a'

Pour une recette de cuisine, on préfèrera avoir un nom de variable nombreOeufs plutôt que x

En effet, à la relecture, on comprend bien mieux ce qu'il se passe avec des noms clairs

Conventions d'écritures

Vous pouvez en théorie écrire le nom de variable comme vous voulez tant qu'il commence par une lettre et ne contient pas d'espaces

En pratiques, il existe 2 conventions d'écritures mondialement partagées par les développeurs :

  • le snake_case
     
  • le camelCase

Conventions d'écritures

Vous l'aurez compris, en snake_case, on sépare les mots par des underscores (_)

En camelCase, nous séparons les mots en mettant une majuscule à chaque première lettre de mot (sauf le premier)

camelCase snake_case
nombreEnfants nombre_enfants
poidsEnKg poids_en_kg

Conventions d'écritures

Même si vous trouverez encore souvent du snake_case, le plus utilisé reste pour le moment le camelCase

Nous partirons donc sur des variables écrites en camelCase dans ce cours, mais sachez que le snake_case existe !

Entrées / Sorties

Entrées / Sorties

La plupart des algorithmes ont pour but de communiquer avec l'utilisateur

Cela se fait dans les deux sens :

  • l'algorithme demande des infos à l'utilisateur : les entrées
     
  • l'algorithme envoie des infos à l'utilisateur : les sorties

 

Entrées

Pour demander à l'utilisateur de SAISIR une information, nous utiliserons cette écriture :

VARIABLES:
entiers: a

DEBUT

saisir(a);

FIN

La saisie interrompt le programme tant que l'utilisateur n'a pas validé sa saisie

La valeur ainsi saisie est stockée dans la variable a

Sorties

Pour AFFICHER un message à l'utilisateur, on utilisera la commande Afficher :

VARIABLES:
entiers: a

DEBUT

saisir(a);
afficher("La valeur saisie vaut :");
afficher(a);

FIN

Sorties

Il est donc possible d'afficher des chaines et des variables

VARIABLES:
entiers: a

DEBUT

saisir(a);
afficher("La valeur saisie vaut :");
afficher(a);

FIN

Sorties

Pour afficher des variables dans une chaîne, on admettra l'écriture suivante :

VARIABLES:
entiers: age, poids

DEBUT

saisir(age);
saisir(poids);
afficher("Vous avez ", age, " ans et vous pesez ", poids, " kilos.");

FIN

Entrées / Sorties

Exemple

Ecrivons un algorithme qui demande une valeur à l'utilisateur, l'affiche, puis affiche cette valeur incrémentée de 1

Entrées / Sorties

TITRE: Exemple
VARIABLES:
entiers: a

DEBUT

afficher("Saisir une valeur :");
saisir(a);
afficher("La valeur saisie est :");
afficher(a);
afficher("La valeur incrémentée de 1 vaut :");
afficher(a + 1);

FIN

Entrées / Sorties

A partir de maintenant, il devient intéressant de tester vos algorithmes sur Algobox !

Cela vous permettra de vous rendre compte des interactions utilisateurs et de leur fonctionnement !

Ce n'est pas une obligation, mais vous verrez que c'est plus claire que la théorie sur papier et ça vous aidera peut-être à mieux comprendre !

Exercices

  • affectations
  • entrées sorties

Exercice 1

Quelles sont les valeurs des variables après les affectations suivantes ?

Titre: Ecercice 1
Variables:
entiers: a, b, c, d

Debut

a = 1;
b = a + 2;
c = 3;
c = c + a;
d = c + 2;

Fin

Exercice 2

Comment faire pour permuter les valeurs des variables a et b ? 

Titre: Ecercice 2
Variables:
entiers: a, b

Debut

a = 1;
b = 2;

Fin

Astuce : vous avez le droit de rajouter des vairiables !

Permuter signifie que a doit avoir la valeur de b et inversement

Comment faire si a et b sont des valeurs dynamiques ?

Exercice 3

Demander son âge et son nom à l'utilisateur, puis les afficher de cette manière :

Bonjour ****

Vous avez ** ans

Exercice 4

Saisir 4 notes et afficher leur moyenne

Exercice 5

Demander à l'utilisateur de saisir son poids et sa taille (en mètres)

Lui afficher son IMC (calcul trouvable sur internet)

Exercice 6

Demander à l'utilisateur de saisir 4 variables : A, B, C et D

Appliquer des permutations telles que le résultat produit soit :

l'algorithme doit fonctionner quelles que soient les valeurs saisies ! a devient d, inversement et b devient c et inversement

Corrections

  • affectations
  • entrées sorties

Correction exercice 1

Quelles sont les valeurs des variables après les affectations suivantes ?

Titre: Ecercice 1
Variables:
entiers: a, b, c, d

Debut

a = 1;
b = a + 2;
c = 3;
c = c + a;
d = c + 2;

Fin
  • a = 1
  • b = 3
  • c = 4
  • d = 6

Correction exercice 2

Titre: Ecercice 2
Variables:
entiers: a, b, temp

Debut

a = 1;
b = 2;
temp = b;
b = a;
a = temp;

Fin

La notion d'une variable dite "temporaire" pour effectuer une permutation est assez utile

Elle permet de stocker une valeur pour effectuer la permutation

Correction exercice 3

Titre: Ecercice 3
Variables:
entiers: age
chaine: nom

Debut

afficher("Quel est votre âge ?");
saisir(age);
afficher("Quel est votre nom ?");
saisir(nom);

afficher("Bonjour ");
afficher(nom);
afficher("Vous avez ");
afficher(age);
afficher("ans");

Fin

Correction exercice 4

Titre: Ecercice 4
Variables:
réels: a, b, c, d

Debut

afficher("Saisir note");
saisir(a);
afficher("Saisir note");
saisir(b);
afficher("Saisir note");
saisir(c);
afficher("Saisir note");
saisir(d);

afficher("La moyenne des notes est de : ");
afficher((a + b + c + d) / 4);

Fin

Correction exercice 5

Titre: Ecercice 5
Variables:
réels: tailleEnM, poids

Debut

afficher("Quel est votre poids");
saisir(poids);

afficher("tailleEnM est votre taille en mètres ?");
saisir(tailleEnM);


afficher("Votre IMC est de : ");
afficher(poids / (tailleEnM * tailleEnM));

Fin

Correction exercice 6

Titre: Ecercice 6
Variables:
entiers: a, b, c, d, temp

Debut

afficher("Saisir A");
saisir(a);
afficher("Saisir B");
saisir(b);
afficher("Saisir C");
saisir(c);
afficher("Saisir D");
saisir(d);

temp = a;
a = d;
d = temp;

temp = b;
b = c;
c = temp:


Fin

Petit aparté sur le modulo

Le Modulo

En informatique, l'opération "modulo", ou opération mod, est une opération binaire qui associe à deux entiers naturels le reste de la division euclidienne du premier par le second

Notre ami Wikipedia :

Le reste de la division de a par n (n différent de 0) est noté a % n

Le Modulo

En gros, imaginons la division euclidienne de 598 par 7

598 7
56 85
  38
  35
    3
  • dividende : 598
  • diviseur : 7
  • quotient : 85
  • reste : 3

Le Modulo

On peut donc dire que :

598 % 7 = 3

En effet, 3 est bien le reste de la division euclidienne de 598 par 7

Exercices

  • modulos

Exercice

Donnez les résultat des calculs suivants :

  • 34 % 10
  • 3 % 7
  • 98 % 2
  • 55 % 5
  • 57 % 5

Corrections

  • modulos

Corrections

  • 34 % 10 = 4 
  • 3 % 7 = 3
  • 98 % 2 = 0
  • 55 % 5 = 0
  • 57 % 5 = 2

Traitements conditionnels

(et introduction aux booléens)

Traitements conditionels

Un traitement conditionnel est une portion de code qui n'est exécutée que dans certaines conditions

En français, ça pourrait ressembler à :

Si l'utilisateur est majeur, alors j'affiche "majeur", sinon j'affiche "mineur" 

Traitements conditionels

Nous écrirons ces traitements de cette manière :

Si <test> alors
	// instructions si le test est passé
Fin Si

Traitements conditionels

Mais alors comment réaliser ces fameux "tests" ?

Si on réfléchit bien, un test est soit VRAI, soit FAUX

Il serait donc intéressant d'avoir un nouveau type de variables qui représente ce genre de valeur ....

Ca existe ! Et ça s'appelle :

les booléens

Traitements conditionels

La valeur d'un booléen peut être soit vrai soit faux

Ca donne donc ce genre de choses :

Titre: Exemple
Variables:
booleens: monBooleen

Debut

monBooleen = vrai;
// ou
monBooleen = faux;

Fin

Traitements conditionels

Sauf que ... comment faire pour tester si un utilisateur est majeur par exemple ?

Il faudrait pouvoir comparer 2 valeurs

C'est possible, grâce aux opérateurs relationnels !

Traitements conditionels

Voici les opérateurs relationnels :

  • a == b (pour savoir si a est égal à b)
  • a < b (pour savoir si a est strictement inférieur à b)
  • a <= b (pour savoir si a est inférieur ou égal à b)
  • a != b (pour savoir si a est différent de b)
  • a > b (pour savoir si a est strictement supérieur à b)
  • a >=b (pour savoir si a est supérieur ou égal à b)

Traitements conditionels

Pourquoi utiliser == plutôt que = ?

La raison est toute simple !

Le signe = est déjà utilisé pour l'affectation de variable, il a donc fallu trouver une autre notation pour représenter une égalité

Traitements conditionels

a = 3;
b = 5;
a = b;
a == b;

l'instruction 3 est une affectation

l'instruction 4 est une égalité

Traitements conditionels

Nous pouvons désormais écrire des algorithmes avec des traitements conditionnels !

Titre : Mon premier test conditionnel
Variables:
entiers: a
Debut

a = 5;
Si a == 5 alors
	afficher("babar");
Fin si

Fin

Traitements conditionels

Titre : Mon premier test conditionnel
Variables:
entiers: a
Debut

a = 5;
Si a == 5 alors
	afficher("babar");
Fin si

Fin

cet algorithme va afficher "babar" !

Traitements conditionels

Petit exercice :

Ecrire un algorithme qui demande son âge à l'utilisateur. Si il est majeur, afficher "majeur"

Traitements conditionels

Il est aussi possible d'étendre ce traitement en ajoutant une portion de code si le test est faux

Ceci grâce au mot Sinon

Si <condition> alors
	// instructions si le test est vrai
Sinon
	// instructions si le test est faux
Fin si

Traitements conditionels

Ecrivons l'algorithme suivant : 

Demander son âge à l'utilisateur, si l'utilisateur est majeur alors on affiche "majeur" sinon on affiche "mineur"

A la fin, quoi qu'il arrive, on affiche "Au revoir"

Afficher "Bonjour"

Traitements conditionels

Titre: Mineur ou majeur ?
Variables:
entiers: age

Debut

afficher("Bonjour");
afficher("Veuillez saisir votre âge");
saisir(age);

Si age >= 18 alors
	afficher("majeur");
Sinon
	afficher("mineur");
Fin si

afficher("Au revoir");

Fin

Traitements conditionels

Il est aussi possible de stocker le résultat du test dans une variable de type booléen

Cela donnerait ça :

Traitements conditionels

Titre: Mineur ou majeur ?
Variables:
entiers: age
booleans: estMajeur

Debut

afficher("Bonjour");
afficher("Veuillez saisir votre âge");
saisir(age);
estMajeur = age >= 18;

Si estMajeur alors
	afficher("majeur");
Sinon
	afficher("mineur");
Fin si

afficher("Au revoir");

Fin

Traitements conditionels

Dans cet exemple, l'utilisation d'une variable booléenne supplémentaire "estMajeur" est un peu inutile

Finalement, le test de base 

Si age >= 18 alors

marche tout aussi bien ET rend l'algorithme plus clair car nous n'avons pas besoin d'une variable en plus

mais c'était un bon exemple pour comprendre le fonctionnement des booléens

Traitements conditionels

Il est aussi possible d'imbriquer des tests

Traitements conditionels

saisir(a);
saisir(b);

Si a < 0 alors
	Si b < 0 alors
		afficher("a et b sont négatifs");
	Sinon
		afficher("a est négatif mais b est positif");
	Fin si
Sinon
	Si b < 0 alors
		afficher("a est positif mais b est négatif");
	Sinon
		afficher("a et b sont tous les deux positifs !");
	Fin si
Fin si

Traitements conditionels

Les opérateurs logiques

Traitements conditionels

Parfois, faire certains tests à la suite demandent une imbrication qui rend l'algorithme un peu plus dur à lire

entiers: age, tailleEnCm

// ..on imagine qu'on a demandé les informations à l'utilisateur...

Si age < 15 alors
	Si tailleEnCm > 200 alors
		afficher("Il est super grand pour son âge !");
	Sinon
		afficher("Rien à signaler");
	Fin si
Sinon
	afficher("Rien à signaler");
Fin si

Traitements conditionels

Dans cet exemple, nous affichons un message spécifique lorsque l'âge est en dessous de 15 ET que la taille est supérieure à 2m

Dans tous les autres cas, on affiche un même message "Rien à signaler"

Pour faciliter ce genre de codes, il existe les opérateurs logiques

Traitements conditionels

Ces opérateurs logiques sont les suivants :

  • et
  • ou
  • xor
  • nor
  • nand
  • non

Par exemple, ET est vérifié si les deux conditions sont vérifiées simultanément

Traitements conditionels

Réécrivons notre exemple :

entiers: age, tailleEnCm

Si age < 15 et tailleEnCm > 200 alors
	afficher("Il est super grand pour son âge !");
Sinon
	afficher("Rien à signaler");
Fin si

notez donc ici le ET qui nous fait économiser des imbrications !

Traitements conditionels

Pour savoir comment utiliser un opérateur logique, il faut connaître sa "table de vérité".

Il s'agit, pour chaque opérateur, d'un tableau rappelant les conditions de vérification des opérateurs

Traitements conditionels

Table de vérité de l'opérateur: ET

Valeur A Valeur B Résultat
0 0 0
0 1 0
1 0 0
1 1 1

ET est vérifié si les 2 conditions le sont simultanément

Traitements conditionels

Table de vérité de l'opérateur: OU

Valeur A Valeur B Résultat
0 0 0
0 1 1
1 0 1
1 1 1

OU est vérifié si au moins une des 2 conditions est vérifiée

Traitements conditionels

Table de vérité de l'opérateur: XOR

Valeur A Valeur B Résultat
0 0 0
0 1 1
1 0 1
1 1 O

XOR est vérifié si la condition A est vrai OU si la condition B est vrai, mais pas les deux en même temps

On appelle le XOR aussi le "ou exclusif"

Traitements conditionels

Table de vérité de l'opérateur: NOR

Valeur A Valeur B Résultat
0 0 1
0 1 0
1 0 0
1 1 0

NOR se dit aussi "NON ou", c'est donc l'inverse total du OU

Traitements conditionels

Table de vérité de l'opérateur: NAND

Valeur A Valeur B Résultat
0 0 1
0 1 1
1 0 1
1 1 O

NAND se dit aussi "NON et", c'est donc l'inverse total du ET

Traitements conditionels

En pratique, vous allez presque toujours utiliser ET et OU, très peu le reste

Mais gardez leur fonctionnement toujours en tête, ça peut être très utile dans certains cas !

Traitements conditionels

Petit exemple pratique :

Ecrire un algorithme qui saisi 2 nombres entiers

Sans même faire le calcule, afficher à l'utilisateur si le résultat du produit des 2 nombres sera positif ou négatif

Traitements conditionels

Titre: Exemple operateurs logiques
Variables:
entiers: a, b
Debut

saisir(a);
saisir(b);
Si (a < 0 et b < 0) ou (a > 0 et b > 0) alors
	afficher("Le résultat de a * b sera positif");
Sinon
	afficher("Le résultat de a * b sera négatif");
Fin si

Fin

Traitements conditionels

Titre: Exemple operateurs logiques
Variables:
entiers: a, b
Debut

saisir(a);
saisir(b);
Si a < 0 XOR b < 0 alors
	afficher("Le résultat de a * b sera négatif");
Sinon
	afficher("Le résultat de a * b sera positif");
Fin si

Fin

La version XOR :

Traitements conditionels

SUIVANT ... CAS

Traitements conditionels

Parfois, nous n'avons pas le choix, il faut écrire beaucoup de Si les uns à la suite des autres

Commençons à écrire par exemple un algorithme qui demande le jour de la semaine à l'utilisateur puis qui lui affiche le lendemain 

Traitements conditionels

Titre: Exemple Suivant Cas
Variables:
chaines: jour, lendemain
Debut

afficher("Saisir le jour de la semaine :");
saisir(jour);

Si jour == "lundi" alors
	lendemain = "mardi";
Fin Si
Si jour == "mardi" alors
	lendemain = "mercredi";
Fin Si
Si jour == "mercredi" alors
	lendemain = "jeudi";
Fin Si

// Et on peut tous les faire comme ça..

afficher("Le lendemain sera : ", lendemain);

Fin

Traitements conditionels

Il existe une manière d'alléger tout ça grâce à l'instruction SUIVANT..CAS

Titre: Exemple Suivant Cas
Variables:
chaines: jour, lendemain
Debut

afficher("Saisir le jour de la semaine :");
saisir(jour);

Suivant jour:
	Cas "lundi":
		lendemain = "mardi";
	Cas "mardi":
		lendemain = "mercredi";
	Cas "mercredi":
		lendemain = "jeudi";
	Cas "jeudi":
		lendemain = "vendredi";
	Cas "vendredi":
		lendemain = "Samedi";
	Cas "samedi":
		lendemain = "dimanche";
	Cas "dimanche":
		lendemain = "lundi";
	Autres cas:
		// Aucun des autres cas n'a été vérifié
Fin Suivant


afficher("Le lendemain sera : ", lendemain);

Fin

Traitements conditionels

On notera 2 choses importante:

  • la notion d'indentation (les tabulations) qui permet de délimiter les instructions à effectuer pour chaque cas

     
  • la notion de "Autres cas" qui permet de traiter tous les autres cas

Autre cas est OBLIGATOIRE à écrire si on fait un Suivant !

Traitements conditionels

Dans la situation où plusieurs cas provoqueraient les même instructions, il est autorisé d'écrire ceux-ci comme ça :

Titre: Exemple 
Variables:
entiers: mois
Début

afficher("Saisir un mois de l'année (de 1 à 12)");
saisir(mois);

Suivant mois:
	Cas 1, 3, 5, 7, 8, 10, 12:
		afficher("Ce mois a 31 jours");
	Cas 4, 6, 9, 11:
		afficher("Ce mois a 30 jours");
	Cas 2:
		afficher("Ce mois a tantôt 28 tantôt 29 jours");
	Autres cas:
		afficher("On a dit entre 1 et 12");
Fin Suivant

Fin

Exercices

  • traitements conditionnels

Exercice 1

Que valent les variables à la fin de cet algorithme ?

Titre: Exercice 1
Variables:
entiers: a, b

Début

a = 3;
b = a;

Si a <= b alors
	a = a + 2;
Sinon
	a = 9;
Fin si

Si a > b alors
	b = b - 2;
Fin si

Fin
  • a =
  • b =

?

?

Exercice 2

  • Saisir un nombre entier
  • Afficher sa valeur absolue

Rappel : la valeur absolue d'un nombre X est la distance entre X et 0

Exemples :

  • valeur absolue de 8 = 8
  • valeur absolue de -5 = 5

Ecrire un algorithme tel que :

Exercice 3

Ecrire un algorithme tel que :

  • l'utilisateur saisi une note  (un réel donc, pas un entier)
     
  • l'algorithme lui affiche sa mention :
    • mention nulle si la note est en dessous de 5 compris
    • mention moyen si entre 5 et 10 compris
    • mention assez bien entre 10 et 14 compris
    • mention bien entre 14 et 18 compris
    • mention très bien au dessus de 18

Exercice 4

Ecrire un algorithme tel que :

  • demander à l'utilisateur de saisir 3 valeurs a, b et c
  • afficher la plus petite valeur des 3

Exercice 5

Ecrire un algorithme tel que :

  • demander à l'utilisateur de saisir 3 valeurs a, b et c
  • afficher si on trouve un doublon dans ces 3 valeurs

Exercice 6

Ecrire un algorithme tel que :

  • demander à l'utilisateur de saisir a et b
  • calculer x

Soit l'équation : a*x + b = 0

Prendre en compte les cas impossibles..

Exercice 7

Ecrire un algorithme tel que :

  • demander à l'utilisateur de saisir deux entiers a et b
  • demander à l'utilisateur de saisir un caractère OP correspondant à un opérateur ('+','-','*' ou '/')
  • si le caractère sélectionné n'est pas un opérateur valide, afficher une erreur
  • sinon, afficher le résultat de : a OP b

Exemple si l'utilisateur saisi : 3, 5 et *
Alors le résultat sera: 3*5 = 15

Exercice 8

Ecrire un algorithme tel que :

  • demander à l'utilisateur de rentrer une heure de début (en demandant d'abord les heures puis les minutes)
  • demander à l'utilisateur de rentrer une heure de fin (en demandant d'abord les heures puis les minutes)
  • Afficher le temps écouler entre les deux
    Si l'utilisateur rentre 10h30 et 12h15, on doit lui afficher 1h45
     
  • Si l'heure de fin est avant celle de début, afficher une erreur

Exercice 9

Ecrire un algorithme tel que :

  • demander une date à l'utilisateur en 3 parties : le jour, le mois et l'année
  • afficher à l'utilisateur la date du lendemain en prenant en compte :
    • le nombre de jours par mois
    • le fait que Février comporte 29 jours les années bissextiles
    • une année est bissextile si elle est divisible par 4 mais pas par 100

Corrections

  • traitements conditionnels

Correction exercice 1

Que valent les variables à la fin de cet algorithme ?

Titre: Exercice 1
Variables:
entiers: a, b

Début

a = 3;
b = a;

Si a <= b alors
	a = a + 2;
Sinon
	a = 9;
Fin si

Si a > b alors
	b = b - 2;
Fin si

Fin
  • a =
  • b =

5

1

Correction exercice 2

Titre: Valeur Absolue
Variables:
entiers: a

Début

afficher("Saisir un nombre");
saisir(a);

Si a < 0 alors
	afficher("la valeur absolue de ", a, " est : ", -a);
Sinon
	afficher("la valeur absolue de ", a, " est : ", a);
Fin si

Fin

Correction exercice 3

Titre: Mention
Variables:
reels: note

Début

afficher("Saisir la note");
saisir(note);

Si note < 5 alors
	afficher("mention nulle !");
Sinon Si note >= 5 et note <= 10 alors
	afficher("mention moyen");
Sinon Si note > 10 et note <= 14 alors
	afficher("mention assez bien !");
Sinon Si note > 14 et note <= 18 alors
	afficher("mention bien !");
Sinon
	afficher("mention très bien");
Fin si

Fin

Correction exercice 4

Titre: Plus petite valeur
Variables:
entiers: a, b, c, min

Début

afficher("Saisir première valeur");
saisir(a);
min = a;

afficher("Saisir seconde valeur");
saisir(b);
Si b < min alors
	min = b;
Fin si

afrficher("Saisir troisième valeur");
saisir(c);
Si c < min alors
	min = c;
Fin si

afficher("La plus petite valeur rentrée est : ", min);

Fin

Correction exercice 5

Titre: Doublons
Variables:
entiers: a, b, c

Début

afficher("Saisir première valeur");
saisir(a);

afficher("Saisir seconde valeur");
saisir(b);

afficher("Saisir troisième valeur");
saisir(c);

Si a == b ou a == c ou b == c alors
	afficher("Doublon trouvé !");
Fin si

Fin

Correction exercice 6

Soit l'équation : a*x + b = 0

Alors on sait que x = -b/a

Titre: ax+b = 0
Variables:
entiers: a, b
Début

afficher("Saisir a");
saisir(a);
afficher("Saisir b");
saisir(b);

Si a == 0 alors
	afficher("diviser par 0 est impossible !");
Sinon
	afficher("Soit a*x + b = 0");
	afficher("Si a = ", a, " et b = ", b, " alors x = ", -b/a);
Fin Si

Fin

Correction exercice 7

Titre: Exercice 7
Variables: 
entiers: a, b
caractere: operateur

Début

afficher("Saisir a");
saisir(a);

afficher("Saisir b");
saisir(b);

afficher("Saisir opérateur");
saisir(operateur);

Suivant operateur:
	Cas '+':
		afficher("a + b = ", a + b);
	Cas '-':
		afficher("a - b = ", a - b);
	Cas '*', 'x':
		afficher("a * b = ", a * b);
	Cas '/':
		Si b == 0 alors
			afficher("impossible de diviser par 0");
		Sinon
			afficher("a / b = ", a / b);
		Fin Si
    Autres cas:
		afficher("Opérateur impossible !");
Fin Suivant

Fin

Correction exercice 8

Titre: Une question d'heures
Variables:
entiers: heureDebut, minutesDebut, heureFin, minutesFin
Début

afficher("Saisir l'heure de début");
saisir(heureDebut);

afficher("Saisir minutes de début");
saisir(minutesDebut);

afficher("Saisir l'heure de fin");
saisir(heureFin);

afficher("Saisir minutes de fin");
saisir(minutesFin);

Si heureFin < heureDebut ou (heureFin == heureDebut et minutesFin < minutesDebut) alors
	afficher("l'heure de fin ne peut être avant celle de début");
Sinon
	Si minutesFin >= minutesDebut alors
		afficher("Durée écoulée = ", heuresFin - heuresDebut, "h", minutesFin - minutesDebut, "min");
	Sinon
		afficher("Durée écoulée = ", heuresFin - (heuresDebut + 1), "h", 60 - minutesDebut + minutesFin);
    Fin Si
Fin Si

Fin
Titre: Une histoire de date
Variables: jour, mois, annee
Début

afficher("Saisir numéro jour (exemple: 5)");
saisir(jour);

afficher("Saisir numéro mois (exemple: 3)");
saisir(mois);

afficher("Saisir année (exemple: 1994)");
saisir(annee);

Suivant mois:
	Cas 1, 3, 5, 7, 8, 10, 12:
		Si jour == 31 alors
			jour = 1;
			Si mois == 12 alors
				mois = 1;
				annee = annee + 1;
			Sinon
				mois = mois + 1;
			Fin Si
		Sinon
			jour = jour + 1;
		Fin Si
	Cas 4, 6, 9, 11:
		Si jour == 30 alors
			jour = 1;
			mois = mois + 1;
		Sinon
			jour = jour + 1;
		Fin Si
	Cas 2:
		Si annee % 4 == 0 et annee % 100 != 0 alors
			Si jour == 29 alors
				jour = 1;
				mois = 3;
			Sinon
				jour = jour + 1;
		Sinon
			Si jour == 28 alors
				jour = 1;
				mois = 3;
			Sinon
				jour = jour +1;
			Fin Si
		Fin SI
	Autres cas:
		afficher("Erreur de saisie du mois !");
Fin suivant

afficher("Lendemain = ", jour, "/", mois, "/", annee);

FIn

et encore, on a pas géré les cas d'erreurs !

Correction exercice 9

Les boucles

Les boucles

Si je vous demandais quelque chose comme écrire un algorithme affichant les nombres de 1 à 10, qu'écririez-vous ?

Les boucles

Ca ?

Titre: Nombres de 1 à 10
Variables:
Début

afficher("1");
afficher("2");
afficher("3");
afficher("4");
afficher("5");
afficher("6");
afficher("7");
afficher("8");
afficher("9");
afficher("10");

Fin

Avouer que c'est moche !

Trop de copiés collés, trop de lignes, etc.

Et que faire si on veut que les bornes min et max soient dynamiques ?

Les boucles

Nous allons donc apprendre à faire beaucoup, beaucoup, ... beaucoup plus propre !

Et ça grâce aux boucles !

Les boucles

Une boucle permet d'exécuter plusieurs fois de suite une même séquence d'instructions

Cet ensemble d'instructions d'appelle le corps de la boucle

Chaque exécution du corps d'une boucle d'appelle une itération

(on parle aussi, plus formellement, de passage dans la boucle)

Les boucles

Lorsqu'on s'apprête à exécuter la première itération, on dit que l'on rentre dans la boucle

Lorsque la dernière itération est terminée, on dit que l'on sort de la boucle

Les boucles

Mais c'est quoi, une boucle ?

Il en existe 3 types différents

  • tant que
  • répéter ... jusqu'à
  • pour

Chaque boucle a ses avantages et ses inconvénients comme nous allons le voir

Les boucles

La boucle Tant que

Les boucles

La boucle Tant que

La syntaxe de la boucle Tant que est la suivante :

Tant que <condition>
	<instructions>
Fin tant que

Les boucles

La boucle Tant que

La condition est évaluée avant chaque itération

A chaque fois que la condition est vérifiée, on rentre dans la boucle et on exécute les instructions 

Une fois que la condition n'est plus vérifiée, l'algorithme reprend à la suite du Fin tant que

Les boucles

La boucle Tant que

Exemples pour afficher les nombres de 1 à 10 :

Titre: Afficher les nombres de 1 à 10
Variables:
entiers: i

Début

i = 1;
Tant que i <= 10
	afficher(i);
	i = i + 1;
Fin tant que

Fin

Les boucles

La boucle Répéter ... jusqu'à

Les boucles

La boucle Répéter ... jusqu'à

La syntaxe de la boucle Répéter ... jusqu'à est la suivante :

Répéter
	<instructions>
Jusqu'à <condition>

Les boucles

La boucle Répéter ... jusqu'à

La condition est évaluée après chaque itération

On exécute le corps de la boucle jusqu'à ce que la condition soit vérifiée

On passe donc toujours au moins une fois dans le corps d'une boucle Répéter ... jusqu'à

Les boucles

La boucle Répéter ... jusqu'à

Exemples pour afficher les nombres de 1 à 10 :

Titre: Afficher les nombres de 1 à 10
Variables:
entiers: i

Début

i = 1;
Repeter
	afficher(i);
	i = i + 1;
Jusqu'à i > 10

Fin

Notez le supérieur strictement

Comme la condition est évaluée après, on doit mettre strictement

Les boucles

La boucle Répéter ... jusqu'à

Petit exercice

Demander à l'utilisateur de saisis un nombre positif.

Tant que ce n'est pas le cas, répéter la demande.

Les boucles

La boucle Répéter ... jusqu'à

Titre: Saisir un nombre positif
Variables:
entiers: i

Début

Repeter
	afficher("Saisir un nombre strictement positif");
	saisir(i);
Jusqu'à i > 0

Fin

Les boucles

La boucle Pour

Les boucles

La boucle Pour

La syntaxe de la boucle Pour est la suivante :

Pour <variable> allant de <valeur de départ> à <valeur d'arrivée> (par pas de <pas>)
	<instructions>
Fin pour

Les boucles

La boucle Pour

La boucle Pour fait varier la valeur de <variable> entre <valeur de départ> et <valeur d'arrivée>

Le <pas> est optionnel et permet de représenter la variation du compteur entre chaque itération

Le pas par défaut est 1 et correspond donc à une incrémentation

Les boucles

La boucle Pour

Exemples pour afficher les nombres de 1 à 10 :

Titre: Afficher les nombres de 1 à 10
Variables:
entiers: i

Début

Pour i allant de 1 à 10
	afficher(i);
Fin Pour

Fin

Les boucles

La boucle Pour

La boucle Pour se charge d'initialiser elle-même la variable compteur, on a donc pas à affecter une valeur à i puisqu'il prendra la valeur de <valeur de départ>, et donc ici 1

Les boucles

La boucle Pour

Petit exercice :

Demander un nombre entier à l'utilisateur.

Afficher "bonjour" autant de fois que le nombre donné.
Utiliser une boucle POUR. 

Les boucles

Alors... quelles boucle utiliser ?

Lorsque l'on sait d'avance combien d'itérations nous souhaitons faire, la boucle la plus pertinente est la boucle POUR

Sinon, il nous reste à choisir entre Tant que et Répéter ... jusqu'à

Là le choix se fait davantage sur le besoin (ou non) d'exécuter les instructions une première fois quoi qu'il arrive

Les boucles

Attention

Lorsqu'on utilise une boucle, il est important de toujours faire attention à la fameuse "boucle infinie"

Une boucle infinie est une boucle .. qui ne finit jamais et qui provoque une erreur très problématique en informatique

Les boucles

Attention

Par exemple :

Tant que vrai
	// instructions
Fin tant que

// Ici, les instructions ne seront jamais lues !

"vrai" étant toujours vrai, la boucle ne finira jamais !

Au delà du fait que les instructions suivantes ne seront jamais traitées, cela peut provoquer de gros problèmes de RAM sur un ordinateur

Exercices

  • les boucles

Exercices

Pour les exercices suivants, vous devez y répondre en utilisant les 3 types de boucles à chaque fois

Exercice 1

Ecrire un algorithme tel que :

  • demander à l'utilisateur un nombre n positif
  • afficher tous les nombres entiers de n à 0 

Exercice 2

Ecrire un algorithme tel que :

  • demander à l'utilisateur un nombre n
  • afficher la factorielle de n 

Pour rappel, la factorielle d'un nombre n est le produit de tous les entiers positifs inférieurs ou égaux à n 

  • 1! = 1
  • 2! = 1 x 2
  • 3! = 1 x 2 x 3
  • ...
  • 6! = 1 x 2 x 3 x 4 x 5 x 6

Exercices

Pour les exercices suivants, partez direct sur la boucle la plus pertinente par rapport à l'énoncé

Exercice 3

Ecrire un algorithme tel que :

  • demander un nombre n à l'utilisateur
  • afficher la table de multiplication du nombre n

Exercice 4

Ecrire un algorithme tel que :

  • demander un mot de passe à l'utilisateur
     
  • continuer à lui demander tant qu'il n'aura pas trouver le bon mot de passe : babar

Exercice 5

Ecrire un algorithme tel que :

  • demander un nombre n à l'utilisateur
  • demander un nombre b positif à l'utilisateur (on ne prendra que des nombres >= 0)
  • afficher le résultat de n^b (n puissance b)

Pour rappel :

  • 2^1 = 2
  • 2^2 = 2 x 2
  • 2^5 = 2 x 2 x 2 x 2 x 2 = 32
  • ...

Exercice 6

Ecrire un algorithme tel que :

  • demander un nombre n à l'utilisateur
  • afficher la somme des entiers de 1 à n compris

Exercice 7

Ecrire un algorithme tel que :

  • demander un nombre n à l'utilisateur
  • si ce nombre est pair, afficher les 10 prochains nombres pairs
  • si ce nombre est impair, afficher les 10 prochains nombres impairs

Exercice 8

Ecrire un algorithme tel que :

  • faites un jeu du plus ou moins !
  • faites deviner un nombre au joueur (entre 0 et 100)
  • tant qu'il n'a pas trouvé, il continue
  • à la fin, affichez lui en combien d'essais il a réussi

Exercice 9

Ecrire un algorithme tel que :

  • Afficher toutes les tables de multiplications, de 1 à 10

On imagine un affichage comme ceci :

Table de 1

1x1 = 1

1x2 = 2

1x3 = 3

...

Table de 2

...

Exercice 10

Ecrire un algorithme tel que :

  • demander à l'utilisateur un nombre de minutes et un nombre de secondes
  • afficher un compte à rebours
  • par exemple, si l'utilisateur rentre 1 pour les minutes et 30 pour les secondes :
    1min30s
    1min29s
    1min28s
    ...
    0min2s
    0min1s
    0min0s

On test pas les cas d'erreurs

Corrections

  • les boucles

Correction exercice 1

Titre: Entiers de n à 0
Variables:
entiers: n

Début

afficher("Saisir un nombre n positif");
saisir(n);

Répéter
	afficher(n);
	n = n -1;
Jusqu'à n < 0

Fin
Tant que n >= 0
	afficher(n);
	n = n - 1;
Fin Tant que

entiers: n, i
Pour i de n à 0 (pas de -1)
	afficher(i)
Fin Pour

Correction exercice 2

Titre: Factorielle de n
Variables:
entiers: n, i, factorielle

Début

afficher("Saisir un nombre n positif");
saisir(n);

factorielle = 1;

Pour i de 2 à n
	factorielle = factorielle * i;
Fin Pour

afficher(factorielle);

Fin
i = 1;
factorielle = 1;

Répéter
	factorielle = factorielle * i;
	i = i + 1;
Jusqu'à i > n

afficher(factorielle);
i = 1;
factorielle = 1;

Tant que i <= n
	factorielle = factorielle * i;
	i = i + 1;
Fin tant que

afficher(factorielle);

Correction exercice 3

Titre: Table de multiplication de n
Variables:
entiers: n, i

Début

afficher("Saisir un nombre n positif");
saisir(n);

Pour i de 0 à 10
	afficher(i, "x", n, " = ", i * n);
Fin Pour

Fin

Correction exercice 4

Titre: Mot de passe
Variables:
chaine: mdp

Début

Répéter
	afficher("Saisissez le bon mot de passe");
	saisir(mdp);
Jusqu'à mdp == "babar"

afficher("Mot de passe trouvé !");
Fin

Correction exercice 5

Titre: n^b
Variables:
entiers: n, b, resultat, i

Début

afficher("Saisir un nombre");
saisir(n);

Répéter
	adficher("Saisir un nombre entier positif");
	saisir(b);
Jusqu'à b >= 0

Si b == 0 alors
	afficher(1);
Sinon
	resultat = 1;

	Pour i de 1 à b
		resultat = resulat * n;
	Fin Pour

	afficher(b, "^", n, " = ", resultat);
Fin Si

Fin

Correction exercice 6

Titre: Somme des entiers de 1 à n
Variables:
entiers: n, somme, i

Début

afficher("Saisir un nombre");
saisir(n);

somme = 0;
Pour i de 1 à n
	somme = somme + i;
Fin Pour

afficher(somme);

Fin

Correction exercice 7

Titre: 10 prochains pairs ou impairs
Variables:
entiers: n, i

Début

afficher("Saisir un nombre");
saisir(n);

Pour i de 2 à 20 (pas de 2)
	afficher(n + i);
Fin Pour

Fin

Correction exercice 8

Titre: Plus ou moins !
Variables:
entiers: nombreADeviner, choix, compteur

Début

nombreADeviner = 42;
compteur = 0;

afficher("Jouons au plus ou moins ! Le but : trouver le nombre (entre 0 et 100)");

Répéter
	afficher("Tentative :", compteur);
	saisir(choix);
	compteur = compteur + 1;
Jusqu'à nombreADeviner == choix

afficher("Bravo vous avez trouvé en ", compteur, " tentatives !");
    
Fin

Correction exercice 9

Titre: Tables de multiplication
Variables:
entiers: i, j

Début

Pour i de 1 à 10
	afficher("Table de ", i);
	Pour j de 1 à 10
		afficher(i, "x", j, " = ", i * j);
    Fin Pour
Fin Pour
Fin

Correction exercice 10

Titre: Compte à rebours
Variables:
entiers: min, secondes

Début

saisir(min);
saisir(secondes);

Tant que min != 0 OU secondes != 0

	Si secondes == 0 alors
		min = min - 1;
		secondes = 59;
	Sinon
		secondes = secondes - 1;
	Fin Si
	
	afficher(min,"min",secondes,"s");
	
Fin Tant que

Fin

Les fonctions

Les fonctions

Avec tout ce que nous avons appris, on peut maintenant faire pas mal de choses et de minis-programmes !

Seulement, vous l'avez peut-être remarqué, un algorithme peut vitre devenir brouillon :

Code mal organisé, morceaux de codes copiés collés, etc.

Les fonctions

Plus votre code est mal organisé et contient des duplications, plus il sera difficile :

  • de déceler une erreur
  • de maintenir et de faire évoluer le code

Pour pallier ce problème, il est possible d'écrire des Fonctions

Les fonctions

Une fonction est un ensemble d'instructions portant un nom

On peut voir une fonction comme un sous-algorithme que votre algorithme pourra appeller

Les fonctions

La syntaxe pour déclarer une fonction est la suivante :

Fonction nomDeLaFonction()
	// Instructions
Fin Fonction

Exemple :

Fonction direBonjour()
	afficher("Bonjour");
Fin Fonction

Les fonctions

Pour appeler une fonction, il suffit d'écrire son nom, suivit de ()

Titre: Ma première fonction
Variables:

Début

Fonction direBonjour()
	afficher("Bonjour");
Fin Fonction

direBonjour();

Fin

Par exemple :

cet algorithme affiche Bonjour

Les fonctions

Il est tout à fait possible d'appeler une fonction .. dans une autre fonction !

Les fonctions

Titre: Bonjour Au revoir
Variables:
Début

Fonction afficherBonjour()
	afficher("Bonjour");
Fin Fonction

Fonction afficherAuRevoir()
	afficher("Au revoir");
Fin Fonction

Fonction afficherBonjourAuRevoir()
	afficherBonjour();
	afficherAuRevoir();
Fin Fonction

afficherBonjourAuRevoir();

Fin

Les fonctions

Il est tout a fait possible de déclarer des variables au sein d'une fonction

Nous appellerons ces variables, des variables locales à la fonction

Attention :  un variable locale n'existe que dans la fonction qui la déclare, ou dans son "scope"

Les fonctions

Par exemple: il est tout à fait possible de créer une fonction comme ceci :

Titre: Variable locale
Variables:

Début

Fonction afficherDe1a10()
	eniers: i
	Pour i de 1 à 10
		afficher(i);
	Fin Pour
Fin Fonction

Fin

Les fonctions

Ainsi, si on appelle la fonction

Titre: Variable locale
Variables:

Début

// Code de la fonction ...

afficherDe1a10();

Fin

cela affichera bien les nombres de 1 à 10 !

Les fonctions

Attention donc : la variable i déclarée dans la fonction afficherDe1a10 n'existe QUE dans le scope de cette fonction !

Fonction afficherDe1a10()
	eniers: i
	Pour i de 1 à 10
		afficher(i);
	Fin Pour
Fin Fonction

afficherDe1a10();

afficher(i);

Ici, l'instruction d'affichage de i est donc une grosse erreur ! Car i n'existe pas dans l'algorithme principal mais uniquement dans la fonction !

!

Les fonctions

Petits exemples: Dire ce qui est valable ou non :

Titre: Exemple 1
Variables
Debut

Fonction a()
	entiers: i
	i = 1;
	afficher(i);
Fin Fonction

afficher(i);

Fin
Titre: Exemple 2
Variables
Debut

Fonction a()
	entiers: i
	i = 1;
	afficher(i);
Fin Fonction

Fonction b()
	afficher(i);
Fin Fonction

Fin
Titre: Exemple 3
Variables
entiers: i
Debut

Fonction a()
	entiers: i
	i = 1;
	afficher(i);
Fin Fonction

i = 1;
afficher(i);

Fin

Les fonctions

Il est aussi important de comprendre que chaque appel à une fonction réinitialise toutes les variables locales

Titre: Exemple
Variables
Debut

Fonction maBoucle()
	entiers: i
	Pour i de 1 à 10
 		afficher(i);
	Fin Pour
Fin Fonction

maBoucle();
maBoucle();

Fin

La variable locale i est re-initialisée à chaque appel

Les deux appels auront donc exactement le même effet : afficher les nombres de 1 à 10

Les fonctions

Attention, toutes les variables déclarée dans un scope parent sont en revanche utilisables dans un scope enfant

Titre: Exemple
Variables
entiers: babar
Debut

babar = 42;

Fonction maBoucle()
	entiers: i
	Pour i de 1 à 10
 		afficher(i, ": ", babar);
	Fin Pour
Fin Fonction

maBoucle();

Fin

Nous avons ici le droit d'appeler la variable "babar" dans la fonction car cette variable existe dans le scope parent de la fonction

Les fonctions

Il est possible de passer des paramètres à une fonction

Et c'est très très utile !

Les fonctions

Un paramètre est en fait une valeur envoyée à la fonction 

Voici la syntaxe :

Fonction afficherBonjour(chaine: nom)
	afficher("Bonjour ", nom);
Fin Fonction

Les fonctions

Fonction afficherBonjour(chaine: nom)
	afficher("Bonjour ", nom);
Fin Fonction

Ici, la fonction déclare recevoir une chaîne en paramètre

La fonction déclare en fait le nom d'une variable ("nom", ici) qui prendra la valeur qui est envoyée à la fonction

La fonction pourra alors ensuite utiliser cette variable comme bon lui semble !

Les fonctions

Fonction afficherBonjour(chaine: nom)
	afficher("Bonjour ", nom);
Fin Fonction

afficherBonjour("Bob");

Pour appeler la fonction, il faudra désormais mettre le paramètre attendu entre les parenthèses d'appel, comme ceci :

Les fonctions

Fonction afficherBonjour(chaine: nom)
	afficher("Bonjour ", nom);
Fin Fonction

afficherBonjour();

Attention, une fonction qui prend un paramètre entre parenthèse ne peut plus être appelée sans ce paramètre ! 

cet appel est impossible et causera une erreur !

!

Les fonctions

Fonction afficherBonjour(chaine: nom)
	chaines: nom
	afficher("Bonjour ", nom);
Fin Fonction

Attention 2, une fonction ne peut donner un nom à un paramètre qui serait le même qu'une variable locale

!

interdit !

Les fonctions

Titre
Variables
chaine: nom

Début

nom = "toto";

Fonction afficherBonjour(chaine: nom)
	chaines: nom
	afficher("Bonjour ", nom);
Fin Fonction

Fin

Attention 3, une fonction, par souci de lecture, ne peut pas non plus déclarer une variable qui aurait le même nom qu'une variable provenant du scope parent

!

interdit !

Les fonctions

Fonction afficherBonjour(chaine: prenom, chaine: nom)
	afficher("Bonjour ", prenom, " ", nom);
Fin Fonction

afficherBonjour("Thomas", "Ecalle");

Une fonction peut tout à fait prendre plusieurs paramètres :

Les fonctions

Petit exercice :

  • Ecrire une fonction qui prend un entier en paramètre
  • Cette fonction affichera les nombres de 1 à l'entier donné
  • Appeller la fonction

Si l'entier vaut 3, affichera : 1, 2, 3

Si l'entier vaut 6, affichera : 1, 2, 3, 4, 5, 6

Les fonctions

Titre: Exemple
Variables
entiers: monNombre
Debut

Fonction boucle(entier: n)
	entier: i
	Pour i de 1 à n
		afficher(i);
	Fin Pour
Fin Fonction

saisir(monNombre);

boucle(monNombre);
boucle(4);

Fin

Les fonctions

Il y a 2 manières de passer un paramètre à une fonction :

  • le passage de paramètre par valeur/copie (par défaut)
  • le passage de paramètre par référence (cas particulier)

Les fonctions

Le passage de paramètre par valeur signifie que le paramètre est en fait une copie de la variable envoyée

Cela signifie qu'aucune modification de cette variable ne pourra affecter la variable initiale

Les fonctions

Exemple :

Titre: Passage par valeur
Variables:
entiers: a
Début

Fonction test(entiers: n)
	n = 10;
Fin Fonction

a = 3;
test(a);
afficher(a);

Fin

Le paramètre a été passé par valeur, ainsi la fonction manipule une COPIE de a !

La fonction a beau modifier n, cela n'a d'effet que dans le scope de la fonction, la variable a dans le scope principal vaut toujours 3

Les fonctions

Le passage de paramètre par référence signifie que le paramètre partage la même référence de variable que celle d'origine

Cela signifie que toutes les modifications apportées dans la fonction auront un effet sur la variable initiale !

Nous utiliserons dans notre pseudo code le symbole "*" à côté du nom de la variable pour indiquer qu'elle est passée par référence

Les fonctions

Exemple :

Titre: Passage par référence
Variables:
entiers: a
Début

Fonction test(entiers: n*)
	n = 10;
Fin Fonction

a = 3;
test(a);
afficher(a);

Fin

Ici, la fonction prend un paramètre a passé par référence (*)

Ainsi, dans le scope principal, la valeur de a a été changé et vaut maintenant 10 !

Les fonctions

Petit exercice : écrire un algorithme qui demande 3 fois un mot à l'utilisateur et qui affiche à chaque fois "Le mot choisi est : ***" avec me mot choisi

Evidemment, on utilise une fonction pour afficher le mot choisi :)

Les fonctions

Petit exercice 2: écrire un algorithme qui échange les valeurs de 2 nombres,

Evidemment, on utilise une fonction et des paramètres passés par référence

Les fonctions

Une fonction peut, enfin, renvoyer une valeur !

On appelle cela une valeur de retour

Les fonctions

Une fonction, si elle retourne une valeur, ne peut en retourner qu'une seule et doit impérativement indiquer le type de la valeur

Par exemple :

Fonction exemple(): entier
	retourner 42;
Fin Fonction

Pour indiquer que l'on retourne une valeur, on utilise le mot-clé Retourner

: entier indique que la valeur retournée sera un entier

Les fonctions

Attention, une fois que Retourner est appelé, la fonction est interrompue sur le champs, aucune instruction suivant le Retourner ne sera effectuée

Fonction exemple(): entier
	afficher("Hello");
	retourner 42;
	afficher("Bye");
Fin Fonction

Bye ne sera jamais affiché !

Les fonctions

Petit exemple d'utilisation de retour de fonction :

Titre: Exemple
Variables:
entiers: a, b, resultat

Début

Fonction addition(entier: n, entier: m): entier
	retourner n + m;
Fin Fonction

afficher("Saisir a");
saisir(a);

afficher("Saisir b");
saisir(b);

resultat = addition(a, b);
afficher(resultat);

Fin

Les fonctions

On peut aussi directement écrire :

Titre: Exemple
Variables:
entiers: a, b

Début

Fonction addition(entier: n, entier: m): entier
	retourner n + m;
Fin Fonction

afficher("Saisir a");
saisir(a);

afficher("Saisir b");
saisir(b);

afficher(addition(a, b));

Fin

Les fonctions

Petit parallèle avec les mathématiques

En mathématique, une fonction comme :

f(x) = 3x + 2

représente parfaitement une fonction en informatique !

On dit que f est une fonction qui, pour tout x, renvoie 3x + 2

En algorithmique :

Fonction f(entier: x): entier
	retourner 3 * x + 2;
Fin Fonction

Les fonctions

Règles

Il y a des règles quant à l'écriture de fonction, et surtout quant à leur nommage

Un certain nombre de mots sont interdits pour nommer une fonction : les mots clés du langage

Par exemple les mots : Si, Fin, Pour, etc.

Les fonctions

Règles

Est-ce que 2 fonctions peuvent avoir le même nom ?

Oui... et non !

En fait, ce qui rend une fonction unique ce n'est pas son nom, mais sa signature

La signature d'une fonction est la combinaison de :

  • son nom
  • les types de ses paramètres
  • son type de retour

Les fonctions

Règles

2 fonctions ne peuvent donc pas avoir la même signature, ça n'aurait pas de sens

Fonction a(entier: unNombre): entier
	retourner unNombre;
Fin fonction

Fonction a(entier: unAutreNombre): entier
	retourner unAutreNombre;
Fin fonction

ces 2 fonctions ont exactement la même signature et ne peuvent donc pas être écrites dans le même programme

Les fonctions

Règles

En revanche, ceci est possible par exemple :

Fonction afficherBonjour(chaine: nom)
	afficher("Bonjour ", nom);
Fin fonction

Fonction afficherBonjour(chaine: nom, chaine: prenom)
	afficher("Bonjour ", prenon, " ", nom);
Fin fonction

elles ont le même nom et le même type de retour (rien) mais pas les même types de paramètres (1 de plus pour la seconde), c'est donc OK !

Les fonctions

Bonnes pratiques

En théorie, vous pouvez écrire vos fonctions où vous voulez, mais nous allons nous forcer à utiliser de bonnes pratiques

Toutes les déclarations de fonctions devront être écrites en premier dans votre algorithme (avant les instructions "normales")

Les fonctions

Pourquoi et quand utiliser des fonctions ?

Les fonctions

Les fonctions sont extrêmement importantes

Plus vous progresserez, plus vous vous en rendrez compte

Elles permettent notamment de :

  • réduire la quantité de code
  • rendre le code plus maintenable

Les fonctions

Réduire la quantité de code :

Dans vos algorithmes, il va arriver souvent que vous ayez à répéter des bouts de codes identiques à des endroits différents

Utiliser une fonction permet de factoriser le code

Le code est alors beaucoup plus concis et moins verbeux

Les fonctions

Rendre le code plus maintenable : 

La maintenabilité est le fait d'être capable de modifier son algorithme après coup, après l'avoir écrit une première fois

La maintenabilité est un critère super important pour un algorithme car une bonne maintenabilité signifie :

  • le faire évoluer plus rapidement
  • le corriger plus rapidement

Les fonctions

Rendre le code plus maintenable : 

Imaginons une entreprise qui permet de faire un calcul révolutionnaire entre votre age et votre poids et qui permet d'en tirer .. l'âge de votre mort par exemple !

Il serait super intéressant d'encapsuler ce calcul dans une fonction comme ceci :

Fonction calculDeFou(entier: age, entier: poids) : entier
	retourner 42 * age + poids / 7; // Calcul bidon heih
Fin Fonction

Les fonctions

Rendre le code plus maintenable : 

Le fait d'avoir mis ce calcul dans une fonction, au delà du fait de rendre tout le reste du code plus lisible, le rend bien plus maintenable !

En effet, imaginons que demain le scientifique vous dise qu'en fait il y a une erreur et qu'il ne faut pas diviser par 7 mais par 8 !

Vous n'aurez pas à changer tout votre algorithme, uniquement votre fonction, tout le reste fonctionnera encore !

Exercices

  • les fonctions

Exercice 1

Titre: Exercice 1
Variables:
entiers: a
Début

Fonction estPair(entiers: n): booleen
	afficher("Voyons ça");
	Si n % 2 == 0 alors
		retourner vrai;
	Sinon
		retourner faux;
	Fin Si
Fin Fonction

a = 3;

Si estPair(a) alors
	afficher("Pair");
Sinon
	afficher("Impair");
Fin Si

Fin

Qu'affiche cet algorithme ?

Il existe une manière de réduire drastiquement le code de la fonction en le faisant passer de 6 lignes à 2 lignes

Savez-vous comment ?

Exercice 2

Quels algorithmes sont correctement écrits, lesquels sont impossibles ?

Fonction a(entiers: a): entier
	retourner a;
Fin Fonction

Fonction b(entiers: a): entier
	retourner a;
Fin Fonction
Fonction test()
	retourner "Salut !";
Fin Fonction
Fonction test()
	entier: i
	i = 10;
Fin Fonction

Fonction afficherI()
	afficher(i);
Fin Fonction
Fonction a(entiers: a): chaine
	Si a == 42 alors
		retourner "Ok";
	Fin Si
	retourner "Pas ok";
Fin Fonction

1

2

3

4

Exercice 3

Qu'affiche cet algorithme ?

Titre : Exercice 3
Variables:
entiers: a, b
Début

Fonction test(entier: n*, entier: m)
	n = m + 1;
	m = n + 3;
Fin Fonction

a = 3;
b = 5;
test(a, b);

afficher(a);
afficher(b);

Fin

Exercice 4

Ecrire un algorithme tel que :

  • écrire une fonction affichant le carré d'un nombre passé en paramètres
     
  • demander 10 nombres à l'utilisateur et afficher à chaque fois son carré grâce à la fonction

Exercice 5

Ecrire un algorithme tel que :

  • écrire une fonction prenant en paramètre une note et affichant une mention (<10 = pas bon, entre 10 et 14 = moyen, >=15 = très bien)
     
  • demander 10 notes à l'utilisateur et afficher à chaque fois la mention

Exercice 6

Ecrire un algorithme tel que :

  • écrire une fonction prenant en paramètre une entiers et renvoyant la valeur absolue de cet entier
     
  • demander 5 nombres à l'utilisateur et afficher la valeur absolue à chaque fois

Exercice 7

Ecrire un algorithme tel que :

  • écrire une fonction prenant en paramètre un nom et un age
     
  • Si la personne est majeur, afficher "Salut <nom>, tu peux rentrer"
     
  • Sinon, afficher  "Salut <nom>, tu es trop jeune encore !"
     
  • utiliser cette fonction

Exercice 8

Ecrire un algorithme tel que :

  • écrire une fonction prenant en paramètre deux nombres entiers et renvoyant le PGCD de ces deux nombres
     
  • demander 2 nombres à l'utilisateur et afficher leur PGCD

Rappel : le PGCD est le plus grand dénominateur commun 

PGCD(4, 6) = 2

Exercice 9

Ecrire un algorithme tel que :

  • demander à l'utilisateur un jour de la semaine
  • si l'utilisateur indique samedi ou dimanche, afficher une erreur "Erreur"
  • si il indique autre chose qu'un jour de la semaine, afficher la même erreur
  • si il indique un jour de la semaine, afficher "ok"
     
  • où créez-vous votre fonction ici et quel est son intérêt ?

Exercice 10

Ecrire un algorithme tel que :

  • Ecrire une fonction qui renvoie la partie entière d'un nombre réel

    Exemple : Soit 10,8 le nombre réel, la partie entière est 10.
    Soit 4,5 le nombre réel, la partie entière est 4, etc.

Exercice 11

Ecrire un algorithme tel que :

  • Ecrire une fonction qui renvoie si un nombre entier passé en paramètre est un nombre pair

    Attention, petit challenge, le corps de votre fonction ne doit faire qu'une seule ligne (on retournera directement le résultat)

     

Exercice 12

Ecrire un algorithme tel que :

  • Ecrire une fonction nommée "miroir"
  • Elle prend en paramètre un nombre entier et, affichera ce nombre en sens inverse.
    Exemple, si le nombre est 4365
    Alors l'algo affichera :
    5
    6
    3
    4

Exercice 13

Ecrire un algorithme tel que :

  • Ecrire une fonction nommée "prime" et prenant un entier en paramètre
    Cette fonction renvoie un booléen selon si ce nombre est un nombre premier ou non

    Rappel : Un nombre est premier si il accepte uniquement 2 diviseurs positifs entiers : 1 et lui-même

Corrections

  • les fonctions

Correction exercice 1

L'algorithme affichera :

Voyons ça

Impair

Fonction estPair(entiers: a): booleen
	afficher("Voyons ça");
	retourner a % 2 == 0;
Fin Fonction

Correction exercice 2

Correctement écrits : 

Impossible :

1 et 4

2 et 3

Correction exercice 3

Titre : Exercice 3
Variables:
entiers: a, b
Début

Fonction test(entier: n*, entier: m)
	n = m + 1;
	m = n + 3;
Fin Fonction

a = 3;
b = 5;
test(a, b);

afficher(a);
afficher(b);

Fin

a = 6

b = 5

Correction exercice 4

Titre: Carré d'un nombre
Variables: 
entiers: a, i
Début

Fonction carre(entiers: n)
	afficher(n * n);
Fin Fonction

Pour i de 1 à 10
	afficher("Saisir un nombre");
	saisir(a);
	carre(a);
Fin Pour

Fin

Correction exercice 5

Titre: Mention
Variables: 
entiers: n
Début

Fonction afficherMention(entier: note)
	Si note < 10 alors
		afficher("pas bien");
	Sinon
	Si note >= 10 et note < 15 alors
		afficher("moyen");
	Sinon
		afficher("très bien");
	Fin Si
Fin Fonction

Pour i de 1 à 10
	afficher("Saisir une note");
	saisir(n);
	afficherMention(n);
Fin Pour

Fin

Correction exercice 6

Titre: Valeur absolue
Variables: 
entiers: a, i
Début

Fonction valeurAbsolue(entier: n): entier
	Si n < 0 alors
		retourner -n;
	Fin Si
	retourner n;
Fin Fonction

Pour i de 1 à 5
	afficher("Saisir un nombre");
	saisir(a);
	afficher("La valeur absolue de ", a, " est :", valeurAbsolue(a));
Fin Pour

Fin

Correction exercice 7

Titre: Majeur / Mineur
Variables: 
entiers: a
chaines: n
Début

Fonction videurDeBoite(entier: age, chaine: nom)
	Si age >= 18 alors
		afficher("Salut ", nom, ", tu peux rentrer");
	Sinon
		afficher("Salut ", nom, ", tu es encore trop jeune");
	Fin si
Fin Fonction


afficher("Saisir votre nom");
saisir(n);

afficher("Saisir age");
saisir(a);

videurDeBoite(a, n);

Fin

Correction exercice 8

Titre: PGCD
Variables: 
entiers: n, m
Début

Fonction pgcd(entiers: a, entier: b): entier
	Tant que a != b
		Si a > b alors
			a = a - b;
		Sinon
			b = b - a;
	Fin Tant que
	retourner a;
Fin Fonction

afficher("Saisir un nombre");
saisir(n);

afficher("Saisir un autre nombre");
saisir(m);

afficher("PGCD(", n, ",", m,") = ", pgcd(n,m));

Fin

Correction exercice 9

Titre: Gestion d'erreur
Variables: 
chaines: jour
Début

Fonction afficherErreur(chaine: mauvaiseValeur)
	afficher("Erreur:", mauvaiseValeur, "n'est pas une valeur possible !");
Fin Fonction

afficher("Saisir un jour");
saisir(jour);

Suivant jour:
	Cas "samedi", "dimanche":
		afficherErreur(jour);
	Cas "lundi", "mardi", "mercredi", "jeudi", "vendredi":
		afficher(jour);
	Autres cas:
		afficherErreur(jour);
Fin Suivant

Fin

Correction exercice 10

Titre: Exercice 10
Variables:
reel: nombre, resultat

Début

Fonction partieEntiere(reel: n): reel
	reel: i
	i = 0;
	Tant que i < n
		i = i + 1;
	Fin Tant Que

	retourner i - 1
Fin Fonction

saisir(nombre);
resultat = partieEntiere(nombre);

afficher("La partie entière de ", nombre, " est : ", resultat);

Fin

Correction exercice 11

Titre: Exercice 11
Variables:
reel: nombre

Début

Fonction estPair(entier: n): booleen
	retourner n % 2 == 0;
Fin Fonction

saisir(nombre);
afficher(estPair(nombre));

Fin

Correction exercice 12

Titre: Exercice 12
Variables:
entiers: nombre

Début

Fonction miroir(entier: n)
	entier: x
	Tant que n != 0
		x = n % 10;
		afficher(x);
		n = n / 10;
	Fin Tant que
Fin Fonction

miroir(3465);

Fin

Correction exercice 13

Titre: Exercice 13
Variables:
entiers: nombre

Début

Fonction prime(entier: n): booleen
	booleen: estPremier
	entier: i

	i = 2;
	estPremier = vrai;

	Tant que i < (n / 2) ET estPremier == vrai
		Si n % i == 0 alors
			estPremier = faux;
		Sinon
			i = i + 1;
		Fin Si
	Fin Tant que

	retourner estPremier;

Fin Fonction



Fin

Les tableaux

Les tableaux

Même si nous avons déjà bien progressé, il nous reste quelques cas que nous ne pouvons toujours pas gérer...

Imaginons que nous souhaitions écrire un algorithme demandant de remplir les 30 notes d'une classe 

Les tableaux

Comment écrire cet algorithme sans devoir déclarer 30 variables ?

Les tableaux

La réponse est "simple": grâce aux tableaux

Un tableau est un regroupement de variables de même type, identifié par un nom

Chacune des variables de ce tableau est numérotée, on appelle son numéro un indice

Les tableaux

Chaque variable du tableau est donc caractérisée par le nom du tableau et l'indice concerné

Par exemple, si T est un tableau de 10 variables, alors chacune d'entre elles sera numérotée et il sera possible d'y accéder en utilisant simultanément le nom du tableau et le numéro (l'indice) de la variable

Les tableaux

Voyez les tableaux comme une collection : un paquet de carte, une liste de courses, etc.

Les tableaux

Comme les variables d'un tableau doivent toutes avoir le même type, il est important de le déclarer

Voici donc comment déclarer un tableau :

<type> nom[<taille>]
entier: monTableau[20]

exemple :

Les tableaux

entier: monTableau[20]

Nous déclarons donc ici un tableau nommé monTableau qui peut contenir 20 variables de type entier

Les tableaux

Attention ! En informatique, nous considérons qu'on commence à compter à partir de 0 !

La première case d'un tableau sera donc la case 0 et non la case 1

Les tableaux

Il suffit en fait de préciser la case que nous souhaitons viser et faire une affectation de variable comme d'habitude

Comment affecter une valeur à une case de tableau ?

Pour cibler la case, nous utilisons le nom du tableau et l'indice souhaité

  • monTableau[3] => représente la 4ème case du tableau
  • monTableau[5] => représente la 6ème case du tableau

Les tableaux

Voici donc comment on affecte une  valeur à la case 3 (et dernière case) du tableau par exemple :

Titre: Affecter variable dans tableau
Variables:
entier: monTableau[3]
Début

monTableau[2] = 10;

Fin

Ici, on affecte la valeur 10 à la 3ème case du tableau

Les tableaux

Pour lire la valeur renseignée dans une case de tableau, rien de plus simple, on utilise la même syntaxe que pour lui affecter une valeur :

Titre: Affecter variable dans tableau
Variables:
entier: monTableau[3]
Début

monTableau[2] = 10;
afficher(monTableau[2]);

Fin

Ici, on affiche donc 10 !

Les tableaux

Nous pouvons désormais faire pleins de nouvelles choses !

Ecrivons un algorithme qui récupère 5 notes de la part du professeur :

Titre: Notes
Variables:
entier: monTableau[5]
Début

affiche("Saisir note");
saisir(monTableau[0]);

affiche("Saisir note");
saisir(monTableau[1]);

affiche("Saisir note");
saisir(monTableau[2]);

affiche("Saisir note");
saisir(monTableau[3]);

affiche("Saisir note");
saisir(monTableau[4]);


Fin

Les tableaux

On peut même faire beaucoup plus propre et simple !

Les tableaux

Titre: Notes
Variables:
entier: monTableau[5]
Début

Pour i de 0 à 4
	afficher("Saisir note");
	saisir(monTableau[i]);
Fin Pour

Fin

Boucles et tableaux font très bon ménage !

Les tableaux

Titre: Notes
Variables:
entier: monTableau[5]
Début

Pour i de 0 à 4 
	afficher("Saisir note");
	saisir(monTableau[i]);
Fin Pour

Pour i de 0 à 4
	afficher(monTableau[i]);
Fin Pour

Fin

Voici comment afficher ensuite les notes renseignées : 

Les tableaux

Attention !

Lorsqu'on lit  ou qu'on affecte une case d'un tableau, il faut impérativement que cette case existe !

SI on a un tableau de 10 cases, il est interdit de lire une case supérieure à 9 ou inférieur à 0, sous peine de plantage du programme 

Les tableaux

Titre: Exemple tableaux
Variables:
entiers: tableau[10]

Début

tableau[3] = 12;    // OK
tableau[10] = 42;   // PROVOQUE UNE ERREUR !

Fin

Les tableaux

Petit exercice !

  • écrire un algorithme qui demande 10 noms
  • ensuite, proposez à l'utilisateur de donner un chiffre et affichez lui le nom correspondant
  • si l'utilisateur donne un chiffre négatif, arrêtez

Exemple:

l'utilisateur saisi : toto, tata, titi, .... tutu

l'utilisateur saisi 2, on affichera tata

l'utilisateur saisi 10, on affichera tutu

etc.

Les tableaux

Titre: Exemple tableaux
Variables:
entiers: i, n
chaines: tableau[10]

Début

Pour i de 0 à 9
	afficher("Saisir un nom");
	saisir(tableau[i]);
Fin Pour

Répéter

	afficher("Saisir un nombre");
	saisir(n);
	Si n >= 1 ET n <= 10 alors
		afficher(tableau[n-1]);
    Sinon
    	afficher("Nombre impossible");
	Fin Si
Jusqu'à n <= 0

FIn

Les tableaux

Comment envoyer un tableau comme paramètre dans une fonction ?

On écrire ça ainsi :

Fonction maFonction(entier: monTableau[n])
	entiers: i
	Pour i de 0 à n - 1
		afficher(monTableau[i]);
	Fin Pour
Fin Fonction

Les tableaux

Il est également possible d'envoyer un tableau en paramètre par référence

On écrire ça ainsi :

Fonction maFonction(entier: monTableau[n]*)
	entiers: i
	Pour i de 0 à n - 1
		monTableau[i] = 2;
	Fin Pour
Fin Fonction

On vient de mettre toutes les cases à 2

Les tableaux

Comment dire qu'une fonction renvoie un tableau ?

On écrire ça ainsi :

Fonction maFonction(): entier[n]
	// Corps de la fonction
Fin Fonction

Les tableaux

Attention

Il y a des règles importantes lors de l'utilisation d'un tableau

  • les case non affectée d'un tableau donc comme des variables non affectées, on ne peut les utiliser !
     
  • il est formellement interdit de tenter d'accéder à une case qui n'est pas dans le tableau, ça provoquerai une erreur

Les tableaux

entier: monTableau[3]

monTableau[0] = 3
afficher(monTableau[0] + monTableau[1]);

Interdit ! la deuxième case n'est pas affecté

entier: monTableau[3]

monTableau[0] = 3
monTableau[1] = 58
monTableau[2] = 14
monTableau[3] = 16

Interdit ! la 4ème instruction affecte une valeur à la 4ème case d'un tableau qui n'en comporte.. que 3 ! Provoque une erreur !

Les tableaux

Petit exercice à faire ensemble :

  • créer un algorithme qui demande 5 notes à l'utilisateur
  • ensuite, demander à l'utilisateur un nombre
  • afficher si le nombre fait partie des 5 notes renseignées ou non

Les tableaux

Titre: Exercice des notes
Variables:
entiers: i, n, notes[5]
booleen: dansTableau

Début

Pour i de 0 à 4
	afficher("Saisir une note");
	saisir(notes[i]);
Fin Pour


afficher("Saisir un nombre");

saisir(n);

dansTableau = faux;

Pour i de 0 à 4
	Si notes[i] == n alors
    	dansTableau = vrai;
    Fin SI
Fin Pour;

Si dansTableau alors
	afficher("La valeur ", n, " est bien contenue dans le tableau");
Sinon
	afficher("La valeur ", n, " n'est pas dans le tableau");
Fin Si


Fin

Les tableaux

Si on se base sur l'exercice précédent, pourquoi cette solution pose problème ?

Tant que notes[i] != note
	i = i + 1;
Fin Tant que

Exercices

  • les tableaux

Exercice 1

Ecrire un algorithme tel que :

  • affecter des valeurs de 2 à 8 dans un tableau de 7 cases
  • afficher les valeurs du tableau en commençant par la fin

Résultat attendu :

8, 7, 6, 5, 4, 3, 2

Exercice 2

Ecrire un algorithme tel que :

  • demander 10 nombres entiers positifs à l'utilisateur et les renseigner dans un tableau
     
  • vous refuserez toute valeur négative
     
  • l'algorithme ne prend fin qu'une fois que 10 valeurs positives ont été renseignées
     
  • afficher les 10 valeurs positives

Exercice 3

Ecrire un algorithme tel que :

  • demander 10 nombres entiers à l'utilisateur, positifs ou non
     
  • demander ensuite un 11ème nombre
     
  • afficher combien de nombres parmi les 10 premiers sont supérieurs au 11ème

Bonus : écrire une fonction qui, en fonction d'un tableau de N éléments et d'un entier X renvoie le nombre d'éléments supérieurs à x

Exercice 4

Ecrire un algorithme tel que :

  • demander les prix des 5 derniers articles achetés par l'utilisateur et les renseigner dans un tableau
     
  • lui afficher la somme de ses dépenses

(on pourrait ne pas créer de tableau mais on le fait pour l'exercice)

Bonus : écrire une fonction qui renvoie la somme des valeur d'un tableau

Exercice 5

Ecrire un algorithme tel que :

  • écrire les instructions permettant de réaliser une permutation circulaire d'un tableau

Il s'agit de décaler vers la droite chaque case du tableau

Exemple: [3,16,2,20]

Qui devient : [20, 3, 16, 2]

Bonus : écrire une fonction qui effectue une permutation circulaire d'un tableau et renvoie le tableau généré

Exercice 6

Ecrire un algorithme tel que :

  • écrire  une fonction permettant de permuter toutes les variables d'un tableau symétriquement

Il s'agit donc d'inverser les valeurs :

Exemple: [3,16,2,20]

Qui devient : [20, 2, 16, 3]

Exercice 7

Ecrire un algorithme tel que :

  • écrire les instructions nécessaires pour trouver la plus petit valeur dans un tableau d'entier
     
  • en faire une fonction qui renvoie cette valeur minimale pour tout tableau d'entiers

Exercice 8

Ecrire un algorithme tel que :

  • écrire une fonction contenuDans(entier: x, T[N]) qui, pour chaque tableau T de N éléments renvoie vrai si il contient la valeur x

Exercice 9

Ecrire un algorithme tel que :

  • écrire une fonction
    remplace(entier: T[n], x, y)
    qui remplace dans le tableau T toutes les occurrences de x par des y
  • le tableau est envoyé par référence

Exemple :

Soit T = [3, 16, 3, 2, 49]

remplace(T, 3, 7) = [7, 16, 7, 2, 49]

Corrections

  • les tableaux

Correction exercice 1

Titre: Exercice 1
Variables:
entiers: tableau[7], i
Début

Pour i de 0 à 6
	tableau[i] = i + 2;
Fin Pour

Pour i de 6 à 0 (par pas de -1)
	afficher(tableau[i]);
Fin Pour
Fin

Correction exercice 2

Titre: Exercice 2
Variables:
entiers: tableau[10], compteur, nombre, i
Début

compteur = 0;

Répéter
	afficher("Saisir un nombre positif");
	saisir(nombre);
	Si nombre > 0 alors
		tableau[compteur] = nombre;
		compteur = compteur + 1;
	Fin si
Tant que compteur < 10

Pour i de 0 à 9
	afficher(tableau[i]);
Fin Pour

Fin

Correction exercice 3

Titre: Exercice 3
Variables:
entiers: tableau[10], x, i, nombre, total
Début

Pour i de 0 à 9
	afficher("Saisir un nombre");
	saisir(tableau[i]);
Fin Pour

afficher("Saisir un dernier nombre");
saisir(nombre);

total = 0;
Pour i de 0 à 9
	Si tableau[i] > nombre
		total = total + 1;
    Fin Si
Fin Pour

afficher("nombre de valeurs supérieures à ", nombre, " = ", total);

Fin

Correction exercice 3 bonus

Fonction nbValeursSup(entiers: tableau[n], entier: x): entier
	entiers: i, total
    
	total = 0;
    
	Pour i de 1 à n - 1
		Si tableau[i] > x
			total = total + 1;
		Fin Si
	Fin Pour
    
	retourner total;
Fin Fonction

Correction exercice 4

Titre: Exercice 4
Variables:
entiers: tableau[5], i, total
Début

Pour i de 0 à 4
	afficher("Saisir un prix");
	saisir(tableau[i));
Fin Pour

total = 0;

Pour i de 0 à 4
	total = total + tableau[i];
Fin Pour

afficher("valeur totale = ", total);

Fin

Correction exercice 4 bonus

Fonction somme(entier: tableau[n]): entier
	entiers: total, i
    
	total = 0;
    
	Pour i de 0 à n - 1
		total = total + tableau[i];
	Fin pour
    
	retourner total;
Fin Fonction

Correction exercice 5

Titre: Exercice 5
Variables:
entiers: tableau[5], i, temp
Début

Pour i de 0 à 4
	afficher("Saisir un nombre");
	saisir(tableau[i]);
Fin Pour

temp = tableau[4];

Pour i de 4 à 1 (par pas de -1)
	tableau[i] = tableau[i-1];
Fin Pour

tableau[0] = temp;


Fin

Correction exercice 5 bonus

Fonction permutationCirculaire(entiers: tableau[n]): entiers[n]
	entiers: i, temp
    
	temp = tableau[n - 1];
    
	Pour i de (n - 1) à 1 (par pas de -1)
		tableau[i] = tableau[i-1];
	Fin Pour
    
	tableau[0] = temp;
    
    retourner tableau;
    
Fin Fonction

Correction exercice 6

Fonction miroir(entier: tableau[n]*)
	entiers: min, max, temp
	min = 0;
	max = n - 1;
	Tant que min < max
		temp = tableau[max];
		tableau[max] = tableau[min];
		tableau[min] = temp;
		min = min + 1;
		max = max - 1;
	Fin Tant que
Fin fonction

Correction exercice 7

Fonction min(entier: tableau[n]): entier
	entiers: i, min
    
	Si n < 1 alors
		afficher("Aucune valeur dans le tableau !");
		Retourner 0;
	Fin si
    
	min = tableau[0];
    
	Pour i de 1 à n - 1
		Si tableau[i] < min
			min = tableau[i];
		Fin Si
	Fin Pour
    
	retourner min;
Fin Fonction

Correction exercice 8

Fonction contenuDans(entiers: x, tableau[n]): booleen
	entiers: i
	booleen: contenu
    
	contenu = faux;
    
	Pour i de 0 à n - 1
		Si tableau[i] == x
			contenu = vrai;
		Fin Si
	Fin Pour
    
	retourner contenu;
Fin Fonction

Correction exercice 9

Fonction remplace(entiers: tableau[n]*, entier: x, entier: y)
	entiers: i
    
	Pour i de 0 à n - 1
		Si tableau[i] == x alors
			tableau[i] = y;
		Fin Si
	Fin pour
    
Fin Fonction

Les tableaux

les dimensions

Les dimensions

Il nous reste une subtilité des tableaux à voir ensemble

On sait maintenant qu'un tableau est un ensemble de variables du même type

Mais un tableau peut aussi contenir ... d'autres tableaux !

cela signifie que chaque case du tableau d'origine contiendra un autre tableau

Les dimensions

Si chaque case d'un tableau est composé d'autres tableaux, alors le premier est considéré comme un tableau à 2 dimensions

On peut évidemment imaginer un tableau à X dimensions, mais le plus courant est un tableau à 2 dimensions

Les dimensions

Quelle utilité ?

Le plus souvent, un tableau à 2 dimensions permet de représenter une matrice

Mais cela peut aussi être utile pour représenter un échiquier ou autre objet à 2 dimensions (lignes, colonnes)

Les dimensions

Un tableau à deux dimensions est donc un tableau de tableaux auxquels on accède grâce à deux indices

En effet, pour accéder à une variable, il faut préciser la ligne et la colonne de celle-ci

Les dimensions

Déclaration d'un tableau à 2 dimensions :

<type>: <nom>[<nombreDeLignes>][<nombreDeColonnes>]

Ainsi, pour représenter un tableau à 2 dimensions de 3 lignes et 4 colonnes :

entier: tableau[3][4]

Les dimensions

On l'a dit, pour accéder à une variable on utilise 2 indices, un pour la ligne et l'autre pour la colone

tableau[2][1]

Ici nous avons donc accès à la variable ligne 2 colonne 1

Les dimensions

Comme un tableau à 2 dimensions utilise 2 indices, son parcours nécessitera 2 boucles !

Ainsi pour afficher toutes les variables contenues dans notre tableau :

entier: tableau[3][4], i, j

Pour i de 0 à 2
	Pour j de 0 à 3
		Afficher tableau[i][j]
	Fin Pour
Fin Pour

Les dimensions

Petit exercice ensemble

Ecrire un algorithme permettant de remplir un tableau tel qu'il représente cette matrice :

  • 3 lignes
  • 3 colonnes
  • chaque élément d'indice de colonne pair sera un 1
  • tous les autres éléments seront des 0

Les dimensions

Titre: Exemple
Variables:
entiers: tableau[3][3], i, j
Début

Pour i de 0 à 2
	Pour j de 0 à 2
		Si j % 2 == 0
			tableau[i][j] = 1
		Sinon
			tableau[i][j] = 0
		Fin Si
	Fin Pour
Fin POur

Fin

Exercices

  • les tableaux à  2 dimensions

Exercices

Pour le exercices suivants, on imagine qu'un tableau de dimension 5,5 a déjà été initialisé tel qu'il représente : 

Exercice 1

Ecrire un algorithme pour afficher le tableau

Exercice 2

Ecrire un algorithme :

  • n'afficher que les éléments d'indice de ligne pair

Exercice 3

Ecrire un algorithme :

  • n'afficher que la diagonale principale (6,6,6,6,6)

Exercice 4

Ecrire un algorithme :

  • écrire une fonction qui prend un tableau à 2 dimensions en paramètre et renvoie le même tableau mais met les lignes paires à 0
  • le tableau sera passé par référence

Corrections

  • les tableaux à  2 dimensions

Exercice 1

Titre: Exercice 1
Variables:
entiers: tableau[5][5], i, j
Début

// On imagine que le tableau est initialisé

Pour i de 0 à 4
	Pour j de 0 à 4
		Afficher tableau[i][j]   
	Fin Pour
Fin Pour

Fin

Exercice 2

Titre: Exercice 2
Variables:
entiers: tableau[5][5], i, j
Début

// On imagine que le tableau est initialisé

Pour i de 1 à 4 ( par pas de 2)
	Pour j de 0 à 4
		Afficher tableau[i][j]   
	Fin Pour
Fin Pour

Fin

Exercice 3

Titre: Exercice 3
Variables:
entiers: tableau[5][5], i, j
Début

// On imagine que le tableau est initialisé

Pour i de 0 à 4
	Afficher tableau[i][i]
Fin Pour

Fin

Exercice 4

Fonction pairsAZero(entier: tableau[n][m]*)
	Pour i de 1 à n-1 (par pas de 2)
		Pour j de 0 à m - 1
			tableau[i][j] = 0		
		Fin Pour
	Fin Pour
Fin Fonction

La récursivité

La récursivité

La récursivité est un des concepts de base de l'algorithmique et de l'informatique

Un algorithme est dit récursif si il s'utilise lui-même pour arriver au résultat souhaité

Une fonction est donc récursive si, pour atteindre le résultat souhaité, elle s'appelle elle-même

La récursivité

Petit exemple :

Ecrivons une fonction qui donne la factorielle d'un nombre

Pour rappel, la factorielle d'un nombre n est le produit de tous les entiers inférieurs à n, n compris

fac(3) = 1 * 2* 3

La récursivité

Fonction factorielle(entiers: a): entier
	entiers: factorielle, i
	factorielle = 1;
	Pour i de 2 à a
		factorielle = factorielle * i;
	Fin Pour
	Retourner factorielle;
Fin Fonction

Sans récursivité :

La récursivité

Fonction factorielle(entiers: a): entier
	Si a == 1 alors
		retourner 1;
	Fin Si
	retourner a * factorielle(a - 1);
Fin Fonction

Avec récursivité :

La récursivité

Comment ça marche ?

On sait que :

  • fac(3) = 3 * 2 * 1
  • fac(5) = 5 * 4 * 3 * 2 * 1
  • fac(n) = n * n-1 * ... * 1

Développons ensemble l'algo récursif précédent étape par étape :

La récursivité

analysons factorielle(4) :

  • 4 n'est pas égal à 1, on renvoi donc : 4 * factorielle(3)
  • il nous reste donc à calculer factorielle(3)
  • 3 n'est pas égal à 1, on renvoi donc : 3 * factorielle(2)
  • le calcul principal en est donc à : 4 * 3 * factorielle(2)
  • il nous reste à calculer factorielle(2)
  • 2 n'est pas égal à 1, on renvoi donc : 2 * factorielle(1)
  • le calcul principal en est donc à : 4 * 3 * 2 * factorielle(1)
  • il nous reste à calculer factorielle(1)
  • 1 est égal à 1, on renvoi donc : 1
  • le calcul principal en est donc à 4 * 3 * 2 * 1

La récursivité

Si a == 1 alors
	retourner 1;

Attention !

Une fonction récursive doit toujours avoir une condition de sortie !

Pour la factorielle, il s'agit de ces instructions :

Sans une condition de sortie, la fonction s'appellerai à l'infini et provoquerai un "dépassement de pile"

Exercices

  • la récursivité

Exercice 1

Ecrire un algorithme tel que :

  • écrire une fonction prenant un nombre n en paramètre
  • la fonction doit afficher un compte à rebours de n à 0
  • il est interdit d'utiliser une boucle dans la fonction !
  • utilisez la récursivité :)

Exercice 2

Ecrire un algorithme tel que :

  • écrire une fonction prenant un entier n en paramètre
  • la fonction doit retourner la somme des n premiers entiers sans utiliser de boucle

Exercice 3

Ecrire un algorithme tel que :

  • écrire une fonction prenant deux nombres entiers positifs en paramètres
  • la fonction doit calculer le produit des 2 nombres positifs sans jamais utiliser le signe * ni de boucle

Exercice 4

Ecrire un algorithme tel que :

  • écrire une fonction prenant deux entiers a et b en paramètre
  • la fonction doit retourner a^b sans utiliser de boucle

Corrections

  • la récursivité

Correction exercice 1

Fonction compteARebours(entier: n)
	Si n == 0 alors
		afficher("0");
	Sinon
		afficher(n, ", ", compteARebours(n - 1));
	Fin Si
Fin Fonction

Correction exercice 2

Fonction sommePremiersEntiers(entier: n): entier
	Si n == 1 alors
		retourner 1;
	Fin Si
    
	retourner n + sommePremiersEntiers(n - 1);
Fin Fonction

Correction exercice 3

Fonction produit(entier: a, b): entier
	Si a == 0 OU b == 0
		retourner 0;
	Fin Si
    
	Si b == 1 alors
		retourner a;
	Sinon
		retourner a + produit(a, b - 1);
	Fin Si
   
Fin Fonction

Correction exercice 4

Fonction puissance(entier: a, b): entier    
	Si b == 0 alors
		retourner 1;
	Sinon
		retourner a * puissance(a, b - 1);
	Fin Si 
Fin Fonction

Les tris

Les tris

L'une des problématiques les plus connues en algorithmique est la notion de tri de collection

Il arrive très souvent que vous ayez à trier une collection de données, comme une liste de nombre, une liste de prénom, etc.

La notion de tris en algorithmique est fondamentale car l'étude des tris a mis en valeur de nombreuses choses sur la construction des algorithmes et sur leur complexité

Les tris

La complexité d'un algorithme :

Cette notion est encore trop avancée pour le niveau de base d'algorithmique, mais nous allons la décrire brièvement

Si l'un des objectifs d'un algorithme est évidemment d'automatiser une tâche, l'autre objectif est bien entendu de le faire de la manière la plus optimisée possible

Les tris

La complexité d'un algorithme :

"Optimiser" un algorithme, c'est surtout faire attention à deux chose :

  • sa rapidité d'exécution
  • son empreinte mémoire

Les tris

La complexité d'un algorithme :

Pour la rapidité, ça paraît logique

Si votre algorithme donne le même résultat que le mien mais avec 5 secondes de calcul en plus.. alors le mien est meilleur, plus rapide

Pour l'empreinte mémoire, c'est un peu plus compliqué à comprendre pour le moment, mais sachez juste que plus on crée et utilise de variables, plus cela prend de l'espace dans la mémoire vive de votre ordinateur

Les tris

La complexité d'un algorithme :

Si votre algorithme est aussi rapide que le mien, mais que le votre crame la RAM de l'ordinateur parce que trop gourmand... alors il est moins optimisé 

Exemple des grenouilles d'OpenClassroom :

https://openclassrooms.com/fr/courses/1467201-algorithmique-pour-lapprenti-programmeur/1467309-les-grenouilles-partent-en-vacances

Les tris

Bon, ok ! Et le tris dans tout ça ?

Les tris

Imaginez que vous ayez le tableau suivant :

tableau = [13, 2, 45, 7, 2, 9, 30]

A l'oral, dîtes-moi ce que donnerait ce tableau une fois trié dans l'ordre croissant

Comment êtes-vous arrivé à ce résultat ?

Les tris

Petit exemple, complétez l'algorithme suivant :

Titre: exemple de tri
variables:
entiers: tableau[5], i
Début

Pour i de 1 à 5
	Afficher "Saisir un nombre"
	Saisir tableau[i]
Fin Pour

// Complétez en proposant un algorithme 
// permettant de trier les données du tableau

Fin

Les tris

Pour ceux qui ont réussi, combien de boucles imbriquées avez-vous utilisé ?

Vous l'apprendrez plus tard dans votre cursus, mais imbriquer des boucles les unes dans les autres est très mauvais niveau performances

Parfois on ne peut pas faire autrement, bien sûr, mais sachez que c'est un vrai choix et que chercher à faire différemment est très important

Les tris

La problématique de tris de tableau est donc une problématique très connue

Elle a été étudiée depuis toujours par tous les informaticiens et mathématiciens du monde, afin de trouver les méthodes les plus pertinentes

Les tris

Nous allons étudier les 4 algorithmes de tris les plus connus :

  • le tri par sélection
  • le tri à bulle
  • le tri par insertion
  • le tri rapide

Les tris

Le tri par sélection

Il s'agit de la méthode la plus basique de tri :

  • rechercher le plus petit élément 
  • remplacer la première case par le plus petit élément
  • rechercher le 2ème plus petit élément
  • remplacer la deuxième case par cet élément
  • continuer ainsi jusqu'à la dernière case

Les tris

Le tri par sélection

Titre: Tri par sélection
Variables:
entiers: tableau[n], i, j, temp
Début

// On imagine que le tableau a été initialisé

Pour i de 1 à (n - 1)
	minIndice = i
	Pour j de i + 1 à n
		Si tableau[j] < tableau[min] alors
			minIndice = j
		Fin Si
	Fin Pour
	Si minIndice != i alors
		temp = tableau[i]
		tableau[i] = tableau[minIndice]
		tableau[minIndice] = temp
	Fin Si
Fin Pour

Fin

Les tris

Le tri à bulle

  • on parcours le tableau
  • on compare 2 éléments consécutifs
  • si ils ne sont pas dans l'ordre, on les permute
  • après un tout complet, le plus grand est élément est à la fin du tableau
  • on re-parcours donc le tableau jusqu'à les avoir tous ordonné

A chaque tour le plus grand est forcément à la fin, on a donc plus à s'en soucier

Les tris

Le tri à bulle

Titre: Tri à bulle
Variables:
entiers: tableau[n], i, j, temp
Début

// On imagine que le tableau a été initialisé

Pour i de n à 1 (par pa de -1)
	Pour j de 2 à i
		Si tableau[j-1] > tableau[j] alors
			temp = tableau[j-1]
			tableau[j-1] = tableau[j]
			tableau[j] = temp
		Fin Si
 	Fin Pour
Fin Pour

Fin

Une idée d'optimisation ?

Les tris

Le tri par insertion

  • parcourir le tableau en commençant au deuxième élément
  • si un élément est inférieur au précédent, les permuter
  • répéter cela tant que l'élément n'a pas trouver sa place

Les tris

Le tri par insertion

Titre: Tri par insertion
Variables:
entiers: tableau[n], i, j, temp
Début

// On imagine que le tableau a été initialisé

Pour i de 2 à n
	j = i
	Tant que j > 1 et (tableau[j - 1] < tableau[j])
		temp = tableau[j]
		tableau[j] = tableau[j-1]
		tableau[j-1] = temp
		j = j - 1
	Fin Tant Que
Fin Pour

Fin

Les tris

Le tri rapide

  • certainement l'un des algorithmes de tris les plus utilisés dans tous les programmes informatiques
     
  • basé sur le concept "diviser pour mieux régner"
     
  • algorithme récursif

Les tris

Le tri rapide