IPT_2016_2017_PCSI

- page 8 -

Corrigé DST2

Exercice 1

Que renvoie le programme de l'exercice 1? Expliquer la réponse.

Le programme retourne 0 : lors de la première itération, la variable de boucle i est égale à 0. ..................................

Le return fait partie du corps de boucle vu l'indentation. Le programme est donc interrompu dès la première itération et

la valeur renvoyée est i*x = 0*5 = 0 ..............................................................................................................................

Exercice 2

1) Fonction construisant l'échantillon de temps : deux solutions

1 def echantillon_temps(N, dt) :

2 | T = [] # initialisation de la liste .................................................................

3 | for i in range(N) : ......................................................................................

4 | | T.append(i*dt)................................................................................

5 | return T ......................................................................................................

1 def echantillon_temps(N, dt) :

2 | T = [] # initialisation de la liste .................................................................

3 | t = 0

4 | for i in range(N) : ......................................................................................

5 | | T.append(t) .....................................................................................

6 | | t = t + dt .........................................................................................

7 | return T ......................................................................................................

2) Programme calculant la solution approchée, à compléter

1 def solutionS(T, E0 = 5, tau = 10**(−2), K0 = 2) : # définition des valeurs de K0, E0 et τ par défaut

2 | S = [0] # initialisation de S .......................................................................

3 | for i in range (len(T) − 1) : .......................................................................

4 | | S.append(S[i] + (K0*E0 - S[i])/tau) ...................... # ajout du i+1éme

terme de S

5 | return(S) # retourne S ..............................................................................

Remarque : S[i] existe déjà lorsqu'à l'itération d'index i, on exécute l'instruction ligne 4. Le résultat est ajouté à la liste S

et c'est S[i+1].

3) a)

module à importer en python pour les tracer de courbes : sous-module pyplot de la bibliothèque matplotlib ..............

Ecrire l’instruction correspondante : import matplotlib.pyplot as plt .............................................................................

b)

1 def tracer_solution(N, dt) :

2 | T = echantillon_temps(N, dt) ........................................... # appel de la fonction echantillon_temps

3 | S = solutionS(T, 5, 10**(−2), 2) ...................................... # appel de la fonction solutionS

4 | plt.plot(T, S) ..............................................................................................

5 | plt.show() ..................................................................................................

IPT_2016_2017_PCSI

- page 9 -

Exercice 3

1) nom_villes[2] retourne 'Chartres' .................................................................................................................................

position_villes[1][0] retourne 82 ( première composante de la liste position_villes[1] = [82,493] ................................

position_villes[1] retourne [82,493] ................................................................................................................................

instruction pour obtenir l'ordonnée de la ville Rouen : position_villes[1][1] .................................................................

........................................................................................................................................................................................

2) a)

xG = 1/4*(position_villes[0][0] + position_villes[1][0] + position_villes[2][0] + position_villes[3][0]) ......................

yG = 1/4*(position_villes[0][1] + position_villes[1][1] + position_villes[2][1] + position_villes[3][1]) ......................

........................................................................................................................................................................................

b) Fonction calculant le centre de gravité

1 def centre_gravite(position_villes) :

2 | n = len(position_villes) .......................... # longueur de position_villes

3 | sx, sy = 0,0 .................................... # initialisation de la somme des abscisses et de celle des ordonnées

4 | for i in range( n): ......................................................................................

5 | | sx = sx + position_villes[i][0] # contribution en abscisse de la i-ième ville

6 | | sy = sy + position_villes[i][1] # contribution en ordonnée de la i-ième ville

7 | xG, yG = sx/n, sy/n .............................................. # moyenne des abscisses et des ordonnées

8 | return [xG, yG] # on doit retourner un point, donc une liste de deux nombres flottants

3) tab_distance est initialisé avec toutes ses composantes nulles. On n'a donc pas à utiliser ici append mais seulement la

syntaxe permettant de modifier la valeur d'une composante : tab_distance[i][j] = d. L'avantage, c'est qu'on peut

également remplir tab_distance[j][i] puisque la position existe déjà dans la liste.

1 def distances_deux_a_deux(position_villes) :

2 | n = len(position_villes) .......................... # longueur de position_villes

3 | tab_distances = [[0]*n for k in range(n)] # toutes les distances sont initialisées à 0

4 | for i in range(n): # cas de la i-ième ville

5 | | tab_distances[i][i] = 0

6 | | for j in range(i + 1,n): # calcul de la distance entre la ville i et la ville j, j > i (i ≤ j déjà traité

7 | | | d = round(distance_euclidienne(position_villes[i] , position_villes[j]), 0)

8 | | | # calcul de la distance entre les villes i et j

9 | | | tab[i][j] = d ................................................................... # actualiser tab_distance

10 | | | tab[j][i] = d ................................................................. # symétrie des distances

11 | return tab .............................................................................................................................................

12 | ............................................................................................................................................................

