Cette page fait partie du cours de polytech PeiP1 et 2 Bio

1. Langage algorithmique

1.1. Introduction

Dans cette première partie nous nous intéressons au langage algorithmique qui va nous permettre d'exprimer ce que nous voulons faire. Nous mettrons en relation l'algorithmique avec les instructions de Python.

Ce langage utilise :

On fera la distinction entre les opérateurs = et == :

Les types de base du langage sont les suivants :

Les instructions que nous utiliserons sont les suivantes :

1.2. Déclaration de variable

La déclaration d'une variable est réalisée comme suit :

  1. x, y sont des entiers
  2. rayon est un réel = 10.67
  3. l est une liste entiers = [1, 2, 3]
  4. t est un tableau de 10 booléens
  5. m est un tableau de 10 par 10 réels
  6.  

On voit qu'après la déclaration de la variable il est possible de lui attribuer une valeur d'initialisation.

Dans notre langage algorithmique, le premier élément d'une liste ou d'un tableau est à l'indice 1.

En Python, en revanche, le premier élément d'une liste est à l'indice 0 !

1.3. Affectation de variable

Elle consiste a attribuer une valeur à une variable :

  1. pi = 3.14
  2. rayon = 10
  3. circonference = 2 * pi * rayon
  4. _2_ou_3 = 2
  5.  

Le nom des variables obéit à des règles de construction :

Ainsi la suite de caractères 2_ou_3 n'est pas un nom de variable car elle commence par un chiffre, alors que _2_ou_3 et DeuxTrois sont des noms de variables valides.

1.4. Définition et appel de sous-programme

L'appel de sous-programme consiste à utiliser une fonction en lui passant éventuellement des paramètres.

Il existe deux types de sous-programmes : les procédures et les fonctions qui se distinguent par le fait qu'une fonction retourne un résultat alors que ce n'est pas le cas d'un sous-programme.

  1. // définition de fonction
  2. fonction addition(x, y : entiers) : entier
  3.   retourner x + y
  4. fin fonction
  5.  
  6. // définition de procédure
  7. procédure affiche(nom : chaine)
  8.   écrire("bonjour ", nom)
  9. fin procédure
  10.  
  11. // appel de fonction
  12. variable z est un entier
  13. z = addition(1, 2)
  14.  
  15. // appel de procédure
  16. affiche("toto")
  17.  

En Python, on ne distingue pas les fonctions des procédures qui sont toutes les deux introduites par le mot-clé def.

  1. # definition d'une constante
  2. pi = 3.14
  3.  
  4. # definition d'une fonction qui calcule la circonference
  5. # d'un cercle connaissant son rayon
  6. def calcule_circonference(rayon):
  7.   global pi
  8.   circonference = 2 * pi * rayon
  9.   return circonference
  10.  

1.5. Retour de sous-programme

L'instruction retourner (return en Python) permet de sortir d'un sous-programme :

  1. // le nombre entier 'n' est-il un nombre pair ?
  2. fonction est_pair(n est un entier) : booléen
  3.   // si le reste de la division de n par 2 est égal à 0
  4.   // alors 'n' est pair
  5.   si n modulo 2 == 0 alors
  6.     retourner vrai
  7.   sinon
  8.     retourner faux 
  9.   fin si
  10. fin fonction
  11.  
  12. procédure affiche_racine_carrée(n est un entier)
  13.   si n < 0 alors
  14.     retourner
  15.   fin si
  16.   écrire( "racine carrée de ", n, " = ", sqrt(n) )
  17. fin procédure
  18.  

Dans une fonction, elle est suivie d'une expression (qui peut se résumer à une constante) qui représente la valeur retournée par la fonction.

1.6. La conditionnelle: si alors sinon, sinon si

La conditionnelle si alors est de la forme suivante :

  1. si x < 3 ou x > 7 alors
  2.   écrire("la valeur n'est pas dans l'intervalle [3..7]")
  3. fin si
  4.  

La liste d'instructions sera exécutée uniquement si la condition est vraie.

Dans d'autres cas, il est nécessaire d'exécuter une autre série d'instructions si la condition est fausse car les instructions situées entre alors et sinon ne seront pas exécutées :

  1. si x < 3 alors
  2.   écrire("valeur inférieure à 3")
  3. sinon
  4.   écrire("valeur supérieure ou égale à 3")
  5. fin si
  6.  

Enfin, il existe un dernier cas qui correspond à plusieurs conditions à vérifier :

  1. si x < 3  alors
  2.   écrire("valeur inférieure à 3")
  3. sinon si x > 3 alors
  4.   écrire("valeur supérieure à 3")
  5. sinon
  6.   écrire("x = 3")
  7. fin si
  8.  

