Informatique Pour Tous Interrogation n°3 I

Informatique Pour Tous page 1/6 PCSI1 2016-2017
Nom : Prénom :
Informatique Pour Tous
Interrogation n°3
I-Syntaxe Python
I-1) Quelle est la commande Python qui permet d’ouvrir en lecture un fichier nommé MonFichier.txt
dans le répertoire courant du disque dur pour en utiliser ensuite le contenu ?
VarFichier = open(‘MonFichier.txt’,’r’)
I-2) On rappelle qu’en Python, la fonction sum(liste) produit la somme de tous les éléments de
liste
et que la forme liste = [valeur for i in range(entier)] produit exactement la même
chose que :
liste = []
for i in range(entier)
liste.append(valeur)
Soit la variable var = [(0,0,0,0),(1,0,0,0),(0,1,0,0),(0,0,1,0),(1,1,1,1)]
a) Quelle est la valeur de var[2]
(0, 1, 0, 0)
b) Quelle est la valeur de len(var)
5
c) Quelle est la valeur de len(var[1])
4
d) Quelle est la valeur de [var[i][1] for i in range(2,4)]
[1, 0]
e) Quelle est la valeur de [var[1][i] for i in range(2,4)]
[0, 0]
f) Quelle est la valeur de [var[i][i] for i in range(4)]
[0, 0, 0, 0]
II-Analyse de code
II-1) On rappelle qu’en Python l’opérateur % donne le reste de la division. Par exemple, 10%2 donne
0, 10%3 donne 1.
Qu’affiche à l’écran le script suivant :
def fonction(n, a):
terme = a
for k in range(n):
terme = (k*a*terme+a**2) % 256
return terme

Informatique Pour Tous page 2/6 PCSI1 2016-2017
n = 2
a = 10
print("resultat1 = ", fonction (n, a))
print("resultat2 = ", fonction (a, n))
print("resultat3 = ",(n, a))
resultat1 = 76
resultat2 = 204
resultat3 = (2, 10)
II-2) Extrait de la documentation Python : « enumerate(thing), where thing is either an iterator or a
sequence, returns a iterator that will return the tuples (0, thing[0]), (1, thing[1]), (2,
thing[2]), and so forth.. »
Qu’affiche à l’écran le script suivant :
def fonction(t,p):
t1, t2 = [], t
for (i, x) in enumerate(t):
if x <= p :
t1.append(x)
else:
t2[i] = p
return t1, t2
t1 = [10, 1515, 2048, -10, 42]
t2 = [42, 73]
print(t1,t2)
print(t1,t2,fonction(t1 , 42))
[10, 1515, 2048, -10, 42] [42, 73]
[10, 42, 42, -10, 42] [42, 73] ([10, -10, 42], [10, 42, 42, -10, 42])
III-Projet : Prévention des collisions aériennes (d’après Centrale -
Informatique commune MP, PC, PSI, TSI )
Lors du dépôt d’un plan de vol, une compagnie aérienne doit préciser à quel niveau de vol elle souhaite
faire évoluer son avion lors de la phase de croisière. Ce niveau de vol souhaité, le RFL pour requested
flight level, correspond le plus souvent à l’altitude à laquelle la consommation de carburant sera mini-
male. Cette altitude dépend du type d’avion, de sa charge, de la distance à parcourir, des conditions mé-
téorologiques, etc.
Cependant, du fait des similitudes entre les différents avions qui équipent les compagnies aériennes, cer-
tains niveaux de vols sont très demandés ce qui engendre des conflits potentiels, deux avions risquant de
se croiser à des altitudes proches. Les contrôleurs aériens de la région concernée par un conflit doivent
alors gérer le croisement de ces deux avions.
Pour alléger le travail des contrôleurs et diminuer les risques, le système de régulation s’autorise à faire
voler un avion à un niveau différent de son RFL. Cependant, cela engendre généralement une augmen-
tation de la consommation de carburant. C’est pourquoi on limite le choix aux niveaux immédiatement
supérieur et inférieur au RFL.
Ce problème de régulation est modélisé par un graphe dans lequel chaque vol est représenté par trois
sommets. Le sommet 0 correspond à l’attribution du RFL, le sommet + au niveau supérieur et le sommet
− au niveau inférieur. Chaque conflit potentiel entre deux vols sera représenté par une arête reliant les

