Comment calculer la puissance d’un nombre par la méthode récursive en Python ?

Qu’est-ce la méthode récursive en python ?

La méthode récursive en Python est une technique de programmation qui consiste à utiliser une fonction qui s’appelle elle-même pour résoudre un problème. Cela permet de décomposer un problème complexe en sous-problèmes plus simples qui peuvent être résolus de manière indépendante, puis d’assembler les solutions pour obtenir la solution globale.

Une fonction récursive doit avoir au moins un cas de base (ou cas d’arrêt), qui est une condition pour laquelle la fonction ne s’appelle plus elle-même, et au moins un cas récursif, où la fonction s’appelle elle-même avec des arguments différents pour résoudre un sous-problème.

Lorsqu’une fonction s’appelle elle-même, une nouvelle instance de cette fonction est créée, qui est exécutée en parallèle avec l’instance précédente. Cela signifie que chaque appel récursif crée une nouvelle frame de pile, qui contient des informations sur les variables locales et les paramètres de la fonction en cours d’exécution.

Comment calculer une puissance en Python avec la méthode récursive ?

Voici un exemple de fonction Python qui calcule la puissance d’un nombre en utilisant la méthode récursive :

def power(x, n):
    if n == 0:
        return 1
    else:
        return x * power(x, n-1)

Vous pouvez ensuite utiliser cette fonction en l’appelant avec un nombre entier et une puissance, par exemple :

print(power(2,3)) # affiche 8

Cela calcule la puissance de 2 à la puissance de 3 en utilisant des appels récursifs :

2 * power(2,2) = 2 * ( 2 * power(2,1)) = 2 * ( 2 * ( 2 – power(2,0))) = 2 – ( 2 * ( 2 * 1 )) = 8

Il est important de noter que cette méthode récursive est efficace pour des petites puissances mais peut causer des problèmes de mémoire pour des puissances plus importantes, il existe d’autres méthodes plus adaptées pour cela.

Comment fonctionne la fonction puissance ?

Voici une explication détaillée du code pour calculer la puissance d’un nombre en utilisant la méthode récursive :

  1. La fonction power(x, n) prend en entrée un nombre x et un entier n, qui représente la puissance à laquelle on veut élever x.

  2. La première instruction de la fonction vérifie si n est égal à 0. Si c’est le cas, la fonction renvoie immédiatement 1, car tout nombre élevé à la puissance 0 est égal à 1.

  3. Si n est différent de 0, la fonction renvoie x multiplié par la puissance de x pour la puissance n-1. Cette partie de la fonction est récursive, car elle appelle elle-même avec un nouveau paramètre n-1.

  4. Pour comprendre comment cette fonction fonctionne, considérons l’exemple power(2,3) :

    • Lors de la première itération, la fonction est appelée avec x=2 et n=3. Comme n n’est pas égal à 0, elle renvoie 2 * power(2,2)
    • Lors de la seconde itération, la fonction est appelée avec x=2 et n=2. Comme n n’est pas égal à 0, elle renvoie 2 * power(2,1)
    • Lors de la troisième itération, la fonction est appelée avec x=2 et n=1. Comme n n’est pas égal à 0, elle renvoie 2 * power(2,0)
    • Lors de la quatrième itération, la fonction est appelée avec x=2 et n=0. Comme n est égal à 0, elle renvoie immédiatement 1.
    • Les itérations précédentes peuvent maintenant être remplacées par leur valeur de retour: 2 * (2 * (2 * 1)) = 8
  5. La fonction renvoie donc la puissance de x pour la puissance n.

Il est important de noter que cette méthode récursive est efficace pour des petites puissances mais peut causer des problèmes de mémoire pour des puissances plus importantes, il existe d’autres méthodes plus adaptées pour cela.

En résumé

