1. n est de type int (entier). Si x ∈ [0,1[, alors 0 ≤ (h+2)/2× x < (h+2

CORRIGÉ SUJET 0 MINES
1. nest de type int (entier). Si x∈[0,1[, alors 0 ≤(h+2)/2 ×x<(h+2)/2, donc nest un entier tel
que : 0 ≤n<h
2+2.
2. def calcul_n ( h ) :
i f h>1 :
return int ( ( h+2.0)/2*random ( )) +1
else :
return 0
3. Petite difficulté : si on ne fait rien, toute variable piles définie dans le corps de la fonction est
locale et sera "détruite" à la fin de l’exécution. On rend une variable "globale" en la déclarant, à
l’aide du mot-clé "global".
def i n i t i a l i s a t i o n (P ) :
global p il e s
pi les = [0 ] *P
Méthodes alternatives pour créer la liste [0,· · · ,0] :
pi les =[0 for i in range (P ) ]
ou
pi les = []
for i in range (P ) :
pi le s . append (0 )
On évite le problème de la variable globale en définissante une fonction qui renvoie une liste
[0,· · · ,0], on ne définit piles que dans le programme principal :
def i n i t i a l i s a t i o n (P)
return [ 0 ]*P
pi le s = i n i t i a l i s a t i o n (100) # par exemple
Rappel cours :
Les variables créées par une fonction sont, par défaut, locales, et masquent (sans les "écraser") les
variables globales de même nom. Elles sont "détruites" à la fin de l’évaluation. Les paramètres
formels de la fonction sont des variables locales qui sont initialisées avec la même identité (et
en particulier la même valeur) que les arguments passés à la fonction. Il n’est pas interdit de
modifier leur valeur pendant l’évaluation, mais à la fin de l’évaluation, ces modifications ne sont
pas conservées car les variables locales sont détruites. Deux exceptions : La déclaration "global"
permet à la fonction de créer et modifier des variables globales, ces modifications étant conservées
après l’évaluation de la fonction. Quand l’argument est une liste (type "mutable"), les modifica-
tions apportées à ses termes sont conservées, car elle conserve son identité, ce sont les identités
des termes qui changent (ce n’est pas le cas si on ré-affecte directement la liste).
En Python, les listes (et les dictionnaires) sont mutables. Attention : les entiers, les floats, mais
aussi les strings et les tuples ne sont pas mutables !
4. def actualise ( piles , perdus ) :
global perdus # pas nécessaire pour une l i s t e
for p in range ( len ( p il es ) −1):
h= pi l e s [ p+1]−p i l e s [ p ]
i f h>1:
n=calcul_n (h )
p i l es [ p ] −= n

p i l es [ p+1] +=n
h=p il es [ −1]
n=calcul_n (h )
p il es [ −1] −= n
perdus +=n
5. L’utilisateur entre P à l’aide de la commande "input". Attention, input lit ce qu’on entre au clavier
comme une chaîne. Il faut penser à convertir en entier.
P= int ( input ( " nombre de pi le s " ) )
initialisation(P)
nb_instructions=0
perdus=0
while ( perdus <1000):
i f nb_instructions % 10 ==0 :
pi les [ 0 ] +=1
actualise ( piles , perdus )
6. Pour tracer une courbe connaissant une liste x d’abscisses et y d’ordonnées, on utilise la fonction
plot de la bibliothèque matplotlib.pyplot (abrégée en plt).
x=[ i f or i in range (P ) ] # ou bien x= np . arange (P)
y=piles
pl t . p lot ( x , y )
Si on se contente de fournir une liste, les indices sont pris comme listes d’abscisses, les termes
comme liste d’ordonnées, ce qui simplifie le code :
plt . plot ( pi le s )
7. L’intitulé des colonnes est trompeur : Votant sans "s", et aucune répétition dans cette colonne. La
colonne Votant contient bien le nombre de votants qu’il y a dans chaque laboratoire, la requète
est donc naturellement :
SELECT
densite , R, Kn, Gamma, Kt , mu
FROM granular_base
WHERE mat = " verre " AND geom = " sphere " AND note >= 3
AND Votant >=3;
8. On définit une classe "grain". Pour créer une instance (c-à-d., un objet de cette classe), on utilise
la syntaxe G=grain(x,y), ce qui appelle en réalité la fonction __init__(G,x,y) et initialise un grain G
possédant les attributs : G.pos (position) de valeur initiale (x,y), G.vit (vitesse) de valeur initiale
(0,0), G.force (force d’interaction) de valeur initiale (0,0).
9. Les grains sont empilés comme sur le schéma :
2/ 4

10. Les erreurs d’arrondis font qu’il n’est pas possible numériquement d’avoir une distance entre
les grains qui soit exactement de 2R.
11. hypotenuse = sqrt ( ( Xi−Xj )**2+( Yi−Yj )** 2)
cos_alpha = (Xj−Xi ) / hypotenuse
sin_alpha = (Yj−Yi )/ hypotenuse
12. def somme_int ( ) : # sommation pour chaque grain des interac ti o ns
for i in range ( len ( tas ) ) :
for j in range ( len ( tas ) ) :
i f j != i :
Fjin , F j i t = calcul_Fnt ( i , j )
Fj ix = Fjin *cos_alpha −F j i t *sin_alpha
Fj iy = Fjin *sin_alpha + F j i t *cos_alpha
tas [ i ] . for c e [0 ] += Fjix
tas [ i ] . for c e [1 ] += Fjiy
13. En considérant, l’accélération constante égale à aksur l’intervalle ](k−1/2)∆t,(k+1/2)∆t[, on
obtient une approximation à l’ordre 1 de la vitesse vk+1/2 ; de même, en considérant la vitesse
constante égale à vk+1/2 sur l’intervalle ]k∆t,(k+1)∆t[, on obtient une approximation à l’ordre 1
de la position xk:
(vk+1/2 =vk−1/2 +ak∆t
xk+1=xk+vk+1/2∆t
14. Delta_t = T_stop / inc
for k in range ( inc ) :
somme_int ( )
for i in range ( len ( tas ) ) :
Fix , Fiy=tas [ i ] . force
mi = M
ax = Fix / mi
ay = Fiy / mi−g
x , y = tas [ i ] . pos
vx , vy = tas [ i ] . v it
vx += ax*Delta_t
x += vx*Delta_t
vy += ay*Delta_t
y += vy*Delta_t
tas [ i ] . pos = x , y
tas [ i ] . v it = vx , vy
15. Dans tout schéma d’intégration numérique, on approche la courbe entre deux instants par une
courbe plus simple (ici, un segment). Il faut bien chosir le pas car :
augmenter le pas augmente le risque d’un écart entre la courbe et son approximation ;
diminuer le pas augmente le temps de calcul et les accumulations d’erreurs d’arrondi.
16. L’introduction du terme d’ordre 1 est problématique car dans la méthode, la vitesse est calculée
en fonction de l’accélération. On résout le problème en calculant aken fonction de vk−1/2, c’est-à-
dire :
ax = Fix / mi −1/tau / mi*vx
ay = Fiy / mi−1/tau / mi*vy −g
vx += ax*Delta_t
x += vx*Delta_t
3/ 4

vy += ay*Delta_t
y += vy*Delta_t
mais on a une méthode proche de celle d’Euler. Il vaut mieux approcher : vk=vk−1/2 +vk+1/2
2. On
obtient la formule de récurrence :
µ1+
∆t
2τmi¶vk+1/2 =µ1−
∆t
2τmi¶vk−1/2 +F mi
∆t
Il est préférable de choisir ∆tpetit devant τmi.
17. Le calcul de somme_int() est quadratique (2 boucles imbriquées).
18. Un grain de sable semble n’interagir qu’avec (environ) 6 autres grains. Si on a un accès direct à
ces grains-là, on peut espérer une complexité de l’ordre de 6n, donc linéaire, pour cette partie de
l’algorithme.
19. ? ? ?
4/ 4