Exercices¶

1. Déboguer : Trouvez les erreurs¶

Chacun des programmes suivants comportent une erreur :

• Trouvez-la de tête avant de vérifier votre hypothèse sous Python.
• Identifiez la nature de cet erreur.

Exercice 1¶

In [ ]:

def fonction1(n : int) -> int:
  a = 1
  while a < n :
    b = 2*b + 1
    a = a+1
  return b

fonction1(15)

def fonction1(n : int) -> int: a = 1 while a < n : b = 2*b + 1 a = a+1 return b fonction1(15)

Exercice 2¶

In [ ]:

def fonction2(n : int) -> int:
  b = 1
  while n != 0 :
    b = 2*b
    n = n-2
  return b

def fonction2(n : int) -> int: b = 1 while n != 0 : b = 2*b n = n-2 return b

Exercice 3¶

In [ ]:

def fonction3(n : int) -> int:
  a = 1
  b = 0
  while a < n :
    b = b + a
  return b

def fonction3(n : int) -> int: a = 1 b = 0 while a < n : b = b + a return b

Exercice 4¶

In [ ]:

def fonction4(a : int, n : int) -> int:
  b=1
  c=a
  while b < n :
    c = c x a
    b = b + 1
  return c

def fonction4(a : int, n : int) -> int: b=1 c=a while b < n : c = c x a b = b + 1 return c

---

2. Tester : Vérifier le résultat¶

Exercice 5 : La fonction factorielle¶

En mathématiques, la fonction factorielle est définie par la suite :

$$n!=1×2×3×...×(n−1) ×n$$

Parmi les algorithmes suivants, lesquels sont corrects ?
Après avoir donné une réponse de tête, évaluer les programmes sous Python à l’aide d’une batterie de tests bien choisis : un programme sera alors déclaré incorrect dès lors qu’au moins un des tests est falsifié, et probablement correct dès lors que tous les tests sont validés.

In [ ]:

def factorielle1(n : int) -> int:
  i = 0
  f = 1
  while i <= n :
    i = i+1
    f = f*i
  return f

def factorielle1(n : int) -> int: i = 0 f = 1 while i <= n : i = i+1 f = f*i return f

In [ ]:

def factorielle2(n : int) -> int:
  i = 0
  f = 1
  while i < n :
    i = i+1
    f = f*i
  return f

def factorielle2(n : int) -> int: i = 0 f = 1 while i < n : i = i+1 f = f*i return f

In [ ]:

def factorielle3(n : int) -> int:
  f = 1
  for i in range(1,n+1):
    f = f*i
  return f

def factorielle3(n : int) -> int: f = 1 for i in range(1,n+1): f = f*i return f

In [ ]:

def factorielle4(n : int) -> int:
  f = 1
  for i in range(n):
  f = f*i
return f

def factorielle4(n : int) -> int: f = 1 for i in range(n): f = f*i return f

---

3. Commenter et Nommer : Identification du traitement réalisé par un programme¶

Il est parfois difficile à la seule lecture d’un programme de comprendre ce qu’il fait exactement. Le développeur doit donc prendre un soin tout particulier à bien nommer ces fonctions et à commenter son code.

Que fait ce programme ?¶

Un élève a produit de drôles de programmes. Saurez-vous trouver ce qu’ils renvoient ?

• Utiliser des tests en Python pour se donner une idée,
• puis essayez de trouver des arguments pour valider vos idées.
• Donnez un nom cohérent à ces fonctions et commentez-les.

In [ ]:

def mystere1(n : int, m : int) -> int:
''' Indiquez ici ce que fait la fonction, ce quelle attend en paramètres et ce quelle retourne '''
  i = m
  while i < n :
    i = i+1
  return i

def mystere2(n : int) -> int:
''' Indiquez ici ce que fait la fonction, ce quelle attend en paramètres et ce quelle retourne '''
  a = 0
  s = 1
  t = 1
  while s <= n :
    a += 1
    s += t+2
    t += 2
  return a

def mystere1(n : int, m : int) -> int: ''' Indiquez ici ce que fait la fonction, ce quelle attend en paramètres et ce quelle retourne ''' i = m while i < n : i = i+1 return i def mystere2(n : int) -> int: ''' Indiquez ici ce que fait la fonction, ce quelle attend en paramètres et ce quelle retourne ''' a = 0 s = 1 t = 1 while s <= n : a += 1 s += t+2 t += 2 return a

---

4. Le bug de Zune¶

Il s’agit d’un bug rencontré par les lecteurs MP3 Microsoft Zune, le 31 décembre 2008 : le matin de ce jour-là, les utilisateurs voulant allumer leur appareil ont eu la désagréable surprise de découvrir l’écran de démarrage restant gelé comme dans l’image ci-dessous.

Impossible pour eux d’utiliser leur lecteur. Le plus drôle dans l’histoire est que rien ne pouvait être fait pour régler ce problème, mais que le lendemain matin, le 1er janvier 2009, tout s’est remis à fonctionner comme si rien ne s’était jamais passé. Une mise à jour du logiciel a évidemment ensuite été mise en ligne pour corriger le bug. Mais quel est donc ce bug étrange ? Comme on peut le deviner du fait du redémarrage sans souci le lendemain, le bug se situe dans la partie du code en charge des fonctions calendaires du lecteur. Microsoft a rapidement trouvé l’origine du bug qu’ils ont depuis publié : la faute provient de 10 lignes de code écrites originellement en C, traduite ici en Python :

In [ ]:

year = 1980
while days > 365:
  if is_leap_year(year):
    if days > 366:
      days -= 366
      year += 1
  else:
    days -= 365
    year += 1

year = 1980 while days > 365: if is_leap_year(year): if days > 366: days -= 366 year += 1 else: days -= 365 year += 1

Ces quelques lignes utilisent une variable globale days qui est initialisée, lors du démarrage du lecteur, au nombre de jours écoulés depuis le 1er janvier 1980.
Le principe du code est assez simple, et utilise un fonction booléenne is_leap_year qui renvoie True si l’année est bissextile et False sinon.

1. Compléter le code¶

• Commencez par écrire le code de la fonction is_leap_year en se rappelant qu’un numéro d’année est bissextile si elle est divisible par 4 sans être divisible par 100, ou si elle est divisible par 400.

• Testez le code du Zune, en attribuant préalablement une valeur à la variable days.

2. Identifier le bug¶

• Trouvez une valeur de days où le programme bugue. Décrivez le comportement du programme dans ce cas et expliquez le comportement observé du lecteur Zune le matin du 31 décembre 2008.

3. Corriger le bug¶

Proposez finalement une correction du bug de Zune. Testez à nouveau votre programme pour vous assurer qu’il ne présente a priori plus d’erreur.