Cours Algorithmique Chahin

Cours algorithmique
Mr Radouane CHAHIN
Site web :https://sites.google.com/a/uca.ma/r-chahin
Année Académique 2017-2018

1
Objectif
• Objectif :
• Apprendre les concepts de base de l'algorithmique et de la programmation
• Être capable de mettre en œuvre ces concepts pour analyser des problèmes simples et écrire les
programmes correspondants
• Savoir expliciter et formaliser son raisonnement
• obtenir de la «machine» qu’elle effectue un travail à notre place
• On traite deux syntaxes pseudocode Logiciel Pratiquer l'Algorithmique 12 et python
• Problème: expliquer à la «machine» comment elle doit s'y prendre
Mais... comment le lui dire ?
Comment le lui apprendre ?
Comment s'assurer qu'elle fait ce travail aussi bien que nous ?
Mieux que nous?
Outils: Logiciel Pratiquer l'Algorithmique 12 : http://fr.lagache.free.fr/algo/telechargement.php

2
Plan du cours
• Introduction à l’algorithmique et à la programmation
• Généralités sur l’algorithmique et les langages de programmation
• Introduction à la complexité des algorithmes
• Algorithmique : Processus de développement
• Méthode de recherche d'un algorithme
• Notion de variable, affectation, lecture et écriture
• Instructions conditionnels et instructions itératives
• Les tableaux, les fonctions et procédures, la récursivité
• Données structurées
• Techniques Rusées
3
Définition : Programme informatique
• Un programme correspond à la description d’une méthode de résolution
pour un problème donné.
• Cette description est effectuée par une suite d’instructions d’un langage
de programmation
• Ces instructions permettent de traiter et de transformer les données

(entrées) du problème à résoudre pour aboutir à des résultats (sorties).
• Un programme n’est pas une solution en soi mais une méthode à suivre
pour trouver les solutions.
4
Langages informatiques
• Un langage informatique est un code de communication, permettant à un être humain de dialoguer avec
une machine en lui soumettant des instructions et en analysant les données matérielles fournies par le
système.
• Le langage informatique est l’intermédiaire entre le programmeur et la machine.
• Il permet d’écrire des programmes (suite consécutive d’instructions) destinés à effectuer une tache donnée
• exemple : un programme de résolution d’une équation du second degré
• Programmation : ensemble des activités orientées vers la conception, la réalisation, le test et la
maintenance de programmes.
• Deux types de langages:
• Langages procéduraux : Fortran, Cobol, Pascal, C, …
• Langages orientés objets : C++, Java, C#,…
• Le choix d'un langage de programmation n'est pas facile, chacun a ses spécificités et correspond mieux à
certains types d'utilisations
5
L'algorithmique, vous la pratiquez tous les jours et
depuis longtemps...
6
Notion d’algorithme
• Un programme informatique permet à l’ordinateur de résoudre un
problème
• Avant de communiquer à l’ordinateur comment résoudre ce problème, il faut
en premier lieu pouvoir le résoudre nous même
• Un algorithme peut se comparer à une recette de cuisine

• Le résultat c’est comme le plat à cuisiner
• Les données sont l’analogues des ingrédients de la recette
• Les règles de transformations se comparent aux directives ou instructions de
la recette
7
Algorithme informatique
• Un algorithme est une suite finie et non-ambiguë d’instructions ayant pour
but de résoudre un problème donné. Ces instructions doivent être
exécutées de façon automatique par un ordinateur.
• Un algorithme est une méthode générale pour résoudre un ensemble de

problèmes. Il est dit correct lorsque, pour chaque instance du problème, il
se termine en produisant la bonne sortie, c'est-à-dire qu'il résout le
problème posé
• un algorithme doit donc contenir uniquement des instructions

compréhensibles par celui qui devra l’exécuter
8
Algorithme informatique: propriété
• Un algorithme doit:
• avoir un nombre fini d’étapes,
• avoir un nombre fini d’opérations par étape,
• se terminer après un nombre fini d’opérations,
• fournir un résultat.
• Chaque opération doit être:
• définie rigoureusement et sans ambiguïté
• effective, c-à-d réalisable par une machine
• Le comportement d'un algorithme est déterministe.
9
Analyse d’algorithmes
Analyser un algorithme = évaluer son efficacité
Efficacité ?
• Temps d'exécution : complexité en temps
• Espace mémoire occupé : complexité en espace
• Qualité du résultat :
• correction : si l’algorithme termine en donnant une proposition de solution,
alors cette solution est correcte.
• complétude : pour un espace de problèmes donné, l’algorithme, s’il termine,
donnera toujours des propositions de solutions.
• Simplicité ….
10
Théorie de la complexité (informatique théorique)
• La théorie de la complexité est un domaine des mathématiques, et plus précisément de l'informatique
théorique, qui étudie formellement la quantité de ressources (en temps et en espace) nécessaire pour la
résolution de problèmes au moyen de l'exécution d'un algorithme. Il s'agit donc d'étudier la difficulté
intrinsèque de problèmes posés mathématiquement.
• L'analyse de la complexité est étroitement associée à un modèle de calcul:
• la machine de Turing, le modèle de calcul le plus utilisé
• la machine RAM (Random Access Machine).
• Mesure de la complexité : Les mesures les plus classiques de la complexité d'un algorithme sont le temps et
l'espace utilisés. D'autre mesures existent, sur les communications par exemple.
• Règle de calcul de la complexité (nombre d’opérations de base): est exprimée sous la forme du nombre
d'opérations effectuées par celui-ci. En général, ce nombre dépend des données d'entrée.
• Nous noterons dorénavant T nomalgo (d) est le nombre d’opérations élémentaires pour exécuter l’algorithme sur
la donnée d’entrée d
• Classes de complexité :
• complexité en temps et en espace: TIME, NTIME, SPACE, NSPACE
• Classes en temps: P, NP, EXPTIME, NEXPTIME
• Classes en espace : L, NL, PSPACE, EXPSPACE 11
Théorie de la complexité : Fonction asymptotique
La famille de notations de Landau O, o, Ω, Θ
Notation Nom Description informelle Lorsque , à partir d'un certain rang...
La fonction |f | est bornée par

Grand O pour un k > 0
la fonction |g|
(Grand Définition rigoureuse
asymptotiquement,
Omicron)
à un facteur près
En théorie des algorithmes :

En théorie des algorithmes :
Grand
f est minorée par g (à un pour un k > 0
Omega
facteur près) Définition rigoureuse
pour un k1 > 0, et un k2 > 0

Grand f est dominée et soumise Définition rigoureuse
Theta à g asymptotiquement
f est négligeable , quel que soit > 0 (fixé).

