Introduction

Durée

5 heures

Mots-clés

sous-programme, procédure, fonction, paramètre, appel

Objectif

Dans ce chapitre, vous apprenez à :

déclarer et invoquer une procédure et une fonction ;
déclarer des paramètres ;
transmettre des paramètres en entrée et en sortie ;
renvoyer le résultat d’une fonction.

Prérequis

Pour valider les prérequis nécessaires avant d’aborder le TP, répondez aux questions ci-après.

1.	Parmi les éléments suivants, lesquels figurent dans la déclaration d’un sous-programme :
	a.	le nom du sous-programme ;
	b.	le bloc d’instructions du sous-programme ;
	c.	la liste des programmes pouvant appeler le sous-programme ;
	d.	la déclaration éventuelle de plusieurs variables locales.
2.	Un sous-programme peut être appelé :
	a.	depuis le programme principal ;
	b.	depuis un autre sous-programme ;
	c.	depuis le système d’exploitation.
3.	Quelle est la différence entre une procédure et une fonction ?
4.	Comment est déterminée la valeur de retour d’une fonction ?

Énoncé 3.1 : La bannière de bienvenue

Durée estimative : 5 minutes

Écrivez en langage algorithmique la procédure qui affiche la bannière suivante :

********************************************* 
**                                         ** 
**              BIENVENUE                  ** 
**                                         ** 
*********************************************

Écrivez ensuite l’algorithme principal qui appelle cette procédure. Traduisez le tout en Java/Python.

Énoncé 3.2 : Initialisation d’une variable tableau

Durée estimative : 15 minutes

Modifiez l’algorithme de l’exercice 2.3 de recherche d’une variable dans un tableau.

Modifiez cet algorithme pour que le remplissage de la variable tableau par des nombres aléatoires soit réalisé dans une procédure séparée. Cette procédure est alors invoquée dans l’algorithme principal.

Modifiez ensuite le programme Java/Python correspondant.

Indice

En langage algorithmique, une procédure peut accéder à une variable globale si elle est déclarée après cette variable globale.

En Java, une procédure statique peut accéder à une variable uniquement dans le cas où cette dernière est déclarée statique.

En Python, une procédure peut accéder à une variable globale si celle-ci a reçu une valeur au moment de son accès. La modification d’une variable globale dans une procédure doit être déclarée explicitement avec le mot-clé global.

Énoncé 3.3 : Affichage d’un tableau

Durée estimative : 15 minutes

Modifiez à nouveau le premier programme Java/Python de l’exercice 2.3.

Ajoutez-y la procédure qui affiche le contenu de la variable tableau. Un paramètre permet de déterminer si un saut à la ligne ou un espace doit séparer chaque élément du tableau lors de l’affichage.

Appelez cette procédure depuis le programme principal en demandant préalablement à l’utilisateur s’il préfère un affichage de toutes les valeurs en ligne ou séparées par un retour à la ligne.

Énoncé 3.4 : Fonctions de conversion de degrés en radians et vice versa

Durée estimative : 15 minutes

Écrivez en langage algorithmique la fonction de conversion de degrés en radians. La valeur de l’angle en degrés est transmise comme paramètre. Le résultat de la fonction est la valeur de l’angle en radians.

Écrivez ensuite la fonction inverse qui convertit une valeur en radians en une valeur en degrés.

Traduisez ensuite ces deux fonctions en Java/Python. Réalisez pour chacune d’elles le programme de test.

Indices

La conversion de degrés en radians s’effectue en divisant par 180 et en multipliant par π.

La conversion de radians en degrés s’effectue en divisant par π et en multipliant par 180.

En langage algorithmique, vous pouvez préciser la constante Pl et sa valeur (3,1415 par exemple). Évidemment, la précision de cette valeur n’a pas d’importance.

En Java, la valeur de π est fournie en Java par Math.PI.

En Python, la valeur de π est donnée par l’expression math.pi.