Pour résumer, la récursion est une technique de programmation qui consiste à décomposer un problème complexe en sous-problèmes plus simples, qui peuvent être résolus de manière indépendante, en utilisant des fonctions qui s’appellent elles-même. Cela permet de simplifier la compréhension et la résolution de certains problèmes en utilisant des étapes simples à comprendre et à suivre.

Pour aller plus loin

Comment calculer la factorielle par la méthoderécursive en Python ?

Qu’est-ce la méthode récursive en python ?

La méthode récursive en Python est une technique de programmation qui consiste à utiliser une fonction qui s’appelle elle-même pour résoudre un problème. Cela permet de décomposer un problème complexe en sous-problèmes plus simples qui peuvent être résolus de manière indépendante, puis d’assembler les solutions pour obtenir la solution globale.

Une fonction récursive doit avoir au moins un cas de base (ou cas d’arrêt), qui est une condition pour laquelle la fonction ne s’appelle plus elle-même, et au moins un cas récursif, où la fonction s’appelle elle-même avec des arguments différents pour résoudre un sous-problème.

Lorsqu’une fonction s’appelle elle-même, une nouvelle instance de cette fonction est créée, qui est exécutée en parallèle avec l’instance précédente. Cela signifie que chaque appel récursif crée une nouvelle frame de pile, qui contient des informations sur les variables locales et les paramètres de la fonction en cours d’exécution.

Qu’est-ce que la factorielle ?

La factorielle d’un nombre entier n, notée n!, est égale à la multiplication de tous les nombres entiers plus petits ou égaux à n. Par exemple, 5! = 5 x 4 x 3 x 2 x 1 = 120. La factorielle de 0 est définie comme étant égale à 1.

Comment calculer une factorielle en Python avec la méthode récursive ?

Voici un exemple de fonction Python qui calcule la factorielle d’un nombre en utilisant la méthode récursive :

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

Vous pouvez ensuite utiliser cette fonction en l’appelant avec un nombre entier, par exemple

print(factorial(5)) # affiche 120

Comment fonctionne la fonction factorielle ?

Voici une explication détaillée du code pour calculer la factorielle d’un nombre en utilisant la méthode récursive :

  1. La fonction factorial(n) prend en entrée un nombre entier n.

  2. La première instruction de la fonction vérifie si n est égal à 0. Si c’est le cas, la fonction renvoie immédiatement 1, car la factorielle de 0 est définie comme étant égale à 1.

  3. Si n est différent de 0, la fonction renvoie n multiplié par la factorielle de n-1. Cette partie de la fonction est récursive, car elle appelle elle-même avec un nouveau paramètre n-1.

  4. Pour comprendre comment cette fonction fonctionne, considérons l’exemple factorial(5) :

    • Lors de la première itération, la fonction est appelée avec n=5. Comme n n’est pas égal à 0, elle renvoie 5 * factorial(4)
    • Lors de la seconde itération, la fonction est appelée avec n=4. Comme n n’est pas égal à 0, elle renvoie 4 * factorial(3)
    • Lors de la troisième itération, la fonction est appelée avec n=3. Comme n n’est pas égal à 0, elle renvoie 3 * factorial(2)
    • Lors de la quatrième itération, la fonction est appelée avec n=2. Comme n n’est pas égal à 0, elle renvoie 2 * factorial(1)
    • Lors de la cinquième itération, la fonction est appelée avec n=1. Comme n n’est pas égal à 0, elle renvoie 1 * factorial(0)
    • Lors de la sixième itération, la fonction est appelée avec n=0. Comme n est égal à 0, elle renvoie immédiatement 1.
    • Les itérations précédentes peuvent maintenant être remplacées par leur valeur de retour: 5 * (4 * (3 * (2 * 1))) = 120
  5. La fonction renvoie donc la factorielle de n.

Il est important de noter que cette méthode récursive est efficace pour des petits nombres mais peut causer des problèmes de mémoire pour des nombres plus importants, il existe d’autres méthodes plus adaptées pour cela.