Voyons à présent comment se traduit la conditionnelle en Python. Il s'agit du programme instruction_if.py :

  1. # lecture d'une donnée au clavier (chaine)
  2. x = input("saisir un entier")
  3. # convertir en entier
  4. x = int(x)
  5.  
  6. # cas d'un si alors
  7. if x < 3 or x > 7 :
  8.   print("la valeur n'est pas dans l'intervalle [3..7]")
  9.  
  10. # cas d'un si alors sinon
  11. if x < 3:
  12.   print("la valeur est inférieure à 3")
  13. else:
  14.   print("la valeur est supérieure à 3")
  15.  
  16.  
  17.  

On note qu'on utilise le symbole : pour marquer la fin de la condition mais également après le else.

1.7. La boucle pour

Dans les cas des boucles pour on fait varier une variable entière dans un intervalle. Il ne sera pas nécessaire de déclarer la variable de boucle i puisqu'elle est temporaire et que l'on sait qu'il s'agit d'un entier :

  1. // somme des entiers de 1 à 10
  2. somme est un entier = 0
  3. pour i de 1 à 10 faire
  4.   somme = somme + i
  5. fin pour
  6.  
  7. // somme des entiers impairs de 1 à 10
  8. somme = 0
  9. pour i de 1 à 10 par pas de 2 faire
  10.   somme = somme + i
  11. fin pour
  12.  

En Python on obtient (instruction_for.py) :

  1. # somme des entiers de 1 à 10
  2. sum = 0
  3. for i in range(1,11):
  4.   sum = sum + i
  5.  
  6. print("sum=", sum)
  7.  
  8. # somme des entiers impairs de 1 à 10
  9. sum = 0
  10. for i in range(1,11,2):
  11.   sum = sum + i
  12.  
  13. print("sum=", sum)
  14.  

On notera l'utilisation de la fonction (itérateur) range(a,b,c=1) qui permet d'énumérer des valeurs entre $a$ et $b-1$ par pas de $c$.

1.8. La boucle tant que

Dans les cas des boucles tant que on exécute les instructions de la boucle tant que la condition est vraie :

  1. somme est un entier
  2. i est un entier
  3.  
  4. // somme des entiers de 1 à 10
  5. somme = 0
  6. i = 1
  7. tant que i <= 10 faire
  8.   somme = somme + i
  9.   i = i + 1
  10. fin tant que
  11.  
  12. // somme des entiers impairs entre 1 à 10
  13. somme = 0
  14. i = 1
  15. tant que i <= 10 faire
  16.   somme = somme + i
  17.   i = i + 2
  18. fin tant que
  19.  

En Python on obtient (instruction_while.py) :

  1. # somme des entiers de 1 à 10
  2. sum = 0
  3. i = 1
  4. while i <= 10:
  5.   sum = sum + i
  6.   i = i + 1
  7.  
  8. # somme des entiers impairs de 1 à 10
  9. sum = 0
  10. i = 1
  11. while i <= 10:
  12.   sum = sum + i
  13.   i = i + 2
  14.  

1.8.1. Autres instructions

Nous utiliserons les instructions :

1.9. Exercices

Exercice 1.1

Que fait l'algorithme suivant ?

  1. i est un entier
  2. p est un entier = 1
  3.  
  4. pour i de 1 à 10 faire
  5.   p = p * i
  6. fin pour
  7.  
  8.  

Exercice 1.2

Que fait l'algorithme suivant ? On rappelle que le modulo donne le reste de la division entière.

  1. s est une chaine = ""
  2. s1 est une chaine = "*"
  3. s2 est une chaine = "-"
  4. i est un entier = 6
  5.  
  6. tant que i > 0 faire
  7.   si i modulo 2 == 0 alors
  8.     s = s + s1
  9.   sinon
  10.     s = s + s2
  11.   fin si
  12.   i = i - 1
  13. fin tant que
  14.  

Exercice 1.3

Que fait l'algorithme suivant ?

  1. fonction f(n : entier) : booleén
  2.  
  3.   si n <= 1 alors
  4.     retourner faux
  5.   fin si
  6.  
  7.   nb_div = 0
  8.   pour i de 1 à n faire
  9.     si n modulo i == 0 alors
  10.       nb_div = nb_div + 1
  11.     fin si
  12.   fin pour
  13.  
  14.   si nb_div == 2 alors
  15.     retourner vrai
  16.   sinon
  17.     retourner faux
  18.   fin si
  19.  
  20. fin fonction
  21.  

Exercice 1.4

Que fait l'algorithme suivant ?

  1. fonction f(s : chaine) : entier
  2.  
  3.   pour i de 1 à longueur(s) faire
  4.     si s[i] == '.' alors
  5.       retourner i
  6.     fin si
  7.   fin pour
  8.  
  9.   retourner -1
  10.  
  11. fin fonction
  12.  

Exercice 1.5

Que fait l'algorithme suivant ?

  1. fonction g(tab : tableau entiers) : booléen
  2.  
  3.   pour i de 2 à longueur(tableau) faire
  4.     si tab[i-1] > tab[i] alors
  5.       retourner faux
  6.     fin si
  7.   fin pour
  8.  
  9.   retourner vrai
  10.  
  11. fin fonction
  12.