Petit o
devant g asymptotiquement Définition rigoureuse
12
Exemple: la complexité en temps
• La complexité en temps (temps d'exécution) d’un algorithme dépend de :
• la taille des données d’entrée
• Les valeur des données(diverses exécutions peuvent avoir temps d'exécutions diverses)
• Considère touts les entrées est indépendant des environnements matériels et logiciels
• Différentes approches calcul dans:
• le pire des cas Tmax nomalgo (d) ,
• le moyenne Tmoy nomalgo (d),
• le meilleur cas Tmin nomalgo (d),
• Exemple: la recherche dans un dictionnaire
1. Recherche linéaire : parcourir les pages dans l'ordre (alphabétique) jusqu'à trouver le nom cherché pire le
dernier mot, meilleur le premier mot de dictionnaire
2. Recherche dichotomique : ouvrir l'annuaire au milieu, si le nom qui s'y trouve est plus loin alphabétiquement que
le nom cherché, regarder avant, sinon, regarder après. Refaire l'opération qui consiste à couper les demi-
annuaires (puis les quarts d'annuaires, puis les huitièmes d'annuaires, etc.) jusqu'à trouver le nom cherché.
13
complexité : Ordre de grandeur
• Ordre de grandeur du temps nécessaire à l'exécution d'un algorithme d'un type de complexité
Temps Temps
Temps Temps Temps Temps Temps Temps
pour pour
Temps Type de complexité pour pour pour pour pour pour Problème exemple
n = 10 00 n = 1 000
n=5 n = 10 n = 20 n = 50 n = 250 n = 1 000
0 000
complexité
10 ns 10 ns 10 ns 20 ns 30 ns 30 ns 40 ns 60 ns Dichotomie
logarithmique
complexité linéaire 50 ns 100 ns 200 ns 500 ns 2.5 µs 10 µs 100 µs 10 ms Parcours de liste
complexité quasi-
50 ns 100 ns 200 ns 501 ns 2.5 µs 10 µs 100,5 µs 10 050 µs Triangulation de Delaunay
linéaire
complexité Tris dont le Tri fusion ou le Tri
40 ns 100 ns 260 ns 850 ns 6 µs 30 µs 400 µs 60 ms
linéarithmique par tas
complexité
2.8 heure
quadratique 250 ns 1 µs 4 µs 25 µs 625 µs 10 ms 1s Parcours de tableaux 2D
s
(polynomiale)
complexité cubique 2.7 heure Multiplication matricielle non-
1.25 µs 10 µs 80 µs 1.25 ms 156 ms 10 s 316 ans
(polynomiale) s optimisée.
complexité Problème du sac à dos par force
320 ns 10 µs 10 ms 130 jours ans ... ... ...
exponentielle brute.
Problème du voyageur de
complexité an
1.2 µs 36 ms 770 ans ... ... ... ... commerce (avec une approche
factorielle s
naïve). 14
Classes de complexité :Rappelle mathématique 1/2
• Dans ce cours on va utiliser que la fonction O (Fonction asymptotique la plus petite)
de et à la complexité au pire de cas Tmax.
1. Rappelle mathématique: Propriétés fonction asymptotique
• O(f(n))+O(g(n))=O(f(n)+ g(n))
• O(1)+O(1)+O(1)= O(1)
• O(1)+……+O(1)= O(n)
n fois
• O(n3)>O(n2)>O(nlog(n))>O(n)>O(log(n))
• O(3n3+n2+5)=O(3n3)+O(n2)+O(5)=O(n3)
• f(n) = nlog(n) + 12n + 888  O(n log n)
15
Classes de complexité :Rappelle mathématique 2/2
Rappelle mathématique: raisonnement/
Démonstration
En utilise la Démonstration par déduction pour
démontrer une propriété O(log(n)) ou O(nlog(n)),
Rappel: Raisonnement par déduction / induction
• la déduction serait le procédé de l’esprit qui va du
général au particulier
• Le raisonnement déductif consiste à prouver une
implication du type HC
avec H désigne les hypothèses et C la ou les
conclusion(s).
• Comment faire ? on procède par un chaînage de
déductions logiques :
H C(1) C(2) C(3)……C(n) C
16
Représentation d’un algorithme
• Historiquement, deux façons pour représenter un algorithme:
• L’Organigramme: représentation graphique avec des symboles
(carrés, losanges, etc.)
• offre une vue d’ensemble de l’algorithme
• représentation quasiment abandonnée aujourd’hui
• Le pseudo-code: représentation textuelle avec une série de
conventions ressemblant à un langage de programmation
• plus pratique pour écrire un algorithme
• représentation largement utilisée
17
bon en algorithmique ?
• La maîtrise de l’algorithmique requiert deux qualités, très complémentaires d’ailleurs :
• il faut avoir une certaine intuition, car aucune recette ne permet de savoir a priori quelles
instructions permettront d’obtenir le résultat voulu. C’est là, si l’on y tient, qu’intervient la forme
« d’intelligence » requise pour l’algorithmique. Alors, c’est certain, il y a des gens qui possèdent au
départ davantage cette intuition que les autres. Cependant, et j’insiste sur ce point, les réflexes, cela
s’acquiert. Et ce qu’on appelle l’intuition n’est finalement que de l’expérience tellement répétée que
le raisonnement, au départ laborieux, finit par devenir « spontané ».
• il faut être méthodique et rigoureux. En effet, chaque fois qu’on écrit une série d’instructions qu’on
croit justes, il faut systématiquement se mettre mentalement à la place de la machine qui va les
exécuter, armé d'un papier et d'un crayon, afin de vérifier si le résultat obtenu est bien celui que l’on
voulait. Cette opération ne requiert pas la moindre once d’intelligence. Mais elle reste néanmoins
indispensable, si l’on ne veut pas écrire à l’aveuglette.
• Et petit à petit, à force de pratique, vous verrez que vous pourrez faire de plus en plus souvent l’économie
de cette dernière étape : l’expérience fera que vous « verrez » le résultat produit par vos instructions, au
fur et à mesure que vous les écrirez. Naturellement, cet apprentissage est long, et demande des heures
de travail patient. Aussi, dans un premier temps, évitez de sauter les étapes : la vérification méthodique,
pas à pas, de chacun de vos algorithmes représente plus de la moitié du travail à accomplir... et le gage de
vos progrès.
18
Organisez-vous
Pour bien réfléchir, il faut être dans de bonnes conditions. En particulier, il faut éviter de perdre du temps à
retrouver sur quelle page on a écrit le premier exemple, il vaut mieux gommer des lignes que les rayer dans
tous les sens, et c'est pratique de laisser dans la marge des petites notes pour s'y retrouver entre les
différentes phases de recherche de la solution. Pour être dans de bonnes conditions :
1. Prenez un porte-mine et une gomme. C'est très pratique de gommer, ça permet d'améliorer une partie
de ce qu'on a écrit sans tout recopier.
2. Prenez une grande feuille toute blanche. Trouvez du papier qui ne se froisse pas quand on le gomme
plusieurs fois.
3. Notez le nom de l'exercice et le numéro de la page en haut de chacune des feuilles utilisées pour
l'exercice, afin de vous y retrouver plus tard. L'idéal est d'avoir une grande feuille double.
4. Marquez l'heure de début et de fin de chaque phase de recherche dans la marge, pour pouvoir bien
gérer votre temps.
19
Structures algorithmiques
Les concepts en œuvre en algorithmique, sont en petit nombre. Ils

appartiennent à deux classes :
• les structures de contrôle
• séquences
• conditionnelles
• boucles
• les structures de données
• constantes
• variables
• tableaux
• structures récursives (listes, arbres, graphes)
20
De ADN au instruction algorithmique
• Comme L’ADN, qui est en quelque sorte le programme génétique, l’algorithme à la
base de construction des êtres vivants, est une chaîne construite à partir de quatre
éléments invariables. Ce n’est que le nombre de ces éléments, ainsi que l’ordre dans
lequel ils sont arrangés, qui vont déterminer si on obtient une puce ou un éléphant.
• Un programme informatique est formé de quatre types d’instructions considérées

comme des petites briques de base :
• l’affectation de variables
• la lecture / écriture
• les tests
• les boucles
21
Algorithmique : Processus de développement
• Processus de développement :
• Conception
• comment développer un algorithme?
• quelles techniques produisent de bons algorithmes?
• Analyse
• étant donné un algorithme, quelles sont ses qualités?
• est-il adapté au problème?
• est-il efficace?
• comment mesurer ses performances?
• Étant donné un problème sans solution évidente, comment peut on le résoudre?
• en considérant les problèmes similaires connus,
• en considérant les solutions analogues - algorithmes - connues,
• en faisant marcher son imagination !!!
22
Clarifier et valider une idée d'algorithme
1. Décrivez vôtres solution en deux ou trois phrases.
2. Trouvez une bonne représentation visuelle de cette solution.
3. Appliquez votre idées sur quelques exemples, en utilisant cette
représentation.
4. Cherchez des contre-exemples à vos idées d'algorithmes.
5. Essayez de déterminer pourquoi l'algorithme fonctionne. Déterminez ses
invariants.
6. Calculez la complexité en temps et mémoire de vos solutions.
7. Ecrivez le pseudo-code de l'algorithme, et essayez de le simplifier.
23
Méthode de résolution des sujets d'algorithmique 1/2
Étapes de la méthode:
1. Lisez le sujet: Ce qui est important est :
1. Ne faites surtout pas de contresens. Si vous comprenez un autre sujet que celui qui est décrit, c'est
foutu. Ne commencez pas à chercher avant d'être sûr d'avoir bien compris le sujet.
2. À la fin, vous devez avoir le sujet entièrement en tête. Il faut vraiment éviter d'y revenir toutes les 30
secondes pendant que vous cherchez une solution.
3. Reformulez le sujet le plus simplement possible, de manière à faire le tri entre les idées clés et le
texte d'enrobage.
2. Résolvez des exemples :En résumé, résoudre des exemples sert à :
1. faire sortir des idées ;
2. déterminer les cas limites (les cas triviaux et les cas pathologiques) ;
3. préparer un support pour tester et déboguer efficacement.
3. Cherchez un algorithme :est détaillé dans la méthode de recherche d'un algorithme
24
Méthode de résolution des sujets d'algorithmique 2/2
Étapes de la méthode(suite):
4. Pseudo-codez l'algorithme et Vérifiez votre solution (crayon et papier)
Ne commencez pas à coder avant d'avoir vérifié que votre algorithme :
1. répond bien au sujet (relire le sujet !),
2. est correct (en particulier qu'il résout bien les exemples que vous avez générés au début, y compris
les cas limites),
3. a bien la complexité que vous pensez (recalculez-là soigneusement),
4. a le pseudo-code le plus simple possible.
5. Codez votre solution et Testez votre solution (logiciel exemple AlgExec ou python):Voici l'ordre
recommandé des exemples à tester :
1. l'exemple du sujet,
2. les exemples résolus entièrement à la main,
3. d'autres exemples générés sur le tas,
4. des exemples de pire cas, dans la mesure du possible
25
Méthode de recherche d'un algorithme 1/4
1. Lisez bien le sujet, et reformulez-le.

Cela peut paraître évident, mais l'expérience montre qu'il arrive à tout le monde de lire le sujet un peu vite,
et de ne pas voir certains détails importants. Pour éviter cela, il faut donc prendre son temps pour lire le
sujet, et ne pas hésiter à le relire plusieurs fois pour bien tout comprendre et voir tous les détails
2. Faites la liste des dimensions du sujet.
• Les dimensions d'entrée: type, taille…
• Les dimensions de sortie : type, taille…
• Les dimensions implicites :type, taille…
Pour chacune de ces dimensions, précisez
• Les valeurs minimales et maximales
• Si l'ordre est important
26
3. Cherchez une bonne représentation visuelle du problème.(graphe, arbre…)
4. Générez des exemples, et résolvez les entièrement à la main.

5. Décrivez la solution naïve, puis essayez de l'améliorer.
Le but de cette étape est donc de trouver au moins une manière très simple de résoudre le problème, par un
algorithme dit naïf, ou bourrin, cela a plusieurs avantages :
• Vous aurez au moins un programme qui permet d'obtenir quelques points.
• Vous pouvez l'utiliser pour résoudre de nombreux exemples, et remarquer certaines choses en analysant les
solutions.
• Il y a des chances qu'une partie du code puisse être repris tel-quel dans la solution finale, et il est plus facile de
débugger du code d'une solution naïve simple, que de débugger le même code lorsqu'il fait partie d'un algorithme
complexe.
• Quand vous aurez implémenté un meilleur algorithme, vous pourrez comparer les résultats, et vérifier que vous
n'avez pas fait d'erreur.
• Si votre algorithme final ne fonctionne pas à tous les coups, vous pourrez intégrer la solution naïve à votre source
et l'appeler pour les petits tests, pour vous assurer d'avoir au moins les points correspondants.
27
6. Simplifiez le problème, puis généralisez-les solutions obtenues.
Cette technique est particulièrement efficace pour les raisons suivantes :
• Il est plus facile de trouver les solutions des versions simplifiées, que de résoudre le problème initial.
• Tout algorithme qui résoudre le problème complet doit nécessairement résoudre les problèmes simplifiés,
donc doit au moins faire ce que fait une solution de chacune des versions simplifiées.
• Les idées qui permettent de résoudre les versions simplifiées sont des idées qu'il faut généralement avoir, pour
être capable de résoudre le problème initial.
Pour appliquer ce conseil efficacement, il faut :
• Chercher toutes les versions simplifiées du problème qui gardent un sens:
 Simplifier certaines des dimensions du problèmes soit en:
 la supprimer complètement
 la réduire à la plus petite valeur, ou au plus petit sous-ensemble de valeurs pour lequel le problème
garde un sens.
 la fixer à une valeur bien précise (la même valeur pour tous les objets).
 Supprimer ou simplifier certaines règles du sujet
• Bien choisir quelles versions tenter de résoudre en priorité, et y réfléchir dans cet ordre.
• Une fois les versions simplifiées résolues, généraliser ces solutions, ou les adapter au problème complet.
28
7. Changez de point de vue, en envisageant les algorithmes classiques.
Il n'y a pas des millions de types de problèmes différents. On peut en général les classer dans une quinzaine
de catégories. Certains types d'algorithmes apparaissent très souvent. Vous pouvez trouver une liste des
algorithmes les plus utilisés, on va voir dans ce cours:
• Algorithmique des nombres:
• Crible d'Ératosthène
• Algorithme d'Euclide
• Algorithme de tri
• Tri sélection
• Trie bulle
• Trie insertion
• Algorithme de recherche
• dichotomie
• Algorithme optimisation: Algorithme glouton
• Algorithme géométrique
• Fouille de flots de données:
• Fenêtres Glissantes
• Algorithmes d’approximation :méthode de Monte-Carlo 29
Algorithmique : Processus de développement exemple
• Exemple : Algorithme d’Euclide PGCD
Étant donnés deux entiers, retrancher le plus petit au plus grand et recommencer jusqu’à ce que les deux nombres soient
égaux. La valeur obtenue est le plus grand diviseur commun.
• Étape 1 : Écrire proprement l’idée
Prendre les deux nombres et, tant qu’ils ne sont pas égaux, retirer le plus petit au plus grand.
• Étape 2 Algorithme (idée détaillé) : Décrire précisément les étapes
a,b : deux nombres
Répéter tant que a et b sont différents :
si le plus grand est a :
les deux nombres deviennent a−b et b
sinon (b est donc le plus grand) :
les deux nombres deviennent a et b−a
le pgcd est a
Étape 3 Algorithme (pseudocode) : Écrire un algorithme formel fonction
Fonction pgdc(a,b : entiers) :entier
tantque a<>b faire
si a>b alors
aa−b
sinon
bb−a
finsi
retourner a
fin
Étape 4 : Écrire un programme consiste à traduirel’algorithme dans un langage de programmation
# CODE PYTHON /* CODE C */ // Code Java

def pgdc(a,b): int pgdc(int a,int b) public static int pgdc(int a, int b)
while a!=b : { {
if a>b : while (a != b) while (a!=b)
a=a-b { {
else : if (a>b) if (a>b)
b=b-a a=a-b; a=a-b;
return a else else
b=b-a; b=b-a;
} }
return a; return a;
} }
Structure de base d’un algorithme
En pseudocode En python
algo nom_algo Def main():
Variables
instruction
début
instruction main()
fin
33
Variables
• La première chose à faire avant de pouvoir utiliser une variable est de créer la boîte et de lui coller une étiquette
(identificateur).
• Ceci se fait tout au début de l’algorithme, avant même les instructions proprement dites.
• C’est ce qu’on appelle la déclaration des variables
• La variable doit être déclarée avant d’être utilisée, elle doit être caractérisée par :
• un nom (Identificateur) est un mot : - commençant obligatoirement par une lettre
- ne comportant aucun espace
• un type qui indique l’ensemble des valeurs que peut prendre la variable (entier, réel, booléen, caractère, chaîne
de caractères, …)
• Une valeur: En informatique, une variable possède à un moment donné une valeur et une seule valeur
• Exemple:
variable i, j, k : entier
i
variable x, y : réel
x
variable OK: booléen
variable Ch1, ch2 : chaîne de caractères
• Dans un programme une variable a un identificateur unique
• Conseil Identificateur : pour la lisibilité du code choisir des noms significatifs qui décrivent les données manipulées
34
Type de variable résumé
type Syntaxe caractères ensemble exemples taille en octets
python autorisés de valeurs de valeurs
booléen bool {.vrai., .faux.} .vrai. ou 1 1
{true, false} python .faux. ou 0
chaîne string tout caract. "abcd" Max 255
"67000"
entier int 0 à 9, -, + [-32768..+32767] -152 2
+4560 ou 4560
réel float 0 à 9, -, +, . -3,40x1038 à -1,40x1045 pour -12.3652 4
les valeurs négatives +0.186 ou
1,40x10-45 à 3,40x1038 pour 0.186
les valeurs positives
caractère tout caract. "A" 1

"*"
35
Constante
• Instruction permettant de réserver de l’espace mémoire pour stocker des
données dont la valeur est fixée pour tout l’algorithme
• La déclaration des constants se fait avant la déclaration des variables
• La constantes doit être caractérisée par :
• Un nom (Identificateur)
• valeur
• Dans un programme une constant a un identificateur unique
• Exemple:
constante
PI=3.14
MAX=14
36
Affectation
• L’affectation consiste à attribuer une valeur à une variable (c’est-à-dire remplir ou modifier le contenu d'une zone
mémoire)
• En pseudo-code, l'affectation est notée par le signe ← (logiciel <-)et en python =
V← e : attribue la valeur de e à la variable V
• e peut être une valeur, une autre variable ou une expression
• V et e doivent être de même type ou de types compatibles
• l’affectation ne modifie que ce qui est à gauche de la flèche
• Exemples :(avec i, j, k : entier; x :réel; ok :booléen; ch1,ch2 :chaine de caractères)
i ←1
j ←i
k ←i+j
x ←10.3
OK ←FAUX
ch1 ←"SMI"
ch2 ←ch1
x ←4
• Exemples non valides: i ←10.3
OK ←"SMI"
j ←x
37
i+1 j
Affectation :Expressions et opérateurs
• Opérateurs numériques :
• + : addition
• - : soustraction
• * : multiplication
• / : division
• Parenthèses * et / + et –
• 12 * 3 + 5 et (12 * 3) + 5 valent strictement la même chose.
• En revanche, 12 * (3 + 5) vaut 12 * 8 soit 96
• Opérateur alphanumérique : +  concaténer
• Opérateurs logiques (ou booléens)  ET, du OU, du NON
38
Affectation :Expressions et opérateurs (résume)
Opérateurs Commentaires Type d'opérandes Type du résultat
+ et - + - tous les langage entier, réel, décimal de l'opérande
non not tous les langage booléen booléen
* multiplication entier, réel, décimal entier, réel, décimal
/ division entier, réel, décimal entier, réel, décimal
DivEnt ( n,d) quotient de division// en python entier, réel, décimal entier
Modulo(n,d) reste d'une division % en python entier, réel, décimal entier
+ concaténation + en python chaîne ou caractère chaîne
+ et - binaire entier, réel, décimal entier, réel, décimal
< <= > >= <> équivalant à != en python tout type
= <>
et AND python booléen booléen
ou OR python booléen booléen
39
Affectation: remarques pour terminer
• Certains langages donnent des valeurs par défaut aux variables déclarées.
Pour éviter tout problème il est préférable d'initialiser les variables déclarées.
• La valeur d’une variable ne change pas jusqu’à une affectation vers cette
variable
• Lors d’une affectation, l’expression de droite est évaluée et la valeur trouvée
est affectée à la variable de gauche. Ainsi, A←B est différente de B←A
• l'affectation est différente d'une équation mathématique
• Les opérations x ← x+1 et x ← x-1 ont un sens en programmation et se nomment
respectivement incrémentation et décrémentation.
• A+1 ← 3 n'est pas possible en langages de programmation et n'est pas équivalente à
A←2
40
Affectation : exemple Instruction ligne A B
variables A, B : Entiers
Début 1 1 -
1) A ← 1 2 1 6
2) B ← 6 3 1 4
3) B ← A + 3
3 3 4
4) A ← 3
Fin
Illustration avec python
Complexité
Tmax = T(ligne1)+ T(ligne2)+ T(ligne3)+ T(ligne4)
= 4 affectation + 1 addition
= 5 ≤constant *1 = O(1)
41
Affectation : exercice 1
• Tracer les valeurs des variables A, B et C après exécution des instructions
suivantes ?
• Variables A, B, C : Entier
Début
A←5 Instruction ligne A B C
B←3
C←A+B 1
A←2 2
C←B–A 3
Fin
4
5
• Calculer complexité?
42
• Plus difficile, mais c’est un classique absolu, qu’il faut absolument
maîtriser : écrire un algorithme permettant d’échanger les valeurs de
deux variables A et B, et ce quel que soit leur contenu préalable.
43
solution: exercice 2
• Début
…
C←A
A←B
B←C
Fin
• On est obligé de passer par une variable dite temporaire (la variable
C).
Complexité Tmax=3 affectation
= 3≤constant *1 = O(1)
44
• Que produit l’algorithme suivant ?
• Variables A, B, C :Caractère
Début
A ← "423"
B ← "12"
C←A+B
Fin
• A la fin de l’algorithme, C vaudra donc "42312".
Complexité T =3 affectation + 1 concaténation
=4
45
Les instructions de lecture et d’écriture
(I/O standard: clavier/ écran )
• Dans un sens, ces instructions permettent à l’utilisateur de rentrer
des valeurs au clavier pour qu’elles soient utilisées par le programme.
Cette opération est la lecture.
• Dans l’autre sens, d’autres instructions permettent au programme de
communiquer des valeurs à l’utilisateur en les affichant à l’écran.
Cette opération est l’écriture.
46
Syntaxe des instructions d’écriture (I/O standard: écran )
• Syntaxe
afficher Toto
Dans le sens inverse, pour écrire quelque chose à l’écran. on peut utiliser le mot clé : afficher
• Important
afficher peut prendre de un à plusieurs paramètres de n'importe quel type de base. Elle affiche tous les paramètres les uns après
les autres (résultat identique à celui d'une concaténation).
instruction 1 : instruction 3 : instruction 4 :
Algorithme
affichage du texte affichage de la valeur texte et valeur
afficher ("nombre ? " )

nb  10
afficher (nb)
afficher ("nb vaut ", nb, ".")
Remarque :afficher :affiche à l’écran avec un saut de ligne par défaut afficher et pour afficher à l’écran sans saut de ligne il faut
écrire virgule à la fin de l'instruction pour annuler le saut de ligne en algo,
Exemple pour écrire "bonjour tous le monde " en même ligne on peut soit écrire afficher ( "bonjour tous le monde ") ou
afficher ("bonjour "), (équivalent print ("bonjour",end= "" ) en python).
afficher (" tous" ) (équivalent print (" tous" ) en python)
47
Les instructions
Syntaxe saisir nomVariable
de lecture (I/O standard: clavier)
Dès que le programme rencontre une instruction saisir, l’exécution s’interrompt, attendant la frappe d’une valeur au
clavier. Dès lors, aussitôt que la touche Entrée (Enter) a été frappée, l’exécution reprend
instruction 1 : instruction 2 : étape 1 instruction 2 étape 2 instruction 3 : texte
Algorithme
affichage du texte attente action utilisateur affecter la valeur et valeur
afficher ("nombre ? " )

saisir (nb) nb 10
10 ENTER
afficher ("nb vaut ", nb, ".")
saisir une donnée : saisir nom_de_la_variable

Lire plusieurs données : saisir nom_de_la_variable_1, nom_de_la_variable_2, ...
(équivalent python à input() qui lit toute la ligne en ASCII..) illustration
Saisir (nombreEntrer) nombreEntrer=int (input())
Saisir (NombreReel) NombreReel=float(input())
Saisir (Texte) Texte=input()
48
Saisir (varEnt1,varEnt2) varEnt1,varEnt2 = map(int, input().split())
Les instructions de lecture et d’écriture
(I/O standard: clavier/ écran ) exemple
Variable v, double: entier
Début
saisir (v)
Double ← v * 2
afficher (v)
afficher ("le double de ",v, " est ",Double)
Fin
Instruction v doubl clavi écran
illustration : ligne e er
1 23 23
2 46
3 23
4 et Le double de 23 est
49 46
Les instructions de lecture et d’écriture (I/O standard: clavier/ écran ) exercice
• écrire un programme qui lit le prix HT d’un article, le nombre d’articles et le taux de TVA, et qui fournit le prix total TTC correspondant.
Faire en sorte que des libellés apparaissent clairement.
• solution
variable nb, pht, ttva, pttc : entier
Début
afficher ("Entrez le prix hors taxes :")
saisir (pht)
afficher ("Entrez le nombre d’articles :")
saisir (nb)
afficher ("Entrez le taux de TVA ( %):")
saisir (ttva)
pttc ← nb * pht * (1 + (ttva/100))
afficher ( "Le prix toutes taxes est : ", pttc)
Fin
• Là aussi, on pourrait économiser une variable et une ligne en écrivant directement. :
afficher "Le prix toutes taxes est : ", nb * pht * (1 + ttva)
• C'est plus rapide, plus léger en mémoire, mais un peu plus difficile à relire (et à écrire !)
Complexité T =1 affectation + 1 addition + 2 multiplication + 1 division + 6 lecture/ écriture I/O = 11 ≤constant *1 = O(1) 50
Tests: instructions conditionnelles
• Si booléen Alors
Instructions non
Booléen 1
Finsi
oui
• Si booléen Alors oui
Instructions 1 Instruction 1 Instruction 2
Sinon
Instruction 3
Instructions 2
Instructions 3 Instruction suivant
Finsi
• un booléen peut être une condition obtenu avec les comparaisons <; <= ; > ; >=; = ;<> ;
• Conditions composées (voir algèbre de Boole)avec NON;ET;OU;XOU
Calcule de complexité :
• TMax(si Comp alors Inst1 sinon Inst2 finsi ) = coût(Comp) + Max(coût(Inst1), coût(Inst2))
• TMin (si Comp alors Inst1 sinon Inst2 finsi ) = coût(Comp) + Min(coût(Inst1), coût(Inst2))
51
Instruction plusieurs ligne :bloc instruction
algoc python
si a=0 alors If a==0: • Instruction parente:
inst1 inst1 Bloc instruction 1:
inst2 inst2 Instruction …
Indentation touche TAB

Sinon else: Instruction …
inst3 inst3 Instruction parente:
inst4 inst4 Bloc instruction 2:
Finsi Instruction …
Instruction …
Si a=0 alors If a==0:
si b=0 alors if b==0:
inst1 inst1
sinon else
inst2 inst2
• Instruction suivante après bloc 1
finsi else:
Sinon inst3
inst3 instsuivant
finsi
instsuivant
Tests imbriqués Tests combiné
• Les tests peuvent avoir un degré quelconque
d'imbrications (déconseiller) • Les tests peuvent avoir un degré combinaison de test
Si condition1 alors (conseiller)

Si condition2 alors Si condition1 ET condition2 alors
instructionsA instructionsA
Sinon Sinonsi condition1 ET non condition2 alors
instructionsB instructionsB
Finsi Sinonsi condition3 alors
Sinon instructionsC
Si condition3 alors Finsi
instructionsC Remarque:
Finsi • Une seul instruction
Finsi • Plus d’effort à exploiter mais facile en vérification
Remarque:
• Une instruction à l’intérieur d’une autre instruction
• Facile à exploiter mais demande plus d'effort en 53
vérification
Tests: enchaînement de plusieurs tests successifs
• Les tests peuvent avoir un degré quelconque d'imbrications
• Si booléen1 Alors Booléen non
Instructions 1 1 oui
Sinonsi booléen2 Alors Instruction 1 Booléen non
Instructions 2 2 oui
Instructions 3 Instruction 2 Instruction4
Instruction 3
Sinon
Instructions 4
Finsi Instruction Syntaxe En python
suivant
if cont1:
• Remarque : inst1
• Il faut utiliser les Conditions composées (voir algèbre de Boole) Elif cond2:
inst2
• Facile à vérifier mais demande plus d'effort en exploitation
Inst3
Else:
inst4
54
Tests : exemple inst x y clv écran
• Variable x, y : réel 1 - - Entrez un réel :
Début 2 -2 -2
1) afficher (" Entrez un réel : " ) 34
2) saisir (x) 4 2
3) Si x < 0 alors 47
4) y ← -x
8 la valeur absolue de -2 est: 2
5) Sinon
6) y← x
7) Finsi
8) afficher ("la valeur absolue de ", x, "est:",y) inst x y clv écran
Fin 1 - - Entrez un réel :
Illustration cas 1: 2 3 3
Illustration cas 2: 35
Complexité 6 3
Tmax= 1 comp +max (1,1 aff) +3 I/O 67
8 la valeur absolue de 3 est: 3
=5≤constant *1 = O(1) 55
Tests imbriqués
Variable n : entier
: exemple inst n clv écran
inst n cl écran
1 entrez un nombre :
Début 1 entrez un nombre
1) afficher ("entrez un nombre : ") 2 1 1
2 0 0
2) saisir (n) 35
35
3) Si n < 0 alors 68
67
4) afficher("négatif") positif
710 nul 9
5) Sinon
6) Si n = 0 alors 10 et 11
7) afficher("nul") 10 et 11
ligne cout
8) Sinon
inst n clv écran 1 1
9) afficher("positif")
10) Finsi 1 entrez un nombre 2 1
11) Finsi 2 -3 -3 3 1
Fin 34 4 1
Illustration : Cas1, Cas2, Cas3 411 négatif 5
Complexité 11 6 1
Tmax= 2 I/O + Tmax(si_3à11)= 2 I/O + 1 comp +max(1 I/O, Tmax(si_5à10)) 7 1
= 2 I/O + 1 comp +max(1 I/O, 1 comp + max( 1 I/O, 1 I/O))=3 + max (1, 2)= 5 ≤ constant *1 = O(1) 8
56
9 1
Tests : Organigramme selon non
selon v v=1ou
v=3 non
cas 1,3: oui
instruction 1 Instruction 1 V=2 ou
v=4
cas 2,4: oui
instruction 2 Instruction 2 Instruction3
Autres :
instruction 3 Instruction
Finselon suivant
Illustration: Cas1 ,Cas2, Cas3
Algo Pas d’équivalent en python, mais on utilise if comme suit:
selon v If v==1 or v==3:
cas 1, 3 : print("impaire ")
afficher( "impaire") elif v==2 or v==4:
cas 2 ,4: print("paire ")
afficher (" paire") else:
Cas Autre : print("[1,3]")
afficher ("[1,3]")
finselon
57
Test :instruction selon
Lorsque l’on doit comparer (égalité) une même variable avec plusieurs valeurs, comme par exemple:
si abr = "M" OU abr = "Mr" alors selon abr

