Fonction carré : \(f(x) = x^2\), transforme un nombre en son carré.
- Déclaration du nom de la fonction
- Spécification des paramètres d'entrée
- Corps de la fonction (instructions)
- Valeur de retour
Fonction Carré(x)
Variables resultat : réel
Début
resultat ← x * x
Retourner resultat
FinFonction
La fonction prend un seul paramètre x de type réel
Calcul : resultat ← x * x
Retourner resultat
Variables a, b, c : réels
Début
a ← Carré(5) // a = 25
b ← Carré(-3) // b = 9
c ← Carré(2.5) // c = 6.25
Fin
| Entrée | Résultat |
|---|---|
| 0 | 0 |
| 1 | 1 |
| 2 | 4 |
| 3 | 9 |
| -2 | 4 |
| 2.5 | 6.25 |
La fonction Carré calcule le carré d'un nombre et retourne le résultat.
• Paramètres : Variables d'entrée de la fonction
• Valeur de retour : Résultat fourni par la fonction
• Appel : Utilisation de la fonction avec des arguments
La fonction encapsule un traitement réutilisable
Les paramètres permettent de passer des données à la fonction
Distance euclidienne : \(d = \sqrt{(x_2-x_1)^2 + (y_2-y_1)^2}\).
Fonction Distance(x1, y1, x2, y2)
Variables dx, dy, resultat : réels
Début
dx ← x2 - x1
dy ← y2 - y1
resultat ← racine_carree(dx*dx + dy*dy)
Retourner resultat
FinFonction
La fonction prend 4 paramètres : x1, y1, x2, y2 (coordonnées des points)
dx ← x2 - x1 (différence des abscisses)
dy ← y2 - y1 (différence des ordonnées)
resultat ← √(dx² + dy²)
Variables dist : réel
Début
dist ← Distance(0, 0, 3, 4) // Distance entre (0,0) et (3,4)
// dist = √(9 + 16) = √25 = 5
Fin
| Point 1 | Point 2 | Distance |
|---|---|---|
| (0,0) | (3,4) | 5 |
| (1,1) | (4,5) | 5 |
| (0,0) | (1,1) | √2 ≈ 1.414 |
| (2,3) | (2,3) | 0 |
La fonction Distance calcule la distance euclidienne entre deux points du plan.
• Plusieurs paramètres : La fonction peut prendre plusieurs entrées
• Calcul intermédiaire : Variables locales pour les calculs
• Retour : La fonction renvoie une seule valeur
Les variables locales à la fonction n'existent que pendant l'exécution
Les paramètres permettent de rendre la fonction générique
Nombre premier : Nombre supérieur à 1 qui n'est divisible que par 1 et lui-même.
Fonction EstPremier(n)
Variables i, estPremier : entiers
Début
Si n <= 1 Alors
Retourner 0 // Non premier
FinSi
estPremier ← 1 // Supposé premier
Pour i de 2 à racine_carree(n) Faire
Si n MOD i = 0 Alors
estPremier ← 0 // Trouvé diviseur
Retourner estPremier
FinSi
FinPour
Retourner estPremier
FinFonction
Si n ≤ 1, n n'est pas premier
estPremier ← 1 (supposé premier)
On teste les diviseurs de 2 à √n
Si n MOD i = 0, alors i divise n, donc n n'est pas premier
On n'a besoin de tester que jusqu'à √n
Car si n a un diviseur > √n, il en a un < √n
Variables resultat : entier
Début
resultat ← EstPremier(17) // Retourne 1 (vrai)
resultat ← EstPremier(15) // Retourne 0 (faux)
Fin
| Entrée | Résultat | Commentaire |
|---|---|---|
| 2 | 1 | Premier |
| 3 | 1 | Premier |
| 4 | 0 | 4 = 2×2 |
| 17 | 1 | Premier |
| 25 | 0 | 25 = 5×5 |
| 29 | 1 | Premier |
La fonction EstPremier teste si un nombre est premier en cherchant des diviseurs.
• Booléen simulé : Utilisation de 0/1 pour représenter vrai/faux
• Optimisation : Test jusqu'à √n seulement
• Retour anticipé : Quitter dès qu'un diviseur est trouvé
Le test s'arrête dès qu'un diviseur est trouvé pour optimiser
Tester jusqu'à la racine carrée réduit considérablement le nombre d'opérations
PGCD : Plus Grand Commun Diviseur de deux nombres.
Algorithme d'Euclide : PGCD(a,b) = PGCD(b, a MOD b) jusqu'à b = 0.
Fonction PGCD(a, b)
Variables temp : entiers
Début
TantQue b ≠ 0 Faire
temp ← b
b ← a MOD b
a ← temp
FinTantQue
Retourner a
FinFonction
PGCD(a,b) = PGCD(b, a MOD b)
On répète jusqu'à ce que b = 0
Lorsque b = 0, PGCD = a
On remplace a par b et b par a MOD b
On continue tant que b ≠ 0
Itération 1: a=48, b=18 → a=18, b=48 MOD 18=12
Itération 2: a=18, b=12 → a=12, b=18 MOD 12=6
Itération 3: a=12, b=6 → a=6, b=12 MOD 6=0
Itération 4: a=6, b=0 → Sortie de la boucle, retourne a=6
Variables resultat : entier
Début
resultat ← PGCD(48, 18) // Retourne 6
resultat ← PGCD(17, 13) // Retourne 1
Fin
| a | b | PGCD(a,b) |
|---|---|---|
| 48 | 18 | 6 |
| 17 | 13 | 1 |
| 100 | 25 | 25 |
| 7 | 3 | 1 |
| 24 | 36 | 12 |
La fonction PGCD implémente l'algorithme d'Euclide pour calculer le plus grand commun diviseur.
• Algorithme d'Euclide : Méthode itérative pour le PGCD
• Division euclidienne : Utilisation de l'opérateur MOD
• Itération : Répétition jusqu'à l'obtention d'un reste nul
L'algorithme d'Euclide est très efficace et converge rapidement
Le PGCD est le dernier reste non nul dans la suite des divisions
Factorielle : \(n! = 1 \times 2 \times 3 \times ... \times n\), avec \(0! = 1\).
Fonction Factorielle(n)
Variables i, resultat : entiers
Début
Si n = 0 Alors
Retourner 1 // Convention : 0! = 1
FinSi
resultat ← 1 // Initialisation pour la multiplication
Pour i de 1 à n Faire
resultat ← resultat * i
FinPour
Retourner resultat
FinFonction
Par convention mathématique : 0! = 1
resultat ← 1 (initialisation pour la multiplication)
Pour i de 1 à n : resultat ← resultat * i
On multiplie successivement tous les entiers de 1 à n
i=1: resultat=1×1=1
i=2: resultat=1×2=2
i=3: resultat=2×3=6
i=4: resultat=6×4=24
i=5: resultat=24×5=120
Variables resultat : entier
Début
resultat ← Factorielle(5) // Retourne 120
resultat ← Factorielle(0) // Retourne 1
Fin
| n | n! |
|---|---|
| 0 | 1 |
| 1 | 1 |
| 2 | 2 |
| 3 | 6 |
| 4 | 24 |
| 5 | 120 |
| 6 | 720 |
La fonction Factorielle calcule la factorielle d'un nombre en multipliant tous les entiers de 1 à n.
• Convention : 0! = 1 par définition mathématique
• Accumulation : Multiplication cumulative des entiers
• Initialisation : Valeur initiale de 1 pour la multiplication
La factorielle croît très rapidement avec n
Le cas n=0 doit être traité spécifiquement selon la convention
- Analyser le problème : Identifier les entrées et sorties attendues
- Choisir le nom : Donner un nom explicite à la fonction
- Définir les paramètres : Spécifier les variables d'entrée
- Écrire le corps : Implémenter le traitement
- Spécifier la sortie : Déterminer la valeur de retour
- Une fonction a un nom unique dans le programme
- Les paramètres sont les variables d'entrée de la fonction
- Une fonction retourne une seule valeur
- Les variables locales à la fonction n'existent que pendant son exécution
- Une fonction peut appeler d'autres fonctions