En résumé

Pour résumer, la récursion est une technique de programmation qui consiste à décomposer un problème complexe en sous-problèmes plus simples, qui peuvent être résolus de manière indépendante, en utilisant des fonctions qui s’appellent elles-même. Cela permet de simplifier la compréhension et la résolution de certains problèmes en utilisant des étapes simples à comprendre et à suivre.

Pour aller plus loin

Comment déterminer le nombre maxi d’une liste en Python avec la méthode récursive ?

Qu’est-ce la méthode récursive en python ?

La méthode récursive en Python est une technique de programmation qui consiste à utiliser une fonction qui s’appelle elle-même pour résoudre un problème. Cela permet de décomposer un problème complexe en sous-problèmes plus simples qui peuvent être résolus de manière indépendante, puis d’assembler les solutions pour obtenir la solution globale.

Une fonction récursive doit avoir au moins un cas de base (ou cas d’arrêt), qui est une condition pour laquelle la fonction ne s’appelle plus elle-même, et au moins un cas récursif, où la fonction s’appelle elle-même avec des arguments différents pour résoudre un sous-problème.

Lorsqu’une fonction s’appelle elle-même, une nouvelle instance de cette fonction est créée, qui est exécutée en parallèle avec l’instance précédente. Cela signifie que chaque appel récursif crée une nouvelle frame de pile, qui contient des informations sur les variables locales et les paramètres de la fonction en cours d’exécution.

Comment déterminer le nombre maximum d’une liste de nombre en Python avec la méthode récursive ?

Voici un exemple de code en Python qui utilise une méthode récursive pour déterminer le nombre maximum dans une liste de nombres:

def max_num(nums, n):
    # Condition d'arrêt: si la liste ne contient qu'un élément,
    # celui-ci est le maximum
    if n == 1:
        return nums[0]
    else:
        # On appelle récursivement la fonction pour trouver le maximum
        # des n-1 premiers éléments de la liste
        max_n_1 = max_num(nums, n-1)
        # On compare le dernier élément de la liste avec le maximum des n-1 premiers
        if nums[n-1] > max_n_1:
            return nums[n-1]
        else:
            return max_n_1

# Exemple d'utilisation de la fonction
nums = [3, 5, 1, 7, 9, 2]
print(max_num(nums, len(nums))) # affiche 9

Dans ce code, la fonction “max_num(nums, n)” prend en entrée une liste “nums” de nombres et un entier “n” qui indique la longueur de la liste. La fonction utilise une méthode récursive pour déterminer le nombre maximum dans la liste.

La fonction utilise une condition d’arrêt pour gérer le cas où la liste ne contient qu’un élément, dans ce cas celui-ci est le maximum. Sinon, la fonction appelle récursivement elle-même pour trouver le maximum des n-1 premiers éléments de la liste et compare le dernier élément de la liste avec le maximum des n-1 premiers. Si le dernier élément est plus grand, il devient le nouveau maximum, sinon, le maximum des n-1 premiers éléments est retourné.

On appelle la fonction avec la liste de nombre et sa taille pour obtenir le maximum de cette liste.

Pour un aperçu, 👉 cliquez sur une couverture pour feuilleter le livre sur Amazon 📚.


Comment fonctionne la fonction max_list récursive ?

Voici un exemple de code pour déterminer le nombre maximum d’une liste de nombres par la méthode récursive :