afficher "Monsieur" cas "M", "Mr" :
sinon afficher " Monsieur "
si abr = "Mme“ alors cas "Mme" :
afficher "Madame" afficher " Madame "
sinon cas "Mlle" :
si abr = "Mlle" alors afficher " Mademoiselle "
afficher "Mademoiselle" Autres :
sinon afficher " Humain "
afficher " Humain " Finselon
finsi
finsi
Finsi
Remarque: La complexité Tmax avec selon est égale à Tmax avec si
58
inst v écran
1 1
Tests : Organigramme selon 23
1) selon v 38 impaire

ligne cout
inst v écran
2) cas 1,3: 1
3) afficher "impaire" 2 3 1 2
3 1 24
4) cas 2,4:
4 3 45
5) afficher "paire" 5 1 58 paire
6) cas Autres : 6
inst v écran
7) afficher " v<1 ou v>4" 7 1
8 1 6
8) finselon
24
Complexité
46
Tmax(v)= T(l2)+max(T(l3),T(l4à8)) et T(l4à8)= T(l4)+max(T(l5),T(l7)) 67
Alors Tmax(v)= 3 + max (1, 3+max(1, 1 )) 78 v<1 ou v>4
59
= 3+4 =7≤constant *1 = O(1)
Tests : instruction selon (exemple)
Variable c : caractère
Début ligne cout
1) afficher (" entrer un caractère ")
1 1
2) saisir c
3) Si((c>= "A") ET (c<= "Z")) alors 2 1
4) Selon c 3 3
5) cas "A", "E", "I", "O", "U", "Y" 4
6) afficher (c, "est une voyelle majuscule ")
5 11
7) cas autre
8) afficher (c, "est une consonne majuscule ") 6 1
9) Finselon 7
10) sinon 8 1
11) afficher (c, "n’est pas une lettre majuscule ")
9
12) Finsi
10
Fin
11 1
Complexité
Tmax = 2 + Tmax (si_3à12) = 2+ 3 + max (Tmax(selon_4à9), 1)
Avec Tmax(selon_4à9)= 6comp + 5 OU + max(1, 1 )= 11+ max(1, 1)= 12
Alors Tmax= 2+3+max(12,1) = 5+12=17≤constant *1 = O(1) 60
Instructions itératives : les boucles
• Les boucles servent à répéter l'exécution d'un groupe d'instructions un certain nombre de
fois
• On distingue trois sortes de boucles en langages de programmation :
• Les boucles tantque : on y répète des instructions tant qu'une certaine condition est
réalisée
• Les boucles Répéter : on y répète des instructions jusqu'à ce qu'une certaine condition
soit réalisée
• Les boucles pour ou avec compteur : on y répète des instructions en faisant évoluer un
compteur (variable particulière) entre une valeur initiale et une valeur finale
• Les boucles sont des instructions de plusieurs lignes alors on peut imbriquer :
• Si a l’intérieur de boucle
• Boucle a l’intérieur de boucle
• ….. 61
Instructions itératives : La boucle «tant que»
amorçage {initialisation de la (des) variable(s) de condition}
Tantque < condition logique (vraie)> faire
traitement {suite d’instructions}
relance {ré-affectation de la (des) variable(s) de condition}
FinTantQue
• Fonctionnement :-répéter une suite d’instructions tant qu’une condition est remplie
• remarque: - si la condition est fausse dès le départ, le traitement n’est jamais exécuté
- si vous oubliez la ré-affectation de la (des) variable(s) de condition la condition, le traitement ne
s’arrêtera jamais .
• Attention aux boucles infinies
Exemple erreur : correction
i←1 i←1
TantQue i > 0 faire TantQue i <10 faire
i ← i+1 i ← i+1
FinTantQue FinTantQue
algo python
n1 n=1
tantque (n >0) while n>0:
saisir (n) n= int(input())
afficher( "essai négatif !" ) print("essai négatif!")
Fintantque 62
Organigramme tantque
Tantque booléen(vraie) faire
Booléen(vraie)
non
instruction1 l cout fois oui

