$course$/QCM de NSI/Terminale/Récursivité Définition d'une fonction récursive (cas de base, appel récursif),
déroulement de la pile d'appels, terminaison, exemples classiques
(factorielle, Fibonacci, somme, parcours d'arbre, tours de Hanoï),
récursivité simple vs double, complexité et mémoïsation.

]]> Récursivité — Q01 : Définition d'une fonction récursive Quelle propriété caractérise une fonction récursive ?

]]> Une fonction récursive comporte deux ingrédients indispensables :
au moins un cas de base (qui renvoie une valeur sans appel
récursif) et un ou plusieurs appels récursifs sur un
sous-problème strictement plus petit, pour garantir la
terminaison.

]]> 1.0 0.0 0 true true abc Elle s'appelle elle-même, avec au moins un cas de base qui ne fait pas d'appel récursif

]]> Bonne réponse : une fonction récursive est définie par un ou
plusieurs cas de base (qui arrêtent la récursion) et un ou
plusieurs appels à elle-même sur un sous-problème plus petit.

]]> Elle prend obligatoirement deux paramètres : une valeur et une accumulation

]]> Erreur : une fonction récursive peut n'avoir qu'un seul
paramètre (par exemple factorielle(n)). L'accumulateur est
un schéma possible, pas une obligation.

]]> Elle renvoie obligatoirement une liste qui se construit pas à pas

]]> Erreur : la valeur de retour peut être de n'importe quel type
(entier, booléen, chaîne, liste, etc.).

]]> Elle utilise une boucle while qui décompte une variable

]]> Erreur : c'est la définition d'une fonction itérative. La
récursivité remplace justement les boucles par des appels
successifs de la fonction à elle-même.

]]> Récursivité — Q02 : Nécessité du cas de base Que se passe-t-il en Python si une fonction récursive ne possède
aucun cas de base ?

]]> Le cas de base est ce qui garantit la terminaison de la
récursion. Sans lui, on a une boucle infinie qui empile des
appels jusqu'à dépassement de la pile.

]]> 1.0 0.0 0 true true abc Elle renvoie systématiquement None

]]> Erreur : None est la valeur renvoyée par défaut quand une
fonction n'a pas d'instruction return. Ici, le problème
est la non-terminaison, pas la valeur de retour.

]]> Elle renvoie $0$

]]> Erreur : aucune valeur de retour spéciale n'est associée à
l'absence de cas de base.

]]> Elle s'exécute infiniment et finit par lever une erreur RecursionError

]]> Bonne réponse : Python limite la profondeur de la pile
d'appels (par défaut autour de $1000$). Sans cas de base,
la fonction s'auto-appelle indéfiniment et provoque cette
erreur.

]]> Le compilateur la rejette avant exécution

]]> Erreur : Python n'analyse pas la sémantique de la fonction
avant de l'exécuter. Sans cas de base, l'erreur survient à
l'exécution, pas à la compilation.

]]> Récursivité — Q03 : Rôle de la pile d'appels Quand une fonction f s'appelle récursivement, que stocke la
pile d'appels pendant l'exécution ?

]]> C'est la limite physique de la pile (typiquement quelques
milliers d'appels) qui rend les récursions très profondes
problématiques en Python : un parcours linéaire d'une liste de
$10\ 000$ éléments par récursion plante avec
RecursionError.

]]> 1.0 0.0 0 true true abc Une copie complète de la mémoire à chaque appel

]]> Erreur : ce serait inefficace et inutile. Seules les
informations propres à l'appel courant sont empilées.

]]> Le contexte de chaque appel : paramètres, variables locales et point de retour

]]> Bonne réponse : à chaque appel, Python empile un cadre
d'exécution contenant les paramètres, les variables locales
et l'instruction où reprendre une fois l'appel terminé. Au
retour, ce cadre est dépilé.

]]> Uniquement la valeur de retour de chaque appel

]]> Erreur : la valeur de retour n'est connue qu'à la fin de
chaque appel. La pile sert justement à conserver l'état
pendant que les appels imbriqués se déroulent.

]]> Le code source de la fonction, dupliqué à chaque appel

]]> Erreur : le code source de la fonction n'est stocké qu'une
seule fois. La pile contient seulement le contexte
d'exécution de chaque appel.

]]> Récursivité — Q04 : Évaluation d'une récurrence simple On considère la fonction Python suivante :

def f(n):
    if n == 0:
        return 1
    return 2 * f(n - 1)

Que renvoie l'appel f(4) ?

]]> Cette fonction calcule $2^n$. La récurrence $f(n) = 2 \cdot f(n-1)$
avec $f(0) = 1$ donne immédiatement $f(n) = 2^n$.

]]> 1.0 0.0 0 true true abc $32$

]]> Erreur : c'est $f(5) = 2^5$. Une multiplication en trop.

]]> $16$

]]> Bonne réponse : $f(4) = 2 \cdot f(3) = 2 \cdot 2 \cdot f(2) = \ldots = 2^4 \cdot f(0) = 2^4 = 16$.

]]> $4$

]]> Erreur : confusion entre l'argument $n$ et la valeur de
retour. Ici $f(4) = 2^4$, pas $4$.

]]> $8$

]]> Erreur : c'est $f(3) = 2^3$. Le calcul de $f(4)$ ajoute une
multiplication par $2$.

]]> Récursivité — Q05 : Identifier le cas de base de la factorielle On définit factorielle ainsi :

def factorielle(n):
    if n <= 1:
        return 1
    return n * factorielle(n - 1)

