Qu'est-ce que la récursivité en NSI ?

La récursivité est une technique de programmation où une fonction s'appelle elle-même pour résoudre un problème en le décomposant en sous-problèmes plus petits. Elle nécessite un cas de base et un appel récursif qui modifie les paramètres.

Comment éviter une récursion infinie en Python ?

Pour éviter une récursion infinie, assure-toi d'avoir un cas de base atteignable et que chaque appel récursif modifie les paramètres pour se rapprocher de ce cas de base. Vérifie aussi que tu ne fais pas d'appel avec les mêmes arguments.

Quelle est la différence entre une fonction récursive et une fonction itérative ?

Une fonction récursive s'appelle elle-même et utilise la pile d'appels, tandis qu'une fonction itérative utilise une boucle (for ou while). La récursivité est souvent plus élégante pour des problèmes comme les arbres, mais peut être moins efficace en mémoire.

Quels sont les exemples classiques de récursivité au bac NSI ?

Les exemples classiques sont : factorielle, suite de Fibonacci, recherche dichotomique, parcours d'arbre binaire, vérification de palindrome, et tri rapide (quicksort).

Comment débuguer une fonction récursive ?

Utilise des impressions (print) pour tracer les appels et les retours. Vérifie le cas de base et la modification des paramètres. Tu peux aussi utiliser un débogueur ou limiter la profondeur avec un compteur.

Récursivité NSI : astuces et exemples Python pour réussir au lycée

Tu galères avec la récursivité ? Pas de panique, c'est normal au début. Pourtant, c'est une notion clé en NSI, que ce soit en première ou en terminale. Dans cet article, on va décortiquer ensemble ce qu'est une fonction récursive, comment l'écrire sans se tromper, et surtout comment éviter les pièges classiques. Prêt à devenir un as de la récursivité ?

Qu'est-ce qu'une fonction récursive ?

Une fonction récursive, c'est tout simplement une fonction qui s'appelle elle-même. Oui, comme un miroir infini. Mais attention, pour que ça fonctionne, il faut deux ingrédients essentiels :

Un cas de base : une condition qui stoppe la récursion (sinon ça tourne en boucle infinie).
Un appel récursif : la fonction s'appelle elle-même avec un paramètre modifié, pour se rapprocher du cas de base.

Prenons un exemple simple : le calcul de la factorielle. En maths, n! = n × (n-1) × ... × 1. Et on sait que 0! = 1. En Python, ça donne :

def factorielle(n):
    # Cas de base
    if n == 0:
        return 1
    # Appel récursif
    else:
        return n * factorielle(n-1)

Teste avec factorielle(5) : le résultat est 120. Magique ? Non, logique !

Comment raisonner avec la récursivité ?

L'approche diviser pour régner

La récursivité, c'est souvent : résoudre un petit problème (cas de base) et décomposer le grand problème en un sous-problème plus petit. Par exemple, pour calculer la somme des entiers de 1 à n :

def somme(n):
    if n == 1:
        return 1
    else:
        return n + somme(n-1)

Ici, somme(n) = n + somme des entiers jusqu'à n-1. Simple, non ?

Visualise la pile d'appels

Quand tu exécutes une fonction récursive, Python empile les appels. Chaque appel attend le résultat du suivant. C'est comme une pile d'assiettes : on pose une assiette, puis une autre, et on les dépose en commençant par la dernière. C'est ce qu'on appelle la pile d'exécution. Si tu fais trop d'appels (ex: factorielle(1000)), tu risques un RecursionError car la pile déborde. On verra plus tard comment gérer ça.

Astuces pour écrire une fonction récursive sans erreur

Voici les erreurs les plus fréquentes et comment les éviter :

Oublier le cas de base : sans cas de base, la fonction s'appelle indéfiniment → erreur de récursion infinie. Vérifie toujours que ta condition d'arrêt est atteignable.
Mauvais paramètre dans l'appel récursif : si tu ne modifies pas le paramètre vers le cas de base, tu restes bloqué. Exemple : return n * factorielle(n) au lieu de n-1.
Récursion trop profonde : Python limite la profondeur de récursion (par défaut 1000). Pour des problèmes plus grands, préfère une version itérative.

Pour t'entraîner, consulte la page cours de NSI qui propose des explications détaillées, et la section exercices de NSI pour t'exercer.

Exemple concret : le palindrome

Un palindrome est un mot qui se lit dans les deux sens (ex: 'radar'). Voici une fonction récursive pour le vérifier :

def est_palindrome(mot):
    # Cas de base : mot vide ou un seul caractère
    if len(mot) <= 1:
        return True
    # Si premier et dernier caractères différents
    if mot[0] != mot[-1]:
        return False
    # Appel récursif sur le mot sans les extrémités
    return est_palindrome(mot[1:-1])

Teste avec 'radar' : ça renvoie True. Avec 'python' : False. Ici, on réduit la taille du mot à chaque appel.

Récursivité et bac NSI : ce qu'il faut savoir

Au bac, la récursivité tombe souvent dans les exercices d'algorithmique. On te demande d'écrire une fonction récursive ou de l'analyser. Les classiques : factorielle, Fibonacci, recherche dichotomique, parcours d'arbre. Maîtrise bien ces exemples.

Un conseil : pour t'entraîner, utilise des plateformes comme AlloBac ou AlloLycée qui proposent des exercices interactifs. Et n'oublie pas de consulter notre page erreurs Python fréquentes pour éviter les pièges.

Quand utiliser la récursivité ?

La récursivité est élégante pour les problèmes qui ont une structure récursive naturelle : arbres, fractales, algorithmes de tri (quicksort, mergesort). Mais attention, elle peut être moins performante qu'une boucle à cause de la pile d'appels. En NSI, on te demande surtout de comprendre le principe et de savoir l'écrire.

Conclusion

La récursivité, ce n'est pas sorcier ! Avec un bon cas de base et des appels bien paramétrés, tu peux résoudre des problèmes complexes en quelques lignes. Entraîne-toi sur des exercices, visualise la pile d'appels, et n'hésite pas à revenir sur les bases. Tu verras, ça deviendra un réflexe. Et si tu bloques, souviens-toi : la récursivité, c'est comme les poupées russes : on ouvre, on ouvre, et à la fin on referme tout.