relance Instruction 1
2 1 1
FinTantQue
Calcule complexité: Exemple 3 1 1 relance
1) N ← 2 4 1 n+1
2) R← 1
5 2 n
3) I ← 1
4) TantQue I ≤ N Faire 6 2 n Instruction 2
5) R ← R*I 7
6) I ← I+1 inst N R I
7) FinTantQue 2 2 1
Illustration:
3 1
Le temps d’exécution t(n) de cet algorithme en supposant que:
- N=n 45 1
- t1 est le temps d’exécution entre le début et ligne 3 6 2
- t2 est le temps d’exécution de la ligne 4
- t3 est le temps d’exécution de la ligne 5 74
- t4 est le temps d’exécution de la ligne 6 45 2
- t1, t2, t3, t4 sont des constantes (ne dépendent pas de n)
s’écrit: T (n)  t1  n (t 2  t 3  t 4)  t 2  3  n (1  2  2)  1 5n  4  O(n) 6 3

i 1

i 1 74
alors Tmax(n) ≤ constant*n=O(n)
48 63
Ici un algorithme est asymptotiquement linéaire en n.
La boucle «tant que»: exemple
inst N cl écran
• variable N : Entier
Début 1 0
1) N ← 0 2 Entrez un nombre entre 1
2) afficher "Entrez un nombre entre 1 et 3 " et 3
3) TantQue N < 1 ou N > 3 faire 34
4) saisir N 4 4 4
5) Si N < 1 ou N > 3 Alors 56 Recommencez Saisie

7
6) afficher "Recommencez Saisie.”
83
7) FinSi
34 2 2
8) FinTantQue
57
9) afficher ”terminer.”
Fin 83
39 terminer
64
Instructions itératives :La boucle Répéter
• La boucle «répéter ... jusqu’à»
Répéter
relance { réaffectation de la (des) variable(s) de} condition
traitement {suite d’instructions}
jusqu’à <expression logique (faux)>
• exécuter une suite d’instructions au moins une fois et la répéter tant qu’une condition est pas remplie
• Remarque: varie selon le langage on peut trouver plusieurs syntaxes et organigrammes:
Faire Ou Répéter
instructions instructions
tantque <expression logique (vrai)> tantque <expression logique (vrai)>
algoc En python Pas équivalent mais en peut utiliser équivalence avec tantque(voir le diapo
répéter équivalence répéter et tantque)
saisir (n) n=1
afficher ("essai négatif !" ) While n>=0:
jusqu’à (n <=0) n=int(input())
print("essai négatif !" )
65
Organigramme répéter…jusqu’à Instruction 1
répéter
instruction1 relance
relance
Jusqu’à booléen (faux)
Calcule complexité Booléen
Exemple non oui
1) R ← 1
2) I ← 1
3) Répéter Instruction 2
4) R ← R*I
5) I ← I+1
6) Jusqu'à I > N inst n R I
l c fois
Le temps d’exécution t(n) de cet algorithme en supposant que:
1 1 1 1 2 1
- N=n
- t1 est le temps d’exécution entre le début et la ligne 2 2 1 1 2 1
- t2 est le temps d’exécution de la comparaison de la ligne 6 34 1
- t3 est le temps d’exécution de l’action de la ligne 4 3
- t4 est le temps d’exécution de l’action de la ligne 5 4 2 n 5 2
- t1, t2, t3, t4 sont des constantes (ne dépendent pas de n) 63
5 2 n
s’écrit: n n
T (n)  t1   (t 2  t 3  t 4)  2   (1  2  2) 5n  2  O(n) 34 2
i 1 i 1
6 1 n
alors Tmax(n) ≤ constant*n=O(n) 5 3
un algorithme est asymptotiquement linéaire en n 67 66
Lien entre la Boucle répéter…jusqu’à et tantque(suite)
• Equivalence entre boucles répéter et tant que (exemple)
Répéter
afficher "Donnez une valeur positive paire :"
saisir nombre
jusqu’à (nombre>= 1 ET (nombre=< 3) )
équivaut à:
Nombre 0
saisir nombre
tantque (nombre< 1 ou (nombre> 3) ) faire
afficher "Donnez une valeur positive paire:"
saisir nombre
FinTantQue
67
Les Boucles répéter…jusqu’à (suite)
• Comparaison boucles répéter et tant que (suite)
•boucle tantque
-condition vérifiée avant chaque exécution du traitement
-le traitement peut donc ne pas être exécuté
-de plus : la condition porte surtout sur la saisie de nouvelles variables (relance)
•boucle répéter
-condition vérifiée après chaque exécution du traitement
-le traitement est exécuté au moins une fois
-de plus : la condition porte surtout sur le résultat du traitement
• Remarque: la boucle répéter est typique pour les saisies avec vérification.
68
Les Boucles
• Sémantique de la boucle pour
• Implicitement, l’instruction pour:
-initialise une variable de boucle (le compteur)
-incrémente cette variable à chaque pas
-vérifie que cette variable ne dépasse pas la borne supérieure
• Attention : -le traitement ne doit pas modifier le compteur de boucle
69
Instructions itératives : la boucle Pour
• Remarque : le nombre d'itérations dans une boucle Pour est connu avant le début de la boucle
• Pour compteur ← Initiale à finale par pas 2
instruction 1
finpour
• Compteur est une variable de type entier (ou caractère). Elle doit être déclarée
• Pas est un entier qui peut être positif ou négatif. Pas peut ne pas être mentionné, car par défaut sa valeur
est égal à 1. Dans ce cas, le nombre d'itérations est égal à finale - initiale+ 1
• Initiale et finale peuvent être des valeurs, des variables définies avant le début de la boucle ou des
expressions de même type que compteur
algo Pyton
pour i  0 à 3 Instruction range:
afficher ("Valeur de i : ", i) En pratique range(10) se comporte comme la suite de valeurs 0, 1, ..., 9 et ce code
finpour revient à dire : for i in range(4):
Pour chaque valeur dans [0, 1, ..., 3] affecter cette valeur à la variable i et
La dernier valeur de i est 4 for i in range(4):
avant la fin de boucle print("Valeur de i : ", i)
70
Remarque: range(1,4) commence par 1, les valeurs sont [1, 2, 3]
Organigramme: boucle pour
Pour compteur ← 0 à 4 par pas 2
Compteur1
instruction 1 non
compteur<=2
finpour
Calcule complexité oui
T( pour k ← a à b faire I(k) finpour) Instruction 1
= coût(I(a))+ coût(I(a+1)) … +coût(I(b))
Exemple Compteur Compteur+1
1) N← 2
2) R← 1
3) pour I ← 1 à N
4) R ← R*I Instruction 2
5) Finepour
Illustration l c foi inst n R I
Le temps d’exécution t(n) de cet algorithme en supposant que: 2 1 1 2 2 1
- t1 est le temps d’exécution entre le début et ligne 2
- t2 est le temps d’exécution de la comparaison de la ligne 3 3 1 initia 1 34 1
- t3 est le temps d’exécution de l’action de la ligne 4 3 1 comp n+1 4 1
- t4 est le temps d’exécution de l’incrémentation de la ligne 5
-t5 temps d’initialisation de compteur 4 2 n 53 2
- t1, t2, t3, t4 sont des constantes (ne dépendent pas de n) 5 2 incr n 34
s’écrit: n n
T (n)  t1  t 5   (t 2  t 3  t 4)  t 2  3   (1  2  2) 1  5n  4  O(n) 4 2
i 1 i 1 3
53
Tmax(n) ≤ constant*nTmax=O(n)
Encors un algorithme est asymptotiquement linéaire en n 36 71
Boucle Pour: exemple inst Ni cl écran
variable N, i : Entier 1 Entrez

Début nombre
1) afficher ("Entrez nombre : " ) 2 5 5
2) saisir (N) 3 Les 3
3) afficher ("Les 3 nombres suivants sont:") nombres
4) Pour i ← N + 1 à N + 3 suivants sont
5) afficher (i) 4 6
6) Finpour ligne cout fois 5 6
7) afficher ("terminer" ) 1 1 64 7
Fin 2 1 5 7
• Calcule complexité 3 1
64 8
4 2
T(n)= 6+ 3*(2+1+2)+2 5 8
4 2 3+1
= 6+15+2 64 9
5 1 3
=23=O(1) 47 terminer
6 2 3
7 1 72
inst r N i j C écran
Boucle imbriqués Pour: exemple

1 Entrez nombre
2 2 2
Calcule du carré méthode additions successives 3 0
variable N,r, i,j : Entier lign cout fois 4 1
Début 5 1
1) afficher ("Entrez nombre : " ) 1 1 6 1
2) saisir (N) 75 2
3) r ←0 2 1
4) Pour i ← 1 à N 5
3 1
5) Pour j ← 1 à N 6 2
6) r ← r+1 4 1 init 1
75 3
7) Finpour 4 1comp n+1 58 2
8) Finpour
9) afficher (r)
5 1 init 1 84
Fin 5 1 comp (n+1) 4 1

5 1
Illustration : 6 2 n *n
6 3
cas1 avec N=2
7 2incr n 75 2
Cas2 avec N= 3
• Calcule complexité 8 2incr n 5
n n n 9 1 6 4
T (n)  5   (1  ( 2))   (1  2n) n(1  2n)  2n  n
2
i 1 j 1 i 1
75 3
T (n)  cons tan t  n 2 58 3
84 73
 T (n) est en O(n 2 )
Lien entre Pour et TantQue
pour cpt ←1 à nbVal
afficher "Donnez une valeur :"
saisir nombre
totalValeurs←totalValeurs+ valeur //cumul
Finpour
…………. équivaut à………………………
cpt ←1
tant que cpt <=nbVal faire
afficher "Donnez une valeur :"
saisir nombre
totalValeurs←totalValeurs+ valeur //{cumul}
cpt ←cpt + 1 //{compte le nombre de valeurs traitées}
fintantque
74
Lien entre répéter et TantQue
Répéter
saisir nombre
jusqu’à (nombre> 1 ET (nombre< 3) )
…………. équivaut à………………………