Quel est le rôle de la condition if n <= 1: return 1 ?

]]> Sans ce cas de base, la fonction continuerait à décrémenter $n$
indéfiniment, en passant par $0, -1, -2, \ldots$, et
provoquerait une RecursionError. Le cas de base est l'élément
central de toute récursion bien définie.

]]> 1.0 0.0 0 true true abc Elle assure que n reste positif pendant l'exécution

]]> Erreur : la condition n'a pas d'effet sur les autres appels.
Son rôle est d'arrêter la récursion quand $n$ atteint $1$.

]]> Elle initialise une variable de comptage

]]> Erreur : aucune variable n'est initialisée. C'est une
condition de fin qui interrompt la récursion.

]]> C'est le cas de base, qui arrête la récursion sans nouvel appel

]]> Bonne réponse : c'est le cas de base. Pour $n \leq 1$, la
fonction renvoie $1$ directement, sans appel récursif. C'est
ce qui garantit la terminaison.

]]> Elle gère uniquement les cas d'erreur quand n est négatif

]]> Erreur : la condition couvre $n \leq 1$ (donc aussi $n = 0$
et $n = 1$), pas seulement les cas négatifs. Elle joue un
rôle algorithmique, pas seulement défensif.

]]> Récursivité — Q06 : Identifier le cas de base de l'algorithme d'Euclide Dans la fonction suivante, qui calcule le PGCD de deux entiers,
quel est le cas de base ?

def pgcd(a, b):
    if b == 0:
        return a
    return pgcd(b, a % b)
]]> L'algorithme d'Euclide repose sur la propriété
$\text{PGCD}(a, b) = \text{PGCD}(b, a \mod b)$, avec le cas de
base $\text{PGCD}(a, 0) = a$. À chaque appel, $b$ diminue
strictement (puisque $a \mod b < b$), garantissant la
terminaison.

]]> 1.0 0.0 0 true true abc a == 0

]]> Erreur : la condition d'arrêt teste b, pas a.
L'algorithme d'Euclide réduit progressivement b vers $0$.

]]> b == 0

]]> Bonne réponse : quand b vaut $0$, la fonction renvoie a
directement, sans nouvel appel. C'est le cas de base.

]]> a == b

]]> Erreur : ce cas n'est pas géré explicitement. Dans cet
algorithme, l'égalité a == b mène à pgcd(b, 0) au prochain
appel, qui déclenche le vrai cas de base.

]]> a % b == 0

]]> Erreur : ce n'est pas la condition utilisée. Si a % b == 0,
l'appel récursif suivant sera pgcd(b, 0), qui déclenchera
le vrai cas de base à l'appel suivant.

]]> Récursivité — Q07 : Récursivité simple ou récursivité double Une fonction qui contient deux appels récursifs sur des
sous-problèmes différents est dite :

]]> La distinction simple/double est importante pour la complexité :
une récursivité simple a typiquement une complexité linéaire,
tandis qu'une récursivité double naïve a une complexité
exponentielle (cas de Fibonacci sans mémoïsation).

]]> 1.0 0.0 0 true true abc Une récursivité double (ou multiple)

]]> Bonne réponse : c'est typique du parcours d'arbres binaires
(un appel pour le sous-arbre gauche, un pour le droit), de
Fibonacci ($f(n-1) + f(n-2)$) ou de la stratégie « diviser
pour régner ».

]]> Une récursivité terminale

]]> Erreur : la récursivité terminale désigne un cas où l'appel
récursif est la dernière opération de la fonction
(optimisable par certains compilateurs).

]]> Une récursivité simple

]]> Erreur : on parle de récursivité simple quand la fonction ne
contient qu'un seul appel récursif (par exemple
factorielle).

]]> Une récursivité croisée

]]> Erreur : la récursivité croisée concerne deux fonctions qui
s'appellent mutuellement (par exemple pair(n) et
impair(n)), pas deux appels d'une même fonction.

]]> Récursivité — Q08 : Garantir la terminaison Quelle propriété l'argument d'un appel récursif doit-il vérifier
pour garantir que la fonction termine ?

]]> En toute rigueur, on associe à chaque appel un entier appelé
« variant », strictement décroissant et minoré par $0$. Pour
factorielle(n), le variant est $n$. Pour une fonction sur
L[1:], c'est len(L).

]]> 1.0 0.0 0 true true abc Il doit être un entier

]]> Erreur : ce n'est pas une condition. Les arguments peuvent
être des chaînes, des listes, des arbres, etc. Ce qui compte,
c'est qu'ils diminuent en « taille » à chaque appel.

]]> Il doit augmenter strictement à chaque appel

]]> Erreur : si l'argument augmente, on s'éloigne du cas de
base au lieu de s'en rapprocher. La fonction ne termine
jamais.

]]> Il doit rester constant tant que le cas de base n'est pas atteint

]]> Erreur : si l'argument reste constant, la fonction se rappelle
avec les mêmes valeurs et ne termine jamais.

]]> Il doit décroître strictement à chaque appel, vers le cas de base

]]> Bonne réponse : pour qu'une fonction récursive termine, il
faut que la suite des arguments des appels successifs
atteigne le cas de base en un nombre fini d'étapes. La
décroissance stricte d'une quantité positive (la « variant »)
assure cette terminaison.

]]> Récursivité — Q09 : Lecture d'une récursion sur les chaînes Dans la fonction suivante, quel est le cas de base ?

def compte(chaine):
    if chaine == "":
        return 0
    return 1 + compte(chaine[1:])
]]> Cette fonction calcule en réalité la longueur de la chaîne. Le
cas de base est la chaîne vide (longueur $0$) ; chaque appel
récursif retire le premier caractère et ajoute $1$.

]]> 1.0 0.0 0 true true abc chaine == ""

]]> Bonne réponse : quand la chaîne est vide, la fonction renvoie
$0$ sans nouvel appel. C'est le cas de base, qui arrête la
récursion.

]]> 1 + compte(chaine[1:])

]]> Erreur : c'est l'instruction de l'appel récursif. Le cas de
base est la branche qui ne fait pas d'appel.

]]> La fonction n'a pas de cas de base

]]> Erreur : la branche if chaine == "": return 0 arrête bien
la récursion sans nouvel appel.

]]> chaine[1:]

]]> Erreur : chaine[1:] est l'argument de l'appel récursif, pas
le cas de base. Le cas de base est ce qui arrête la
récursion.

]]> Récursivité — Q10 : Récursivité et définition par récurrence Quelle suite mathématique peut être implémentée le plus
naturellement par une fonction récursive simple (un seul appel
récursif par cas) ?

]]> La récursion simple correspond aux suites du premier ordre
($u_n$ dépend uniquement de $u_{n-1}$). Une récurrence d'ordre
$2$ (Fibonacci) demande une récursion double, plus coûteuse en
temps si on n'utilise pas de mémoïsation.

]]> 1.0 0.0 0 true true abc Une suite quelconque, tirée au hasard

]]> Erreur : il faut une définition claire (cas initial et
relation de récurrence) pour pouvoir écrire une fonction
récursive.

]]> Une suite définie par $u_n = f(u_{n-1}, u_{n-2})$

]]> Erreur : cette définition demande deux valeurs
précédentes, donc deux appels récursifs (récursivité double).
La suite de Fibonacci en est l'exemple classique.

]]> Une suite définie par $u_0$ et $u_{n} = f(u_{n-1})$

]]> Bonne réponse : on a un cas de base ($u_0$) et un appel
récursif (calcul de $u_n$ à partir de $u_{n-1}$). La
structure correspond exactement à une récursion simple.

]]> Une suite définie uniquement par sa valeur initiale

]]> Erreur : sans relation de récurrence, il n'y a pas d'appel
récursif à faire. Une seule valeur ne nécessite pas de
fonction récursive.

]]> Récursivité — Q11 : Déroulement d'une somme récursive On considère :

