Bases d`algorithmique

Bases d’algorithmique
Table des matières
1 Bases d’algorithmique I
1.1 Algorithmes et programmes
1.2 Tests . . . . . . . . . . . . .
1.3 Fonctions . . . . . . . . . .
1.3.1 Définir une fonction
1.3.2 Portée des variables
1.4 Boucles . . . . . . . . . . .
1.4.1 Boucle for . . . . . .
1.4.2 Boucle while . . . .
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
2
4
4
5
5
5
6
Bases d’algorithmique I
1.1
Algorithmes et programmes
Définition 1.1 Un algorithme est une suite d’instructions permettant, à partir de données, de
produire un résultat.
Exemples 1.1
Un algorithme peut très bien être décrit en langage naturel, avec un schéma. . . L’existence d’algorithmes précéde
d’ailleurs de nombreux siècles l’apparition des premiers ordinateurs !
Définition 1.2 Un programme est un algorithme écrit dans un langage permettant son exécution par un ordinateur.
En python, nous avons vu pour l’instant 3 instructions :
• L’affectation
• L’affichage (à l’aide la commande print)
• La demande de valeur à l’utilisateur (à l’aide la commande input)
Dans les exemples que nous avons étudiés jusqu’à présent, les instructions d’un programme sont effectuées séquentiellement
– ce qui ne va pas permettre de traduire des algorithmes autres que très simples.
Exemple 1.2 Comment utiliser python pour afficher séquentiellement les carrés des entiers de 1 à 10 ? On cherchera
à taper le moins de caractères possibles, et l’on pourra utiliser la flêche vers le haut pour rappeler une commande
précédemment tapée.
1
Exemple 1.3 L’algorithme d’Euclide permet de calculer le plus grand diviseur commun (pgcd) de deux entiers
strictement positifs a et b, avec a > b.
(i) On calcule le reste r de la division de a par b.
(ii) Si r est nul, le résultat recherché est b.
(iii) Sinon, on recommence à l’étape (i) en remplaçant a par b, et b par r.
Nous prouverons plus tard que cet algorithme fonctionne.
1. Utiliser cet algorithme pour calculer à la main le pgcd de 120 et 25.
2. Comment utiliser python pour calculer le pgcd de 22212 et 2178 ? (On évitera de taper trop de caractères. . .)
Les méthodes utilisées dans les exercice précédents ne sont pas entièrement automatiques. Elles nécessitent l’intervention
de l’utilisateur :
• pour répéter des mêmes instructions un certain nombre de fois ;
• pour tester quand est-ce-qu’il faut s’arrêter.
Tout langage de programmation dispose d’instructions permettant d’automatiser complètement ce type de procédés.
1.2
Tests
Les tests (ou branchement conditionnels) permettent d’effectuer une série d’instructions si et seulement si une certaine
condition est vérifiée.
La syntaxe est la suivante :
if condition :
bloc d’instructions
Rem
Le bloc d’instruction doit être indenté par rapport au if, c’est-à-dire décalé de 4 espaces (que l’on peut
obtenir directement à l’aide de la touche tabulation).
Code Python :
a=int(input(’Entrez un entier positif : ’))
if a<0 :
print(’Vous n’avez pas rentré un entier positif...’)
Exercice 1 Quelle est la différence entre les 2 programmes suivants :
Code Python :
Code Python :
a=int(input(’Entrez un entier : ’))
if a==0 :
print(’Votre entier est nul.’)
print(’Au revoir’)
a=int(input(’Entrez un entier : ’))
if a==0 :
print(’Votre entier est nul.’)
print(’Au revoir’)
2
Il est possible d’ajouter des instructions à effectuer lorsque la condition n’est pas vérifiée.
Code Python :
a=int(input(’Entrez un entier : ’))
if a>=0 :
print(’a est positif’)
else :
print(’a’ est strictement négatif)
Exercice 2 En imbriquant 2 instructions conditionnelles, écrire un programme qui demande un entier à l’utilisateur, et
affiche un message qui dit si cet entier est nul, strictement positif ou strictement négatif.
Le programme de l’exercice précédent peut être compacté de la façon suivante :
Code Python :
a=int(input(’Entrez un entier : ’))
if a>0 :
print(’a est strictement positif’)
elif a==0 :
print(’a est nul’)
else :
print(’a est strictement négatif’)
Exercice 3
1. Que fait le programme suivant ?
Code Python :
if a>b :
if a>c :
M=a
else :
M=c
else :
if b>c :
M=b
else :
M=c
2. Le modifier pour qu’à l’issue de son exécution, la variable m contienne de plus le minimum de a, b et c.
3
1.3
Fonctions
1.3.1
Définir une fonction
Lorsque l’on a besoin d’utiliser plusieurs fois une même série d’instructions, il faut les mettre sous forme de fonction. Une
fonction possède :
• un nom – que l’on choisira de façon à ce qu’il soit suffisamment explicite) ;
• des paramètres, qui sont ses entrées ;
• d’un résultat, ou valeur de retour
La syntaxe de base pour déclarer une fonction est la suivante :
def nom(paramètres) :
bloc d’instruction
return valeur de retour
Il y a des variantes possibles, que nous allons étudier au fur et à mesure des exemples qui suivent.
Voici une fonction qui calcule le minimum de deux réels :
Code Python :
def mon_min(a :float,b :float) :
"""renvoie le minimum des réels a et b """
if a<=b :
return a
return b
Il est alors possible d’utiliser cette fonction dans la console, ou dans un autre programme :
Code Python :
>>> a=mon_min(1,2.4)
>>> print(a)
1
Une fonction peut ne pas renvoyer de résultat :
Code Python :
def dis_bonjour(nom :str) :
"""affiche un message de bienvenue personalisé"""
print(’Bonjour’,nom,’ !’)
Ne pas confondre :
Rem
• return
• print
Exercice 4 Sans utiliser abs, écrire une fonction mon_abs(a :float), qui renvoie la valeur absolue d’un réel a.
4
1.3.2
Portée des variables
Les variables utilisées à l’intérieur d’une fonction sont appelées variables locales. Une variable locale n’est pas visible à
l’extérieur de la fonction.
Code Python :
def test(a :int) :
b=2
a=a+1
return a+b
>>>
>>>
>>>
2
>>>
a=-1
b=-1
test(a)
a
>>> b
On parle de variable globale pour une variable définie à l’extérieur de toute fonction. L’usage des variables globales
est réservé à la définition de constantes. Il est impossible de modifier une variable globale dans une fonction.
Code Python :
#vitesse de la lumière, en m.s^-1
c=299792458
def distance_km_min(m :float) :
"""calcule la distance en km parcouru par la lumière en m minutes"""
return 60*m*c/1000
def temps_km_min(k :float) :
"""calcule le temps en min mis par la lumière pour parcourir k km"""
return k*1000/(60*c)
def test() :
c=c+1
>>> distance_km_min(60)
1079252848.8
>>> temps_km_min(1)
5.5594015866358675e-08
>>> test()
.....
UnboundLocalError : local variable ’c’ referenced before assignment
1.4
Boucles
Les boucles sont des instructions qui permettent de répéter plusieurs fois un bloc d’instructions donné.
1.4.1
Boucle for
Une boucle for permet de répéter un nombre de fois prédéterminé une séquence d’instructions.
for compteur in range((debut),fin) :
bloc d’instructions
5
Au premier passage dans la boucle, le compteur prend la valeur début (0 si elle est omise). Après le première passage, le
compteur est augmenté de 1 (on dit qu’il est incrémenté). On sort de la boucle lorsque la valeur de fin est atteinte ou
dépassée (la fin est donc exclue : le compteur ne vaut jamais fin lors de l’exécution de la boucle).
Voici quelques exemples, dont on va détailler le fonctionnement :
Code Python :
for k in range(10) :
print (’bonjour’)
Code Python :
for k in range(1,11) :
print (k**2)
Code Python :
def somme(n :int) :
s=0
for k in range(n+1) :
s=s+k
return s
Exercice 5 Écrire une fonction qui prend un entier positif n en argument, et renvoie n! (n! est défini par n! = 1 si n = 0,
et n! = 1.2. . . . n sinon.)
Rem
math.factorial(n) existe dans le module math de Python.
Exercice 6 On considère la suite (un ) définie par u0 = 1, et pour tout n ∈ N, un+1 = cos(un ). Écrire un programme qui
demande n ∈ N à l’utilisateur, puis calcule et affice un .
Exercice 7 Comment calculer une valeur approchée de
100 X
i
X
cos(i + j) en Python ?
i=0 j=0
Exercice 8 Soit (un ) la suite définie par u0 = 0, u1 = 1, et ∀n ∈ N, un+2 = un+1 + un .
Écrire un programme qui demande n ∈ N à l’utilisateur, puis qui affiche un .
1.4.2
Boucle while
On utilise une boucle while lorsqu’on ne connait pas a priori le nombre d’itérations d’une série d’instructions à effectuer.
L’exécution s’arrêtera lorsqu’une certaine condition sera vérifiée.
while condition :
bloc d’instructions
6
Code Python :
n=int(input(’Entrez un entier strictement positif’))
p=1
while p<=n :
print(p)
#(1)
p=2*p
#(2)
Exercice 9 Que se passe-t-il si l’on intervertit les lignes (1) et (2) dans le programme précédent ?
Code Python :
def pgcd(a :int,b :int) :
"""calcule le pgcd de deux entiers naturels a et b, avec a>=b"""
while b !=0 :
(a,b)=(b,a%b)
return a
Exercice 10 Que se passe-t-il si l’on appelle la fonction précédente avec b > a ?
Exercice 11 On considère la suite (un ) définie par u0 = 1 et un+1 = sin(un ). On peut montrer que (un ) est de limite
nulle.
Écrire un programme qui demande e ∈ R+∗ à l’utilisateur, et qui affiche n et un , où n est le plus petit entier tel que
un 6 e.
Exercice 12 Sans utiliser les fonctions du module math ni de conversion float en int, écrire une fonction qui prend en
argument un réel positif, et renvoie sa partie entière.
Toute boucle for peut se réécrire comme une boucle while :
Code Python :
Rem
Code Python :
k=0
while k<n :
$instructions
k=k+1
for k in range(n) :
#instructions
Dès que l’on utilise des boucles while, un problème de terminaison peut se poser.
Code Python :
Rem
t=0
while t>-1 :
t=t+1
print(t)
Il faut dans ce cas interrompre de force l’exécution du programme. Nous verrons un peu plus tard comment éviter ce type
de problèmes.
7