saisir nombre
tantque (nombre=< 1 OU (nombre>= 3) ) faire
afficher "Donnez une valeur positive paire:"
saisir nombre
FinTantQue
75
Choisir pour... tant que… répéter…
NON Boucle tant que
Traitement
exécuté au
moins une OUI Boucle répéter
NON fois ?
Nombre
d’itérations
connu ?
OUI
Boucle pour
76
Boucle : exemple complexité O(log(n))
• Exemple
1) TantQue N div 2 <> 0 Faire ligne cout fois
2) NN div 2 1 2 q+1 avec n = 2q
3) I ← I+1 2 2 q
4) FinTantQue 3 2 q
iteration 1
• On remarque que la complexité de chaque tour de la boucle
Tantque est en O(1).
iteration 2
• La complexité de l’algorithme vaut q = le nombre max de
tours de boucle.
iteration 3
Illustration :
Cas1 avec N =8
iteration 4
Cas2 avec N=16
• En utiliser le raisonnement par récurrence ou par déduction 0 5 10 15 2
pour démontrer Que q= log(n)
77
Raisonnement par déduction :complexité O(log(n))
• Exemple
1) TantQue divEnt(N,2) <> 0 Faire ligne cout fois
2) NdivEnt(N,2) 1 2 q+1 avec n = 2q
3) I ← I+1 2 2 q
4) FinTantQue 3 2 q
• Supposons que n une puissance de 2 (n = 2q).
• Le pire des cas pour de ce algorithme est de continuer les divisions jusqu'à obtenir n égale à 1.
• q le nombre d'itérations nécessaires pour aboutir à n égale à 1
dernière itération  n = 1
q log(n )
T max( n)   (2  2  2)   (6) 6 log(n)
i 1 i 1
T max( n)  cons tan t  log(n)
 T max( n) est en O(log(n))

78
Boucles itératives, fonctions récursives (approches de type diviser pour régner notamment)
ligne cout fois
Boucle : exemple complexité O(nlog(n))1 1
• Exemple
1) TantQue divEnt(N,2) <> 0 Faire 1 1 q +1 avec n = 2q
2) Pour i ← 1 à N 2 2 (q)*(n+1) avec n = 2q
3) nombreDeFois← nombreDeFois+1 3 2 (q)*(n) avec n = 2q
4) Finpour 4 2 (q)*(n) avec n = 2q
5) NN div 2
5 2 q
6) Fintantque
6
Illustration cas1 N= 8
Supposons que n une puissance de 2 (n = 2q).
• Le pire des cas pour de ce algorithme est de continuer les divisions jusqu'à obtenir n égale à 1.
• q le nombre d'itérations nécessaires pour aboutir à n égale à 1
Valeur réel de nombre d’itération en
fonction de N
dernière itération  n = 1 N nombreDeFois n*log(n) log(n)
4 6 8 2
n q n log(n ) 8 14 24 3
T max( n)  1   (1   ((2  2  2)  2)  1  1   (3   (6))
i 1 j 1 i 1 i 1 16 30 64 4
n
 1   (3 6 log(n))  1  3n  6n log(n)  n log(n) 32 62 160 5
i 1
T max( n)  cons tan t  n log(n)

79
 T max( n) est en O(n log(n))
Boucle : exemple complexité 2
O(n )
• Exemple
ligne cout fois
1) Pour i ← 1 à N
1 1
2) pour j i à N
1 1 1+n
3) r ← r+1
2 1 1*n
4) Finpour
2 2 (n)*(i+1)
5) Finpour 3 2 (n)*i
4 2 (n)*(i+1)
max(1, 1
5 n
n i n i
T max( n)  1   (1   ((2  2)  2)  1  1   (3   ( 4))
i 1 j 1 i 1 j 1
n n i n n
 1   (3  4 * i )  1  3n  4n 2
car  ( (i ))   ( (1))
i 1 i 1 j 1 i 1 j 1
T max( n)  cons tan t  n 2
 T max( n) est en O ( n 2 )
80
Les Tableaux
• Un ensemble de valeurs portant le même nom de variable et repérées par un nombre, s’appelle un tableau, ou encore une
variable indicée.
Le nombre qui, au sein d’un tableau, sert à repérer chaque valeur s’appelle l’indice. Chaque fois que l’on doit désigner un
élément du tableau, on fait figurer le nom du tableau, suivi de l’indice de l’élément, entre [].
• Dans ce chapitre, les tableaux seront statiques : leur taille sera fixée une fois pour toute au moment de déclaration
• l'indice minimum est toujours égal à 1 jusqu’à taille
exemple:
variables T: réel [taille]
T[4] ←0 est équivalent à i←4
T[i] ← 0
Remarque : on peut traiter qu‘un élément par élément d’un tableau et jamais plus. exemple pour initialiser les éléments d’un
tableau par 0 on peut pas écrire T 0 Mais on écrit: Pour i1 à 4
T[i]0
finpour
algoc python
variable t : entier[4] t=[1,2,3,4]
avec des indices 1, 2, 3 et 4 avec des indices avec des indices
t[1] 1 0, 1, 2 et 3.
Pour i1 à 4 t[0]=1
T[i]0 T=[0]*4 81
finpour Tableau de 4 element initializer avec des zero
Les Tableaux: opérations sur liste
• On peut utiliser des indices négatifs pour compter à partir de la fin de la liste :
en python
• exemple la valeur de :tab[-1] est 8, tab[-3] est 2
0 1 2 3 4 5
• La fonction len donne la longueur d’une liste :exemple len(tab) est 6 tab
1 5 7 2 2 8
• On peut extraire un sous-ensemble des éléments d’une liste en spécifiant un intervalle d’indices de la façon suivante :
liste[min:max] attention min inclus et max exclu de l'intervalle, si min ou max peut être omis. Dans ce cas, tout se passe comme s
min était 0, et max était len(liste)
• exemple : tab[1:4] le sous tableau avec les valeurs[5, 7, 2], Tab[:3] le sous tableau avec les valeurs [1, 5, 7],
Tab[3:] le sous tableau avec les valeurs[2, 2, 8]
• On peut aussi préciser un pas avec l’instruction liste[min:max:pas]. Pour avoir les éléments d’indices pairs : exemple tab[::2] le
sous tableau avec les valeurs[1, 7, 2]
• append permet d’ajouter un élément à la fin de la liste : tab.append(9) la taille de tab est 7 avec ces valeurs[1, 5,7,2,2,8,9]
• del permet de supprimer un élément d’une liste : del tab[2] la taille de tab est 5 avec ces valeurs[1, 5,2,2,8]
• remove(val) suppression du premier élément de valeur val tab.remove(7) la taille de tab est 5 avec ces valeurs[1,5,2,2,8]
• Parcourt de tableau avec instruction in exemple for valeur in tab:
• insert(idx,val) insertion d'un élément à une position exemple tab.insert(2,0) la taille de tab est 7 avec ces valeurs[1, 5,0,7,2,2,8]
• pop([idx]) retourne et supprime la valeur d'index idx (défaut le dernier) x=tab.pop()la taille de tab est 5 avec ces valeurs[1,5,7,2,2
82
• tab.sort() trie le tableau et tab.reverse() inversion de la liste sur place
Les Tableaux (listes): unidimensionnel
• Définition du type
nom du tableau Indice
1 2 3 4 5 6
tab
12 5 -78 2 -21 8
Valeur élément du tableau

1 2 3 4 5 6
untab
t e s t e Null est un flag de fin de chaine de caractère
• Remarques :
• Indices : algo démarrage à 1, mais en python démarrage à 0
• Nombre d’octets occupés : dépend du type des valeurs enregistrées
Illustration
• Il existe deux types de tableaux :
• les tableaux statiques, dont la taille est connue à l’étape de déclaration,
• les tableaux dynamiques, dont la taille est connue à l'exécution.
83
Les Tableaux (listes): les tableaux statiques
Enoncer exercice: Si vous voulez saisir les notes des étudiants d’une classe qui peut avoir au max 25 étudiants.
Solution: Vous devez déclarer un tableau de taille 25. même si vous avez une classe de 5 étudiants  on va utiliser
que 5 élément de ce tableau.
• variable Note : Entier [25] Note=[0]*25

nbr,i : Entier print("entrer le nombre des étudiants")
• Début
nbr=int(input())
1) afficher ("entrer le nombre des étudiants" )
2) saisir (nbr ) for i in range(nbr):
3) Pour i ← 1 à nbr print("entrer la note", i)
4) afficher ("entrer la note", i)
Note[i]=int(input())
5) saisir (Note[i])
6) Finpour Illustration:
• Fin
84
Les Tableaux (listes): les tableaux dynamiques
Enoncer exercice: Si vous voulez saisir les notes des étudiants d’une classe. Avec -1 on arrête la saisie
Solution: Vous devez déclarer un tableau vide . On ajoute élément par élément
• Algo ne gère pas les tableaux dynamiques Note=[]

variables Note[] : tableau de Entier while (Note==[])or (Note[-1]>0):
nbr,i : Entier valeur=int(input())
Début Note.append(valeur)
i<--0
répéter
Illustration:
i<--i+1
saisir (Note[i])
jusqu’à Note[i]<0
Fin
85
inst N i écran
Tableaux : exemple 1 -, -, -, - 1
2 1, -, -, -
• variable N : Entier [4]
i : Entier 3 1, -, -, - 1
• Début
41 1, -, -, - 2
1) Pour i ← 1 à 4
12 1, 4, -, -
2) N[i] ← i * i
3) afficher (N[i]) 3 1, 4, -, - 4
4) Finpour 41 1, 4, -, - 3
• Fin 2 1, 4, 9, -
• Calculer complexité? 3 1, 4, 9, - 9
41 1, 4, 9, - 4
12 1, 4, 9,16
3 1, 4, 9,16 16
41 1, 4, 9,16 5
15
86
Tableaux Multidimensionnels
• Exemple tableau à 2 lignes et 7 colonnes
10 3 20 5 25 2 422
tab
9 132 1 0 124 7 9
• Remarque :
• équivalent à déclarer un tableau de 7 colonne répéter 2 foie ( ligne)
• Déclaration
tab[2, 7] d’entiers
indice max indice max

des lignes des colonnes
• Illustration
Algo N[nLigne,Ncolonne] Python

Variable N : Entier [ 2 , 3 ] On doit initializer avec des zero, ordre inverser N [iLigne] [icolonne]
N[1,1]100 N = [[0] * nbColonnes for _ in range(nbLignes)]
N[2,3]10 N[0][0]=100
N[1][2]=10
87
Tableaux Multidimensionnels
• REMARQUE ESSENTIELLE :
Il n’y a aucune différence qualitative entre un tableau à deux dimensions ( M, N ) et un tableau à une dimension ( M * N ).
De même que le jeu de dames qu’on vient d’évoquer, tout problème qui peut être modélisé d’une manière peut aussi être
modélisé de l’autre. Simplement, l’une ou l’autre de ces techniques correspond plus spontanément à tel ou tel problème,
et facilite donc (ou complique, si on a choisi la mauvaise option) l’écriture et la lisibilité de l’algorithme.
• Equivalence d’indice
Exemple T[itab] et T[iligne, icolonne] taille (3,2)=tableau de 2 colonne répéter 3 fois 1 4
iligne,icolonne 1,1 1,2 2,1 2,2 3,1 3,2 2 5
• itab= 2*(iligne-1)+ icolonne itab 1 2 3 4 5 6 3 6
• Relation général 1 :pour une taille (M,N): itab= N*(iligne-1)+ icolonne si indice commence par 0 itab= N*iligne+ icolonne
iligne,icolonne 1,1 2,1 3,1 1,2 2,2 3,2 1 2
itab 1 2 3 4 5 6 3 4
itab= 3*(icolonne -1)+ iligne 5 6
• Relation général 2 :pour une taille (M,N): itab= M*(icolonne -1)+ iligne si indice commence par 0 itab= M*icolonne + iligne
88
inst T iligne icolon
Tableaux multidimensionnel 12 -, -; -, -; -, - 1 -
: exemple 23
3
-, -; -, -; -, -
1, -; -, -; -, -
1
variable T : Entier [3,2] 42 2

iligne, icolon : Entier 23 1, 2; -, -; -, -
Début 42 3
1) Pour iligne 1 à 3 25
2) Pour icolon1 à 2 51 2

