POO et récursivité

On donne ci-dessous le code d'une classe Chien.

    1. Associer, en vous appuyant sur l'extrait de code précédent les noms : nom, poids, Chien donne_nom aux termes classe, attribut, méthode.

      nom et poids sont des attributs ; Chien est une classe, donne_nom est une méthode.

    2. Quel est le type du paramètre poids de la méthode __init__ de la classe Chien ?

      Le paramètre poids est un flottant d'après la signature de la méthode __init__

    3. Donner une instruction permettant d'instancier un objet c de type Chien, représentant un chien nommé Médor qui pèse 12 kilos.

      c = Chien("Médor", 12.0)

    4. Donner une instruction permettant d'instancier un objet home de type Chenil, qui abrite deux chiens : le chien Médor de la question précédent, et un chien Milo pesant 10,5 kilos.

      home = Chenil([c, Chien("Milo", 10.5)])

  2. Écrire une méthode mange de la classe Chien qui modifie l'attribut poids du chien self en lui ajoutant la valeur de l'argument ration. On ajoute les contraintes suivantes concernant la méthode mange :

    • on vérifiera que la valeur de ration est comprise entre 0 (exclu) et un dixième du poids du chien (inclus),

    • la méthode renverra True si ration satisfait ces conditions et que l'attribut poids est bien modifié, False dans le cas contraire.

      1
2
3
4
5
      def mange(self, ration):
    if 0 < ration <= self.poids*0.1:
        self.poids += ration
        return True
    return False

  3. Écrire une méthode nourrir de la classe Chenil qui nourrit tous les chiens de la liste self.contenu. On renverra le nombre de chiens qui ont été effectivement nourris. 

    1
2
3
4
5
6
7
8
    def nourrir(self, ration):
    """ Chenil, float -> int """
    nb_chiens_nourris = 0
    for c in self.contenu:
        a_mangé = c.mange(ration)
        if a_mangé:
            nb_chiens_nourris = 0
    return nb_chiens_nourris

On considère la suite \((u_n)_{n \in \mathbb{N}}\) définie par la relation :

\[ u_n = \begin{cases} 3 & \text{ si } n = 0\\ 3u_{n - 1} + 5 & \text{sinon.} \end{cases} \]

    1. Écrire une fonction récursive \(u\) qui étant donné un entier n renvoie le nombre \(u_n\).

      1
2
3
4
5
6
      def u(n):
    """ int -> int """
    if n <= 0:
        return 3
    else:
        return 3*u(n - 1) + 5

    2. Justifier que la fonction u que vous avez écrite est récursive.

      Il y a un appel récursif à la ligne 5 du code précédent.

  2. Dresser l'arbre d'appel de l'instruction u(3).

    img