Énoncé 3.5 : Fonction de génération d’un nombre entier aléatoire entre une borne inférieure et une borne supérieure

Durée estimative : 25 minutes

Écrivez en Java/Python la fonction qui génère un nombre entier aléatoire compris entre une borne inférieure et une borne supérieure. Les bornes sont incluses. Ces deux bornes sont des entiers.

Écrivez ensuite le programme Java/Python de test.

Modifiez à nouveau le programme Java/Python de l’exercice 2.3 modifié dans les exercices 3.2 et 3.3 pour y intégrer cette fonction.

Énoncé 3.6 : Fonction de calcul de la factorielle

Durée estimative : 15 minutes

Écrivez en langage algorithmique la fonction calculant la factorielle d’un nombre entier positif ou nul.

Écrivez ensuite l’algorithme principal qui appelle cette fonction.

Traduisez le tout en Java/Python.

En Java, le type de retour de la fonction factorielle est long.

En Python, le type de retour de la fonction factorielle est int.

Indices

La factorielle de n est obtenue par le produit de tous les nombres entiers compris entre 1 et n. La factorielle de 0 est 1.

Par conséquent, le calcul de la factorielle s’effectue à l’aide d’une boucle.

Ne testez pas si le nombre entier passé en paramètre à la fonction factorielle est positif ou nul.

Énoncé 3.7 : Fonction min et max de trois nombres réels

Durée estimative : 25 minutes

Écrivez en langage algorithmique la fonction calculant le minimum de trois nombres réels passés en paramètres.

Écrivez la fonction calculant le maximum de trois nombres réels passés en paramètres.

Écrivez ensuite l’algorithme principal qui appelle ces deux fonctions.

Traduisez ces deux fonctions et l’algorithme principal en Java/Python.

En Java, utilisez le type double pour les paramètres et le résultat des deux fonctions.

En Python, le type des paramètres et du résultat des deux fonctions est float.

Indice

Pour calculer le minimum et le maximum, n’utilisez pas de fonctions existantes, mais seulement des instructions de test.

Énoncé 3.8 : Fonction calculant la racine carrée d’un nombre réel

Durée estimative : 20 minutes

Écrivez en langage algorithmique la fonction calculant la racine carrée réelle d’un nombre réel passé en paramètre. Cette fonction renvoie un booléen qui vaut vrai si le calcul est possible, c’est-à-dire si le nombre réel passé en paramètre est supérieur ou égal à zéro, ou faux si le calcul n’est pas possible.

Si le calcul est possible, la valeur de la racine est renvoyée comme paramètre en mode sortie.

Écrivez ensuite l’algorithme principal qui appelle cette fonction. Traduisez la fonction et l’algorithme principal en Java/Python.

Indices

Pour calculer la racine carrée, il faut utiliser la fonction racine en langage algorithmique, Math.sqrt en Java et math.sqrt en Python.

En langage algorithmique, il existe trois modes de transmission :

en entrée : la valeur du paramètre est transmise à l’appel mais pas au retour (le paramètre transmis est une expression) ;
en sortie : la valeur du paramètre est calculée dans le sous-programme et transmise au retour (le paramètre transmis est une variable) ;
en entrée et en sortie : la valeur du paramètre est transmise...

Énoncé 3.9 : Remplissage d’un tableau d’entiers par des nombres aléatoires

Durée estimative : 30 minutes

Écrivez en langage algorithmique la procédure qui remplit un tableau d’entiers, transmis en paramètre, avec des nombres aléatoires. Les paramètres de cette procédure sont le tableau, sa borne inférieure et sa borne supérieure, la valeur minimale et la valeur maximale des nombres aléatoires (ces deux valeurs sont réelles).

Écrivez ensuite l’algorithme principal qui appelle cette procédure. Traduisez le tout en Java/Python en utilisant la fonction de l’exercice 3.5.

Modifiez ensuite le programme Java/Python de l’exercice 2.3 pour qu’il appelle cette procédure pour initialiser sa variable tableau.

