Mines Informatique Commune MP PC PSI 2020Sujet, corrigé et rapport du jury

Images de vagues et de structures

5,0(1 vote)

Bases de données relationnelles et SQL
Manipulation de listes en Python
Complexité algorithmique
Tri fusion
Représentation des nombres en mémoire
Méthode d'Euler

Explorer les annales

BanqueMines Année2020 FilièreMP/PC/PSI MatièreInformatique

Annales Mines MP/PC/PSI Informatique Mines MP/PC/PSI 2020 MP/PC/PSI Informatique Informatique 2020

Téléchargements

Télécharger le sujet (PDF)

Corrigé

Rapport du jury Lire en ligne LaTeX Word

Présentation du sujet

Simulation d'une scène de cinéma : maillages de facettes, vagues et flottaison d'une gondole

Le sujet porte sur la modélisation d'une scène de cinéma en images de synthèse (un bateau créant un sillage et une gondole qui oscille) à l'aide de maillages de facettes triangulaires. Il combine des requêtes SQL sur une base de données, la manipulation de vecteurs et de facettes en Python, puis le calcul de la poussée d'Archimède et l'intégration du mouvement de la gondole par la méthode d'Euler.

1Partie I : création d'un objet dans la scèneRequêtes SQL sur une base de données de maillages, puis manipulation de vecteurs, facettes et listes de sommets en Python.
2Partie II : génération de vaguesEstimation de l'occupation mémoire, écriture des hauteurs de vagues dans un fichier, puis représentation en matrice creuse.
3Partie III : mouvement de flottaisonCalcul de la poussée d'Archimède sur les facettes immergées, tri des facettes par aire par tri-fusion, puis intégration du mouvement par la méthode d'Euler.

Ce qu'a observé le jury

6 erreurs relevées

Remplissage d'une liste vide par indexation · Confusion entre norme d'une différence et différence des normes · Complexité affirmée sans justification

Les copies sont très contrastées et l'épreuve a bien joué son rôle de classement : un nombre non négligeable de copies montre une bonne, voire excellente, maîtrise du langage, mais le jury relève aussi des lacunes récurrentes sur la manipulation des listes, des chaînes de caractères et sur la justification des complexités.

Les erreurs les plus sanctionnées

1
Remplissage d'une liste vide par indexationQ8
Un certain nombre de candidats initialisent une liste vide puis tentent de la remplir en écrivant directement dans un indice qui n'existe pas encore.
« un certain nombre de candidats tombent dans le piège classique d'initialiser une nouvelle liste vide »
2
Confusion entre norme d'une différence et différence des normesQ11
Bien qu'il ne s'agisse pas d'une épreuve de mathématiques, le jury a été surpris par la fréquence de cette confusion.
« nous avons été surpris par le nombre de candidats confondant la norme d'une différence avec la différence des normes »
3
Complexité affirmée sans justificationQ14
Le jury attend une description explicite du meilleur et du pire cas avant de conclure, et non une affirmation du type boucle for donc complexité linéaire.
« Que de réponses affirmées sans aucune justification »
4
Chaînes de caractères non mutables mal comprisesQ16
Certains candidats tentent de modifier un caractère par indexation ou d'utiliser append sur une chaîne, ce qui n'est pas possible en Python.
« La gestion des chaînes de caractères n'est pas maitrisée »
5
Algorithme de fusion mal comprisQ24
Des candidats codent des boucles imbriquées au lieu du principe de parcours simultané de deux listes triées propre au tri-fusion.
« témoignent d'une mauvaise compréhension de l'algorithme de fusion de deux listes »
6
Copies présentées comme un brouillon
Le jury signale des copies contenant de nombreuses ratures sales sur toute la copie, jugées irrespectueuses du travail du correcteur.
« Certaines copies sont trop proches d'un brouillon, avec beaucoup de ratures réalisées sans soin »

Ce qui a été bien réussi

Un nombre non négligeable de copies montre une bonne maîtrise du langage et une compréhension relativement bonne, parfois excellente, des problématiques abordées.
95% des candidats savent reconnaître le calcul de la norme d'un vecteur (question 7).
La question 3 est assez bien réussie.
La question 22 est assez bien réussie.
Le principe de tri puis extraction de la question 26 a plutôt été maîtrisé.

Conseils du jury

Ne pas transposer les réflexes du module numpy aux listes Python : une opération comme a*L avec L une liste n'a pas de sens.
Préférer L.append(a) à la syntaxe L=L+[a], beaucoup moins efficace pour ajouter un élément.
Ne pas omettre les parenthèses des appels de fonction, par exemple dans for i in range(m).
Toujours justifier une analyse de complexité en distinguant explicitement le meilleur et le pire des cas.
Préférer une version itérative du tri-fusion à une version récursive, jugée très peu efficace.
Soigner la présentation de la copie et éviter les ratures répétées.

