Mines Informatique MP-PC-PSI 2020

Thème de l'épreuve Images de vagues et de structures
Principaux outils utilisés programmation, bases de données, complexité, tris, récursivité
Mots clefs images de synthèse, maillage, facette, sommet, cinéma, vagues, flottaison

Corrigé

(c'est payant, sauf le début): - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Extrait gratuit du corrigé

(télécharger le PDF)
           

Énoncé complet

(télécharger le PDF)
                                      

Rapport du jury

(télécharger le PDF)
        

Énoncé obtenu par reconnaissance optique des caractères


A2020 --- INFO

Cm

Concours commun

Mines-Ponts

ÉCOLE DES PONTS PARISTECH,
ISAE-SUPAERO, ENSTA PARIS,
TÉLÉCOM PARIS. MINES PARISTECH.
MINES SAINT-ÉTIENNE, MINES NANCY,
IMT ATLANTIQUE, ENSAE PARIS, CHIMIE PARISTECH.

Concours Centrale-Supélec (Cycle International),
Concours Mines-Télécom, Concours Commun TPE/EIVP.

CONCOURS 2020
ÉPREUVE D'INFORMATIQUE COMMUNE

Durée de l'épreuve : 1 heure 30 minutes

L'usage de la calculatrice et de tout dispositif électronique est interdit.

Cette épreuve est commune aux candidats des filières MP, PC et PSI
Les candidats sont priés de mentionner de façon apparente
sur la première page de la copie :
INFORMATIQUE COMMUNE

L'énoncé de cette épreuve comporte 12 pages de texte.

Si, au cours de l'épreuve, un candidat repère ce qui lui semble être une erreur 
d'énontcé, il le
signale sur sa copie et poursuit sa composition en expliquant les raisons des 
initiatives qu'il est
amené à prendre.

Les sujets sont la propriété du GIP CCMEP. Ils sont publiés les termes de la 
licence
Creative Commons Attribution - Pas d'Utilisation Commerciale - Pas de 
Modification 3.0 France.
Tout autre usage est soumis à une autorisation préalable du Concours commun 
Mines Ponts.

IMAGES DE VAGUES ET DE STRUCTURES

Préambule

Dans une production cinématographique en images de synthèse, les images sont 
crées une à une pour
donner l'illusion du mouvement (sur le principe du dessin animé). Pour 
satisfaire les spectateurs,
il est efficace de réaliser des images conformes aux équations de la physique.

Le sujet aborde la réalisation d'une scène montrant un bateau à moteur 
traversant un canal, créant
un sillage à la surface de l'eau, et faisant osciller une gondole amarrée à 
proximité (figure 1).

Les programmes demandés sont à rédiger en langage Python 3. Si toutefois le 
candidat utilise une
version antérieure de Python, il doit le préciser. Il n'est pas nécessaire 
d'avoir réussi à écrire le code
d'une fonction pour pouvoir s'en servir dans une autre question. Les questions 
portant sur les bases
de données sont à traiter en langage SQL.

Notations mathématiques et physiques

On note V un vecteur de R°, et V la variable qui lui est associée en Python. 
Dans l'ensemble du
sujet, les vecteurs sont représentés par une liste de trois flottants. Par 
exemple, un vecteur dont les
coordonnées sont x = 2, y = 3 et z = 1,5 sera exprimé par :

code Python
L OV = [2., 3., 1.5]

Partout où cela est nécessaire, les variables sont considérées être exprimées 
dans les unités SI. Le
repère (O,e7,e} ei) servant de référentiel est fixe par rapport au décor.

Modèle de facettes

La scène contient plusieurs objets géométriques tri-dimensionnels (3D). Chaque 
objet géométrique
est représenté de manière numérique par un maillage. On définit les termes 
suivants :
e Maillage : ensemble des facettes qui constituent la géométrie d'un objet. Un 
maillage sera
représenté par une liste de facettes.
e Facette : polygone élémentaire qui constitue une partie de la surface d'un 
objet. Ici, toutes les
facettes seront des triangles. Une facette sera représentée par une liste 
ordonnée de 3 sommets.
e Sommet : point délimitant une facette. Il peut être commun à une ou plusieurs 
facettes. Tout
point sera représenté par son vecteur position de coordonnées (x,y,2).

