Cours d'Algorithmique

et Programmation
premier cycle INSA – semestre S1
2020 - 2021
Véronique Delcroix
Antoine Gallais, Christelle Rozé, Youcef Imine

source : cours Gérard Swinnen site : developpez.com

 Plan du cours
• Objectifs et Introduction
• Programme et sous-programme
• Variables et Types
• Structures de contrôle (tests et boucles)
• Fonctions et paramètres
• Tableaux et Listes
• Portée des variables
 L’informatique en 1re cycle INSA à l'UPHF
• Algorithmique et programmation (S1)
• Algorithmique et programmation (S2)
• Algorithmique et programmation, langage C (S3)
• Bases de Données relationnelles (S3)
• Architecture des ordinateurs et systèmes d'exploitation (S3)
• Programmation Orientée Objet (S4)
• Génie Logiciel (S4)
• Module département (S4)
– Sensibilisation à la cybersécurité
– Réseaux
– APP développement d'applications
• Module découverte spécialité Informatique (S4)
 Objectifs du cours
(semestre 1)
• Etre capable de proposer des algorithmes
pour résoudre des problèmes simples à l'aide
d'une application avec une interface texte
– Maitriser les principes de base de l'algorithmique
– Savoir décomposer un problème en sous-
problème
• Etre capable d'implémenter un algorithme
dans un langage de programmation
 Introduction
à la programmation
 Application, Programme

Application (logiciel, software): coté utilisateur

Exemples : suite bureautique, jeu, logiciel de
dessin, comptabilité, gestion …

Pour développer une application logicielle,

il faut (entre autre) un (des) programmes
écrit par le programmeur
dans un langage de programmation
 Des applications
avec différents types d’interface

Interface : moyens utilisés pour gérer les

interactions entre l’utilisateur et l’application :
 l’application affiche (montre) des informations à
l’utilisateur (texte, graphique, boutons, menus, …)
 l’utilisateur utilise l’application en faisant des actions :
clic, sélection, saisie de texte, …
Différents types d'interfaces :
• graphique
• texte
• vocale, tactile, …
 Application avec interface
graphique

• L'interface graphique
– contient des composants graphiques
(menu, bouton, liste déroulante, zone de texte, etc.)
• L'utilisateur
– intéragit avec l'interface graphique (clics, etc.), et
déclenche ainsi des évenements sur des objects
– ce qui appelle des sous programmes
– programmation événementielle
– …. (pas au programme)
 Application avec interface texte

• l'unité d'affichage est le caractère

• le programme AFFICHE du texte et demande la
SAISIE d' informations
• s'exécute suivant un programme principal
qui appelle des sous-programmes (SP)
Application en mode graphique
– l'unité d'affichage est le pixel
– le programme principal commande l'affichage
– Exemple : tortue logo
 Programmation d'un ordinateur