def somme(L):
    if L == []:
        return 0
    return L[0] + somme(L[1:])

Que renvoie somme([3, 5, 2]) ?

]]> Cette fonction est l'archétype du parcours récursif d'une liste :
cas de base sur la liste vide ($0$), et appel récursif sur le
reste de la liste après extraction du premier élément.

]]> 1.0 0.0 0 true true abc $5$

]]> Erreur : c'est l'élément du milieu de la liste, mais la
fonction additionne tous les éléments.

]]> $30$

]]> Erreur : confusion possible avec un produit ou un calcul
erroné. La fonction additionne les éléments, elle ne les
multiplie pas.

]]> $0$

]]> Erreur : c'est la valeur renvoyée pour la liste vide, qui
intervient au plus profond de la pile, mais qui est ensuite
additionnée aux éléments dépilés.

]]> $10$

]]> Bonne réponse : $3 + 5 + 2 = 10$. En déroulant :
$3 + \text{somme}([5,2]) = 3 + (5 + \text{somme}([2])) = 3 + (5 + (2 + 0)) = 10$.

]]> Récursivité — Q12 : Compter les chiffres d'un entier On considère :

def nb_chiffres(n):
    if n < 10:
        return 1
    return 1 + nb_chiffres(n // 10)

Que renvoie nb_chiffres(4073) ?

]]> La division entière par $10$ retire le dernier chiffre. Le cas
de base $n < 10$ correspond à un nombre à un seul chiffre
(longueur $1$). Cette technique est très utile pour parcourir un
entier chiffre par chiffre sans le convertir en chaîne.

]]> 1.0 0.0 0 true true abc $3$

]]> Erreur : oubli d'un chiffre. L'entier $4073$ comporte $4$
chiffres : $4, 0, 7, 3$.

]]> $4$

]]> Bonne réponse : on déroule $1 + \text{nb\_chiffres}(407) = 1 + 1 + \text{nb\_chiffres}(40) = 1 + 1 + 1 + \text{nb\_chiffres}(4) = 1 + 1 + 1 + 1 = 4$.

]]> $10$

]]> Erreur : confusion possible avec la base $10$ utilisée pour
extraire les chiffres. La fonction compte le nombre de
divisions par $10$ nécessaires pour atteindre un nombre à un
chiffre.

]]> $5$

]]> Erreur : un chiffre en trop. Quand $n < 10$, la fonction
renvoie $1$ et n'effectue pas d'appel supplémentaire.

]]> Récursivité — Q13 : Compléter une fonction récursive Pour que la fonction suivante renvoie le nombre d'occurrences
d'un caractère c dans une chaîne s, par quoi faut-il
remplacer les pointillés ?

def occurrences(s, c):
    if s == "":
        return ...
    if s[0] == c:
        return 1 + occurrences(s[1:], c)
    return occurrences(s[1:], c)
]]> Le cas de base d'un comptage récursif est presque toujours $0$
(aucun élément trouvé dans la structure vide). La récursion
ajoute ensuite $1$ chaque fois qu'on rencontre un élément
cherché.

]]> 1.0 0.0 0 true true abc $0$

]]> Bonne réponse : une chaîne vide contient zéro occurrence de
n'importe quel caractère. C'est la valeur neutre pour la
somme finale.

]]> None

]]> Erreur : None ne pourrait pas s'additionner avec $1$ dans
la branche récursive, et la fonction est censée renvoyer un
comptage.

]]> $1$

]]> Erreur : une chaîne vide ne contient aucune occurrence d'un
caractère, le cas de base doit donc renvoyer $0$.

]]> c

]]> Erreur : la fonction est censée renvoyer un entier (un
comptage), pas un caractère.

]]> Récursivité — Q14 : Maximum d'une liste sans `max` On souhaite écrire récursivement le maximum d'une liste non vide.
Quel est le cas de base approprié ?

def maximum(L):
    if ...:
        return L[0]
    ...
]]> Une fois le cas de base posé (len(L) == 1), l'appel récursif
compare le premier élément au maximum du reste de la liste :
m = maximum(L[1:]) puis renvoie L[0] if L[0] > m else m.

]]> 1.0 0.0 0 true true abc L[0] > L[-1]

]]> Erreur : c'est une comparaison entre deux éléments, pas un
critère d'arrêt sur la taille de la liste.

]]> L == []

]]> Erreur : sur une liste vide, L[0] provoquerait une erreur
(IndexError). Le cas de base doit garantir que L[0]
existe.

]]> len(L) == 2

]]> Erreur : on n'a alors pas couvert le cas $\text{len}(L) = 1$,
qui peut survenir comme appel récursif terminal. La fonction
ne terminerait pas correctement.

]]> len(L) == 1

]]> Bonne réponse : le maximum d'une liste à un seul élément est
cet élément lui-même. C'est le cas de base le plus naturel
pour cette fonction.

]]> Récursivité — Q15 : Inversion récursive d'une liste Quelle expression complète correctement la fonction miroir
ci-dessous, qui doit renvoyer la liste inversée ?