Exercice 4

1) On parcourt la liste en mettant à jour simultanément la plus petite et la plus haute altitudes rencontrées. Pour éviter les

débordements lors de l'initialisation, un test préalable doit vérifier si la liste L est vide.

1 def amplitude(L) :

2 | if len(L) == 0: # liste vide ........................................................................

3 | | return None ...................................................................................

4 | mini, maxi = L[0], L[0] # bien défini car liste non vide ...........................

5 | for i in range(1,len(L)): ............................................................................

6 | | if L[i] < mini: ................................................................................

IPT_2016_2017_PCSI

- page 10 -

7 | | | mini = L[i] .........................................................................

8 | | elif L[i] > maxi: .............................................................................

9 | | | maxi = L[i] .........................................................................

10 | return maxi − mini ..................................................................................

2) On parcourt la liste de gauche à droite (sens des i croissants) et on actualise le maximum. Les indices à conserver sont

ceux pour lesquels la hauteur est supérieure ou égale au maximum déjà rencontré. On a donc besoin de deux variables

maxi et mini qui vont stocker le maximum et le minimum au fur et à mesure du parcours de la liste. Un tel parcours se

fait bien sûr avec une boucle for.

1 def vue_degagee_a_gauche(L) :

2 | if len(L) == 0: # cas traité à part, car le test d'arrêt n'est pas défni quand n = 0 ...........

3 | | return [] ............................................................................................................

4 | vue_degagee = [] # liste qui va contenir les indices cherchés ......................................

5 | maxi = L[0] ..................................................................................................................

6 | for i in range(len(L)): ...................................................................................................

7 | | if L[i] >= maxi: .................................................................................................

8 | | | vue_degagee.append(i) .........................................................................

9 | | | maxi = L[i] .............................................................................................

10 | return vue_degagee .....................................................................................................

Remarque : ligne 6, on pourrait écrire range(1, len(L)) mais à condition d'avoir initialisé vue_degagee = [0] ligne 4, le

premier point ayant forcément une vue dégagée à gauche.

On pourrait remplacer les lignes 7,8 et 9 par maxi = max(maxi, L[i])

3) Comment en déduire une fonction vue_degagee_a_droite(L) :

Première solution : on adapte le code de vue_degagee_a_gauche en parcourant la liste L à partir de la droite et en

actualisant toujours maxi qui est cette fois actualisé au dernier terme de L :

1 def vue_degagee_a_droite(L) :

2 | if len(L) == 0: ...............................................................................................................

3 | | return [] ............................................................................................................

4 | vue_degagee = [] ..........................................................................................................

5 | maxi = L[n − 1] ............................................................................................................

6 | for i in range(len(L)): ...................................................................................................

7 | | if L[n − i − 1] >= maxi: ......................................................................................

8 | | | vue_degagee.append(n − i − 1) .............................................................

9 | | | maxi = L[n − i − 1] ................................................................................

10 | return vue_degagee .....................................................................................................

IPT_2016_2017_PCSI

- page 11 -

Deuxième solution : on applique vue_degagee_a_gauche sur la liste à l'envers. Il ne faut pas oublier de revenir aux

indices initiaux avant de retourner le résultat. .................................................................................................................

1 def vue_degagee_a_droite(L) :

2 | n = len(L) : ...................................................................................................................

3 | L_inv = [L[n − i − 1] for i in range(n)] # liste L inversée .............................................

4 | vue = vue_degagee_a_gauche(L_inv) .........................................................................

5 | vue_rectifiee = [n − 1 − vue[i] for i in range(len(vue))] ..............................................

6 | return vue_rectifiee .....................................................................................................

4)

1 def plsm(L, i0):

2 | "plus longue sequence monotone à partir de l'indice i0,on retourne la longueur de cette séquence"

3 | n = len(L) ................................................................................................................................

4 | if n == 0 or i0 >= n or i0 < 0 : ..................................................................................................

5 | | return None ..................................................................................................................

6 | i = i0 ........................................................................................................................................

7 | while i <= n − 1 and L[i] == L[i0]: # détection du palier éventuel ........................................

8 | | i+=1 .............................................................................................................................

9 | if i == n: ...................................................................................................................................

10 | | return n − i0 ..................................................................................................................

11 | if L[i] > L[i0]: # on recherche une suite croissante, la palier s'est achevé à l'indice i − 1 ........

12 | | while i <= n − 1 and L[i] >= L[i − 1]: ...........................................................................

13 | | | i+=1 ..................................................................................................................

14 | | return i − i0 # nombre d'indices de la séquence de i0 inclus à i − 1 inclus ...................

15 | elif L[i] < L[i0]: # on recherche une suite décroissante ..........................................................

16 | | while i <= n − 1 and L[i] <= L[i −1]: ............................................................................

17 | | | i+=1 ..................................................................................................................

18 | | return i − i0 ..................................................................................................................

19 |