23 1
3) T[iligne, icolon] (2*(iligne-1)) +icolon
3 1, 2; 3, -; -, -
4) finpour
42 2
5) finpour
3 1, 2; 3, 4; -, -
Fin 42 3
Illustration …… ……………. … …..
5 1, 2; 3, 4; 5, 6 4 3
89
les structures
• Nous avons utilisé pour l'instant des types de base : ils contiennent des éléments de type entier, réel, caractère, chaîne.
Dans ce chapitre nous allons définir de nouveaux types qui vont permettre de représenter des entités plus complexes.
• Des types de variables personnalisés, composés d’un « collage » de plusieurs types existants (entier, réel, chaine
,caractère , booléen , etc.). Ce type de variable s'appelle un type structuré.
• Exemple: - pour représenter un point, il faut une abscisse et une ordonnée.
- pour représenter une fraction, il faut un numérateur et un dénominateur …
- Syntaxe Structure définition type date
jour : chaine
j,m,aa : entier
fintype
déclaration de variable variables a : date
affectation à un champ a.jour "lundi"
Remarque: l’instruction saisir peut lire que les type de base exemple :On peut pas saisir ou afficher: saisir a mais on peut
écrire : saisir a.j
type date class date(object):
nomj : chaine
j,moi,an : entier
def __init__(self, nomj , j,moi,an):
fintype self.nomj = nomj
variable d : date self.j = j
d.j30
self.moi=moi
self.an=an
d= date ("lundi", 2,2,2017)
d.j = 21 90
Structure :type
type copoint ins A1 A2 dx dy d clv ecr
x,y : réel x y x y
fintype
1 A1
variables A1,A2 : copoint
2 0 0
dx,dy,d: réel
début 3 0 0
1) afficher " cordonner point A1" 4 A2
2) saisir A1.x 5 0 0
3) saisir A1.y 6 2 2
4) afficher "cordonner point A2" 7 0
5) saisir A2.x
8 2
6) saisir A2.y
9 2
7) dxA2.x-A1.x
8) dyA2.y-A1.y 10 2
9) dRacineCarrée(Carré(dx)+Carré(dy)) illustration
10) afficher ("distance",d)
fin 91
Procédures
• Avantages:
et Fonctions
• Lorsqu'on a un ensemble de lignes de code qui doivent être exécutées à différents endroits dans un
programme, au lieu de réécrire les mêmes lignes de code, il est intéressant de créer des fonctions.
• Au lieu d'écrire un programme de 500 lignes, il est préférable de créer 25 fonctions de 20 lignes
• on structure le programme.
• il est plus facile de tester chaque fonction.
• Il est impossible d'avoir en tête plus de 1000 lignes de codes : or la plupart des programmes réels
comportent des dizaines de milliers de lignes et les grosses applications en comportent des millions.
écrire des fonctions est absolument obligatoire
• Utilisation :
• Lors de la conception d’un programme deux aspects apparaissent :
• La définition de la procédure ou fonction.
• L’appel de la procédure ou fonction au sein du programme.
• L’écriture de la procédure ou fonction s’effectue en fonction de paramètres formels utilisés dans la
conception de celle-ci.
• Par contre au moment de l’utilisation de la procédure ou fonction, on associera de véritables valeurs à
ces paramètres grâce à des paramètres d’appel ou paramètres effectifs.
92
Notion de fonction
93
Les Fonctions Prédéfinies: Math
syntaxe Python Résultat Argument p1
abs(p1) Abs(p1) valeur absolue de p1 entier, réel entier, réel
alea() from random import * nombre aléatoire compris entre réel
random() 0 et 1
ent(p1) Int(p1) partie entière de p1 sans entier, réel réel
arrondi
atn(p1) arc tangente de p1 entier, réel entier, réel
cos(p1) cos(p1) cosinus de p1 (sin,tan) entier, réel entier, réel
exp(p1) exp(p1) exponentielle de p1 entie r, réel entie r, réel
RacineCarrée(p1) sqrt(p1) racine carrée de p1 entier, réel entier, réel
CaractèreAscii (p1) chr(p1) caractère ayant pour code ASCI car, chaîne entier
la valeur de p1
CodeAscii (p1) ord(p1) converti caractère p1 en entier, réel chaîne
nombre
Pour python il faut écrire cette ligne au début: from math import *
94
Les Fonctions Prédéfinies Math python: exemple
variable s,p1,valeurAbs,partieEnt,aascii: Entier from math import *
variable expon,racine: réel from random import *
variable caractereb: caractère
p1=-10
Début
valeurAbs=abs(p1)
P1<- -10
print("la valeur absolu de -10 est ", valeurAbs)
valeurAbs<-abs(p1)
afficher("la valeur absolu de -10 est ", valeurAbs) p1=random()
p1<-Aléatoire(10) print("le chiffre aléatoire est ", p1)
afficher("le chiffre aléatoire [0,10]est ", p1) partieEnt=int(2*p1)
partieEnt<-Ent(2.15) print("la partie entière de", 2*p1, "est", partieEnt)
afficher("la partie entière de 2.15 est", partieEnt) expon=exp(2)
expon<-exp(2) print("exponentielle de 2 est ", expon)
afficher("exponentielle de 2 est ", expon)
racine=sqrt(9)
racine<-RacineCarrée(9)
print("le racine de 9 est ", racine)
afficher("le racine de 9 est ", racine)
aascii=ord("a")
aascii<-CodeAscii ("a")
afficher("le code ascci de a est ", aascii) print("le code ascci de a est ", aascii)
caractereb<-CaractèreAscii (aascii+1) caractereb=chr(aascii+1)
afficher("le caractere apres a est", caractereb) print("le caractere apres a est", caractereb)
fin Illustration
Les Fonctions Prédéfinies: texte
syntaxe Résultat p1 p2 p3
DébutChaîne (p1,p2) partie droite de p1 ; p2 = nombre de chaîne chaîne entier
caractères retournés
FinChaîne (p1,p2) partie gauche de p1 ;p2 = nombre de chaîne chaîne entier
caractères retournés
LgChaîne (p1) longueur de p1 entier chaîne
SousChaîne (p1,p2,p3) sous-chaîne de p1 de p3 caractères à partir chaîne entier entier
de la position p2 incluse
PositionChaîne (p1,p2) position du 1er car. de p1 dans p2 entier chaîne chaîne
maj(p1) caractères de p1 en majuscule chaîne chaîne
min(p1) caractères de p1 en minuscule chaîne chaîne
96
Les Fonctions Prédéfinies: texte (exemple)
• LgChaîne("Bonjour, ça va ?") vaut 16
LgChaîne("") vaut 0
SousChaîne("Zorro is back", 4, 7) vaut "ro is b"
SousChaîne("Zorro is back", 12, 1) vaut "c"
DébutChaîne("Et pourtant…", 8) vaut "Et pourt"
FinChaîne("Et pourtant…", 4) vaut "t…"
PositionChaîne("ur", "Un pur bonheur") vaut 5
PositionChaîne("techno", "Un pur bonheur") vaut 0
97
Les Fonctions Prédéfinies texte python: exemple
animaux = "girafe tigre"
longeur=len(animaux)
caractere4= animaux[3]
premier4caractere=animaux[0:4]
dernier4caractere=animaux[-4:]
for animal in animaux.split():
animalmaj=animal.upper()
animalmin=animalmaj.lower()
animal1maj=animal.capitalize()
print(animal,";", animalmaj,"; ",animalmin,"; ",animal1maj)
animaux = "girafe tigre"
posi=animaux.find('i')
posafe=animaux.find('afe')
postag=animaux.find('tag')
conti=animaux.count("i")
animaux2=animaux.replace("tigre", "singe")
animaux3=animaux.replace("i", "o")
Remarque: on peut pas modifier un caractère dans une chaine animaux[3]='i' . Par conséquent, si vous voulez modifier une chaîne,
vous êtes obligés d'en construire une nouvelle. Pour cela, n'oubliez pas que les opérateurs de concaténation (+)
Illustration
Structure de programme: Procédures et
Fonctions
• Fonction s'écrit toujours en-dehors au début de la procédure principale( au niveau
déclaration).
• Dans une fonction ont peut appelé une autre fonction mais on ne peut jamais définir une
autre fonction.
• Différence entre fonction et procédure
• Les fonctions ne sont qu'un cas particulier des sous-procédures : celui où doit être renvoyé vers la
procédure appelante une valeur et une seule. et celle-ci doit appartenir à un type de base du
Pascal. C’est à dire un nombre, un caractère ou une chaîne de caractère, booléen.
• Les procédures dans tous les autres cas (celui où on ne renvoie aucune valeur, comme celui ou en
en renvoie plusieurs.
Remarque important:
• pour le logiciel algo adopté dans ce cours Fonction s'écrit toujours en-dehors à la fin de
la procédure principale
• le logiciel algo adopté dans ce cours utilise la directive action au lieu de procédure
99
Règles : Procédures et Fonctions
• Les fonctions et les procédures permettent de décomposer un
programme complexe en une série de sous-programmes plus simples,
lesquels peuvent à leur tour être décomposes eux-mêmes en
fragments plus petits, et ainsi de suite.
100
Méthode pour Définition d’une fonction
Les 6 étapes de réflexions pour définir une fonction ou procédure:
1. Choix de Nom : un identificateur suffisamment explicite.
2. Paramètres : la liste des paramètres d’entrée-sortie de l’algorithme.
3. Préconditions : une liste d’expressions booléennes qui précisent les
conditions d’application de l’algorithme de fonction .
4. Appel : des exemples d’utilisation de l’algorithme avec les résultats
attendus.
5. Description : une phrase qui dit ce que fait l’algorithme.
6. Code : la séquence d’instructions nécessaires à la résolution du
problème.
101
Passage de paramètres
• Paramètre formel : variable utilisée dans le corps du sous-programme qui reçoit une valeur de l’extérieur
(ils font parti de la description de la fonction)
• Paramètre effectif : Il s'agit de la variable (ou valeur) fournie lors de l'appel du sous programme (valeurs
fournies pour utiliser la fonction et valeurs renvoyées)
• Le nombre et type des paramètres formel doivent être identique que les paramètre effectif
• Les paramètres formel on une duré de vie égale à l’appelle de la fonction
• Paramètres formel et effectif ont des noms différents
102
Passage de paramètres par variable ou par valeur
 Une fonction peut avoir aucun ou plusieurs paramètres.
 Il y a deux méthodes pour passer des variables en paramètre dans une fonction :
• Passage par valeur : La valeur de l'expression passée en paramètre est copiée dans une variable locale. C'est cette variable qui est
utilisée pour faire les calculs dans la fonction appelée.
• Passage par variable (référence) : La deuxième technique consiste à passer non plus la valeur des variables comme paramètre, mais
à passer les variables elles-mêmes. Il n'y a donc plus de copie, plus de variable locale. Toute modification du paramètre dans la
fonction appelée entraîne la modification de la variable passée en paramètre
python utilise passage par valeur pour les variables simples
(Int,float), et passage par référence pour les variables composés
(liste,chaine,structure)
algo utilise les directive D ou DR devant les Variable, en séparant
les noms de variable de même type par une virgule. Pour déclarer
des variables avec des types différents, placer des points-virgules
entre chaque groupe de variables.
• Remarque important: Le principe des variables globales
On ne peut déclarer dans le corps de notre programme, donc en dehors de tout corps de fonction, une variable, tout ce qu'il y a de plus
normal. Dans le corps d'une fonction qui doit modifier cette variable (changer sa valeur par affectation), on déclare à Python que la
variable qui doit être utilisée dans ce corps est globale, exemple: global i # Python recherche i en dehors de l'espace local de la fonction
103
Procédures et Fonctions :Syntaxe
• Declaration
Fonction RepOuiNon(D Msg : Caractère) : Caractère
arguments formelles type de résultat
variables résultat : caractère
Début
…………………….
Retourner ( résultat )
. qui indique quelle valeur doit prendre la fonction lorsqu'elle est utilisée par le
programme
fin
• Utilisation : il suffit de citer son nom en lui indiquant le paramètre qu'elle demande.
Début
……
afficher RepOuiNon("oui")
argument réel
…….
104
fin
Procédures et Fonctions :Syntaxe
• Déclaration procédure
procédure RepOuiNon( D Msg : Caractère)
arguments formelles
variables résultat : caractère
Début
…………………….
finprocédure
• Utilisation : il suffit de citer son nom en lui indiquant le paramètre qu'elle demande.
Début
……
argument réel
RepOuiNon("oui")
…….
Fin
105
Procédures et Fonctions :Syntaxe python
Procédure
def nomfonction(parametrefor1, parametrefor2, ….):
…..
…..
…….
nomfonction(parametreeff1, parametreeff2, ….)
…….
Fonction
def nomfonction(parametrefor1, parametrefor2, ….):
…..
…..
Return résultat
…….
X=nomfonction(parametreeff1, parametreeff2, ….)
…….
Procédures et Fonctions : passage par valeur
variables X : Entier inst X afficheecr écran
Procédure afficheecr(D k : entier)
k
Début k=5
1) afficher ("au début",k) 1 5
2) kk+1
3) afficher ("au fin",k) 2 Avant 5
finprocédure 3 5
Début Passage par valeur affiche
1) X ← 5 X=5 33.1 Début 5
2) afficher ("au avant",X) 3.2 6
3) afficheecr(X) 3.3 Fin 6
4) afficher ("au apres",X) 3.33 Vide k
retour
Fin
Remarque: avec algo il faut ajouter le mot D avant les argument 4 Apres 5
Généralement par défaut le passage utilisé est par valeur
Exemple :
afficheecr(D k : entier)
Equivalent à
afficheecr( k : entier)
illustration 107
Suggestion : voir support de cours architecture ordinateur diapo passage paramètre à une procédure par pile
Procédures et Fonctions : passage par référence
variables X : Entier inst X afficheecra écran
procédure afficheecra(DR k : entier) K point sur @K=@XK=5
Début k
1) afficher ("au début",k) 1 5
2) kk+1
3) afficher ("au fin",k) 2 Avant 5
fin
Début Passage par variable 3 5
affiche
1) X ← 5 X=5
33.1 Début 5
2) afficher ("au avant",X)
3.2 6
3) afficheecr(X)
4) afficher ("au apres",X) 3.3 Fin 6
Fin 3.33 Vide k
Remarque: avec algo’exe il faut ajouter le mot DR avant les argument (ou adresse ou adr) retour
Exemple : 4 Apres 6
afficheecra(DR k : entier)
Remarque: passage par référence on doit utiliser un tableau d’un seul élément au lieu d’une variable
illustration
Suggestion : voir support de cours architecture ordinateur diapo passage paramètre à une procédure par pile
108
exemple:calcule de quotient et reste d’une division
variables x, y,quo,rest : entier
• procédure division_euclidienne (a,b : entier ; DR q,r:entier)
Début
Début afficher " première valeur "
q 0 saisir x
r a afficher "deuxième valeur"
Tantque r>=b faire saisir y
q  q+1 Division_euclidienne (x,y,quo,rest)
r r-b afficher quo, rest
FinTantque
Fin
Fin
x y quo rest x y quo rest
16 6 16 6 2 4
illustration
a b q a b q
16 6 16 6 2 4
a b q r a b q r
109
Une fonction qui appelle une autre
fonction perimetre_rayon_cercle(p : réel):réel
Début ins prc rac va vp clv ecr
1) Retourner(p/ 6.28) p pp r
fin 1 périmètre
fonction rayon_aire_cercle( pp : réel):réel 2 6.28 6.28
variables r : réel
Début
33.1 6.28
rac
1) rperimetre_rayon_cercle(pp)
3.13.1.1 6.28
2) Retourner(3.14*r*r)
prc
Fin
3.1.13.1 1
variables vp,va : réels prc
Début 3.23 3.14
1) afficher ("périmètre ") rac
2) saisir (vp) 4 Aire 3.14
3) varayon_aire_cercle(vp) illustration
4) afficher ("aire ",va)
Fin
110
Fonctions: récursivité
• Une fonction est dit récursif s'elle s’appelle elle-même
• Un exemple classique:
• La fonction factorielle
n! = 1 ·2 ·3 · ··· ·(n−1) ·n
• Définition récursive:
 1 si n  0