Informatique Pour Tous page 3/6 PCSI1 2016-2017
deux sommets concernés. Le coût d’un conflit potentiel (plus ou moins important en fonction de sa durée,
de la distance minimale entre les avions, etc.) sera représenté par une valuation sur l’arête corres-
pondante.
Dans l’exemple de la figure , faire voler les trois avions à leur RFL engendre un coût de régulation entre
A et B de 100 et un coût de régulation entre B et C de 400, soit un coût total de la régulation de 500 (il n’y
a pas de conflit entre A et C). Faire voler l’avion A à son RFL et les avions B et C au-dessus de leur RFL
engendre un conflit potentiel de coût 100 entre A et B et 150 entre A et C, soit un coût total de 250 (il n’y
a plus de conflit entre B et C).
On peut observer que cet exemple possède des solutions de coût nul, par exemple faire voler A et C à leur
RFL et B au-dessous de son RFL. Mais en général le nombre d’avions en vol est tel que des conflits po-
tentiels sont inévitables. Le but de la régulation est d’imposer des plans de vol qui réduisent le plus possi-
ble le coût total de la résolution des conflits.
Chaque vol étant représenté par trois sommets, le graphe des conflits associé à n vols v
0
, v
1
, …, v
n–1
pos-
sède 3n sommets que nous numéroterons de 0 à 3n − 1. Nous conviendrons que pour 0 ≤ k < n :
 le sommet 3k représente le vol v
k
kk
k
à son RFL ;
 le sommet 3k + 1 représente le vol v
k
au-dessus de son RFL ;
 le sommet 3k + 2 représente le vol v
k
au-dessous de son RFL ;
Le coût de chaque conflit potentiel est stocké dans une liste de 3n listes de 3n entiers (tableau 3n × 3n)
accessible grâce à la variable globale conflit
conflit conflit
conflit (donc utilisable si nécessaire dans les fonctions à écrire ci-
dessous) : si i et j désignent deux sommets du graphe, alors conflit[i][j]
conflit[i][j]conflit[i][j]
conflit[i][j] est égal au coût du conflit
potentiel (s’il existe) entre les plans de vol représentés par les sommets i et j. S’il n’y a pas de conflit entre
ces deux sommets, conflit[i][j]
conflit[i][j]conflit[i][j]
conflit[i][j] vaut 0. On convient que conflit[i][j]
conflit[i][j]conflit[i][j]
conflit[i][j] vaut 0 si les sommets i et j
correspondent au même vol (figure 4).
On notera que pour tout couple de sommets (i, j), conflit[i][j]
conflit[i][j]conflit[i][j]
conflit[i][j] et conflit[j][i]
conflit[j][i]conflit[j][i]
conflit[j][i] , représentent un seul
et même conflit et donc conflit[i][j] = = conflit[j][i].
conflit[i][j] = = conflit[j][i].conflit[i][j] = = conflit[j][i].
conflit[i][j] = = conflit[j][i].
Exemple de conflits potentiels entre trois vols
Tableau des coûts des conflits associé au graphe représenté sur la figure précédente

Informatique Pour Tous page 4/6 PCSI1 2016-2017
III-1-a) Écrire en Python une fonction nb_conflits()
nb_conflits()nb_conflits()
nb_conflits() sans paramètre qui renvoie le nombre de conflits
potentiels, c’est-à-dire le nombre d’arêtes de valuation non nulles du graphe décrit par la variable globale
conflit
conflitconflit
conflit .
def nb_conflits() :
nb_lst = len(conflit) #nombre de listes contenues dans de la liste conflit
nb= 0
for i in range(nb_lst): # on boucle sur l’indice de toutes les lignes
for j in range(i+1, nb_lst): # on boucle sur les éléments au dessus de la diagonale
if conflit[i][j] != 0 : # il y a conflit dans ce cas
nb = nb + 1
return nb
print(nb_conflits())
b) Exprimer la complexité de cette fonction en fonction de n.
La boucle Comme nb_lst = 3n,
la complexité de la fonction est donc
.
III-2) Régulation
Pour un vol v
k
on appelle niveau relatif l’entier r
k
valant 0, 1 ou 2 tel que :
 r