La figure 2(a) représente un exemple de maillage simple (tétraèdre), composé de 
4 facettes (notées
S1 à S1) et de 4 sommets (notés À à D) avec AB = AD = AC = 1. Sa représentation 
en Python
est donnée dans le paragraphe [.b.

Organisation du sujet Ce sujet se compose de trois parties indépendantes.

Éclairage

Gondole

Bateau à moteur  ':.

Caméra

Sillage

ee

FIGURE 1 -- Présentation de la scène étudiée.

N
À e,
C

Sommet OT (Derrière)

Facette 7 |

(a) Un maillage simple : le tétraèdre

(b) Un maillage plus complexe : la coque d'un bateau.

FIGURE 2
Partie I. Création d'un objet dans la scène

Ia Chargement d'un modèle 3D à partir d'une base de données

On souhaite importer, dans Python, le modèle d'un bateau à moteur, élaboré 
préalablement. Ce
modèle définit plusieurs maillages élémentaires (coque, bouée, échelle, moteur, 
etc.). Le fichier
contenant ce modèle est une base de données relationnelle. Son schéma détaillé 
ci-dessous est
illustré en figure 3 :
e relation maillages_bateau : ensemble des maillages. Un maillage possède un 
identifiant (en-
tier) et un nom (chaîne de caractères) :

maillages_bateau(id,nom)

e relation faces : ensemble des facettes du modèle. Chaque facette est définie 
par un numéro
unique, l'identifiant du maillage auquel elle appartient ainsi que les 
identifiants des sommets
qui la composent. Tous sont des entiers.

faces (numero,maillage,s1,s2,s3)

e relation sommets : liste des sommets du modèle. Chaque sommet est défini par 
un identifiant
(entier) et ses coordonnées dans l'espace par rapport au repère principal de la 
scène (flottant) :

sommets (id,x,y,2)

| nom |

id | numero | maillage | sl | s2 | s3 | | id | X | y | Z |
: = 1 3 112 3 1 [0.0 | 0.0 | 0.0
_ a 2 3 2 | 4 3 2 | 1.0 | 0.0 | 0.0
- a 3 2 3 [12 | 5 3 | 0.0 | 1.0 | 0.0

(b) Relation faces (c) Relation sommets

(a) Relation
maillages_ bateau

FIGURE 3 --- Exemples des relations de la base de données.

LH) Q1 -- Proposez une requête SQL permettant de compter le nombre de maillages
que contient le modèle du bateau.

HJ  Q2 -- Proposez une requête SQL permettant de récupérer la liste des numéros 
des
facettes (numero) du maillage nommé « gouvernail ».

HU  Q3 -- Expliquez ce que renvoie la requête SQL suivante :

Requête SQL

SELECT (CMAX(x)-MIN(x))

FROM sommets AS s JOIN faces AS f JOIN maillages _ bateau AS m
ON (s.id=f.s1i OR s.id=f.s2 OR s.id=f.s3) AND f.maillage=m.id
WHERE m.nom="coque"

EE © ND HA
I.b Travail sur les facettes

À partir de requêtes sur la base de données précédente, on suppose avoir 
construit la variable
Python suivante :

maillage_tetra = [ [[0.,0.,0.], [0.,0.,1.1, [O0.,1.,0.]1],
[[0O.,0.,0.1, [0.,1.,0.], [1.,0.,0.]],
[[O.,0.,0.], [1.,0.,0.], [0.,0.,1.]],
[[1.,0.,0.1, [0.,1.,0.], [0.,0.,1.1] ]

Cette variable représente un maillage. L'exemple illustré en figure 2(a) 
représente le tétraèdre (le
point À à pour coordonnées (0,0,0)).

LH Q4 -- À partir de la variable maillage _tetra, écrire une expression Python 
per-
mettant de récupérer la coordonnée y du premier sommet de la première facette.

Q Q5 -- À quel élément, sur la figure 2(a), correspond maillage_tetral1] ?

Dans le reste du sujet, on suppose qu'on dispose d'un module Python dont la 
documentation suit.
Help on module operations_vectorielles :

NAME
operations_vectorielles

DESCRIPTION

Ce module contient des fonctions qui implémentent des opérations usuelles sur 
les
vecteurs. Sauf indication contraire explicite les arguments sont des vecteurs 
passés
sous la forme de liste de trois réels.

FÜUNCTIONS
addition(V1, V2)

Renvoie le vecteur correspondant à l'opération vectorielle V1+V2.
aire(F)

Renvoie l'aire d'une facette.
Argument :
F -- une facette (liste de trois vecteurs)

prod_scalaire(V1, V2)

Renvoie le produit scalaire de VI avec V2.
prod_vectoriel(V1, V2)

Renvoie le vecteur correspondant au produit vectoriel de VI avec V2.
soustraction(V1, V2)

Renvoie le vecteur correspondant à l'opération vectorielle VI-V2.

barycentre(F)

Renvoie le vecteur position du barycentre d'une facette.
Argument :
F -- une facette (liste de trois vecteurs)

FILE

operations_vectorielles.py

LH Q6 -- On souhaite utiliser les fonctions de ce module depuis un autre fichier
Python. Complétez le code ci-dessous afin qu'il fournisse le résultat attendu :

code Python

from ??? import ?? as ?
vect_1 = [1., 2., 3.]

vect_2 = [2., 3., 4.]
scal12 psvect_1, vect_2) #Calcul du produit scalaire de vect_1 avec vect_2

Dans ce module, une fonction n'a pas été documentée :
code Python

l def mysterei (V):
2 return (V[OÏI*xx*x2 + VI[1]xx2 + V[2]*+xx2)*xx0.5

HU Q7 - Que fait la fonction mysterel ?

1H Q8 -- Créer la fonction multiplie _ scalaire, prenant comme argument un flot-
tant a et un vecteur V et renvoyant un nouveau vecteur correspondant à a V.

La fonction barycentre (incomplète) est définie ci-dessous.

code Python

def barycentre(F):
G = [0,0,0]
for i in range(3):  #Pour chaque point de F
ee # Ligne à compléter

ee # Ligne à compléter

OO À & © D

LH  Q9 -- Compléter les lignes Z et 5 permettant de calculer le barycentre.

 Q10 --- Pour une facette F=(A,B,C) d'aire non-nulle, proposer une fonction nor-
male, prenant comme argument une facette F et renvoyant le vecteur unitaire 
normal

... mn
JA

I.c Liste des sommets

LH Q11 --- Compte tenu de la représentation limitée des nombres réels en 
machine,
deux sommets 5, et 5; supposés être au même endroit peuvent avoir des coordon-
nées légèrement différentes. Proposer une fonction sont_proches, prenant comme
arguments deux sommets S1 et S2 (représentés par leur vecteur position) et un 
flot-
tant positif eps, et qui renvoie True si Si et S2 sont proches (i.e. si leur 
distance au
sens de la norme Euclidienne est inférieure à eps) et False sinon.

Soient les fonctions suivantes :
code Python

def mystere2(S1, L):
for S2 in L:
if sont _proches(S1, S2, 1e-7):
return True
return False

def mystere3(maillage):
res = Î]
for facette in maillage:
for sommet in facette
if not mystere2(sommet, res):
res.append(sommet)
return res

= & ND © © 0 JO OR © NH

HU Q12 --- Sous quelle condition la fonction mystere2 renvoie-t-elle True ?

U Q13 --- Donner (sans justification) ce que renvoie mystere3(maillage_tetra), 
dans
le cas où maillage_tetra est la variable définie précédemment.

U Q14 --- Pour une liste L de longueur n, discuter la complexité de la fonction 
mys-
tere2. En déduire la complexité de mystere3, pour un maillage contenant m 
facettes
triangulaires. On distinguera le meilleur et le pire des cas.

Partie II. Génération de vagues

Le bateau à moteur qui traverse le canal génère des vagues (appelées sillage de 
Kelvin). On ne
dispose de formules analytiques décrivant ces ondes que dans des cas très 
simples, comme celui
d'un bateau en translation rectiligne uniforme.

Le calcul numérique permettant d'évaluer la forme de ces vagues étant coûteux, 
il est réalisé par
un programme extérieur. Ce dernier génère l'état du plan d'eau à chaque image 
de la scène (25 par
seconde).

Pour chacune de ces images, on représente le plan d'eau par une grille 
régulière carrée, de taille
(m +1) x (m +1) (figure 4). Chaque case (4,7) de cette grille correspond à un 
sommet du maillage
de la surface de l'eau, noté n;; de coordonnées (x;,y;) (avec (4,5) EUR [0,m{°).

La hauteur (sur ei) de n;, est notée h;,;. L'ensemble de tous les h;; est 
stocké dans une liste de
listes nommée mat_h, tel que mat_hli][j]= h;,;.

Le programme extérieur calcule ainsi mat_h pour chaque nouvelle image. 
L'ensemble de toutes les
valeurs de mat_h est stocké dans une liste nommée liste_vagues.

Sommet
(x; Y;)

FIGURE 4 -- Illustration du stockage de la hauteur d'eau dans un tableau.

La scène est composée de 350 images. Le plan d'eau est composé de 200 x 200 
sommets. Chaque
hauteur h;; est un flottant codé sur 64 bits.

U Q15 -- Quel est l'espace occupé en mémoire vive par l'ensemble des données (en
Mo).
On souhaite enregistrer le contenu de liste_vagues dans un fichier afin de le 
transmettre au logiciel
d'animation.

HJ Q16 --- Écrire une fonction mat2str qui prend en argument une liste de 
listes (re-
présentant un mat_h}) et renvoie les données qu'elle contient sous forme d'une 
chaîne
de caractères qui respecte le format suivant :

Rmo? ++. mm

On rappelle que le retour à la ligne est codé par le caractère \n".

HU Q17 --- En s'appuyant sur mat2str, proposer un code Python qui permet de sau-
vegarder le contenu de liste_vagues dans un fichier nommé m fichier _ vagues 
.txt =
(dans le répertoire courant), en séparant la représentation de chaque mat_h par 
deux
sauts de lignes consécutifs.

Le fichier texte obtenu est jugé trop volumineux. On décide de recourir à des 
matrices creuses.
Dans ce qui suit on désigne par matrice creuse une matrice dont seuls la valeur 
et l'emplacement
des éléments non-nuls (c'est-à-dire significativement éloignés de zéro) sont 
enregistrés.
On propose d'utiliser le format de fichier nommé « Coordinate Format » qui 
consiste à stocker :

e une liste I, comportant les numéros de ligne de chaque élément non-nul,

e une liste J, comportant les numéros de colonne de chaque élément non-nul,

e une liste N, comportant la valeur de chaque élément non-nul.
Les valeurs d'une liste sont enregistrées sur une même ligne et séparées par 
des points-virgules.
Chaque liste est séparée des autres par un retour à la ligne. On admet que les 
flottants sont écrits
dans le fichier avec 15 caractères (tout compris).

1H Q18 -- Après avoir défini judicieusement les types des éléments contenus dans
I, J puis N, estimer la taille (en octets) que prendra une matrice ayant p 
éléments
non-nuls, au format « Coordinate Format », dans le fichier.

HJ Q19 --- En déduire à partir de combien d'éléments non-nuls 1l devient moins 
avan-
tageux d'enregistrer une matrice creuse qu'une matrice complète classique.

J Q20 -- Proposer un code permettant de construire, pour un tableau mat_h donné,
les listes Python I,J et N. On considérera nulles les hauteurs inférieures à 10 
* (en
valeur absolue).

Partie III. Mouvement de flottaison

La gondole amarrée sur le bord du canal perçoit les vagues générées par le 
bateau à moteur et
effectue un mouvement pseudo-oscillant conséquence de sa flottaison. On étudie 
ici le mouvement
de translation verticale de la gondole (on ne prendra en compte ni le tangage 
ni le roulis). On
cherche à modéliser ce mouvement en calculant à un instant donné la force 
exercée par le fluide sur
la gondole.

FIGURE 5 --- Maillage de la gondole.

ITII.a Estimation de la poussée d'Archimède

Seul le mouvement de translation verticale (selon la direction verticale ei) 
est étudié.

On s'intéresse ici au maillage qui constitue la coque extérieure de la gondole. 
Certaines facettes sont
émergées (1.e. leur barycentre est en dehors de l'eau), d'autres sont immergées 
(5.e leur barycentre
est sous l'eau).

À chaque pas de temps, on suppose connue la fonction hauteur(x,y) qui, à tout 
point (x,y) du
plan d'eau, associe la hauteur des vagues par rapport au repère de la scène. Le 
maillage composant
la coque de la gondole est défini dans une liste de facette nommée maillageG, 
similaire à celle
présentée dans la partie précédente.

LH Q21 -- Proposer une fonction lister_FI prenant comme argument un maillage M
et renvoyant la liste des facettes immergées (i.e dont le centre de gravité est 
sous la
surface définie par hauteur). On pourra utiliser les fonctions de la partie I.

Pour calculer la poussée d'Archimède s'exerçant sur la coque du bateau, on doit 
calculer la résultante
des forces dues à la pression, appliquées par l'eau sur chacune des facettes 
immergées.
On modélise la force appliquée par l'eau sur une facette 2 par :

F = --S; X p(Gi) nm

avec :

e 5; : l'aire de la facette,

e n° : le vecteur normal sortant de la coque,

e p(G;) : la pression hydrostatique de l'eau sur la facette en son barycentre 
G:.
Le théorème de Pascal détermine la pression de l'eau d'un point G en fonction 
de sa profondeur
par rapport à la surface :

pÜra;ya,2c) = p: 9: (hauteur(rc,yc) -- za)

avec :
e p: masse volumique de l'eau (p & 1000)
e g: accélération de la pesanteur (ici : g & 9,81)

LH Q22 -- Proposer une fonction force_facette prenant en argument une facette F,
et renvoyant le vecteur force appliqué par l'eau sur cette facette. On pourra 
utiliser
les fonctions définies précédemment.

10
La force résultante sur toute la coque s'exprime par la somme de toutes les 
forces appliquées sur
chaque facette immergée.

LH Q23 -- Définir la fonction resultante prenant comme argument une liste L de
facettes (supposées immergées), renvoyant la somme des forces sur l'axe 7 de 
l'eau,
appliquée sur l'ensemble des surfaces.

III.b Tri des facettes

On cherche à optimiser l'efficacité de la fonction resultante qui devra être 
utilisée intensément
pour réaliser un grand nombre d'images. On remarque que la taille des facettes 
n'est pas homogène :
la coque est composée de grandes facettes et de petites facettes. Les petites 
facettes représentent
souvent des détails d'intérêt graphique n'apportant qu'une très faible 
contribution à la résultante
des forces hydrostatiques.

Ainsi, une étude montre que la moitié des facettes représente à elle seule 99% 
de la surface totale
de la coque. Pour alléger le processus, on souhaite donc trier les facettes par 
aire décroissante, afin
de n'appliquer les calculs de la poussée d'Archimède qu'à la moitié d'entre 
elles (les plus grandes).
On propose le code (incomplet) du tri-fusion ci-dessous :

code Python

def fusion(Li, L2):
# À compléter (sur une ou plusieurs lignes)

1

2

3

1 def trier _facettes (L):

O # À compléter (sur une ou plusieurs lignes)
6
T

grandesFacettes = # À compléter

HO Q24 -- Compléter la fonction fusion, prenant comme argument deux listes de
facettes Li et L2 (supposée chacune triée par aire décroissante) et renvoyant 
une
nouvelle liste composée des facettes de L1 et L2 triées par aire décroissante.

LH  Q25 -- Compléter la fonction récursive trier_facettes, prenant comme 
argument
une liste de facettes L, et renvoyant une nouvelle liste de facettes triées 
dans l'ordre
des aires décroissantes, par la méthode du tri-fusion.

HU Q26 -- Affecter à une nouvelle variable grandesFacettes la liste des 
facettes de
maillageG, privée de la moitié des facettes les plus petites (en cas de nombre 
impair
d'éléments, on inclura la facette médiane).

ITI.c Mouvement vertical de la gondole

La gondole est attachée à un repère local dont l'origine est son centre de 
gravité (de coordonnées
(xa,Ya,za) et de vitesse verticale notée v) par rapport au décor. Le principe 
fondamental de la
dynamique en projection sur l'axe vertical EUR. appliqué à la gondole énonce 
que :

dv 1
nr --  -- X Peau ondole --
dt mn -+gondol 9
dzc
-- -- À
dt

avec

11
e m: masse de la gondole
© Foaugondote est la résultante des forces appliquées par l'eau sur la gondole 
(renvoyée par la
fonction resultante, vue précédemment).
La position initiale de la gondole est zGp = 0. Sa vitesse verticale initiale 
est vo = 0.

On souhaite estimer le mouvement par la méthode d'Euler. Pour ce faire, on 
utilise la fonction
nouvelle_hauteur avant d'afficher chaque nouvelle image. Cette fonction a pour 
but de recalculer
la hauteur (et la vitesse) de la gondole pour un nouveau pas de temps. Elle 
prend trois arguments :
e posG contiendra le vecteur position actuel du centre de gravité de la gondole 
au moment de
l'appel (liste de trois flottants) :
e vitG contiendra le vecteur vitesse actuel de ce même point au moment de 
l'appel (liste de trois
flottants) :
e mailG contiendra la liste des grandes facettes de la gondole (privée des 
petites, au sens de la
question précédente), au moment de l'appel.

code Python

def nouvelle _hauteur(posG, vitG, mailG):
dt=1.0/25.0 # Pas de temps correspondant à une image du film.
facettes_immergees = lister _FI(mailG)
posG = posG + .......... # à compléter
vitG = vitG + ........... # à compléter
return posG, vitG

OO À È © ND

1H Q27 --- Compléter les lignes 4 et 5 du code précédent conformément à la 
méthode
d'Euler.

FIN DE L'ÉPREUVE

12

Extrait du corrigé obtenu par reconnaissance optique des caractères



Mines Informatique MP-PC-PSI 2020 -- Corrigé
Ce corrigé est proposé par Julien Dumont (professeur en CPGE) ; il a été relu 
par
William Aufort (professeur en CPGE) et Vincent Puyhaubert (professeur en CPGE).

Ce sujet s'intéresse à différents aspects de la fabrication d'images de 
synthèse,
dans le contexte d'une scène contenant des bateaux oscillant à la surface de 
l'eau
dans un canal. L'énoncé comporte trois parties.
· La partie I introduit les notions nécessaires pour la suite du sujet. Elle 
débute
par trois questions assez élémentaires sur les bases de données sans lien avec
la suite, puis les volumes des différents objets de la scène sont définis à 
partir
du maillage de leurs surfaces. L'énoncé étudie les fonctions implémentant des
opérations géométriques utiles, puis quelques éléments liés à la réduction d'une
surface à ses sommets principaux, en enlevant les éventuels doublons dus à de
légers écarts en précision.
· La partie suivante prend le prétexte de la génération de vagues pour poser
quelques questions sur la mise en forme de données récupérées dans un fichier
texte et sur une alternative au stockage brut des données : l'utilisation de 
matrices creuses.
· La dernière partie cherche à rendre réaliste l'évolution d'un bateau soumis à
une vague, grâce à la poussée d'Archimède appliquée à un modèle des parties
des bateaux qui sont situées sous l'eau.
Ce sujet assez facile fait appel à de nombreuses notions des deux années de 
classe
préparatoire. La récursivité et le tri fusion font l'objet de quelques 
questions dans
la dernière partie, les premières étant essentiellement concentrées sur les 
bases de
données, la programmation et la complexité.
C'est un bon sujet de révision qui pâtit toutefois de plusieurs imprécisions qui
nuisent à la clarté de certaines questions. Mais cela reste un très bon 
entraînement
aux contraintes spécifiques des Mines, à savoir un sujet court durant lequel il 
faut être
efficace, rapide, et ne pas se laisser perturber par un énoncé parfois 
contradictoire ou
une question (Q17) à la très grande limite de ce qui peut être exigé au 
concours en
terme de fonctions.

Indications
Partie I
3 Bien identifier dans la lecture des tables à quoi correspond la variable x et 
ce que
contient la table issue de la jointure.
6 La fonction ps n'apparaît pas dans les fonctions fournies, il y a donc eu un 
renommage.
10 Ne pas hésiter à utiliser les fonctions de la bibliothèque fournie.
13 Le return est manifestement indenté une fois de trop.
Partie II
16 Beaucoup de pièges dans cette question : il faut faire attention aux 
conversions de
types entre les chaînes de caractères du fichier texte et les nombres que l'on 
veut
sauvegarder, en utilisant la fonction de conversion en chaînes de caractères 
str.
Par ailleurs, il n'y a ni point-virgule après le dernier caractère de chaque 
ligne,
ni saut de ligne après le dernier caractère de la matrice.
17 Pour ouvrir un fichier en écriture, il faut créer un « objet-fichier » en 
utilisant la
commande open("nomdufichier.txt","w"). Il faut aussi le fermer à la fin pour
que l'écriture soit effective, grâce à la méthode close().
18 Bien détailler les caractères dénombrés selon leur type : entier, flottant, 
pointsvirgules, retours à la ligne...
19 Faire l'hypothèse que le zéro est codé par un seul caractère.
Partie III
21 La facette est immergée si la hauteur d'eau est au-dessus de la cote du 
barycentre
de la facette.
22 Utiliser les deux formules données par l'énoncé.
-
23 Seule la composante de la résultante selon 
ez est demandée.
24 L'énoncé n'impose rien de particulier comme complexité pour la fusion, une 
version itérative est toutefois plus simple. Celle-ci peut, par exemple, 
consister à
remplir au fur et à mesure une liste de longueur len(L1) + len(L2) avec les
éléments pertinents.
25 L'énoncé impose une version récursive de l'algorithme. Utiliser la méthode « 
diviser pour régner » : on coupe la liste en deux, on trie les deux morceaux, 
puis on
fusionne les résultats.
26 Attention à inclure la facette médiane.
27 L'énoncé est erroné car il n'est pas possible avec des listes (mais cela le 
serait
avec des tableaux NumPy) de s'en sortir avec l'amorce de code des deux lignes à
compléter. Réécrire donc totalement ces deux lignes.

I. Création d'un objet dans la scène
1 L'information sur le nombre de maillages est contenue intégralement dans la 
table
maillages_bateau et s'obtient grâce à la requête
SELECT COUNT(*) FROM maillages_bateau
Il y a deux solutions alternatives, en changeant l'argument du COUNT :
COUNT(id) ou COUNT(nom). Cela était en effet possible car chaque enregistrement 
possède une valeur pour ces deux champs.
2 Cette fois-ci, une jointure est nécessaire afin de récupérer les informations 
recherchées qui sont présentes dans les tables maillages_bateau et faces. Cette 
jointure
s'effectue en notant la concordance entre les colonnes maillage et id. Notons 
enfin
que toutes les colonnes ont des noms différents, il n'est donc pas nécessaire 
de faire
des alias. On peut alors proposer par exemple la requête
SELECT numero
FROM maillages_bateau JOIN faces ON id = maillage
WHERE nom = "gouvernail"
3 L'étude du FROM ... JOIN ... ON permet tout d'abord de voir que les trois
tables sont nécessaires à cette requête, et que la table issue de cette 
jointure permet
de regrouper les coordonnées de l'ensemble des points du maillage. L'analyse du
WHERE permet de voir que l'on retient le maillage coque. Enfin, le SELECT 
renvoie
l'écart entre les deux valeurs extrêmes des abscisses. Autrement dit,
-
La requête renvoie l'amplitude du maillage de la coque selon la direction 
ex .
4 Il faut renvoyer la deuxième coordonnée du premier élément de la première 
liste,
en faisant attention à l'indexation démarrant à 0 en Python et en respectant 
l'ordre
d'extraction. L'expression est ainsi
maillage_tetra[0][0][1]
5 Comme expliqué à la question précédente, maillage_tetra[1] se réfère à la
face dont les sommets sont successivement [0.,0.,0.], [0.,1.,0.] et [1.,0.,0.],
autrement dit les sommets respectifs A, D et B. Ainsi,
L'expression maillage_tetra[1] correspond à la face S4 .
6 La seule fonction appelée dans le code proposé est le produit scalaire, mais 
sous
un autre nom que celui donné dans la documentation. Il y a donc eu un renommage.
Le première ligne du code est par conséquent
from operations_vectorielles import prod_scalaire as ps
7 Le code proposé renvoie la racine carrée de la somme des carrés des 
composantes
du vecteur pris en argument d'entrée, par conséquent
La fonction mystere1 calcule la norme euclidienne d'un vecteur.
8 Il s'agit d'écrire une fonction qui renvoie un vecteur dont les composantes 
sont
celles du vecteur en argument d'entrée multipliées chacune par une même 
constante.
Le sujet précise de plus en introduction que les vecteurs considérés sont des 
listes de
trois flottants. Par suite, on peut proposer

def multiplie_scalaire(a, V):
return [a*V[0], a*V[1], a*V[2]]
On peut proposer le code suivant, plus général car le vecteur d'entrée admet
un nombre arbitraire de composantes :
def multiplie_scalaire(a, V):
return [a*v for v in V]
9 Ici, on cherche le barycentre de trois points constituant une face, il s'agit 
donc de
calculer la moyenne de chaque coordonnée des sommets en question. Une première
boucle, indiquée dans le code, balaie chaque sommet tandis qu'une seconde permet
d'en récupérer les coordonnées (abscisse, ordonnée et cote) et d'ajouter les 
termes
permettant de calculer la moyenne. Comme deux lignes seulement sont proposées,
on ne peut faire la somme des coordonnées avant de diviser par trois, il faut 
plutôt
ajouter à chaque étape la contribution de la nouvelle coordonnée balayée 
divisée par
trois. Finalement, le code complet que l'on peut proposer est
def barycentre(F):
G = [0,0,0]
for i in range(3):
for j in range(3):
G[j] = G[j] + F[i][j]/3
return G
Même si c'est souvent assez évident, le sujet est radin en définition des
arguments des différentes fonctions. Ici par exemple, il faut comprendre que
F est une facette.
Le code suivant utilise les fonctions proposées par l'énoncé, il serait tout
aussi valable s'il n'y avait pas le squelette du code dans le sujet.
def barycentre(F):
somme = addition(F[0], addition(F[1], F[2]))
return multiplie_scalaire(1/3, somme)
10 On utilise les fonctions de la bibliothèque proposée par l'énoncé, d'abord 
pour
- -
calculer les vecteurs AB et AC, puis pour effectuer leur produit vectoriel. 
L'usage de
la fonction mystere1 étudiée à la question 7 permet de terminer le code.
def normale(F):
AB = soustraction(F[1], F[0])
AC = soustraction(F[2], F[0])
PV = prod_vectoriel(AB, AC)
norme = mystere1(PV)
return multiplie_scalaire(1/norme, PV)
Notons que l'hypothèse d'aire non nulle -- sous réserve que les calculs 
flottants soient
exacts -- assure que la quantité norme est également non nulle et donc que la 
division
est licite.
11 On suit exactement ce que propose le sujet : on calcule la distance entre 
les deux
sommets considérés et on renvoie le résultat du test comparant cette distance 
avec
la précision fixée.
def sont_proches(S1, S2, eps):
dif = soustraction(S1, S2)