Indice

En Java, il n’est pas nécessaire de transmettre les bornes du tableau, la borne inférieure est toujours zéro et la taille peut être obtenue à l’aide de la propriété length.

En Python, les bornes du tableau n’ont pas besoin d’être transmises. La borne inférieure est toujours zéro et la fonction len() avec le tableau en argument permet d’obtenir sa taille.

Énoncé 3.10 : Division euclidienne

Durée estimative : 25 minutes

Écrivez en langage algorithmique la fonction qui retourne le quotient et le reste d’une division euclidienne. Ces deux valeurs sont retournées dans un tableau de taille 2. Le dividende et le diviseur sont passés en paramètres de la fonction.

Écrivez ensuite l’algorithme principal qui appelle cette procédure. Traduisez le tout en Java/Python.

Indices

Si a est le dividende, b le diviseur, q le quotient et r le reste, la division euclidienne est telle que : a=b*q+r avec r < b. Le quotient q peut être calculé avec l’opérateur de division entière (DIV en langage algorithmique, / en Java et en Python). Le reste peut être calculé avec l’opérateur modulo (% en langage algorithmique, en Java et en Python).

Ne testez pas si le dividende est positif ou nul ni si le diviseur est strictement positif.

Énoncé 3.11 : Recherche d’une valeur dans un tableau d’entiers à deux dimensions

Durée estimative : 30 minutes

Écrivez en langage algorithmique la fonction qui recherche un entier dans un tableau à deux dimensions. Les paramètres de cette procédure sont la valeur à rechercher, le tableau, la borne inférieure et la borne supérieure pour chaque dimension.

La recherche se fait dans l’ordre suivant (où t est le tableau où s’effectue la recherche et dont, ici, les bornes inférieures des deux dimensions sont supposées nulles et dont n et m sont respectivement la borne supérieure de la première et de la seconde dimension) :

t[0,0], t[0,1], t[0,2], ..., t[0,m] 
t[l,0], t[l,1], t[l,2], ..., t[1,m] 
... 
t[n,0], t[n,1], t[n,2], ..., t[n,m]

Si la valeur est trouvée, la fonction renvoie les deux indices sous la forme d’un tableau de deux éléments. Sinon la fonction renvoie un tableau de deux éléments dont les deux valeurs sont égales à la borne inférieure moins un (c’est-à-dire -1 en Java et en Python car la borne inférieure est toujours 0).

Traduisez le tout en Java/Python. Utilisez la procédure de remplissage d’un tableau à une dimension avec des nombres entiers aléatoires qui a été écrite...

Énoncé 3.12 : Somme de deux matrices carrées d’entiers

Durée estimative : 45 minutes

Reprenez l’exercice 2.15 en rendant le programme Java/Python plus modulaire. Pour cela, écrivez :

la procédure pour lire une matrice passée en paramètre ;
la fonction pour calculer la somme de deux matrices carrées passées en paramètres ainsi que leur taille ;
la procédure pour afficher une matrice passée en paramètre.

Intégrez ensuite ces sous-programmes dans le programme principal.

Si vous maîtrisez bien les tableaux en Java/Python, écrivez la fonction pour calculer la somme de deux matrices quelconques. La seule contrainte est que toutes leurs tailles doivent être égales. Intégrez alors cette fonction dans le programme principal.

Énoncé 3.13 : Fusion de deux tableaux triés d’entiers

Durée estimative : 35 minutes

Reprenez l’exercice 2.12 en rendant le programme Java/Python plus modulaire. Pour cela, écrivez :

la procédure pour trier (par tri bulle) un tableau passé en paramètre ;
la fonction pour fusionner deux tableaux passés en paramètres (pas nécessairement triés) et retournant le tableau issu de la fusion ;
la procédure pour afficher un tableau passé en paramètre.

Intégrez les deux procédures et la fonction dans le programme principal Java/Python.