def miroir(L):
    if L == []:
        return []
    return ...
]]> L'idée centrale : pour inverser une liste, on inverse la queue
et on y accole la tête. Cette construction est élégante mais
coûteuse en mémoire (à chaque appel, on crée une nouvelle liste
avec +).

]]> 1.0 0.0 0 true true abc miroir(L[1:]) + [L[0]]

]]> Bonne réponse : on inverse récursivement le reste de la
liste, puis on place L[0] à la fin. Exemple :
$[1, 2, 3] \to \text{miroir}([2, 3]) + [1] = [3, 2] + [1] = [3, 2, 1]$.

]]> miroir(L[0]) + miroir(L[1:])

]]> Erreur : L[0] est un élément simple, pas une liste : on ne
peut pas l'inverser récursivement.

]]> miroir(L)[1:]

]]> Erreur : cette définition est circulaire (la fonction
s'appelle sur la même valeur), donc ne termine jamais.

]]> [L[0]] + miroir(L[1:])

]]> Erreur : cette construction renverrait la liste inchangée.
Pour l'inverser, l'élément L[0] doit aller à la fin, pas au
début.

]]> Récursivité — Q16 : Croissance d'une population Un biologiste modélise une population de bactéries qui double
chaque heure, en partant d'une seule bactérie. Si la fonction
récursive est :

def population(n):
    if n == 0:
        return 1
    return 2 * population(n - 1)

Combien de bactéries y a-t-il après $10$ heures ?

]]> Cet exemple illustre la croissance exponentielle : la population
double à chaque pas. Après $20$ heures, on aurait
$2^{20} \approx 10^6$ bactéries ; après $30$ heures, plus d'un
milliard.

]]> 1.0 0.0 0 true true abc $100$

]]> Erreur : la croissance n'est pas géométrique de raison $10$.
Chaque heure, la population est multipliée par $2$, pas par
$10$.

]]> $1024$

]]> Bonne réponse : $\text{population}(10) = 2^{10} = 1024$. Une
fois la fonction reconnue comme calculant $2^n$, on applique
la formule directement.

]]> $20$

]]> Erreur : confusion avec une croissance linéaire ($2 \cdot n$).
Or la population double, donc on a une croissance
exponentielle.

]]> $2048$

]]> Erreur : c'est $2^{11}$, soit population après $11$ heures,
pas $10$.

]]> Récursivité — Q17 : Récursivité sur un arbre binaire On parcourt un arbre binaire avec la fonction :

def cherche(elt, arbre):
    if arbre is None:
        return False
    if arbre.valeur == elt:
        return True
    return cherche(elt, arbre.gauche) or cherche(elt, arbre.droite)

