Solution

Nom : __________________
Matricule : ______________
Introduction à la programmation avec Python (GLO-1901)
Département de Génie électrique et de Génie Informatique
Automne 2012
EXAMEN FINAL
Question Points Score
1
20
2
20
3
20
4
10
5
5
6
15
7
10
Total:
100
Instructions :
– 1 feuille aide-mémoire manuscrite est permise (recto-verso) ;
– répondre sur le questionnaire ;
– utilisez le verso des pages au besoin ;
– durée de l’examen : 110 minutes.
Pondération : Cet examen compte pour 40% de la note finale.
Question 1
(20 points sur 100)
Soit les énoncés Python suivants entrés directement dans l’interpréteur :
>>>
>>>
>>>
>>>
>>>
>>>
>>>
a = 1
b = 9
c = range(a, b+1)
d = tuple(c)
import numpy
e = numpy.array(d)
f = e.reshape((3,3))
Pour chacune des expressions suivantes, donnez la valeur que l’interpréteur affichera. Si l’expression soulève une exception, dites laquelle. En cas de syntaxe invalide, répondez «syntaxe
invalide».
Page 1 de 8
GLO-1901
Examen Final
17 décembre 2012
(a) (1 point) >>> a+b
(a)
10
(b)
TypeError
(c)
’1’
(d)
’111111111’
(e)
111111111
(f)
range(1, 10)
(b) (1 point) >>> b+c
(c) (1 point) >>> str(a)
(d) (1 point) >>> str(a)*b
(e) (1 point) >>> int(str(a)*b)
(f) (1 point) >>> c
(g) (1 point) >>> d
(g) (1, 2, 3, 4, 5, 6, 7, 8, 9)
(h) (1 point) >>> list(d)
(h) [1, 2, 3, 4, 5, 6, 7, 8, 9]
(i) (1 point) >>> tuple(list(d))
(i) (1, 2, 3, 4, 5, 6, 7, 8, 9)
(j) (1 point) >>> d[1:5]
(j)
(2, 3, 4, 5)
(k) (1 point) >>> e[1:5]
(k) array([2, 3, 4, 5])
(l) (1 point) >>> d[1:5]*d[1:5]
(l)
TypeError
(m) (1 point) >>> e[1:5]**2
(m) array([ 4, 9, 16, 25])
(n) (1 point) >>> f[:,1]
(n)
Page 2 de 8
array([2, 5, 8])
GLO-1901
Examen Final
17 décembre 2012
(o) (1 point) >>> f[1:2,:]
(o) array([[4, 5, 6]])
(p) (1 point) >>> f[:,1]*f[1,:]
(p) array([[ 8, 25, 48]])
(q) (1 point) >>> (f[:,1]*f[1:2,:]).sum()
(q)
81
(r) (1 point) >>> (f*f.T).sum(axis=0)
(r) array([ 30, 81, 150])
(s) (1 point) >>> f.ravel()[3:6]
(s)
array([4, 5, 6])
(t)
81
(t) (1 point) >>> (f*f).max()
Question 2
(20 points sur 100)
Soit la fonction f (n) suivante que l’on veut calculer pour la valeur entière n :
f (n) =
n
X
2 + cos(i)
i2
i=1
(a) (5 points) Écrivez le code Python d’une fonction qui calcule f (n) sans utiliser numpy.
Rappel : la fonction cosinus (cos) se trouve dans le module math.
Solution:
import math
def f(n):
return sum((2+math.cos(i))/i**2 for i in range(1, n+1))
(b) (5 points) En utilisant numpy, écrivez le code Python d’une fonction équivalente.
Rappel : le module numpy contient sa propre fonction cosinus.
Solution:
import numpy
def f(n):
i = numpy.arange(1, n+1)
return ((2+numpy.cos(i))/i**2).sum()
Page 3 de 8
GLO-1901
Examen Final
17 décembre 2012
(c) (10 points) Écrivez le code C d’une fonction équivalente.
Rappel : la fonction cosinus (cos) se trouve dans le fichier d’en-tête math.h.
Solution:
#include <math.h>
double f(int n)
{
int i;
double result = 0;
for(i = 1; i <= n; i += 1) {
result += (2+cos(i))/(i*i);
}
return result;
}
Question 3
(20 points sur 100)
Soit la classe Portefeuille de votre tp6 qui contient entre autres choses les éléments
suivants :
1. un constructeur qui initialise un membre capital correspondant au capital initial du
portefeuille, et un membre titres, de type dictionnaire, pour contenir les quantités de
titres détenus dans le portefeuille ;
2. un opérateur [] qui permet d’accéder à la quantité d’un titre.
Vous disposez aussi du module Bourse et de sa fonction infoTitre qui retourne un
dictionnaire contenant différentes informations relatives à un titre boursier, dont l’attribut
valeur qui correspond à sa valeur.
On vous demande d’écrire le code Python de la fonction membre transiger qui reçoit un
titre et une quantité. Si le titre est invalide, une exception de type TitreInvalide doit être
soulevée. Si la quantité est positive, les titres doivent être achetés. Si le capital est insuffisant,
une exception de type CapitalInsuffisant doit être soulevée. Si la quantité est négative,
les titres doivent être vendus. Si les titres détenus dans le portefeuille sont insuffisants, une
exception de type TitreInvalide doit être soulevée. Si la quantité est nulle, une exception
de type AssertionError doit être soulevée.
Solution:
def transiger(self, titre, qtte):
# déterminer la valeur du titre
try:
valeur = Bourse.infoTitre(titre)[’valeur’]
except Bourse.TitreInvalide:
raise TitreInvalide()
Page 4 de 8
GLO-1901
Examen Final
17 décembre 2012
# vérifier que le capital est suffisant
if valeur * qtte > self.capital:
raise CapitalInsuffisant()
# vérifier que la quantité est non nulle
assert qtte != 0
# vérifier que la quantité est suffisante
if self.titres.get(titre, 0) < -qtte:
raise TitreInvalide()
# procéder à la transaction
self.titres[titre] = self.titres.get(titre, 0) + qtte
self.capital -= valeur * qtte
# éliminer le titre si sa quantité est nulle
if self.titres[titre] == 0:
del self.titres[titre]
Question 4
(10 points sur 100)
Soit les énoncés suivants :
import numpy
from math import pi
x = numpy.linspace(-pi, pi, 50)
y = numpy.cos(x)
qui construisent un tableau numpy de cinquante valeurs uniformément distribuées entre −π et
+π, et calculent le cosinus de ces valeurs. On vous demande d’écrire les énoncés qui utilisent
le module matplotlib pour produire le graphique suivant :
Page 5 de 8
GLO-1901
Examen Final
17 décembre 2012
Solution:
from matplotlib import pyplot
pyplot.plot(x,y,’+’)
pyplot.xlabel(’angle en radian’)
pyplot.ylabel(’valeur du cosinus’)
pyplot.title(’Graphique du cosinus en fonction de l’angle’)
pyplot.xlim(-pi, pi)
pyplot.show()
Question 5
(5 points sur 100)
Dans un module, dites à quoi sert l’énoncé conditionnel suivant ?
if __name__ == ’__main__’:
Solution: À isoler le code qui ne sera exécuté que lorsque le module servira de programme
principal. Les énoncés à l’intérieur du if ne seront jamais exécuté lorsque le module sera
importé par un autre module.
Question 6
(15 points sur 100)
Soit le problème de la tour de Hanoï illustré par la figure suivante :
Le problème consiste à déplacer une tour de n disques, d’un piquet à un autre (ici du piquet
1 vers le piquet 3), en déplaçant un seul disque à la fois, d’un piquet à un autre, sans jamais
placer un disque de diamètre supérieur sur un disque de diamètre inférieur. La solution du
problème est donc une séquence de déplacements caractérisés par un couple d’indices de type
(i, j), où i est le piquet source et j le piquet destination. L’algorithme récursif permettant de
résoudre ce problème est le suivant :
– Si n = 0, ne rien faire ;
– Sinon :
1. déplacer récursivement une tour de n − 1 disques, du piquet source vers le piquet
intermédiaire ;
Page 6 de 8
GLO-1901
Examen Final
17 décembre 2012
2. transférer un disque du piquet source vers le piquet destination ;
3. déplacer récursivement une tour de n−1 disques, du piquet intermédiaire vers le piquet
destination.
(a) (10 points) On vous demande de coder une fonction récursive nommée hanoi recevant
quatre arguments :
1. la hauteur n de la tour ;
2. l’indice du piquet source ;
3. l’indice du piquet destination ;
4. l’indice du piquet intermédiaire ;
Votre fonction doit afficher (print) la séquence des transferts de disques sous la forme :
i1
i2
i3
..
.
--> j1
--> j2
--> j3
.
--> ..
Solution:
def hanoi(n, source, destination, intermediaire):
if n == 0:
return
else:
hanoi(n-1, source, intermediaire, destination)
print(’{} --> {}’.format(source, destination))
hanoi(n-1, intermediaire, destination, source)
(b) (5 points) Donnez la séquence des 7 transferts qui résulte de l’appel :
hanoi(3, 1, 3, 2)
Solution:
1 -->
1 -->
3 -->
1 -->
2 -->
2 -->
1 -->
3
2
2
3
1
3
3
Question 7
(10 points sur 100)
Soit la classe C++ suivante qui permet d’encapsuler deux coordonnées x et y pour former un
point dans le plan cartésien :
Page 7 de 8
GLO-1901
Examen Final
17 décembre 2012
class Point {
public:
// construire un point.
Point(double inX=0, double inY=0) {
x = inX;
y = inY;
}
// additionner ce (this) point avec le point inPoint.
Point operator+(const Point& inPoint) const {
return Point(x+inPoint.x, y+inPoint.y);
}
double x;
double y;
};
On vous demande de coder en Python une classe équivalente.
Solution:
class Point:
__init__(self, x=0, y=0):
self.x = x
self.y = y
__add__(self, pt):
return Point(self.x+pt.x, self.y+pt.y)
Page 8 de 8