f (n)  
n. f (n  1) sin on
111
Fonctions: Trace d’une fonction récursive 1
 Définition du fonction: Paramètre= 3
fonction fact( n : entier) : réel 1
variable Paramètre= 2
r : réel 2
début Paramètre= 1
si n = 1 alors 3 si n = 1 alors
r1 r1
sinon
r n * fact(n-1) 4
finsi
retourner (r) 5
fin résultat= 6
 Trace: 6
 Une boîte pour chaque appel récursif 1 2 3

 Une flèche pour chaque appel fact(3) fact(2) fact(1)
 Une flèche pour chaque retour d’une 6 5 4
112
valeur
Fonctions: Trace d’une fonction récursive 2
fonction fact( n : entier) : entier inst fact a r clv ecr
variable n rr
rr : entier 1 nbr
début 2 3 3
1) si n = 1 alors 33.1 3
Fac(3)
2) rr 1
3.13.3
3) sinon
3.43.4.1 2
4) rr n * fact(n-1) Fac(2)
5) finsi 3.4.13.4.3
6) retourner (rr ) 3.4.33.4.4.1 1
fin Fac(1)
Variable a,res:entier 3.4.4.13.4.4.2 1

3.4.4.23.4.4.5
Début
1) afficher ("nbr") 3.4.4.63.4.4 2
2) saisir (a)
3.4.53.4.6
3) resfact(a)
3.4.63.4 6
4) afficher (res)
3.53.6
Fin illustration 113
3.63 6
Fonctions : Schéma général d'un algorithme récursif
 Fonction R( données X):

Début
si terminaison(X) alors
Y ...
sinon
...
YR( entrée_réduite en fonction de X)
...
finsi
retourner( Y)
 fin
114
Importance de l’ordre des appels récursifs (pile/file)
• Procédure terminale (file) • Procédure non terminale (pile)
procédure decimalbinaire (D n :entier; DR res:entier) procédure decimalbinaire (D n :entier;DR res:entier)
1) Si (n>0) Alors 1) Si (n>0) Alors
2) res  res*10+ n mod 2 2) decimalbinaire(divEnt(n , 2) )
3) decimalbinaire(divEnt(n , 2) ) 3) res  res*10+ n mod 2
4) FinSi 4) FinSi
Fin Fin
• Illustration illustration
11 5 2 1 0
11 5 2 1 0 0 0 0 0 0
0 1 11 110 1101
11 5 2 1 0
11 5 2 1 0 1011 101 10 1 0
1101 1101 1101 1101 1101
Attention :La solution est 1011 au lieu de 1101

115
l’ordre des appels récursifs et traitement affecte la terminaison d’une fonction récursive
Les types de récursivité :La récursivité multiple 1/3
• récursivité multiple  la fonction contient plus d'un appel récursif dans son corps
• Exemple : le calcul du nombre de combinaisons en se servant de la relation de Pascal n>p :
Fonction Combinaisons (n,p : entier) : entier def Combinaisons(n,p):

Début if n==0 or p==n:
Si (p = 0 OU p = n) Alors return 1
retourner( 1) return Combinaisons(n-1,p)+Combinaisons(n-1,p-1)
sinon
illustration
retourner(Combinaisons (n-1, p)+ Combinaisons(n-1,p -1))
finsi
fin
116
Les types de récursivité :La récursivité mutuelle 2/3
• Des fonctions sont dites mutuellement récursives si elles dépendent
les unes des autres
• Par exemple la définition de la parité d'un entier peut être écrite de la
manière suivante :
Fonction pair(e n : entier) : booléen Fonction impair(e n : entier) : booléen

Début Début
Si (n=0) Alors Si (n=0) Alors
retourner (vrai) retourner( faux)
sinon sinon
retourner( impair(n-1)) retourner( pair(n-1))
Finsi Finsi
Fin Illustration1 fin
illustration2 117
Les types de récursivité : La récursivité imbriquée 3/3
• Exemple : La fonction d'Ackermann
Fonction ackermann ( m,n : entier) : entier def ackermann (m,n):

Si (m = 0 ) Alors if m==0 :
retourner (n+1) return n+1
sinon elif n==0 and m>0 :
Si (n = 0 ET m>0 ) Alors return ackermann (m-1,1)
else:
retourner (ackermann (m-1,1))
return ackermann (m-1, ackermann (m,n-1))
Sinon
retourner (ackermann (m-1, ackermann (m,n-1))) illustration
Finsi
fin
118
Calcule de complexité: Equations récursives
• Cas général
T(n) =a×T(n/b) +f(n)
• méthode par substitution,

• méthode générale (par identification)
• méthode par développement itératif(Elimination de la récursivité)
119
Méthode par substitution [Equations
récursives] 1/3
On utilise le résonnement par récurrence
• Principe : on vérifie une intuition
T(n) =a×T(n/b) +f(n) et T(1) =c
• Hypothèse
T(n) =g(n) (intuition)
• Conclusion
a×g(n/b) +f(n) =g(n) et g(1) =c
à démontrer en fixant les constantes
120
Méthode Générale [Equations récursives] 2/3
• On peut ramener une fonction récursive à la Forme générale suivant :
fonction Functionrécursive ( n:entier)
1) si (n > 1) alors
2) Functionrécursive(n/2), coût T(n/2)
3) Traitement(n), coût C(n)
4) Functionrécursive(n/2), coût T(n/2)
5) finsi
fin
• Equation récursive
T(n) = 2 ∗ T(n/2) + C(n)
• si C(n) = 1 (indépendant de n) alors T(n) = K × n=O(n)

• si C(n) = n alors T(n) = K × n × log (n)=O(nlog(n))
121
Calcule de complexité :Elimination de la récursivité 3/3
• Dérécursiver, c’est transformer un algorithme récursif en un
algorithme équivalent ne contenant pas des appels récursifs.
• Elimination de la récursivité terminale simple
• Rappel :
Un algorithme est dit récursif terminal s’il ne contient aucun traitement
après un appel récursif.
La récursivité terminale simple peut être remplacée par une solution
itérative.
122
Méthode d’élimination de la récursivité terminale
simple
• Algo. récursif • Algo. itératif
Procédure ALGOR(X) Procédure ALGOI(X)
Si (COND) Alors Tantque (COND) faire
TRAIT1 TRAIT1
ALGOR(β (X)) X  β (X)
Sinon Fintantque
TRAIT2 TRAIT2
FinSi Fin
Fin
Avec
X est la liste des paramètres ;
COND est une condition portant sur X ;
TRAIT1 est le traitement de base de l'algorithme (dépendant de X) ;
β(X) représente la transformation des paramètres ;
TRAIT2 est le traitement de terminaison (dépendant de X). 123
Méthode d’élimination de la récursivité terminale simple
suite
Itération Récursivité
procédure Itération( ) procédure Itération( )
Tantque (condition) faire Si (condition) alors
<Instructions> <Instructions>
fin tantque Itération()
fin si
finprocédure finprocédure
fonction S(n) : entier
fonction S(n) : entier
S :=0
Tant que (n>0) faire Si (n=0) alors
S0
S:=S+n sinon
n:=n-1 SS(n-1)+n
fin tant que fin si
retourner( S) retourner( S)
fin fin
élimination de la récursivité terminale simple : exemple
• Vérifier si a est diviseur de b avec méthode soustraction successive
 Algo. récursif Algo. itératif
Fonction Diviseur ( a,b:entier) : Booléen 1) Fonction Diviseur ( a,b:entier) : Booléen l c fois
1) Si (a <=0) Alors 2) Si (a <=0) Alors
2) retourner( Faux 3) retourner( Faux) 1 2
3) Sinon 4) Sinon 2 1
4) Si (a>=b) alors 5) Tantque (a>=b) Faire 3 1
5) retourner( a=b) 6) b  b-a 4
6) Sinon 7) Fintantque 5 1 q+1 Avec
7) retourner( Diviseur (a,b-a)) 8) retourner( a=b) b≈q*a
8) FinSi 9) FinSi 6 2 q
4) FinSi 10) fin 7
fin 8 2
q
T max( a, b)   (3)  3 * q  3 * b
 Calcule de complexité par résonnement i 1
a 9
T (a, b)  cons tan t  b
par déduction a
 T (a, b) est en O( b ) 125

a
Automatisation teste programme avec unnitest
• exemple
import unittest
Résultat
def calculatrice(x,o,y): ..
if o=='+':
return x + y ----------------------------------------------------------------------
elif o=='-':
Ran 1 test in 0.002s
return x-y
elif o=='*':
return x*y OK
elif o=='/':
return x/y Process finished with exit code 0
class MyTest(unittest.TestCase):
def test(self):
self.assertEqual(calculatrice(3.1,'+',2.1), 5.2)
self.assertEqual(calculatrice(3.1,'-',2.1), 1)
self.assertEqual(calculatrice(3.1,'*',2), 6.2)
self.assertEqual(calculatrice(6.2,'+',2), 3.1)
Techniques Rusées
• Algorithmique des nombres:
• Crible d'Ératosthène
• Algorithme d'Euclide
• Algorithme de tri
• Tri sélection
• Trie bulle
• Trie insertion
• Algorithme de recherche
• dichotomie
• Algorithme décisionnel : Algorithme glouton
• Fouille de flots de données:
• Fenêtres Glissantes
• Algorithmes d’approximation :méthode de Monte-Carlo
127
Algorithmique des nombres:
• La théorie algorithmique des nombres ou théorie calculatoire des nombres est une branche des
mathématiques et de l'informatique qui essaie de fournir des solutions concrètes et efficaces à
des problèmes calculatoires rencontrés en théorie des nombres.
• Exemple:
• PGCD
• Nombre premier
• Puissance
• Nombres de Fibonacci
• Nombre amicale
• Conversion décimal binaire
• …….
128
Exemple: PGCD
• Il existe plusieurs méthodes pour trouver le PGCD de deux nombres. On peut notamment utiliser
au choix:
• Les listes des diviseurs de chacun des deux nombres.
• L'algorithme des différences. (ou des soustractions successives)
 a si b  0
p gcd(a, b)  
 p gcd(a  b, b) sia  b
• L'algorithme d'Euclide. (ou des divisions successives)
 a si b  0
p gcd(a, b)  
 p gcd(b, a mod b) sin on