Combien d'appels récursifs cette fonction génère-t-elle au
maximum dans une seule exécution ?

]]> Le or court-circuite l'appel droit dès que l'appel gauche
renvoie True, donc dans la pratique on n'explore pas toujours
les deux sous-arbres. Mais dans le pire cas (élément absent ou
présent uniquement à droite), les deux appels sont effectués.

]]> 1.0 0.0 0 true true abc Aucun, c'est une fonction itérative déguisée

]]> Erreur : la fonction contient bien deux appels récursifs
(cherche(elt, arbre.gauche) et
cherche(elt, arbre.droite)). Elle n'est pas itérative.

]]> Deux, un sur chaque sous-arbre

]]> Bonne réponse : c'est de la récursivité double. Chaque appel
peut générer deux nouveaux appels (gauche et droit), ce qui
explore exhaustivement l'arbre dans le pire cas.

]]> Autant que d'éléments dans la liste représentant l'arbre

]]> Erreur : la fonction n'est pas écrite sur une liste mais sur
une structure d'arbre. Chaque appel travaille sur un sous-arbre.

]]> Un seul, sur le sous-arbre gauche

]]> Erreur : si l'élément n'est pas dans le sous-arbre gauche,
on explore aussi le sous-arbre droit. Cela fait potentiellement
deux appels par nœud.

]]> Récursivité — Q18 : Limite pratique de la récursion en Python Pour quelle raison principale Python lève-t-il une
RecursionError lors d'une récursion trop profonde, même si la
fonction comporte un cas de base correct ?

]]> Cette limite est une protection : sans elle, une fonction
récursive mal conçue saturerait la mémoire de la pile et ferait
planter le système. Elle implique que certains algorithmes
fonctionnant sur de grandes structures (parcours d'une liste de
plusieurs milliers d'éléments) doivent être écrits de manière
itérative en Python.

]]> 1.0 0.0 0 true true abc La pile d'appels du programme a une taille limite (par défaut autour de $1000$)

]]> Bonne réponse : Python fixe par défaut une profondeur
maximale de récursion d'environ $1000$ pour éviter qu'une
erreur de programmation ne consomme toute la mémoire de la
pile. On peut augmenter cette limite avec
sys.setrecursionlimit(), mais ce n'est pas une bonne
pratique.

]]> Le cas de base met trop de temps à s'évaluer

]]> Erreur : le temps d'évaluation d'une condition est
négligeable. Le problème est la mémoire consommée par la
pile d'appels.

]]> La fonction utilise trop de variables locales

]]> Erreur : ce n'est pas le nombre de variables locales qui
compte, mais le nombre d'appels imbriqués.

]]> Python ne sait pas gérer la récursivité

]]> Erreur : Python gère parfaitement la récursivité, mais avec
une limite pratique sur la profondeur de la pile.

]]> Récursivité — Q19 : Complexité de Fibonacci récursif naïf Quelle est la complexité en temps de la fonction suivante,
appelée pour calculer fibonacci(n) ?

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
]]> fibonacci(35) génère plusieurs milliards d'appels avec cette
version naïve. C'est un cas typique où la mémoïsation (stocker
les résultats déjà calculés dans un dictionnaire) ramène la
complexité à $O(n)$.

]]> 1.0 0.0 0 true true abc $O(n^2)$

]]> Erreur : la complexité n'est pas polynomiale mais
exponentielle. L'arbre d'appels double de taille à chaque
niveau.

]]> $O(n)$

]]> Erreur : c'est la complexité de la version itérative ou
mémoïsée. La version naïve recalcule plusieurs fois les
mêmes valeurs.

]]> $O(\log n)$

]]> Erreur : aucune division n'est effectuée sur $n$ ; on le
décrémente seulement de $1$ ou $2$. La complexité ne peut
donc pas être logarithmique.

]]> $O(2^n)$

]]> Bonne réponse : chaque appel génère deux appels imbriqués,
créant un arbre binaire de profondeur $n$. Le nombre d'appels
croît comme $2^n$ (plus précisément $\varphi^n$ avec
$\varphi$ le nombre d'or).

]]> Récursivité — Q20 : Principe de la mémoïsation Qu'est-ce que la mémoïsation d'une fonction récursive ?

]]> Pour Fibonacci, la mémoïsation transforme une complexité
$O(2^n)$ en $O(n)$. Python propose un décorateur
@functools.lru_cache qui implémente automatiquement la
mémoïsation sur n'importe quelle fonction.

]]> 1.0 0.0 0 true true abc Le stockage en cache des résultats déjà calculés, pour les réutiliser sans les recalculer

]]> Bonne réponse : on conserve dans un dictionnaire (ou un
tableau) les résultats déjà obtenus. Avant chaque calcul, on
vérifie si le résultat est déjà connu ; si oui, on le
renvoie directement.

]]> Une technique pour réduire la profondeur de la pile d'appels

]]> Erreur : la mémoïsation n'agit pas sur la profondeur de la
pile mais sur le nombre d'appels effectifs : elle évite
de recalculer ce qui a déjà été calculé.

]]> La conversion automatique d'une fonction récursive en boucle

]]> Erreur : ce serait la dérécursivation. La mémoïsation ne
modifie pas la structure de la fonction, elle ajoute un
cache.

]]> La compression des appels récursifs en un seul

]]> Erreur : aucune fusion d'appels n'a lieu. La mémoïsation
conserve la même structure d'appels, mais évite les
redondances.

]]> Récursivité — Q21 : Tours de Hanoï avec deux disques Pour résoudre le problème des tours de Hanoï avec $2$ disques
(déplacer la pile de A vers C en utilisant B), combien de
déplacements minimum sont nécessaires ?

]]> Le nombre de déplacements pour $n$ disques est
$T(n) = 2^n - 1$, donné par la récurrence
$T(n) = 2 \cdot T(n-1) + 1$ avec $T(1) = 1$. Pour $n = 64$
(légende des moines de Hanoï), il faudrait plus de
$1{,}8 \times 10^{19}$ déplacements.

]]> 1.0 0.0 0 true true abc $3$

]]> Bonne réponse : (1) petit de A vers B, (2) grand de A vers C,
(3) petit de B vers C. Cela correspond à $T(2) = 2^2 - 1 = 3$.

]]> $2$

]]> Erreur : il faut d'abord déplacer le petit disque sur l'étape
intermédiaire B, puis le grand disque vers C, puis ramener le
petit sur le grand. Cela fait $3$ déplacements, pas $2$.

]]> $4$

]]> Erreur : un déplacement en trop. Avec $2$ disques, $3$
déplacements suffisent.

]]> $7$

]]> Erreur : c'est $T(3) = 2^3 - 1$, soit le nombre de
déplacements pour $3$ disques, pas $2$.

]]> Récursivité — Q22 : Récurrence des tours de Hanoï Quelle relation de récurrence vérifie $T(n)$, le nombre de
déplacements minimum pour résoudre les tours de Hanoï avec $n$
disques ?

]]> Cette récurrence se résout en $T(n) = 2^n - 1$. La récursivité
est ici double (deux appels à $T(n-1)$), ce qui explique la
croissance exponentielle.

]]> 1.0 0.0 0 true true abc $T(n) = 2 \cdot T(n-1) + 1$

]]> Bonne réponse : pour déplacer $n$ disques, on déplace les
$n-1$ disques du dessus vers la tour auxiliaire ($T(n-1)$
déplacements), puis le grand disque vers la destination ($1$
déplacement), puis on ramène les $n-1$ disques sur la
destination ($T(n-1)$ déplacements). D'où $T(n) = 2T(n-1) + 1$.

]]> $T(n) = T(n-1) + T(n-2)$

]]> Erreur : c'est la récurrence de Fibonacci, sans rapport avec
les tours de Hanoï. Il n'y a pas de raison de combiner deux
tailles différentes ici.

]]> $T(n) = T(n-1) + 1$

]]> Erreur : cette récurrence donne $T(n) = n$ (croissance
linéaire), ce qui est faux. La résolution exige un nombre
exponentiel de déplacements.

]]> $T(n) = n!$

]]> Erreur : ce serait la factorielle, qui croît plus vite que
$2^n$. Pour Hanoï, la croissance est exponentielle de base
$2$, pas factorielle.

]]> Récursivité — Q23 : Choisir entre récursif et itératif Pour calculer la somme des $n$ premiers entiers, on peut écrire
une boucle ou une fonction récursive. Pour $n = 10\ 000$ en
Python, quelle version est préférable ?

]]> En Python, la récursivité est élégante mais coûteuse :
privilégier l'itératif quand le problème ne se prête pas
naturellement à la récursion. La récursion brille pour les
structures naturellement récursives (arbres, listes
hiérarchiques, fractales) ou pour les algorithmes diviser-pour-
régner.

]]> 1.0 0.0 0 true true abc La version récursive, plus rapide grâce à la pile d'appels

]]> Erreur : à compter d'une certaine profondeur, la pile
d'appels devient un handicap (consommation mémoire,
RecursionError). La récursion n'est pas plus rapide qu'une
boucle.

]]> Aucune des deux, il faut absolument utiliser une formule fermée

]]> Erreur : la formule $\frac{n(n+1)}{2}$ existe et est en effet
la solution la plus efficace, mais cela ne disqualifie pas
la boucle. La récursion, elle, pose un vrai problème de pile.

]]> La version itérative, qui évite le débordement de pile et reste très efficace

]]> Bonne réponse : pour $n = 10\ 000$, la version récursive
dépasserait la limite par défaut de la pile Python ($\sim
1000$ appels). Une boucle for est plus sûre, plus rapide,
et tout aussi lisible pour ce calcul.

]]> Les deux versions sont strictement équivalentes en performance

]]> Erreur : la version récursive est plus lente (chaque appel
coûte plus qu'une itération) et risque de planter par
débordement de pile.

]]> Récursivité — Q24 : Analyse d'une récursion mystère On considère :