k
= 0 représente le vol v
k
à son RFL ;
 r
k
= 1 représente le vol v
k
au-dessus de son RFL ;
 r
k
= 2 représente le vol v
k
au-dessous de son RFL.
On appelle régulation la liste (r
0
, r
1
,..., r
n
). Par exemple, la régulation (0, 0, …, 0) représente la situation
dans laquelle chaque avion se voit attribuer son RFL. Une régulation sera implantée en Python par une
liste d’entiers.
Il pourra être utile d’observer que les sommets du graphe des conflits choisis par la régulation r portent
les numéros 3k + r
k
pour 0 ≤
≤≤
≤ k < n.
Écrire en Python une fonction nb_vol_par_niveau_relatif(
nb_vol_par_niveau_relatif(nb_vol_par_niveau_relatif(
nb_vol_par_niveau_relatif(regulation)
regulation)regulation)
regulation) qui prend en paramètre une
régulation (liste de n entiers) et qui renvoie une liste de 3 entiers [a, b, c]
[a, b, c] [a, b, c]
[a, b, c] dans laquelle a est le nombre
de vols à leurs niveaux RFL, b le nombre de vols au-dessus de leurs niveaux RFL et c le nombre de vols
au-dessous de leurs niveaux RFL.
proposition simple
def nb_vol_par_niveau_relatif(regulation) :
a,b,c = 0,0,0 # initialisation des variables
for i in range(len(regulation)) :# on boucle sur les indices de tous les éléments de la liste regula-
tion
r = regulation[i] # on prend l’élément d’indice i
if r == 0 : a = a + 1 # on teste les différents cas possibles
elif r == 1: b = b + 1
else : c = c + 1
return [a,b,c]

Informatique Pour Tous page 5/6 PCSI1 2016-2017
III-3) Coût d’une régulation
On appelle coût d’une régulation la somme des coûts des conflits potentiels que cette régulation engendre.
a) Écrire en Python une fonction cout_regulation(
cout_regulation(cout_regulation(
cout_regulation(regulation)
regulation)regulation)
regulation) qui prend en paramètre une liste
représentant une régulation et qui renvoie le coût de celle-ci.
def cout_regulation1(regulation) :
cout = 0 # on initialise le cout à 0
lst_vols = [] # on commence par créer la liste des vols associés à la régulation
for (k, r) in enumerate(regulation) :
lst_vols.append(3*k + r ) # on utilise la remarque de l’énoncé pour fabriquer ...
# le numéro du vol correspondant à chaque élément de regulation
nb_vols = len(lst_vols) # c’est le nombre de vols
for i in range(nb_vols) : # on boucle sur l’indice de toutes les vols
for j in range(i+1,nb_vols): # on boucle sur les éléments au dessus de la diagonale
cout = cout + conflit[lst_vols[i]][lst_vols[j]] #on ajoute le coût
#de l’éventuel conflit entre les deux vols d’indice i et j
return cout
b) Évaluer la complexité de cette fonction en fonction de n.
On remarque que le nb_vols == len(regulation) == n.
La première boucle for fait n itérations à 2 opérations donc une complexité en O(n). Les deux boucles im-
briquées suivantes en fo
nt n(n – 1
) comme vu plus haut donc la complexité totale de la fonction est aussi en
c) Déduire de la question a) une fonction cout_RFL()
cout_RFL()cout_RFL()
cout_RFL() qui renvoie le coût de la régulation pour la-
quelle chaque avion vole à son RFL.
Il suffit d’appliquer la fonction cout_regulation à une liste regulation ne contenant que des 0.
def cout_RFL() :
n = len(conflit[0])//3
« » » on détermine le nombre de vols à partir du premier élément de la liste conflit .
Attention à utiliser // pour obtenir un int, si l’on utilise /, on obtient un float qui ne permet pas de faire
la concaténation # multiple qui suit « » »
regul = [0] * n # on crée la régulation RFL
return cout_regulation(regul)
d) Combien existe-t-il de régulations possibles pour n vols ?
e) Est-il envisageable de calculer les coûts de toutes les régulations possibles pour trouver celle de
cout minimal ?