def max_list(numbers, n):
    # Si la liste ne contient plus qu'un élément, on renvoie cet élément
    if n == 1:
        return numbers[0]
    # Sinon, on appelle récursivement la fonction pour le sous-ensemble de la liste
    else:
        # On calcule le maximum de la première moitié de la liste en appelant récursivement la fonction avec n/2
        max1 = max_list(numbers, n//2)
        # On calcule le maximum de la seconde moitié de la liste en appelant récursivement la fonction avec n/2
        max2 = max_list(numbers[n//2:], n//2)
        # On renvoie le maximum des deux maxima calculés précédemment
        return max(max1, max2)

# On définit une liste de 4 éléments
numbers = [3, 2, 5, 8]
# On appelle la fonction en lui passant la liste et sa taille
print(max_list(numbers, len(numbers)))

Etape par étape :

  • On définit la fonction max_list qui prend en paramètre la liste de nombre et la taille de cette liste.
  • On vérifie si la taille de la liste est égale à 1, si c’est le cas on renvoie l’unique élément de cette liste.
  • Sinon on calcule le maximum de la première moitié de la liste en appelant récursivement la fonction avec n/2.
  • On calcule le maximum de la seconde moitié de la liste en appelant récursivement la fonction avec n/2.
  • On renvoie le maximum des deux maxima calculés précédemment.
  • On appelle la fonction avec la liste de nombre et sa taille.
  • On affiche le résultat.

Dans ce cas particulier, le nombre maximum de la liste est 8.

Il est important de noter que cette méthode peut être très coûteuse en terme de complexité en temps et en espace, en particulier si la liste est très grande. Il existe des méthodes plus efficaces pour trouver le maximum d’une liste.

En résumé

Pour résumer, la récursion est une technique de programmation qui consiste à décomposer un problème complexe en sous-problèmes plus simples, qui peuvent être résolus de manière indépendante, en utilisant des fonctions qui s’appellent elles-même. Cela permet de simplifier la compréhension et la résolution de certains problèmes en utilisant des étapes simples à comprendre et à suivre.

Pour aller plus loin

NSI sujet bac 2022 – Exercice n°5

Nature de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30 + 1 heure
  • Coefficient : 16
  • Format : L’épreuve terminale obligatoire de spécialité est composée de deux parties :
    • une partie écrite, comptant pour 12 points sur 20,
    • et une partie pratique comptant pour 8 points sur 20.

La note globale de l’épreuve est donnée sur 20 points.

Partie écrite de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30
  • Modalités
    • La partie écrite consiste en la résolution de trois exercices permettant d’évaluer les connaissances et les capacités attendues conformément aux programmes de première et de terminale de la spécialité.
    • Chaque exercice est noté sur 4 points.
    • Le sujet propose cinq exercices, parmi lesquels le candidat choisit les trois qu’il traitera.
    • Ces cinq exercices permettent d’aborder les différentes rubriques du programme, sans obligation d’exhaustivité. Le sujet comprend obligatoirement au moins un exercice relatif à chacune des trois rubriques suivantes : traitement de données en tables et bases de données ; architectures matérielles, systèmes d’exploitation et réseaux ; algorithmique, langages et programmation.

Exercice n°5

L’exercice n°5 est extrait du sujet de bac 2022 de l’épreuve de Spécialité ; Numérique et Sciences Informatiques (NSI) de la filière générale. La calculatrice était interdite.

Thèmes abordés

Cet exercice porte sur les files, les tableaux et les algoritmes associés.

Cliquez sur lien pour télécharger l’exercice n°5 du sujet de  bac NSI officiel.

Comment calculer le nombre de Fibonacci en Python par la méthode récursive ?

Qu’est-ce la méthode récursive en python ?

La méthode récursive en Python est une technique de programmation qui consiste à utiliser une fonction qui s’appelle elle-même pour résoudre un problème. Cela permet de décomposer un problème complexe en sous-problèmes plus simples qui peuvent être résolus de manière indépendante, puis d’assembler les solutions pour obtenir la solution globale.

Une fonction récursive doit avoir au moins un cas de base (ou cas d’arrêt), qui est une condition pour laquelle la fonction ne s’appelle plus elle-même, et au moins un cas récursif, où la fonction s’appelle elle-même avec des arguments différents pour résoudre un sous-problème.

Lorsqu’une fonction s’appelle elle-même, une nouvelle instance de cette fonction est créée, qui est exécutée en parallèle avec l’instance précédente. Cela signifie que chaque appel récursif crée une nouvelle frame de pile, qui contient des informations sur les variables locales et les paramètres de la fonction en cours d’exécution.

Qu’est-ce que le nombre de Fibonacci ?

La suite de Fibonacci est une suite mathématique qui suit cette règle : chaque terme est la somme des deux termes précédents. Elle est définie de la manière suivante :

F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2) pour tout entier n > 1

Les premiers termes de la suite sont : 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

Le nombre de Fibonacci est un terme particulier de cette suite. Il est identifié par un indice n, où n est un entier. Le nombre de Fibonacci à l’indice n est calculé en utilisant la formule F(n) = F(n-1) + F(n-2) avec les valeurs de base de F(0) = 0 et F(1) = 1.

La suite de Fibonacci est utilisée dans de nombreux domaines, notamment en mathématiques, en informatique, en biologie, en physique et en économie. Elle est également utilisée pour modéliser des phénomènes naturels tels que la croissance des populations d’animaux et la formation des spirales dans les coquillages

Comment calculer le nombre de Fibonnacci en Python avec la méthode récursive ?

Voici le code en python pour calculer le nombre de Fibonacci à l’index n en utilisant la méthode récursive:

def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

Exemple :

print(fibonacci(6))

Pour un aperçu, 👉 cliquez sur une couverture pour feuilleter le livre sur Amazon 📚.


Comment fonctionne la fonction récursive de Fibonacci ?

Voici comment fonctionne le code étape par étape:

  1. La fonction fibonacci prend en entrée un entier n qui représente l’index de la suite de Fibonacci que l’on veut calculer.

  2. Il y a une condition de base qui vérifie si n est inférieur ou égal à 1. Si cette condition est vraie, la fonction retourne n. Cette condition est utilisée pour s’assurer que l’appel récursif s’arrête quand n est inférieur ou égal à 1.

  3. Sinon, si n est supérieur à 1, la fonction retourne le résultat de l’appel récursif de la fonction pour n-1 plus l’appel récursif de la fonction pour n-2. Cette étape suit la définition de la suite de Fibonacci où chaque nombre est la somme des deux nombres précédents.

  4. L’appel récursif continue jusqu’à ce que la condition de base soit remplie, c’est-à-dire lorsque n est inférieur ou égal à 1. À ce moment, tous les appels récursifs se résolvent et retournent leur résultat à l’appel récursif précédent, en suivant la définition de la suite de Fibonacci.

  5. Enfin, le résultat final du nombre de Fibonacci à l’index n est retourné.

Exemple

Voici le code en Python pour calculer le nombre de Fibonacci à l’indice 5 par la méthode récursive, avec des commentaires pour expliquer chaque étape :

def fibonacci(n):
    # Si n est égal à 0 ou 1, on renvoie directement la valeur de base
    if n == 0:
        return 0
    elif n == 1:
        return 1
    # Sinon, on appelle récursivement la fonction pour calculer les termes précédents
    else:
        # On calcule F(n-1) en appelant récursivement la fonction avec n-1
        term1 = fibonacci(n-1)
        # On calcule F(n-2) en appelant récursivement la fonction avec n-2
        term2 = fibonacci(n-2)
        # On renvoie la somme des termes précédents pour obtenir F(n)
        return term1 + term2

# On appelle la fonction avec n = 5 pour calculer F(5)
print(fibonacci(5))

La fonction “fibonacci(n)” prend un argument “n” qui spécifie l’indice du terme de Fibonacci que l’on veut calculer.

La première chose que fait la fonction est de vérifier si n est égal à 0 ou 1. Si c’est le cas, la fonction renvoie directement la valeur de base 0 ou 1. C’est la condition d’arrêt de la récursion.

Si n n’est pas égal à 0 ou 1, la fonction appelle elle-même pour calculer les termes précédents de la suite de Fibonacci. Pour ce faire, la fonction utilise deux variables: “term1” et “term2”, qui sont initialisées en appelant récursivement la fonction avec les arguments n-1 et n-2 respectivement. Ces deux appels récursifs vont continuer jusqu’à atteindre les conditions d’arrêt (n = 0 ou n = 1)

Enfin, la fonction renvoie la somme des termes précédents (term1 + term2) pour obtenir F(n).

Enfin, on appelle la fonction avec n = 5 pour calculer F(5) et on affiche le résultat.

En résumé

Pour résumer, la récursion est une technique de programmation qui consiste à décomposer un problème complexe en sous-problèmes plus simples, qui peuvent être résolus de manière indépendante, en utilisant des fonctions qui s’appellent elles-même. Cela permet de simplifier la compréhension et la résolution de certains problèmes en utilisant des étapes simples à comprendre et à suivre.

NSI sujet bac 2022 – Exercice n°3

Nature de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30 + 1 heure
  • Coefficient : 16
  • Format : L’épreuve terminale obligatoire de spécialité est composée de deux parties :
    • une partie écrite, comptant pour 12 points sur 20,
    • et une partie pratique comptant pour 8 points sur 20.

La note globale de l’épreuve est donnée sur 20 points.

Partie écrite de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30
  • Modalités
    • La partie écrite consiste en la résolution de trois exercices permettant d’évaluer les connaissances et les capacités attendues conformément aux programmes de première et de terminale de la spécialité.
    • Chaque exercice est noté sur 4 points.
    • Le sujet propose cinq exercices, parmi lesquels le candidat choisit les trois qu’il traitera.
    • Ces cinq exercices permettent d’aborder les différentes rubriques du programme, sans obligation d’exhaustivité. Le sujet comprend obligatoirement au moins un exercice relatif à chacune des trois rubriques suivantes : traitement de données en tables et bases de données ; architectures matérielles, systèmes d’exploitation et réseaux ; algorithmique, langages et programmation.

Exercice n°3

L’exercice n°3 est extrait du sujet de bac 2022 de l’épreuve de Spécialité ; Numérique et Sciences Informatiques (NSI) de la filière générale. La calculatrice était interdite.

Thèmes abordés

Cet exercice porte sur les arbres binaires de recherche, et leur algorithmes associés.

Cliquez sur lien pour télécharger l’exercice n°3 du sujet de  bac NSI officiel.

NSI sujet bac 2022 – Exercice n°5

Nature de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30 + 1 heure
  • Coefficient : 16
  • Format : L’épreuve terminale obligatoire de spécialité est composée de deux parties :
    • une partie écrite, comptant pour 12 points sur 20,
    • et une partie pratique comptant pour 8 points sur 20.

La note globale de l’épreuve est donnée sur 20 points.

Partie écrite de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30
  • Modalités
    • La partie écrite consiste en la résolution de trois exercices permettant d’évaluer les connaissances et les capacités attendues conformément aux programmes de première et de terminale de la spécialité.
    • Chaque exercice est noté sur 4 points.
    • Le sujet propose cinq exercices, parmi lesquels le candidat choisit les trois qu’il traitera.
    • Ces cinq exercices permettent d’aborder les différentes rubriques du programme, sans obligation d’exhaustivité. Le sujet comprend obligatoirement au moins un exercice relatif à chacune des trois rubriques suivantes : traitement de données en tables et bases de données ; architectures matérielles, systèmes d’exploitation et réseaux ; algorithmique, langages et programmation.

Exercice n°5

L’exercice n°5 est extrait du sujet de bac 2022 de l’épreuve de Spécialité ; Numérique et Sciences Informatiques (NSI) de la filière générale. La calculatrice était interdite.

Thèmes abordés

Cet exercice aborde la programmation objet et la méthode diviser pour régner.

Cliquez sur lien pour télécharger l’exercice n°5 du sujet de  bac NSI officiel.

Comment calculer la somme d’une liste en Python avec la méthode récursive ?

Qu’est-ce la méthode récursive en python ?

La méthode récursive en Python est une technique de programmation qui consiste à utiliser une fonction qui s’appelle elle-même pour résoudre un problème. Cela permet de décomposer un problème complexe en sous-problèmes plus simples qui peuvent être résolus de manière indépendante, puis d’assembler les solutions pour obtenir la solution globale.

Une fonction récursive doit avoir au moins un cas de base (ou cas d’arrêt), qui est une condition pour laquelle la fonction ne s’appelle plus elle-même, et au moins un cas récursif, où la fonction s’appelle elle-même avec des arguments différents pour résoudre un sous-problème.

Lorsqu’une fonction s’appelle elle-même, une nouvelle instance de cette fonction est créée, qui est exécutée en parallèle avec l’instance précédente. Cela signifie que chaque appel récursif crée une nouvelle frame de pile, qui contient des informations sur les variables locales et les paramètres de la fonction en cours d’exécution.

Comment calculer la somme d’une liste en Python avec la méthode récursive ?

Voici un exemple de fonction Python qui calcule la somme des éléments d’une liste en utilisant la méthode récursive :

def sum_list(arr):
    if len(arr) == 0:
        return 0
    else:
        return arr[0] + sum_list(arr[1:])

Vous pouvez ensuite utiliser cette fonction en l’appelant avec une liste, par exemple :

print(sum_list([1,2,3,4,5])) # affiche 15

Cela calcule la somme des éléments de la liste en utilisant des appels récursifs :

1 + sum_list([2,3,4,5]) =

1 + (2 + sum_list([3,4,5])) =

1 + (2 + (3 + sum_list([4,5]))) =

1 + (2 + (3 + (4 + sum_list([5])))) =

1 + (2 + (3 + (4 + (5 + sum_list([]))))) =

1 + (2 + (3 + (4 + (5 + 0)))) = 15

Il est important de noter que cette méthode récursive peut causer des problèmes de mémoire pour des listes très longues, il existe d’autres méthodes plus adaptées pour cela.

Comment fonctionne la fonction somme récursive ?

Voici comment fonctionne le code pour calculer la somme d’une liste en utilisant la méthode récursive étape par étape :

  1. La fonction sum_list prend en entrée une liste arr.

  2. Il y a une condition de base qui vérifie si la longueur de la liste est égale à 0. Si cette condition est vraie, la fonction retourne 0. Cette condition est utilisée pour s’assurer que l’appel récursif s’arrête quand il n’y a plus d’éléments dans la liste.

  3. Sinon, si la longueur de la liste n’est pas égale à 0, la fonction retourne la première valeur de la liste (arr[0]) plus le résultat de l’appel récursif de la fonction sur la liste sans sa première valeur (arr[1:]).

  4. L’appel récursif continue jusqu’à ce que la condition de base soit remplie, c’est-à-dire lorsque la longueur de la liste est égale à 0. À ce moment, tous les appels récursifs se résolvent et retournent leur résultat à l’appel récursif précédent, en ajoutant tous les éléments de la liste ensemble.

  5. Enfin, le résultat final de la somme des éléments de la liste est retourné.

print(sum_list([1,2,3,4,5]))
  • Lors de la première étape, la fonction va renvoyer 1 + sum_list([2,3,4,5])
  • Lors de la deuxième étape, la fonction va renvoyer 1 + (2 + sum_list([3,4,5]))
  • Lors de la troisième étape, la fonction va renvoyer 1 + (2 + (3 + sum_list([4,5])))
  • Lors de la quatrième étape, la fonction va renvoyer 1 + (2 + (3 + (4 + sum_list([5]))))
  • Lors de la cinquième étape, la fonction va renvoyer 1 + (2 + (3 + (4 + (5 + sum_list([])))))
  • Lors de la sixième étape, la fonction va renvoyer 1 + (2 + (3 + (4 + (5 + 0)))) = 15

Dans cet exemple, l’appel récursif s’est effectué 5 fois pour arriver à la somme des éléments de la liste qui est 15.

En résumé

Pour résumer, la récursion est une technique de programmation qui consiste à décomposer un problème complexe en sous-problèmes plus simples, qui peuvent être résolus de manière indépendante, en utilisant des fonctions qui s’appellent elles-même. Cela permet de simplifier la compréhension et la résolution de certains problèmes en utilisant des étapes simples à comprendre et à suivre.

Pour aller plus loin

NSI sujet bac 2022 – Exercice n°1

Nature de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30 + 1 heure
  • Coefficient : 16
  • Format : L’épreuve terminale obligatoire de spécialité est composée de deux parties :
    • une partie écrite, comptant pour 12 points sur 20,
    • et une partie pratique comptant pour 8 points sur 20.

La note globale de l’épreuve est donnée sur 20 points.

Partie écrite de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30
  • Modalités
    • La partie écrite consiste en la résolution de trois exercices permettant d’évaluer les connaissances et les capacités attendues conformément aux programmes de première et de terminale de la spécialité.
    • Chaque exercice est noté sur 4 points.
    • Le sujet propose cinq exercices, parmi lesquels le candidat choisit les trois qu’il traitera.
    • Ces cinq exercices permettent d’aborder les différentes rubriques du programme, sans obligation d’exhaustivité. Le sujet comprend obligatoirement au moins un exercice relatif à chacune des trois rubriques suivantes : traitement de données en tables et bases de données ; architectures matérielles, systèmes d’exploitation et réseaux ; algorithmique, langages et programmation.

Exercice n°1

L’exercice n°1 est extrait du sujet de bac 2022 de l’épreuve de Spécialité ; Numérique et Sciences Informatiques (NSI) de la filière générale. La calculatrice était interdite.

Thèmes abordés

Cet exercice porte sur les arbres binaires de recherche, la programmation orientée
objet et la récursivité.

Cliquez sur lien pour télécharger l’exercice n°1 du sujet de  bac NSI officiel.

NSI sujet bac 2022 – Exercice n°5

5Nature de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30 + 1 heure
  • Coefficient : 16
  • Format : L’épreuve terminale obligatoire de spécialité est composée de deux parties :
    • une partie écrite, comptant pour 12 points sur 20,
    • et une partie pratique comptant pour 8 points sur 20.

La note globale de l’épreuve est donnée sur 20 points.

Partie écrite de l’épreuve  de NSI au bac en terminale

  • Durée : 3 heures 30
  • Modalités
    • La partie écrite consiste en la résolution de trois exercices permettant d’évaluer les connaissances et les capacités attendues conformément aux programmes de première et de terminale de la spécialité.
    • Chaque exercice est noté sur 4 points.
    • Le sujet propose cinq exercices, parmi lesquels le candidat choisit les trois qu’il traitera.
    • Ces cinq exercices permettent d’aborder les différentes rubriques du programme, sans obligation d’exhaustivité. Le sujet comprend obligatoirement au moins un exercice relatif à chacune des trois rubriques suivantes : traitement de données en tables et bases de données ; architectures matérielles, systèmes d’exploitation et réseaux ; algorithmique, langages et programmation.

Exercice n°5

L’exercice n°5 est extrait du sujet de bac 2022 de l’épreuve de Spécialité ; Numérique et Sciences Informatiques (NSI) de la filière générale. La calculatrice était interdite.

Thèmes abordés

Cet exercice porte sur la Programmation Orientée Objet.

Cliquez sur lien pour télécharger l’exercice n°5 du sujet de  bac NSI officiel.

Show Buttons
Hide Buttons
Translate »