def f(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    return f(n - 1) + f(n - 2) + 1

Combien d'appels récursifs au total sont effectués pour
calculer f(4) (en comptant l'appel initial) ?

]]> Cette fonction calcule $f(n) = F_{n+1} - 1$, où $F_n$ est la
suite de Fibonacci. Plus important pédagogiquement : elle
montre comment la récursivité double engendre une explosion du
nombre d'appels : c'est ce que la mémoïsation vient résoudre.

]]> 1.0 0.0 0 true true abc $4$

]]> Erreur : on confond avec l'argument. Il faut compter chaque
appel à f qui apparaît dans l'arbre d'appels, pas la
valeur de $n$.

]]> $9$

]]> Bonne réponse : f(4) appelle f(3) et f(2). f(3)
appelle f(2) et f(1). f(2) appelle f(1) et f(0).
En tout : $f(4)$, $f(3)$, $f(2)$, $f(1)$, $f(0)$, $f(2)$,
$f(1)$, $f(1)$, $f(0)$ = $9$ appels.

]]> $16$

]]> Erreur : $16 = 2^4$ surestime largement le nombre d'appels.
L'arbre n'est pas équilibré jusqu'à la profondeur $n$.

]]> $5$

]]> Erreur : on a oublié les appels redondants. Comme dans
Fibonacci naïf, certains arguments sont recalculés plusieurs
fois.

]]> Récursivité — Q25 : Effet de la mémoïsation On mémoïse la fonction Fibonacci avec un dictionnaire de cache.
Combien d'appels effectifs (calculs réels, avant cache) sont
effectués pour fibonacci(20) après mémoïsation ?

]]> La mémoïsation transforme une complexité exponentielle en
complexité linéaire, au prix d'un espace mémoire supplémentaire
également linéaire (le dictionnaire de cache). C'est l'un des
exemples les plus marquants du compromis temps/espace en
algorithmique.

]]> 1.0 0.0 0 true true abc Le même nombre qu'avant mémoïsation

]]> Erreur : la mémoïsation change précisément le nombre d'appels
réels en évitant les recalculs. Ce nombre passe d'$O(2^n)$ à
$O(n)$.

]]> Exactement $1$

]]> Erreur : le cache n'élimine pas la nécessité de calculer
chaque valeur au moins une fois. Pour
$\text{fibonacci}(20)$, il faut bien évaluer
$\text{fibonacci}(0), \text{fibonacci}(1), \ldots, \text{fibonacci}(20)$
au moins une fois chacun.

]]> Environ $20$

]]> Bonne réponse : avec mémoïsation, chaque valeur
$\text{fibonacci}(k)$ pour $k$ allant de $0$ à $20$ n'est
calculée qu'une seule fois. Les appels suivants sur la même
valeur sont satisfaits par le cache.

]]> Environ $2^{20}$ (un million)

]]> Erreur : c'est l'ordre de grandeur sans mémoïsation. Tout
l'intérêt du cache est précisément de réduire ce nombre à
quelque chose de bien plus petit.

]]> Récursivité — Q26 : Récursivité terminale Une fonction récursive est dite terminale quand son
appel récursif est la dernière opération effectuée
dans la fonction. Parmi les fonctions suivantes,
laquelle est récursive terminale ?

]]> Pourquoi cette propriété est-elle importante ? Une fonction
récursive terminale peut, en principe, être convertie en
boucle sans utiliser de pile : on parle d'élimination
de la récursivité terminale. Certains compilateurs
le font automatiquement (Scheme par exemple), mais pas
Python, qui conserve toujours la pile d'appels.

]]> 1.0 0.0 0 true true abc def f(n): if n <= 1: return n return f(n - 1) + f(n - 2)]]> Erreur : la fonction effectue une addition après les
deux appels récursifs. De plus, comme il y a deux
appels distincts, cette fonction est doublement
récursive et ne peut pas être terminale.

]]> def f(n): if n == 0: return None print(n) return f(n - 1) + 1]]> Erreur : après l'appel récursif f(n - 1), on
ajoute 1. L'opération en attente après le retour
de l'appel empêche cette fonction d'être récursive
terminale.

]]> def f(n): if n == 0: return 1 return n * f(n - 1)]]> Erreur : après l'appel récursif f(n - 1), on
effectue encore une multiplication par n. L'appel
récursif n'est donc pas la toute dernière opération,
ce qui empêche cette fonction d'être récursive
terminale.

]]> def f(n, acc): if n == 0: return acc return f(n - 1, n * acc)]]> Bonne réponse : l'appel récursif f(n - 1, n * acc)
est la dernière opération de la fonction (la
multiplication par n est faite avant l'appel,
dans le calcul du paramètre). Aucune opération n'est
en attente après l'appel. Cette forme se transforme
mécaniquement en boucle.

]]> Récursivité — Q27 : Convertir une récursion en itération On veut transformer la fonction factorielle récursive
simple en une version itérative équivalente. Quel code
effectue cette conversion correctement ?

]]> Schéma général de la dérécursivation d'une récursion
simple : un accumulateur initialisé à l'élément neutre,
une boucle qui parcourt les arguments des appels
récursifs successifs, et une mise à jour à chaque
itération. Pour la récursivité double (Fibonacci), on
conserve souvent les deux dernières valeurs dans deux
variables.

]]> 1.0 0.0 0 true true abc def factorielle(n): if n == 0: return 1 return n * factorielle(n - 1)]]> Erreur : c'est précisément la version récursive.
La question demandait une version itérative, sans
appel à la fonction elle-même.

]]> def factorielle(n): return n ** n]]> Erreur grossière : $n^n$ n'est pas la factorielle de
$n$. Pour $n = 4$, on aurait $256$ au lieu de $24$.
La factorielle est définie par $n \cdot (n-1) \cdot
\ldots \cdot 1$.

]]> def factorielle(n): produit = 1 for i in range(1, n + 1): produit = produit * i return produit]]> Bonne réponse : on remplace les appels récursifs par
une boucle for qui multiplie successivement par
$1, 2, \ldots, n$. La complexité est la même
($O(n)$), mais on évite la pile d'appels et le risque
de RecursionError sur des grandes valeurs de n.

]]> def factorielle(n): produit = 0 for i in range(1, n + 1): produit = produit * i return produit]]> Erreur : l'élément neutre de la multiplication est
$1$, pas $0$. Avec produit = 0, le résultat reste
toujours $0$ quel que soit n. Bug classique
d'initialisation.

]]> Récursivité — Q28 : Récursivité croisée On définit deux fonctions qui s'appellent mutuellement :
def pair(n):
    if n == 0:
        return True
    return impair(n - 1)

