Paradigmes de programmation : exercices corrigés de Terminale NSI

Phrase 1 : des objets qui interagissent, c'est la vue du paradigme orienté objet ³. Donc 1 correspond à B.

Phrase 2 : dans le paradigme logique, le programmeur exprime les règles et le système pilote la recherche ⁴. Donc 2 correspond à D.

Phrase 3 : modifier l'état de variables instruction après instruction caractérise l'impératif, paradigme d'origine ³. Donc 3 correspond à A.

Phrase 4 : des évaluations de fonctions sans état décrivent le paradigme fonctionnel ³. Donc 4 correspond à C.

P1 modifie la variable s à chaque tour de boucle : c'est du style impératif ³.

P2 définit une classe avec un attribut et une méthode, puis crée un objet : c'est du style orienté objet ³.

Python fait partie des langages qui supportent plusieurs paradigmes ³, et la plupart des langages contemporains permettent d'en combiner plusieurs s'ils sont compatibles ⁴. Les deux programmes coexistent donc sans difficulté.

Dans les deux cas, le résultat est le même : $4+7+1=12$.

Avant la boucle : total = 0.

Pour $i=1$ : on ajoute $1$, donc total vaut 1.

Pour $i=2$ : on ajoute $4$, donc total vaut 5.

Pour $i=3$ : on ajoute $9$, donc total vaut 14.

Pour $i=4$ : on ajoute $16$, donc total vaut 30.

Pour $i=5$ : on ajoute $25$, donc total vaut 55.

double(1)=2, double(2)=4, double(3)=6, double(4)=8.

La somme vaut $2+4+6+8=20$.

La liste L n'est pas modifiée : double renvoie une valeur et ne change rien d'autre, et sum renvoie un nombre.

On retrouve l'idée du fonctionnel : un programme vu comme une suite d'évaluations de fonctions sans état ³.

Premier appel : L devient [1, 2, 5] et la fonction renvoie 3, donc a = 3.

Second appel avec les mêmes arguments : L devient [1, 2, 5, 5] et la fonction renvoie 4, donc b = 4.

Deux appels identiques donnent deux résultats différents, car la fonction modifie une donnée extérieure à elle-même : c'est un effet de bord. La programmation fonctionnelle pure interdit justement ces effets ³.

À la fin, L = [1, 2, 5, 5], donc len(L) = 4.

Création : c.pas = 3 et c.valeur = 0.

Premier appel : c.valeur = 0 + 3 = 3.

Deuxième appel : c.valeur = 3 + 3 = 6.

Troisième appel : c.valeur = 6 + 3 = 9.

Dans le paradigme objet, le programme est une collection d'objets en interaction ³ : chaque objet porte son état et les méthodes qui le font évoluer, ce qui limite les endroits du programme où cet état peut changer.

Pour parent(a, b) : les faits qui commencent par b sont parent(b, c) et parent(b, d). On obtient (a, c) et (a, d).

Pour parent(b, c) : le fait qui commence par c est parent(c, e). On obtient (b, e).

Pour parent(b, d) : aucun fait ne commence par d. Pour parent(c, e) : aucun fait ne commence par e. Rien de plus.

Il y a donc 3 couples : (a, c), (a, d) et (b, e).

Le programmeur exprime les règles ; le système pilote le processus de recherche dans l'ensemble de faits ⁴.

S1 : des entités avec états et comportements, c'est le paradigme orienté objet, où l'on voit le programme comme des objets en interaction ³.

S2 : plusieurs tâches simultanées relèvent du paradigme concurrent, qui introduit la notion de thread ⁴.

S3 : des fonctions appliquées successivement, sans état ni effet de bord, relèvent du paradigme fonctionnel ³.

S4 : des faits, des règles de déduction et des recherches relèvent du paradigme logique ⁴.

Les pairs sont 2, 4 et 6. Leurs carrés sont 4, 16 et 36, donc res = [4, 16, 36].

La somme vaut $4+16+36=56$.

La version A construit res en la modifiant au fil de la boucle avec append : c'est du style impératif ³.

La version B décrit le résultat comme une transformation de la liste de départ, sans modifier de variable intermédiaire : elle s'approche du style fonctionnel ³.

Python supporte plusieurs paradigmes ³, donc les deux versions sont valides et donnent le même résultat.