Marches : randonnée, mouvement brownien et chemins auto-évitants
Afficher ou masquer la section
Le sujet comporte trois parties indépendantes consacrées chacune à un type de marche. La première exploite une base de données de randonnées puis calcule en Python l'altitude maximale, les dénivelés et la distance parcourue. La deuxième simule le mouvement brownien d'une particule par la méthode d'Euler, et la troisième génère des chemins auto-évitants dans Z², d'abord naïvement puis par rotations autour d'un pivot.
1Partie I : randonnéeRequêtes SQL sur des tables de randonnées et de participants, lecture d'un fichier texte, calcul du point le plus haut, des dénivelés et de la distance totale (Q1 à Q9).
2Partie II : mouvement brownien d'une petite particuleOpérations sur des vecteurs représentés par des listes, force aléatoire et résolution par la méthode d'Euler (Q10 à Q12).
3Partie III : marche auto-évitanteGénération naïve de chemins auto-évitants, complexité, vérification par tri, puis méthode du pivot par rotations (Q13 à Q23).
Difficulté moyenne. Le jury juge la longueur et la difficulté du sujet tout à fait adaptées à l'épreuve, avec des copies allant de presque vides à quasi parfaites.
Deux tiers des copies environ (moyenne ± écart-type)
Votre note sur 20 à ce sujet, en conditions de concours.
Source : document officiel du concours, épreuve du 29 avril 2021. Notes publiées par le concours (après harmonisation le cas échéant). Courbe : estimation par une loi normale.
Ce qu'a observé le jury
6 erreurs relevées
Requêtes SQL mal construites · Initialisation d'un maximum · Indices et signe du dénivelé
Afficher ou masquer la section
Le sujet couvrait un large éventail de notions des deux années et a bien permis de classer les candidats. Le jury insiste sur la lisibilité des codes, la maîtrise des listes Python sans syntaxe propre à numpy, l'importation correcte des bibliothèques et le bon sens des affectations. La complexité et les tris restent des points faibles.
Les erreurs les plus sanctionnées
1
Requêtes SQL mal construitesQ1 à Q4
Le SELECT est oublié avec une fonction d'agrégation, un encadrement du type 1998 < ne < 2004 est écrit tel quel, et des jointures sont faites sur des clés sans rapport.
« montrant ainsi un manque de compréhension de cette notion. »
2
Initialisation d'un maximumQ6
Initialiser le maximum courant à 0 fausse la recherche du point le plus haut.
« Lors d’une recherche de maximum dans une liste, l’initialisation du maximum courant à 0 est erronée. »
3
Indices et signe du déniveléQ7
Les dépassements d'indices dans la boucle et le signe du dénivelé négatif sont souvent mal gérés, alors que le canevas en fin d'énoncé levait le doute.
« Beaucoup de candidats ont également commis une erreur de signe concernant le dénivelé négatif »
4
Syntaxe numpy appliquée à des listesQ10
Additionner deux listes avec + ou multiplier une liste par un scalaire ne fait pas une opération terme à terme, et L[i, j] ne fonctionne pas sur une liste de listes.
5
Méthode d'Euler et tirages aléatoiresQ11, Q12
Les fonctions uniform ou gauss donnent une valeur différente à chaque appel, ce qui fausse le code si elles sont rappelées. Le principe d'Euler n'est pas toujours maîtrisé.
« Le principe de la méthode d’Euler n’est pas toujours maîtrisé. »
6
Complexité et trisQ16, Q18
Beaucoup confondent nombre de boucles et complexité, au lieu de sommer les coûts des fonctions appelées. Les complexités du tri rapide et du tri fusion sont mal connues.
« Comme souvent, la détermination rigoureuse de la complexité (dans le cas le pire) d’une fonction a beaucoup posé problème. »
Ce qui a été bien réussi
Q9 est plutôt réussie, hormis une erreur fréquente sur le type d'un point de passage.
Q13 : le principe a globalement été compris.
Q19 : l'idée de trier la liste du chemin a été plutôt bien comprise et la question assez réussie.
Les questions Q21 à Q23 ont permis aux meilleurs candidats de montrer leur recul et leur maîtrise des listes.
Des progrès ont été notés dans la gestion des fichiers texte.
Conseils du jury
Construire une liste à partir d'une liste vide avec append plutôt qu'avec L = L + [elt].
Se souvenir que L1 = L2 ne crée pas de copie indépendante et que modifier la variable de boucle ne modifie pas la liste.
Appeler les fonctions d'une bibliothèque selon la syntaxe d'importation choisie.
Stocker une valeur calculée au lieu de rappeler plusieurs fois la même fonction.
Limiter les ratures pour que le code reste lisible.
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.
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 10 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.
Marchons, marchons, marchons...
Ce sujet propose d'appliquer des techniques informatiques à l'étude de trois marches de nature différente :
une marche concrète (partie I - Randonnée)
une marche stochastique (partie II - Mouvement brownien d'une petite particule)
une marche auto-évitante (partie III - Marche auto-évitante)
Les trois parties sont indépendantes. L'annexe à la fin du sujet (pages 8 à 10) fournit les canevas de code en Python que vous devrez reprendre dans votre copie pour répondre aux questions de programmation.
Partie I. Randonnée
Lors de la préparation d'une randonnée, une accompagnatrice doit prendre en compte les exigences des participants. Elle dispose d'informations rassemblées dans deux tables d'une base de données :
la table Rando décrit les randonnées possibles - la clef primaire entière rid, son nom, le niveau de difficulté du parcours (entier entre 1 et 5 ), le dénivelé (en mètres), la durée moyenne (en minutes) :
rid
rnom
diff
deniv
duree
1
La belle des champs
1
20
30
2
Lac de Castellane
4
650
150
3
Le tour du mont
2
200
120
4
Les crêtes de la mort
5
1200
360
5
Yukon Ho !
3
700
210
…
…
…
…
…
la table Participant décrit les randonneurs - la clef primaire entière pid, le nom du randonneur, son année de naissance, le niveau de difficulté maximum de ses randonnées :
pid
pnom
ne
diff_max
1
Calvin
2014
2
2
Hobbes
2015
2
3
Susie
2014
2
4
Rosalyn
2001
4
…
…
…
…
Donner une requête SQL sur cette base pour : ◻ Q1 - Compter le nombre de participants nés entre 1999 et 2003 inclus. ◻ Q2 - Calculer la durée moyenne des randonnées pour chaque niveau de difficulté. ◻ Q3 - Extraire le nom des participants pour lesquels la randonnée n^∘42 est trop difficile.
Q4-Extraire les clés primaires des randonnées qui ont un ou des homonymes (nom identique et clé primaire distincte), sans redondance.
L'accompagnatrice a activé le suivi d'une randonnée par géolocalisation satellitaire et souhaite obtenir quelques propriétés de cette randonnée une fois celle-ci effectuée. Elle a exporté les données au format texte CSV (comma-separated values - valeurs séparées par des virgules) dans un fichier nommé suivi_rando.csv : la première ligne annonce le format, les suivantes donnent les positions dans l'ordre chronologique.
Voici le début de ce fichier pour une randonnée partant de Valmorel, en Savoie, un bel après-midi d'été :
Le module math de Python fournit les fonctions asin, sin, cos, sqrt et radians. Cette dernière convertit des degrés en radians. La documentation donne aussi des éléments de manipulation de fichiers textuels :
fichier = open(nom_fichier, mode) ouvre le fichier, en lecture si mode est "r".
ligne = fichier.readline() récupère la ligne suivante de fichier ouvert en lecture avec open.
lignes = fichier.readlines() donne la liste des lignes suivantes.
fichier.close() ferme fichier, ouvert avec open, après son utilisation.
ligne.split(sep) découpe la chaîne de caractères ligne selon le séparateur sep : si ligne vaut "42,43,44",
alors ligne.split(",") renvoie la liste ["42", "43", "44"].
On souhaite exploiter le fichier de suivi d'une randonnée - supposé préalablement placé dans le répertoire de travail - pour obtenir une liste coords des listes de 4 flottants (latitude, longitude, altitude, temps) représentant les points de passage collectés lors de la randonnée.
À partir du canevas fourni en annexe et en ajoutant les import nécessaires :
Q5 - Implémenter la fonction importe_rando(nom_fichier) qui réalise cette importation en retournant la liste souhaitée, par exemple en utilisant certaines des fonctions ci-dessus.
On suppose maintenant l'importation effectuée dans coords, avec au moins deux points d'instants distincts. ◻ Q6 - Implémenter la fonction plus_haut(coords) qui renvoie la liste (latitude, longitude) du point le plus haut de la randonnée. ◻ Q7 - Implémenter la fonction deniveles(coords) qui calcule les dénivelés cumulés positif et négatif (en mètres) de la randonnée, sous forme d'une liste de deux flottants. Le dénivelé positif est la somme des variations d'altitude positives sur le chemin, et inversement pour le dénivelé négatif.
On souhaite évaluer de manière approchée la distance parcourue lors d'une randonnée. On suppose la Terre parfaitement sphérique de rayon R_T = 6371 km au niveau de la mer. On utilise la formule de haversine pour calculer la distance d du grand cercle sur une sphère de rayon r entre deux points de coordonnées (latitude, longitude) (φ_1, λ_1) et (φ_2, λ_2) :
d = 2rarcsin(√(sin^2((φ_2 − φ_1)/2) + cos(φ_1)cos(φ_2)sin^2((λ_2 − λ_1)/2)))
On prendra en compte l'altitude moyenne de l'arc, que l'on complètera pour la variation d'altitude par la formule de Pythagore, en assimilant la portion de cercle à un segment droit perpendiculaire à la verticale. ◻ Q8 - Implémenter la fonction distance(c1, c2) qui calcule avec cette approche la distance en mètres entre deux points de passage. On décomposera obligatoirement les formules pour en améliorer la lisibilité.
Q9 - Implémenter la fonction distance_totale(coords) qui calcule la distance en mètres parcourue au cours d'une randonnée.
Partie II. Mouvement brownien d'une petite particule
De petites particules en suspension dans un liquide se déplacent spontanément sous l'effet de l'agitation thermique du milieu environnant, donnant ainsi naissance à des trajectoires apparemment chaotiques et peu régulières. Ce phénomène est à la base de la vie : l'agitation incessante des protéines permet aux réactions biochimiques de se produire à l'intérieur de nos cellules. Il a été observé expérimentalement en 1827 sur des grains de pollen en suspension dans l'eau par le botaniste Robert Brown, d'où le nom de mouvement brownien. Son étude théorique par Albert Einstein en 1905 a permis au physicien Jean Perrin d'estimer la valeur du nombre d'Avogadro dans une série d'expériences menées entre 1907 et 1909.
Dans cette partie, on s'intéresse à un modèle du mouvement brownien proposé par Paul Langevin en 1908. Dans ce modèle, la particule étudiée est supposée soumise à deux actions de la part du fluide :
une force de frottement fluide f_F^(→−) = − αv⃗;
une force f_B^(→−) aléatoire simulant l'action désordonnée des molécules d'eau sur la particule.
Le mouvement de cette particule est donc régi par l'équation différentielle :
(dv⃗)/(dt) = − (αv⃗)/m + (f_B^(→−))/m
Pour faire une simulation en deux dimensions, on prend une particule de masse m = 10^(− 6) kg, on attribue à α la valeur 10^(− 5) kg/s, on suppose enfin que f_B^(→−) change à chaque pas d'intégration, avec une direction isotrope aléatoire (l'angle suit une loi de probabilité uniforme) et une norme qui est la valeur absolue d'une variable aléatoire suivant une loi de probabilité gaussienne (loi normale) d'espérance μ nulle et d'écart-type σ = 10^(− 8) N.
On simule le vecteur d'état E = (x, y, x˙, y˙) de la particule en intégrant E˙ = (x˙, y˙, x¨, y¨) selon la méthode d'Euler. E et E˙ seront chacun représentés par une liste de 4 flottants.
L'instruction assert expression de Python vérifie la véracité d'une expression booléenne et interrompt brutalement l'exécution du programme si ce n'est pas le cas. Elle permet de vérifier très simplement une précondition ou un invariant, comme illustré à la ligne 10 du canevas.
Le module random fournit la fonction uniform(bi, bs) qui renvoie un flottant aléatoire entre les valeurs bi et bs incluses en utilisant une densité de probabilité uniforme ainsi que la fonction gauss(mu, sigma) qui renvoie un flottant aléatoire en utilisant une densité de probabilité gaussienne d'espérance mu et d'écart-type sigma.
Le module math fournit enfin les fonctions cos et sin( en radians), la fonction sqrt et la constante pi. La fonction abs est directement disponible.
En utilisant le canevas fourni en annexe et en ajoutant les import nécessaires : ◻ Q10 - Implémenter la fonction vma(v1, a, v2) (multiplication-addition sur des vecteurs) avec v1 et v2 des listes de flottants et a un scalaire flottant, qui renvoie une nouvelle liste de flottants correspondant à :
v⃗ = v_1^(→−) + av_2^(→−)
La fonction vérifiera que les deux listes en entrée sont de même longueur avec assert.
Q11 - Implémenter la fonction derive(E) qui renvoie la dérivée du vecteur d'état passé en paramètre d'après l'équation différentielle décrite en introduction de la partie. ◻ Q12 - Implémenter la fonction euler(E0, dt, n) pour résoudre numériquement l'équation différentielle par la méthode d'Euler avec E0 le vecteur d'état initial, dt le pas d'intégration et n le nombre de pas de la simulation. La fonction renvoie la liste des n + 1 vecteurs d'état.
À titre d'exemple, voici le tracé d'une trajectoire obtenue par cette méthode :
Partie III. Marche auto-évitante
Une marche auto-évitante est un processus au cours duquel un point décrit un chemin auto-évitant, c'est-àdire qui ne se recoupe jamais lui-même. Ce modèle peut servir lors de la modélisation d'une chaîne polymère. En effet, deux monomères distincts de la chaîne ne peuvent pas se trouver à deux positions identiques pour des raisons d'encombrement stérique.
Dans ce sujet, on appellera chemin auto-évitant (CAE) de longueur n tout ensemble de n + 1 points P_i ∈ ℤ^2 pour 0 ≤ i ≤ n tels que :
∀i ‖P_(i + 1) − P_i‖ = 1
∀(i, j) i ≠ j ⇒ P_i ≠ P_j
Chaque point du chemin sera représenté par une liste à deux éléments entiers précisant les deux coordonnées (par exemple P_i = (5, − 4) est représenté par la liste [5, − 4] ). Le chemin lui-même est constitué de la liste des points, dans l'ordre dans lequel ils sont atteints. Les codes Python produits dans cette partie devront manipuler exclusivement des coordonnées entières.
Voici un exemple de représentation graphique de CAE de longueur 30 à partir de ( 0,0 ) :
On s'intéresse dans un premier temps à une méthode naïve pour générer un chemin auto-évitant de longueur n sur une grille carrée. La méthode adoptée est une approche gloutonne :
Le premier point est choisi à l'origine : P_0 = (0, 0).
En chaque position atteinte par le chemin, on recense les positions voisines accessibles pour le pas suivant et on en sélectionne une au hasard. En l'absence de positions accessibles l'algorithme échoue.
On itère l'étape 2 jusqu'à ce que le chemin possède la longueur désirée ou échoue.
Le module random fournit la fonction randrange(a, b) qui renvoie un entier compris entre a et b − 1 inclus, ainsi que la fonction choice(L) qui renvoie l'un des éléments de la liste L , dans les deux cas choisis aléatoirement avec une probabilité uniforme.
L'expression x in L est une expression booléenne qui vaut True si x est l'un des éléments de L et False dans le cas contraire. On supposera que la méthode employée pour évaluer cette expression sur une liste est une recherche séquentielle.
La valeur spéciale None est utilisée en Python pour représenter une valeur invalide, inconnue ou indéfinie. L'expression booléenne v is None indique si la valeur de v est cette valeur spéciale.
En utilisant le canevas fourni en annexe et en ajoutant les import nécessaires :
Q13 - Implémenter la fonction positions_possibles(p, atteints) qui construit la liste des positions suivantes possibles à partir du point p . La liste atteints contient les points déjà atteints par le chemin.
Q14-Mettre en évidence graphiquement un exemple de CAE le plus court possible pour lequel, à une étape donnée, la fonction positions_possibles va renvoyer une liste vide. En prenant en compte les symétries, combien de tels chemins distincts existent pour cette longueur minimale?
Q15 - Implémenter la fonction genere_chemin_naif(n) qui construit la liste des points représentant le chemin auto-évitant de longueur n et renvoie le résultat, ou bien renvoie la valeur spéciale None si à une étape positions_possibles renvoie une liste vide.
Q16 - Évaluer avec soin la complexité temporelle asymptotique dans le pire des cas de la fonction genere_chemin_naif(n) en fonction de n, en supposant que la fonction ne renvoie pas None.
Une personne curieuse et patiente a écrit le code suivant :
from chemin import genere_chemin_naif
N, M, L, P = 10000, 351, [], []
for n in range(1, M):
nb = 0
for i in range(N):
chemin = genere_chemin_naif(n)
if chemin is None:
nb += 1
L.append(n)
P.append(nb / N)
import matplotlib.pyplot as plt
plt.plot(L, P)
plt.grid()
plt.show()
Après un long moment, elle a obtenu le graphique suivant, volontairement laissé sans étiquettes d'axes :
Q17 - Décrire ce que représente ce graphique et interpréter sa signification pour la méthode naïve.
Afin d'éviter les inconvénients de la méthode précédente, on s'intéresse à une solution différente nommée méthode du pivot, proposée par Moti Lal en 1969. Son principe est le suivant :
On part d'un chemin auto-évitant arbitraire de longueur n. Ici, on choisira une initialisation très simple, le chemin droit [[0, 0], [1, 0], [2, 0], …, [n, 0]].
On sélectionne au hasard un point, nommé pivot, entre le second et l'avant-dernier point du chemin, et un angle aléatoire de rotation parmi π, π/2 et − π/2.
On laisse les points avant le pivot inchangés et on fait subir à l'ensemble des points situés strictement après le pivot une rotation ayant pour centre le pivot et pour angle, l'angle choisi à l'étape 2 ci-dessus.
Si le chemin ainsi obtenu est auto-évitant, on le garde. Sinon, on reprend à l'étape 2 la sélection d'un pivot et d'un angle, jusqu'à en trouver une paire qui conviennent.
On répète les étapes 2 à 4 un certain nombre de fois. Le choix du nombre minimal de rotations à effectuer pour obtenir un chemin non corrélé au chemin initial est laissé de côté dans ce sujet.
Cette méthode permet de générer de manière efficace des marches auto-évitantes de plusieurs milliers de points, comme la marche ci-dessous de longueur 2000 :
Dans cet algorithme, une étape importante est la vérification qu'un chemin donné est auto-évitant. Pour vérifier cela on pourrait bien sûr s'y prendre comme dans la fonction positions_possibles, mais on adopte une méthode différente avec une fonction est_CAE(chemin) qui trie les points du chemin puis met à profit ce tri pour vérifier efficacement que le chemin est auto-évitant.
On utilise pour cela la fonction sorted qui renvoie une nouvelle liste triée par ordre croissant. Elle fonctionne sur tout type d'éléments disposant d'une relation d'ordre, y compris des listes pour lesquelles l'ordre lexicographique (ordre du premier élément, en cas d'égalité du second, etc.) est appliqué. On suppose de plus que la complexité temporelle asymptotique dans le pire des cas de cette fonction est la meilleure possible.
Q18 - Rappeler, sans la justifier, la complexité temporelle asymptotique dans le pire des cas attendue de sorted en fonction de la longueur de la liste à trier. Donner le nom d'un algorithme possible pour son implémentation.
En utilisant le canevas fourni en annexe et en ajoutant les import nécessaires :
Q19 - Implémenter la fonction est_CAE(chemin) qui vérifie si un chemin est auto-évitant en se basant sur sorted et renvoie un résultat booléen. Elle devra ne pas être de complexité temporelle asymptotique dans le pire des cas supérieure à la fonction sorted : vous prouverez ce dernier point. ◻ Q20 - Implémenter la fonction rot(p, q, a) qui renvoie le point image du point q par la rotation de centre p et d'angle défini par la valeur de a : 0 pour π, 1 pour π/2, 2 pour − π/2. ◻ Q21 - Implémenter la fonction rotation(chemin, i_piv, a) qui renvoie un nouveau chemin identique à chemin jusqu'au pivot d'indice i_piv, et ayant subi une rotation de a autour du pivot (même codage que la fonction précédente) sur la partie strictement après le pivot. ◻ Q22 - Implémenter la fonction genere_chemin_pivot(n, n_rot) permettant de générer un chemin autoévitant de longueur n en appliquant n_rot rotations. L'application d'une rotation peut nécessiter plusieurs tentatives.
Q23 - On considère un pivot, son point précédent et son point suivant. Quel est l'impact prévisible sur les rotations admissibles? Suggérer un moyen de prendre en compte cette propriété pour améliorer l'algorithme.
Fin de l'énoncéAnnexe canevas de codes Python sur les pages suivantes
Annexe : canevas de codes Python
Partie I : Randonnée
# import Python à compléter...
# importation du fichier d'une randonnée
def importe_rando(nom_fichier):
# À compléter...
coords = importe_rando("suivi_rando.csv")
# donne le point (latitude, longitude) le plus haut de la randonnée
def plus_haut(coords):
# À compléter...
print("point le plus haut", plus_haut(coords))
# exemple : point le plus haut [45.461451, 6.443064]
# calcul des dénivelés positif et négatif de la randonnée
def deniveles(coords):
# À compléter...
print("dénivelés", deniveles(coords))
# exemple : denivelés [4.059999999999945, -1.1759999999999309]
RT = 6371 # rayon moyen volumétrique de la Terre en km
# distance entre deux points
def distance(c1, c2):
# À compléter...
print("premier intervalle", distance(coords[0], coords[1]), "m")
# exemple : premier intervalle 16.230964254992816 m
# distance totale de la randonnée
def distance_totale(coords):
# À compléter...
print("distance parcourue", distance_totale(coords), "m")
# exemple : distance parcourue 187.9700904658368 m
Partie II : Mouvement brownien
# import Python à compléter...
# paramètres physiques
MU = 0.0 # N
SIGMA = 1E-8 # N
M = 1E-6 # kg
ALPHA = 1E-5 # kg/s
# vérification des hypothèses sur les paramètres
assert MU >= 0 and SIGMA > 0 and M > 0 and ALPHA > 0
# multiplication-addition vectorielle
def vma(v1, a, v2):
# À compléter...
# dérivée du vecteur d'état
def derive(E):
# À compléter...
# intégration par la méthode d'Euler
def euler(EO, dt, n):
Es = [ EO ]
# À compléter...
return Es
# simulation
DT = 0.002 # durée du pas en secondes
N = 5000 # nombre de pas
Es = euler([ 0.0, 0.0, 0.0, 0.0 ], DT, N)
print("trajectoire", Es)
Partie III : Chemin auto-évitant - méthode naïve
# import Python à compléter...
# positions auto-évitantes suivantes possibles
def positions_possibles(p, atteints):
possibles = []
# À compléter...
return possibles
# génération gloutonne d'un chemin de longueur n
# renvoie None en cas d'échec
def genere_chemin_naif(n):
chemin = [ [ 0, 0 ] ] # on part de l'origine
# À compléter...
return chemin
N = 10
print("chemin", genere_chemin_naif(N))
Partie III : Chemin auto-évitant - méthode du pivot
# import Python à compléter...
# vérifie si un chemin est CAE
def est_CAE(chemin):
# À compléter...
# calcule la rotation de q autour de p selon a :
# Pi si a vaut 0, Pi/2 si a vaut 1, -Pi/2 si a vaut 2
def rot(p, q, a):
# À compléter...
# renvoie le chemin dont les points après i_pivot
# ont subi une rotation a codé comme précédemment
def rotation(chemin, i_pivot, a):
# À compléter...
# génère un chemin de longueur n (donc n+1 points)
def genere_chemin_pivot(n, n_rot):
# À compléter...
N, A = 1000, 2.3
print("chemin", genere_chemin_pivot(N, int( A * N )))
Questions fréquentes
4 questions
Sur quoi porte le sujet d'informatique commune Mines 2021 ?
Afficher ou masquer la section
Sur quoi porte le sujet d'informatique commune Mines 2021 ?
+
Sur trois types de marche : une randonnée étudiée avec SQL et Python, le mouvement brownien simulé par la méthode d'Euler, et la génération de chemins auto-évitants dans Z².
Quelles erreurs le jury a-t-il le plus relevées en informatique commune Mines 2021 ?
+
Des requêtes SQL mal construites, une syntaxe propre à numpy utilisée sur des listes, des erreurs d'indices, des affectations écrites à l'envers et des complexités mal évaluées.
Peut-on utiliser numpy dans le sujet d'informatique commune Mines 2021 ?
+
Le sujet demandait explicitement de manipuler des listes, et le jury juge l'usage de numpy peu opportun. Il sanctionne les opérations terme à terme écrites avec la syntaxe des tableaux numpy.
Le sujet d'informatique commune Mines 2021 est-il long ?
+
Le jury estime que sa longueur et sa difficulté étaient adaptées à l'épreuve, puisque certaines copies frôlent la perfection.
Pas de description pour le moment
Commentaires• Mines Informatique Commune MP PC PSI 2021
Connectez-vous pour participer aux discussions
Partagez vos avis, posez des questions et échangez avec la communauté
Même année, X-ENSX ENS Informatique Commune MP PC PSI 2021X-ENS · 2021Corrigé
Même année, CCINPCCINP Informatique Commune PSI 2021CCINP · 2021Corrigé
.jpg)
.jpg)