129
Exemple: algorithme
fonction pgcdeuclude( a,b : entier) : entier
PGCD
fonction pgcddiff( a,b : entier) : entier
variable variable
résult : entier résult : entier
début début
si b = 0 alors si b = 0 alors
résult a résult a
sinon sinon
si (a>b) alors si (a>b) alors
résult pgcdeuclude (b, modulo(a, b)) résult pgcddiff (a-b,b)
sinon sinon
résult pgcdeuclude (a,modulo(b, a)) résult pgcddiff (b-a,a)
finsi finsi
finsi finsi
retourner (résult ) retourner (résult )
fin fin
Illustration Illustration 130
Exemple : les Nombres premiers (crible d'Ératosthène)
Variable T: entier [12]
Variable i,j:entier
Début
Pour i1 a 12
T[i]i
Finpour
Pour i2 a 11
si T[i]<>0 alors
pour ji+1 a 12
si(i<>j )ET (modulo(T[j] ,T[i])=0) alors
T[j]0
finsi
finpour
finsi
Finpour
131
fin
Algorithme de tri
• Un algorithme de tri est, en informatique ou en mathématiques, un algorithme qui
permet d'organiser une collection d'objets selon un ordre déterminé. Les objets à trier
font donc partie d'un ensemble muni d'une relation d'ordre (de manière générale un
ordre total). Les ordres les plus utilisés sont l’ordre numérique et l'ordre lexicographique
(dictionnaire)
• On va traiter dans ce chapitre 3 tri:
• Tri à bulles
• Tri par sélection
• Tri par insertion
132
Tri par sélection
procédure trie ( n : entier, DR t: entier [5])
variable i,j,temp,imin:entier t=[4,3,2,1]
début for i in range(4):
pour i 1 à n - 1 imin=i
imin ← i for j in range(i+1, 4):
pour j i + 1 à n if t[j] < t[imin] :
si t[j] < t[imin] alors
imin = j
if imin != i:
imin ← j
temp=t[i]
finsi
t[i]=t[imin]
finpour
t[imin]=temp
si imin <> i alors
for i in range(4):
tempt[i]
print(t[i] )
t[i] t[imin]
t[imin]temp illustration
finsi
finpour
133
fin
Tri à bulles
procédure tri_bulle( n : entier, DR t: entier [5]))
Variable échange_effectué : booléen
j,temp : entier
début
répéter
échange_effectué faux
pour j 1 à n - 1
si T[j] > T[j + 1] alors
TempT[j]
T[j] T[j + 1]
T[j + 1]temp
échange_effectué vrai
finsi
finpour
jusqu’à échange_effectué = faux
fin
134
Tri par insertion
procédure tri_insertion( n : entier, DR t: entier [5]))
variable i,j,x,temp : entier
début
pour i 1 à n-1
x ← T[i]
j←i
tantque j > 1 ET T[j - 1] > x faire
T[j] ← T[j - 1]
j←j-1
fintantque
T[j] ← x
finpour
fin
135
Algorithme de recherche : (exemple recherche racine
fonction) : Méthode de dichotomie
En informatique, un algorithme de recherche est un type d'algorithme qui, pour un domaine, un problème de ce domaine et
des critères donnés, retourne en résultat un ensemble de solutions répondant au problème (racine de f(x)=x-5 dans [a,b])
Fonction f( x :réel):réel
Début
retourner( x-5)
fin
Fonction dichotomie ( a,b,eps :réel):réel
Début
Tantque b-a > eps faire
mil(a+b)/2
Si f(mil)*f(a)<0 alors
bmil
Sinon
amil
FinSi
FinTantque
Retorner (mil)
136
fin
Algorithme glouton
 Aujourd'hui nous allons parler des algorithmes gloutons qui sont des algorithmes couramment utilisés dans la résolution
de problèmes.
 Le principe de tels algorithmes consiste à choisir des solutions locales optimales d'un problème dans le but d'obtenir une
solution optimale globale au problème.
Exemple: sac a dos ou Le problème du rendu de monnaie est le suivant : étant donné un système de monnaie (pièces et
billets), comment rendre une somme donnée de façon optimale, c'est-à-dire avec le nombre minimal de pièces et billets ?
Les pièces de système de monnaie sm[i] 50 20 5
Le nombre de chaque pièce nb[i] 0 0 0
Procédure Glouton( s, i:entier; DR sm,nb : Entier [3]) • Exemple:45 dans un system de 50 ,20 ,5
Si i<= 3 ET s <>0 alors g(45, 1) 0,0,0
Si s>= sm[ i] alors g(45, 2) 0,0,0
nb[i] nb[i]]+1 g(25, 2) 0,1,0
Glouton (s- sm[ i], i) g(5, 2) 0,2,0
Sinon
g(5, 3) 0,2,1
Glouton (s, i+1)
Resultat:2 pièce de 20 et une de 5
finsi
finprocédure 137
géométrie algorithmique
• La géométrie algorithmique est le domaine de l'algorithmique qui
traite des algorithmes manipulant des concepts géométriques
Exemple:
• intersection des segments
• Recherche enveloppe convexe
• recherche des deux points les plus rapprochés
• Calcule de surface ou de l’aire de : cercle, triangle, rectangle…..
• Position dans une forme (intérieur, extérieur)
• …………
138
Exemple :position dans une zone
 équation de segment des triangle vers est: y=-x+5 Alors si y<-x+5 le point est
dans la zone vers
Fonction Zone(x, y : réel):chaîne

variable res:chaine
début
si y<-x+5 alors 5
res "vers"
sinon
res "rouge"
finsi
0
retourner(res) 5 10
fin
139
La fouille de flots de données
La fouille de flots de données est le processus d'extraction des connaissances de flux de données
continus. Un flux/flot de données est une séquence ordonnée d'instances lisibles une seule fois — ou un
nombre de fois très faible — dans un système limité en capacité mémoire et en capacité de stockage. Les
flux sont continus, illimités, arrivent avec une grande rapidité, et ont une distribution qui change avec le
temps.
On va traiter trois principe:
• Algorithmes à balayage, qui consiste à parcourir les données (exemple le plan en suivant une
ligne de balayage, et à calculer, pas à pas.
• Les fenêtres glissantes servent à restreindre l'analyse sur les éléments les plus récents du flot de
données. C'est une méthode déterministe.
• Algorithmes d’approximation :Ce sont des techniques probabilistes qui donnent un résultat dans
une limite donnée à l'avance. Toutes les méthodes de Monte-Carlo et l'algorithme de las Vegas en
font partie. Ces algorithmes donnent des résultats approchés avec des erreurs contenues dans
des limites pré-établies
140
Algorithmes à balayage : exemple Calcul approché d’intégrales (Méthode des trapèzes)
 représenter l’intégrale comme un aire et d’approcher cette aire par la somme d’aires de trapèzes. La ligne de
balayage est suivant l’axe x. Dans ce qui suit, n désigne le nombre de trapèzes et on pose.
Fonction f( x1 :réel):réel
début
retourner( x1-5)
fin
Fonction intégrale( a, b: réel; n:entier ):réel
Variable x, integ, pas: réel
i:entier
Début
Pas(b-a)/n
integ0
pour i1 a n-1
x a+i*pas
integinteg+(((f(x)+f(x+pas))pas/2)
fintpour
retourner( integ)
141
fin
Les fenêtres glissantes: exemple (suite de Fibonacci)
 Croissance de population des lapins selon une suite de Fibonacci:
 au (début du) premier mois, il y a juste une paire de lapereaux ;
 les lapereaux ne procréent qu'à partir du (début du) troisième mois ;
 chaque (début de) mois, toute paire susceptible de procréer engendre effectivement une nouvelle paire de lapereaux ;
 les lapins ne meurent jamais (donc la suite de Fibonacci est croissante).
Fonction Fibonacci( n:entier):entier
Variable pn, pn1 ,pn2 , i:entier
Début
pn11
pn21
pour i3 a n
pnpn1+pn2
pn2pn
pn1pn2
fintpour
retourner( pn)
142
fin
Algorithme d'approximation : exemple (méthode de Monte-Carlo)
 Calcule de la superficie d'un lac : Soit une zone rectangulaire ou carrée dont les côtés sont de longueur connue. Au sein de cette aire se
trouve un lac dont la superficie est inconnue. Grâce aux mesures des côtés de la zone, on connaît l'aire du rectangle. Pour trouver l'aire du
lac, on demande à une armée de tirer X coups de canon de manière aléatoire sur cette zone. On compte ensuite le nombre N de boulets
qui sont restés sur le terrain
Par exemple, si le terrain fait 1 000 m2, que l'armée tire 500 boulets et que 100 projectiles sont tombés dans le lac, estimation de la
superficie du plan d'eau est de : 1000×100÷500 = 20
• Fonction calculePImc( n : entier ) :entier
• Calcul de π :consiste à tirer au hasard
des nombres x et y dans l’intervalle [0 Variable r, x, y :réel
; 1]. Si x2 +y2 < 1 le point M(x, y) ni, i:entier
appartient à un quart de disque de Début
rayon 1. La probabilité pour qu’il en
soit ainsi est le rapport des aires du ni0
quart de disque de rayon 1 et du carré pour i1 a n
de côté 1 et soit π/4
x  Aléatoire(100)/100
y  Aléatoire(100)/100
si (x*x + y*y) <1 alors
nini+1
finsi
finpour
retourner( 4*ni/n)
fin
143
Grands classiques I
• Ce diapositive recense quelques algorithmes « historiques » dont les principales vertus
aujourd’hui sont d’ordre pédagogique. A ce titre, tout informaticien débutant doit être
capable de les redéfinir lui-même:
1 Algorithme d’Euclide 11 Produit de matrices
2 Coefficients du binôme 12 Recherche dichotomique
3 Conversion en base b 13 Recherche séquentielle
4 Courbe fractale de Koch 14 Tours de Hanoï
5 Crible d’Eratostène 15 Tri bulles
6 Développement limite 16 Tri fusion
7 Fonction factorielle 17 Tri par insertion
8 Fonction puissance 18 Tri par sélection
9 Nombres de Fibonacci 19 Tri rapide
10 Palindrome
144
bibliographie
• www.pise.info/algo
• Cours algorithmique Université Libre de Bruxelle
• Cours deLicence Maths Info 2ème année Faculté des sciences Jean
Perrin - Université d’Artois
• http://fr.wikipedia.org/
• www.commentcamarche.net/
• http://www.wikituto.org/index.php/Algorithme:Intro
• http://www.iro.umontreal.ca/~hamelsyl/recursion.pdf
• www.france-ioi.org/
145

Cours Algorithmique Chahin

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Algorithmique Chahin

Transféré par

Droits d'auteur :

Formats disponibles

Cours algorithmique

Site web :https://sites.google.com/a/uca.ma/r-chahin

Année Académique 2017-2018

Outils: Logiciel Pratiquer l'Algorithmique 12 : http://fr.lagache.free.fr/algo/telechargement.php

• Ces instructions permettent de traiter et de transformer les données

• Un algorithme peut se comparer à une recette de cuisine

• Un algorithme est une méthode générale pour résoudre un ensemble de

• un algorithme doit donc contenir uniquement des instructions

La fonction |f | est bornée par

En théorie des algorithmes :

pour un k1 > 0, et un k2 > 0

f est négligeable , quel que soit > 0 (fixé).

Les concepts en œuvre en algorithmique, sont en petit nombre. Ils

• Un programme informatique est formé de quatre types d’instructions considérées

1. Lisez bien le sujet, et reformulez-le.

4. Générez des exemples, et résolvez les entièrement à la main.

# CODE PYTHON /* CODE C */ // Code Java

caractère tout caract. "A" 1

afficher ("nombre ? " )

afficher ("nombre ? " )

saisir une donnée : saisir nom_de_la_variable

Indentation touche TAB

Si condition1 alors (conseiller)

si abr = "M" OU abr = "Mr" alors selon abr

1) selon v 38 impaire

instruction1 l cout fois oui

5) Si N < 1 ou N > 3 Alors 56 Recommencez Saisie

variable N, i : Entier 1 Entrez

Boucle imbriqués Pour: exemple

Fin 5 1 comp (n+1) 4 1

…………. équivaut à………………………

afficher "Donnez une valeur positive paire :"

T max( n)  cons tan t  log(n)

 T max( n) est en O(log(n))

T max( n)  cons tan t  n log(n)

T max( n)  cons tan t  n 2

Valeur élément du tableau

• variable Note : Entier [25] Note=[0]*25

• Algo ne gère pas les tableaux dynamiques Note=[]

indice max indice max

Algo N[nLigne,Ncolonne] Python

variable T : Entier [3,2] 42 2

2) Pour icolon1 à 2 51 2

 Une boîte pour chaque appel récursif 1 2 3

Variable a,res:entier 3.4.4.13.4.4.2 1

 Fonction R( données X):

Attention :La solution est 1011 au lieu de 1101

Fonction Combinaisons (n,p : entier) : entier def Combinaisons(n,p):

Fonction pair(e n : entier) : booléen Fonction impair(e n : entier) : booléen

Fonction ackermann ( m,n : entier) : entier def ackermann (m,n):

• méthode par substitution,

à démontrer en fixant les constantes

• si C(n) = 1 (indépendant de n) alors T(n) = K × n=O(n)

 T (a, b) est en O( b ) 125

Fonction Zone(x, y : réel):chaîne

Vous aimerez peut-être aussi