• « expliquer » à une machine ce qu'elle doit faire
• en utilisant les "commandes" que la machine connait
Programme : suite d'instructions (ordre),
• encodées suivant la syntaxe (règles d'écriture)
• d'un langage informatique.

Exécution d'un programme :

• La machine décode les instructions :
• à chaque « mot » du langage correspond une action.
 Du programme à l'application
Utilisation Programmeur
d'une application d'une application

Programme écrit
dans un langage de programmation
L'ordinateur exécute
une série d'instructions
en langage machine (binaire)
0110 0000 1101 1111
0001 0001 0001 0000
0000 1100 1010 0101
0010 0011 1101 1111
Traduction
en langage binaire
 Dans un ordinateur
Toute information est codée en format binaire
01000110 10101000 10101110 10100110 10100001
00110101 00001010 00110101 01000101 01110101
00010010 00110101 01000101 01110101 00110101
• les données que l‘application manipule
– textes, images, sons, nombres, etc.,
• les programmes, (séquences d'instructions)
– donnés à la machine
– pour traiter ces données.
 "Langage machine" (binaire)
• seul "langage" que l'ordinateur « comprend ».

• longue suite de 1 et de 0 (les "bits")

• traités par groupe de 8 : les octets , (byte en anglais),

ou 16, 32, ou 64 (c'est à dire 2, 4 ou 8 octets).

• incompréhensible pour nous

>> traduction nécessaire !
>> langage de programmation
 Langage de programmation
• Ensemble de mots-clés
• Des règles précises (syntaxe)
pour assembler ces mots en « phrases »
– La structure est importante
– Tous les détails peuvent compter
• la casse (majuscule / minuscule)
• la ponctuation, les retours à la lignes les espaces
>>> Signification du texte unique et littérale.
donc possible à traduire en langage machine
 Du Langage de programmation
au langage machine
Deux modes de traduction :
• interprété : traduction et exécution immédiate d'une
instruction à chaque appui sur la touche "Entrée"
• ou compilé :
traduction de la totalité du programme
et création d'un fichier exécutable (.exe) pour
stocker le programme en langage machine.
Exécution du programme complet à la demande
 Langage de programmation
« de bas niveau »
• Instructions très élémentaires,
« proches de la machine »
• Long et laborieux à écrire 
Exemple : Assembleur
 Langage de programmation
« de haut niveau »
Exemples : Java, scala, python, R, Perl, Smalltalk,
Clarion,..
• Haut niveau d'abstraction,
– instructions plus abstraites, plus « puissantes ».
– Une instruction de haut niveau
est traduite en un grand nombre
d'instructions machine élémentaires.
• + facile et + rapide à écrire 
– moins de fautes
– maintenance facilitée
Quelques langages de programmation
C C++ java scala
Python R
Visual Basic Basic
Delphi Pascal
Perl Clarion Tcl / Tk
Scheme SmallTalk lisp
Fortran Cobol
… … …
 Extrait d'un programme en python

Remarquez :

• mots-clés

• syntaxe

• structure

• ponctuation

• retours à la lignes

• indentation
Programme et sous-programme
Instructions
Actions de base
 Programme, sous-programme,
instruction
• Programme : suite d'instructions réalisant un
objectif global

• un sous programme (SP) est une suite

d'instructions réalisant un objectif précis
• un SP a un nom (qui permet de l’appeler)

• une instruction est un ordre donné à l'ordinateur

• une instruction tient (en général) sur une ligne
 Exécuter … un programme
signifie
• lancer le programme
• le « faire tourner » (run en anglais)
• déclencher le démarrage de l’application

On exécute aussi une fonction, une instruction

• exécution du programme : déroulement du prog.
 Définir (décrire) un programme
Au départ : un problème … plus ou moins bien décrit !
Ensuite
1. une idée … c’est-à-dire quelques phrases
2. un algorithme
1. grossier (phrases plus précises)
2. en pseudo code
3. complètement détaillé en pseudo-code
3. l’implémentation dans un langage de
programmation
 Le pseudo code
• permet de décrire un algorithme
• n’est pas un langage de programmation
• s’utilise sur le papier
• a une syntaxe souple
• n'a pas de standard
• doit être traduit dans un langage de
programmation pour être éxécuté
 Un algorithme
• C'est la description d'une méthode pour
réaliser un objectif (résoudre un problème)
par une machine (un ordinateur)
• exemple : recette de cuisine
• Il est correct s'il résout correctement le
prolème pour toutes les instances
• Il s'exprime par un texte, un logigramme, des
schémas, et souvent en utilisant un pseudo
langage
 Ecrire un algorithme
• C'est décomposer un problème complexe en
problèmes plus simples
et recommencer jusqu'à obtenir
des actions de base qu'on sait exécuter.

• C'est aussi identifier les données du problème

– en entrée
– en sortie
– et celles qu'on va manipuler entre deux
 Programme principal
• Partie principale d'un programme
• contient les instructions qui seront exécutées
au lancement du programme
– première instruction du progr. principal :
première instruction exécutée
• appelle les sous-programmes

• (les sous-programmes qui ne sont pas appelés

ne sont pas éxécutés)
// algo de démonstration – 31 naout 2020
PROCEDURE afficheBonjour(nom:chaine)
// affiche Bonjour suivi du nom
DEBUT Programme simple
affiche( "Bonjour ", nom, "!") et passe 2 lignes
FIN PROCEDURE (en pseudo langage)
// --------------------------------------------------------
PROCEDURE afficheRegle() composé de :
// affiche la règle du jeu
DEBUT
affiche( "Le jeu consiste à … bla bla bla")
2 sous-programmes
affiche( "Bon jeu ! ")
FIN PROCEDURE
(SP)
// ------------ programme principal -----------
ALGORITHME demo le programme
DEBUT
afficheBonjour("Claire") principal (qui appelle
afficheBonjour("Luc")
afficheRegle()
les SP)
affiche("Au revoir !")
FIN
// Auteurs, date, but du programme
IMPORTER les modules
// -------------- Définition des SP ------------
PROCEDURE nomProc1 (…)
Structure générale
// but proc1 d'un programme
DEBUT
<instructions proc1> (en pseudo langage)
FIN PROCEDURE
// ---------------------------------------------------
PROCEDURE nomProc12(…)
- présentation du programme
… (commentaires)
// --------------------------------------------------- - import des sous-programmes
… externes
// ---------- programme principal ---------- - définition des sous-progr.
ALGORITHME titre - programme principal
DEBUT
<instructions du pp>
FIN
 Sous-programme (SP)
• Utile pour décomposer un problème complexe
en sous-problèmes plus simples,
• Les SP sont réutilisables :
– définis (décrits) une seule fois, (suite d'instructions)
– appelés (utilisés) aussi souvent que nécessaire
• Les sous-programmes ne sont éxécutés
que s'ils sont appelés
• 2 types de SP: Fonctions (avec ou sans résultat)
ou procédure (sans résultat)
 Programme principal
et sous-programmes
Il contiennent :
• des instructions de base
– affichage (à l'écran)
– saisie (introduction d'une valeur au clavier),
– affectation (d'une valeur à une variable)
• des instructions complexes
– tests : si (if)
– boucles : pour (for), tant que (while)
• des appels de sous-programmes
 Intéret d'un sous-programme (SP)
(procédure ou fonction)

Appeler (utiliser) un SP
– simplifie le programme :
• dissimule un algorithme secondaire sous une commande
unique,
– augmente la lisibilité :
• nom du SP explicite
– raccourcit un programme :
• élimine les portions de code qui se répètent
 Vous utilisez des SP ...
c’est à dire vous les appelez par leur nom (une ligne)

• des SP que vous n'avez pas écrits

– SP (fonctions) écrits par d'autres programmeurs
– elles sont dans des biliothèques de fonctions
exemple : cos(angle), (dans la bibliothèque math)
– ou elles font partie du langage
exemple : print("Bonjour")
• et des SP que vous avez écrits
– vous avez décrit le corps du SP (bloc d'instructions)
 illustration python
Commentaires

Modules importés

Définition des
fonctions
…

Programme principal
 Bibliothèques de fonctions

Importer les fonction du module math

Importer les fonction du module turtle
voici six appels de fonctions :
avance(100)
• le nom de la fonction
gauche(120) est suivi de parenthèses

avance(100) • entre les parenthèses :

la valeur du paramètre
gauche(150) (ou argument)

avance(int(cos(30)) * 100) NB : une fonction peut avoir 0,

ou plusieurs paramètres
 Appeler un sous-programme (SP)
(procédure ou fonction)
Appeler un SP dans un programme …
• nécessite que ce SP a été défini avant
(dans le même programme ou dans un autre)
• signifie utiliser ce SP
• écrire son nom (avec les paramètres si besoin)

Un appel de SP est une instruction (une ligne)

• Lorsque cette instruction est exécutée,
toutes les instruction qui composent le SP sont
exécutées.
 Appeler une procédure
Programme Procédure procA
instruction A1
instruction 1 instruction A2
instruction 2 instruction A3
procA(…)
Procédure procB
instruction 4
instruction B1
procB(…)
instruction B2
procB(…)
instruction B3
instruction 7
instruction B4
 Appel d'une procédure
(SP qui ne retourne pas de résultat)
• pour appeler une procédure, on écrit
le nom de la procédure suivi de parenthèses

nomFonction(liste des valeurs des paramètres)

• Exemple : 5 appels de procédures:

dessineLigneCarres(3, "red")
avance(100)
gauche(120)
avance(100)
gauche(150)
 Appel d'une fonction
(SP avec résultat)
• pour appeler une fonction, on écrit
le nom de la fonction suivi de parenthèses,
dans une instruction qui exploite le résultat
uneVar  nomFct(liste des valeurs des param.)

• Exemples d’appels de fonctions

y  cos(30)
NbPet  nbArea(im23, ’cat’) + nbArea(im23, ’dog’)
affiche ("Surface du cone : ", surfaceCone(r,h))
 Pour appeler un sous-programme
• il faut qu'il ait déjà été défini
– soit dans le langage
• exemple : fonction pour afficher ou saisir
– soit dans un module importé
• défini par d'autres (modules math, turtle, …)
• défini par vous le programmeur (vous) dans un autre
module
– soit dans le même module que le programme qui
appelle le sous-programme
 Définir un sous-programme (SP)
Il faut décrire :
1. Le type du SP : procédure ou fonction
2. le nom du SP

ENTETE
du SP
3. Les noms et type de chaque paramètre
4. le type du résultat (s'il y en a un)
5. le but du SP et le rôle des paramètres

– Les variables locales (nom, type rôle)

CORPS
du SP
– L’ensemble des instructions
qui composent le sous-programme
 Définir une procédure (SP sans résultat)

PROCEDURE nomProc (<noms et type des

paramètres>)
// but du SP et rôle des paramètres
VARIABLES
<déclaration des variables locales>
DEBUT
<instructions>
FIN PROCEDURE
PROCEDURE nomProc (param1 : type1,
param2 : type2 …)
// objectif du SP
// param1 : rôle du paramètre 1
// param2 : rôle du paramètre 2 …
VARIABLES (locales)
var1 : type // rôle de la variable
var2 : type // rôle de la variable
…
DEBUT
<instructions>
FIN PROCEDURE
 Définir une fonction (SP avec résultat)
FONCTION nomFct (nom et type des paramètres)
: type du résultat
// but de la fonction et rôle des paramètres
VARIABLES
<déclaration des variables locales>
DEBUT
<instructions>
RETOURNE <résultat>
FIN FONCTION
FONCTION nomFct (param1 : type1, …) : typeRes
// but de la fonction,
// param1 : rôle du paramètre 1
// …
Variables locales :
v1 : type // rôle de la variable
…
varRes : type // variable contenant le résultat
DEBUT
<instructions>
RETOURNE varRes
FIN FONCTION
 Exemple de définition d'un SP
PROCEDURE dessineLigneDeCarres (
tailleCarre : entier , nbCarres : entier)
// dessine une ligne composée de nbcarrés carrés
de taille tailleCarre (nb de pixels du coté d'un carré)
Variables locales :
i : entier // compte le nb de carrés dessinés
DEBUT
POUR i de 1 à nbCarres
<dessiner un carré et laisser un espace>
FIN POUR
FIN PROCEDURE
 Exemple d'entête d'un SP

FONCTION nbOccurences (car : caractère,

ch : chaine ) : entier
// retourne le nombre de caractères car
dans le texte ch
 Exemple d'entête d'un SP

FONCTION nbOccurences (car : caractère,

ch : chaine ) : entier
// retourne le nombre de caractères car
dans le texte ch

Trois exemples d'appel de cette fonction

nbE  nbOccurences('e', "table")
nbI  nbOccurences('i', "table")
afficher ("il y a ")
afficher (nbOccurences('o', "table"))
afficher (" 'o' dans le mot table")
FONCTION nbOccurences (car : caractère,
ch : chaine) : entier
// retourne le nombre de caractères car dans le texte ch
VARIABLES (locales) :
i : entier // position d’un caratère dans le texte
nbOcc: entier // nb de caract. car trouvés dans le texte ch
DEBUT FONCTION
nbOcc  0
i  0
TANT QUE i < longueur(ch)
SI ch[i] =? car alors
nbOcc  nbOcc + 1
FIN SI
i  i + 1
FIN TANT QUE
RETOURNER nbOcc
FIN FONCTION
 Exemple de définition d'une fonction
en pseudo code (1)
• Entête de la fonction
– nom de la fonction
– liste des paramètres et leur
type
– type du résultat
– but de la fonction
description des paramètres
et du résultat
• Corps de la fonction
– variables locales
– ensemble des instructions
 Exemple de définition d'une fonction
en pseudo code (2)
• Entête de la fonction
– nom de la fonction
– liste des paramètres et leur
type
– type du résultat
– but de la fonction
description des paramètres
et du résultat
• Corps de la fonction
– variables locales
– ensemble des instructions
 Exemple de définition d'une fonction
en pseudo code (3)
• Entête de la fonction
– nom de la fonction
– liste des paramètres et leur
type
– type du résultat
– but de la fonction
description des paramètres
et du résultat
• Corps de la fonction
– variables locales
– ensemble des instructions
 Exemple de définition d'une fonction
en pseudo code (4)
• Entête de la fonction
– nom de la fonction
– liste des paramètres et leur
type
– type du résultat
– but de la fonction
description des paramètres
et du résultat
• Corps de la fonction
– variables locales
– ensemble des instructions
 Exemple de définition d'une fonction
en pseudo code (5)
• Entête de la fonction
– nom de la fonction
– liste des paramètres et leur
type
– type du résultat
– but de la fonction
description des paramètres
et du résultat
• Corps de la fonction
– variables locales
– ensemble des instructions
 Exemple de définition d'une fonction
en pseudo code (6)
• Entête de la fonction
– nom de la fonction
– liste des paramètres et leur
type
– type du résultat
– but de la fonction
description des paramètres
et du résultat
• Corps de la fonction
– variables locales
– ensemble des instructions
 Exemple de définition d'une fonction
en pseudo code (7)
• Entête de la fonction
– nom de la fonction
– liste des paramètres et leur
type
– type du résultat
– but de la fonction
description des paramètres
et du résultat
• Corps de la fonction
– variables locales
– ensemble des instructions
 Exemple de définition d'une fonction
en pseudo code (8)
• Entête de la fonction
– nom de la fonction
– liste des paramètres et leur
type
– type du résultat
– but de la fonction
description des paramètres
et du résultat
• Corps de la fonction
– variables locales
– ensemble des instructions
Des instructions simples et complexes
(1)
Ce bloc d'instructions
contient quatre
instructions
– deux affectations
– une boucle "tant que"
– l'instruction retourner
Des instructions simples et complexes
(2)
Ce bloc d'instructions
contient quatre
instructions
– deux affectations
– une boucle "tant que"
– l'instruction retourner
Des instructions simples et complexes
(3)
Ce bloc d'instructions
contient quatre
instructions
– deux affectations
– une boucle "tant que"
– l'instruction retourner
Des instructions simples et complexes
(4)
Ce bloc d'instructions
contient quatre
instructions
– deux affectations
– une boucle "tant que"
– l'instruction retourner
 Une instruction complexe (1)
• La boucle contient
un bloc d'instructions qui
sera répété plusieurs fois.
Ce bloc sera exécuté tant
que la condition est vraie.

Ce bloc d'instructions
contient deux instructions
– un test (Si …)
– une affectation
 Une autre instruction complexe (2)
Le test (if) contient
un bloc d'instructions
qui ne sera exécuté
que si la condition
est vraie.

Ce bloc d'instructions
contient une instruction
– une affectation
FONCTION nbOccurences (car : caractère,
ch : chaine de caractères ) : entier
retourne le nombre de caractères car dans le texte ch

Variables locales :
NOM : TYPE (ROLE)
i : entier (position d’un caratère dans le texte)
nbOcc : entier (nb de caractères car trouvés dans le texte ch)
Algorithme :

nbOcc  0 longueur (texte) est une

i  0 fonction qui retourne le
Tant que i < longueur(ch) nombre de caractères
Si ch[i] =? car alors d’un texte
nbOcc  nbOcc + 1
Fin Si
i  i + 1
Fin Tantque
ch[i] représente le ième
caractère de ch
retourner nbOcc
 Actions de bases
• Afficher à l'écran
• Saisir (introduire une valeur au clavier)
• Affecter une valeur à une variable

Ces instructions qui se traduisent par une seule

ligne de programmation
Autre action en une ligne :
• Appeler un sous-programme
 Actions de bases : ex. en pseudo code

• Affecter une valeur à une variable

gagne  True
nbCoups  nbCoups + 1
• Afficher à l'écran
afficher("trop petit !")
afficher("Gagné en ",nbCoups, " coups ! ")

• Saisir (ou lire) (introduire une valeur au clavier)

afficher("Quel age as-tu ?")
lire age ou bien age  lire()
afficher("Entrez un nb entre 0 et 100 : " )
lire nbPropose ou bien nbPropose  lire()