def impair(n):
    if n == 0:
        return False
    return pair(n - 1)

Comment qualifier cette construction et que renvoie
pair(7) ?

]]> La récursivité croisée se prête à des problèmes où
plusieurs cas se répondent (analyseurs syntaxiques,
automates à plusieurs états, alternances). En pratique,
on peut souvent la réduire à une récursivité simple
avec un paramètre supplémentaire (ici, on pourrait
écrire parite(n, est_pair) qui alterne).

]]> 1.0 0.0 0 true true abc C'est de la récursivité croisée (ou mutuelle) :
deux fonctions s'appellent l'une l'autre, formant
ensemble un schéma récursif. pair(7) renvoie False

]]> Bonne réponse : la récursivité croisée est un
schéma où plusieurs fonctions se définissent
mutuellement. Ici, en décrémentant n à chaque
appel et en alternant pair/impair, on aboutit à
pair(0) = True ou impair(0) = False selon la
parité de n. Pour n = 7, on alterne sept fois
et on arrive à impair(0), donc le résultat est
False.

]]> Cette construction est invalide en Python ; le
programme plante immédiatement

]]> Erreur : Python autorise parfaitement deux fonctions
à s'appeler mutuellement, à condition qu'elles soient
toutes les deux définies au moment où on les appelle.
Aucune erreur n'est levée à la définition.

]]> C'est une récursivité terminale, et pair(7)
renvoie True

]]> Erreur de qualification et de résultat : la
récursivité terminale désigne le fait que l'appel
récursif soit la dernière opération de la fonction
(ce qui est vrai ici, mais pas la caractéristique
principale). La caractéristique dominante est qu'il
y a deux fonctions s'appelant mutuellement. Et
pair(7) renvoie False.

]]> C'est une simple récursivité double, et pair(7)
renvoie True

]]> Erreur : la récursivité double désigne deux appels
d'une même fonction, comme dans Fibonacci. Ici, on
a deux fonctions distinctes qui s'appellent
mutuellement, ce qui s'appelle récursivité
croisée. De plus, $7$ est impair, donc
pair(7) renvoie False, pas True.

]]> Récursivité — Q29 : Récursivité avec accumulateur Voici deux écritures de la fonction qui calcule
la somme des entiers de $1$ à $n$ :

# Version A
def somme_a(n):
    if n == 0:
        return 0
    return n + somme_a(n - 1)

# Version B
def somme_b(n, acc=0):
    if n == 0:
        return acc
    return somme_b(n - 1, acc + n)

Quelle est la différence essentielle entre
les deux versions ?

]]> Le motif accumulateur est très utilisé en
programmation fonctionnelle. Il consiste à
transporter le résultat partiel comme
paramètre, ce qui évite de laisser des
opérations en attente. Python ne fait
aucune optimisation de récursivité
terminale (volonté de Guido van Rossum
pour préserver la lisibilité des traces
d'erreur), mais l'écriture reste utile
pédagogiquement et pour porter du code
vers d'autres langages.

]]> 1.0 0.0 0 true true abc La version B utilise plus de mémoire

]]> Erreur : c'est précisément l'inverse en
principe. Avec une optimisation de
récursivité terminale, la version B
peut s'exécuter avec une pile de taille
constante. Sans cette optimisation (cas
de Python), les deux versions consomment
la pile de manière comparable.

]]> La version A est plus rapide à l'exécution

]]> Erreur : les deux versions ont la même
complexité asymptotique $O(n)$ en temps.
La différence porte sur la structure
des appels et la consommation de pile,
pas sur la rapidité.

]]> La version B donne un résultat différent
de la version A

]]> Erreur : les deux fonctions calculent
rigoureusement la même valeur,
$1 + 2 + \ldots + n = n(n+1)/2$. Vérifier
sur un exemple concret : pour $n = 3$,
les deux versions renvoient $6$.

]]> La version A laisse une opération en
attente après chaque appel récursif (le
n + ...), tandis que la version B passe
le résultat partiel par un accumulateur
et n'a aucune opération en attente. La
version B est dite récursive terminale

]]> Bonne réponse : dans la version A, après
le retour de somme_a(n - 1), il reste
encore une addition à effectuer. Tous les
contextes intermédiaires doivent donc
rester sur la pile d'appels. Dans la
version B, l'accumulateur transporte le
résultat partiel comme paramètre de
l'appel suivant, sans rien laisser en
attente. Certains compilateurs (Scheme,
Haskell, OCaml) optimisent
automatiquement la version B en boucle,
évitant le débordement de pile pour de
grandes valeurs de n.

]]> Récursivité — Q30 : Trace de la pile d'appels Lors de l'appel factorielle(4) (avec la
définition récursive standard), combien de
cadres d'exécution sont simultanément
empilés au moment où le cas de base est
atteint ?

]]> C'est précisément cette accumulation de
cadres qui provoque RecursionError pour
les récursions très profondes. La pile
d'appels par défaut en Python a une taille
d'environ $1\,000$ cadres
(paramétrable avec
sys.setrecursionlimit, mais déconseillé).
Pour des problèmes nécessitant une
profondeur supérieure, il faut soit
utiliser une version itérative, soit
transformer la récursion en récursivité
terminale puis en boucle.

]]> 1.0 0.0 0 true true abc $5$ cadres (pour factorielle(4), factorielle(3), factorielle(2), factorielle(1), factorielle(0))

]]> Bonne réponse : chaque appel récursif
empile un nouveau cadre avant que le
précédent ne se termine. Au moment où
factorielle(0) atteint le cas de base,
tous les cadres précédents sont encore
en attente, car ils ont laissé
l'opération n * factorielle(n - 1) à
finir. Les cadres se dépilent ensuite
en sens inverse, en multipliant à chaque
étape. Pour n = 1000, on aurait $1001$
cadres simultanés, ce qui dépasse la
limite par défaut de Python.

]]> $1$ cadre (Python optimise les appels récursifs)

]]> Erreur : Python ne fait pas d'optimisation
de récursivité terminale, contrairement à
d'autres langages. Et même si la version
était terminale, la fonction factorielle
standard ne l'est pas (il y a une
multiplication en attente après chaque
appel récursif).

]]> $4$ cadres

]]> Erreur : on oublie le cadre de
factorielle(0), le cas de base. Au
moment précis où il s'exécute, il est
bien sur la pile, en plus des cadres
des quatre appels précédents.

]]> $2$ cadres (le cadre courant et celui de la fonction qui a fait l'appel)

]]> Erreur : tous les cadres récursifs sont
empilés simultanément, pas seulement
deux. Chaque appel récursif est lui-même
une « fonction qui a fait un appel »,
ce qui empile un nouveau cadre.

]]> Récursivité — Q31 : Fonction d'Ackermann La fonction d'Ackermann est définie par :
A(0, n) = n + 1
A(m, 0) = A(m - 1, 1) si m > 0
A(m, n) = A(m - 1, A(m, n - 1)) si m > 0 et n > 0