Synthèse rédigée par WikiPrépa à partir du rapport officiel du jury (à télécharger en PDF). Les citations sont extraites du rapport.

Ces sujets peuvent vous intéresser

Lecture du sujet en ligne

L'énoncé complet, avec les formules et les figures, sans ouvrir le PDF.

Sujet en PDF

É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'énoncé, il le signale sur sa copie et poursuit sa composition en expliquant les raisons des initiatives qu'il est amené à prendre.

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

ℝ^3

, 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

z = 1, 5

sera exprimé par :

code Python
1 V = [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, e_x^(\to-), e_y\to, e_z\to

) 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 :

Maillage : ensemble des facettes qui constituent la géométrie d'un objet. Un maillage sera représenté par une liste de facettes.
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.
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, z)$ .

La figure 2(a) représente un exemple de maillage simple (tétraèdre), composé de 4 facettes (notées

S_1

S_4

) et de 4 sommets (notés

A

D

) avec

AB = AD = AC = 1

. Sa représentation en Python est donnée dans le paragraphe I.b.

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

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

Figure 2

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

I.a 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 :

relation maillages_bateau : ensemble des maillages. Un maillage possède un identifiant (entier) et un nom (chaîne de caractères) :

maillages_bateau(id,nom)

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)

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,z)

$id _-$	nom
1	coque
2	bouée
3	échelle
4	moteur
$\dots$	$\dots$

(a) Relation maillages_bateau

numero	maillage	s1	s2	s3
1	3	1	2	3
2	3	2	4	3
3	2	3	12	5
$\dots$	$\dots$	$\dots$	$\dots$	$\dots$

(b) Relation faces

$id$	$x$	$y$	$z$
1	0.0	0.0	0.0
2	1.0	0.0	0.0
3	0.0	1.0	0.0
$\dots$	$\dots$	$\dots$	$\dots$

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

◻Q1 -

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

◻Q2 -

Proposez une requête

SQL

permettant de récupérer la liste des numéros des facettes (numero) du maillage nommé «gouvernail».

◻Q3 -

Expliquez ce que renvoie la requête SQL suivante :

Requête SQL
SELECT (MAX(x)-MIN(x))
FROM sommets AS s JOIN faces AS f JOIN maillages_bateau AS m
ON (s.id=f.s1 OR s.id=f.s2 OR s.id=f.s3) AND f.maillage=m.id
WHERE m.nom="coque"

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.], [0.,1.,0.]],
    [[0.,0.,0.], [0.,1.,0.], [1.,0.,0.]],
    [[0.,0.,0.], [1.,0.,0.], [0.,0.,1.]],
    [[1.,0.,0.], [0.,1.,0.], [0.,0.,1.]] ]

Cette variable représente un maillage. L'exemple illustré en figure 2(a) représente le tétraèdre (le point

A

a pour coordonnées

(0, 0, 0))

Q4 - À partir de la variable maillage_tetra, écrire une expression Python permettant de récupérer la coordonnée y du premier sommet de la première facette.
Q5 - À quel élément, sur la figure 2(a), correspond maillage_tetra[1] ?

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.

FUNCTIONS

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 V1 avec V2.
prod_vectoriel(V1, V2)
Renvoie le vecteur correspondant au produit vectoriel de V1 avec V2.
soustraction(V1, V2)
Renvoie le vecteur correspondant à l'opération vectorielle V1-V2.
barycentre(F)
Renvoie le vecteur position du barycentre d'une facette.
Argument :
F - une facette (liste de trois vecteurs)

FILE

operations_vectorielles.py

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 = ps(vect_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
    def mystere1(V):
2 return (V[0]**2 + V[1]**2 + V[2]**2)**0.5

Q7-Que fait la fonction mystere1?
Q8 - Créer la fonction multiplie_scalaire, prenant comme argument un flottant a et un vecteur V et renvoyant un nouveau vecteur correspondant $_a$ 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
        .... # Ligne à compléter
        .... # Ligne à compléter
    return G

Q9 - Compléter les lignes 4 et 5 permettant de calculer le barycentre.
Q10 - Pour une facette $F = (A, B, C)$ d'aire non-nulle, proposer une fonction normale, prenant comme argument une facette F et renvoyant le vecteur unitaire normal

n⃗ = (AB^(\to-) \land AC^(\to-))/(‖AB^(\to-) \land AC^(\to-)‖)

I.c Liste des sommets

Q11 - Compte tenu de la représentation limitée des nombres réels en machine, deux sommets $S_1$ et $S_2$ supposés être au même endroit peuvent avoir des coordonnées légèrement différentes. Proposer une fonction sont_proches, prenant comme arguments deux sommets S 1 et S 2 (représentés par leur vecteur position) et un flottant positif eps, et qui renvoie True si S1 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

◻Q12

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

Q13 - Donner (sans justification) ce que renvoie mystere3(maillage_tetra), dans le cas où maillage_tetra est la variable définie précédemment.
$◻$ Q14 - Pour une liste L de longueur $n$ , discuter la complexité de la fonction mystere2. 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) \times (m + 1)