Quelle est sa caractéristique remarquable ?

]]> Ackermann illustre la hiérarchie des
fonctions calculables : addition (rapide),
multiplication (=addition itérée),
exponentiation (=multiplication itérée),
tétration (=exponentiation itérée), et
ainsi de suite. Ackermann généralise ces
opérations à un niveau d'imbrication
arbitraire, ce qui la place hors d'atteinte
des récursions primitives.

]]> 1.0 0.0 0 true true abc Elle croît extrêmement vite : par exemple
$A(4, 2)$ est un nombre comportant des
milliers de chiffres. Elle est calculable
mais n'est pas primitive récursive,
c'est-à-dire qu'elle ne peut pas être
obtenue par les schémas de récurrence
simples (sans appels imbriqués)

]]> Bonne réponse : la fonction d'Ackermann
a une importance théorique majeure en
calculabilité. Elle illustre que la
récursivité générale est strictement
plus puissante que la récurrence
primitive (boucles bornées). Au niveau
pédagogique, elle est un excellent
exemple de récursivité doublement
imbriquée : l'argument du second appel
dépend lui-même d'un appel récursif.
Quelques valeurs : $A(0, 0) = 1$,
$A(1, 1) = 3$, $A(2, 2) = 7$,
$A(3, 3) = 61$, $A(4, 0) = 13$,
$A(4, 1) = 65\,533$.

]]> Elle a une complexité polynomiale

]]> Erreur : sa complexité dépasse toute
fonction polynomiale, exponentielle, ou
tour d'exponentielles. C'est précisément
ce qui la rend remarquable.

]]> Elle ne se calcule jamais (récursion
infinie)

]]> Erreur : la fonction d'Ackermann termine
toujours, c'est-à-dire qu'elle est
totale sur ses entiers naturels. Mais
le temps de calcul peut être
astronomique pour $m \geq 4$.

]]> Elle calcule simplement la somme $m + n$

]]> Erreur : la fonction d'Ackermann croît
beaucoup plus vite que l'addition, et
plus vite que la multiplication, et
plus vite que l'exponentiation, et plus
vite que toute itération finie de ces
opérations.

]]> Récursivité — Q32 : Fibonacci itératif vs récursif Pour calculer $\mathrm{fib}(50)$, le temps
d'exécution sur un PC moderne est :

]]> Cet exemple est l'argument le plus
pédagogique pour expliquer la mémoïsation.
Avec une mémoïsation simple, on retombe en
$O(n)$ tout en gardant la lisibilité de la
version récursive. C'est le compromis
qu'offre la programmation dynamique :
garder la clarté de la formulation
récursive, sans en payer le coût
exponentiel.

]]> 1.0 0.0 0 true true abc Les deux versions sont instantanées

]]> Erreur : seule la version itérative est
instantanée. La version récursive naïve
devient impraticable bien avant $n =
50$.

]]> Les deux versions plantent par
dépassement de pile

]]> Erreur : la version itérative ne
consomme pas la pile (juste deux
variables). La version récursive a une
profondeur d'appels de $n = 50$, ce qui
est largement sous la limite Python
($\sim 1\,000$). Le problème de la
version récursive est le temps, pas
la pile.

]]> Quelques millisecondes pour la version
itérative ; plusieurs dizaines de
minutes, voire plus, pour la version
récursive naïve

]]> Bonne réponse. La version itérative est
en $O(n)$ : pour $n = 50$, c'est environ
$50$ opérations, donc quelques
microsecondes. La version récursive
naïve est en $O(\varphi^n)$ avec
$\varphi \approx 1{,}618$ : pour $n =
50$, c'est environ
$\varphi^{50} \approx 2{,}9 \cdot
10^{10}$ appels. À environ $10^7$ appels
par seconde en Python, cela représente
environ $50$ minutes.

]]> Les deux versions sont équivalentes en
temps

]]> Erreur : la différence est colossale,
plusieurs ordres de grandeur. C'est
l'exemple classique pour motiver la
mémoïsation ou la version itérative.

]]>