(figure 4). Chaque case

(i, j)

de cette grille correspond à un sommet du maillage de la surface de l'eau, noté

n_(i, j)

de coordonnées (

x_i, y_j

) (avec

(i, j) \in [ [0, m] ]^2

).
La hauteur (sur

e_z\to

) de

n_(i, j)

est notée

h_(i, j)

. L'ensemble de tous les

h_(i, j)

est stocké dans une liste de listes nommée mat_h, tel que mat_h[i] [j]

= h_(i, j)

.
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.

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 \times 200

sommets. Chaque hauteur

h_(i, j)

est un flottant codé sur 64 bits.

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.

_◻

Q16 - Écrire une fonction mat2str qui prend en argument une liste de listes (repré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 :

| h_(01); h_(02); \dots,; h_(0m); h_(11); \dots,; h_(1m); \dots; h_(m0); \dots,; h_(mm)

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

n

◻Q17 -

En s'appuyant sur mat2str, proposer un code Python qui permet de sauvegarder 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 :

une liste I, comportant les numéros de ligne de chaque élément non-nul,
une liste J , comportant les numéros de colonne de chaque élément non-nul,
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).

◻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.

Q19 - En déduire à partir de combien d'éléments non-nuls il devient moins avantageux d'enregistrer une matrice creuse qu'une matrice complète classique.
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^(- 3)$ (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.

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

Seul le mouvement de translation verticale (selon la direction verticale

e_z\to

) est étudié.
On s'intéresse ici au maillage qui constitue la coque extérieure de la gondole. Certaines facettes sont émergées (i.e. leur barycentre est en dehors de l'eau), d'autres sont immergées (i.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.

◻

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

i

par :

F_i^(\to-) = - S_i \times p(G_i)n_i^(\to-)

avec :

$S_i$ : l'aire de la facette,
$n_i^(\to-)$ : le vecteur normal sortant de la coque,
$p(G_i)$ : la pression hydrostatique de l'eau sur la facette en son barycentre $G_i$ .

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(x_G, y_G, z_G) = ρ \cdot g \cdot (hauteur (x_G, y_G) - z_G)

avec :

$ρ$ : masse volumique de l'eau ( $ρ \approx 1000$ )
$g$ : accélération de la pesanteur (ici : $g \approx 9, 81$ )
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.

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

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

z⃗

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(L1, L2):
    # À compléter (sur une ou plusieurs lignes)
def trier_facettes(L):
    # À compléter (sur une ou plusieurs lignes)
grandesFacettes = # À compléter

Q24 - Compléter la fonction fusion, prenant comme argument deux listes de facettes L1 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.

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.

◻

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).

III.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

(x_G, y_G, z_G)

et de vitesse verticale notée

v

) par rapport au décor. Le principe fondamental de la dynamique en projection sur l'axe vertical

e_z\to

, appliqué à la gondole énonce que :

(dv)/(dt), = 1/m \times F_(eau \mapsto gondole) - g; (dz_G)/(dt), = v

avec

$m$ : masse de la gondole
$F_(eau \to gondole)$ 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 $z_(G0) = 0$ . Sa vitesse verticale initiale est $v_0 = 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 :
posG contiendra le vecteur position actuel du centre de gravité de la gondole au moment de l'appel (liste de trois flottants);
vitG contiendra le vecteur vitesse actuel de ce même point au moment de l'appel (liste de trois flottants);
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

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

Les sujets sont la propriété du GIP CCMP. 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.

Questions fréquentes

4 questions

Sur quels chapitres porte l'épreuve d'informatique commune MP PC PSI Mines 2020 ?

Le sujet porte sur les requêtes SQL, la manipulation de listes et de vecteurs en Python, la complexité algorithmique, le tri-fusion, la représentation en matrice creuse et la méthode d'Euler.

Quelles erreurs le jury a-t-il le plus relevées sur ce sujet d'informatique commune 2020 ?

Le jury signale des pièges sur la manipulation des listes (initialisation vide puis remplissage par indexation), une confusion entre norme d'une différence et différence des normes, des complexités affirmées sans justification et une mauvaise maîtrise des chaînes de caractères.

Ce sujet d'informatique commune Mines MP PC PSI 2020 est-il difficile ?

Le rapport ne donne pas de verdict global tranché : il indique seulement que les copies sont très contrastées et que l'épreuve a bien joué son rôle de classement.

Le sujet d'informatique commune Mines 2020 utilise-t-il des bases de données SQL ?

Oui, la première partie demande d'écrire des requêtes SQL pour interroger une base de données de maillages avant de manipuler les facettes en Python.

Pas de description pour le moment

Commentaires• Mines Informatique Commune MP PC PSI 2020

Connectez-vous pour participer aux discussions

Partagez vos avis, posez des questions et échangez avec la communauté

Chargement des commentaires...