Mathématiques

Espaces Vectoriels

Partie III : Applications Linéaires

Table des matières

1 Manipulation de liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2 Probabilités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .28
3 Intégration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4 Gestion de Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

1 Manipulation de liste
Exercice 1 (2017-Da Silva, 2018-Balducci et Dabas) :
On dénit la suiteu (u ) par u puis :
si u est divisible par 4 et u = (3u + 2)\\2 sinon (division entière).
n 0
n
∀n ∈ IN, u =
n+1 n n+1 n

1. Tracer les 30 premiers termes de la suite pour u = 25 puis u = 37.

4
0 0

def q1(d):
u=[d]
for k in range(30):
if u[k]%4==0:
u.append(u[k]//4)
else :
u.append((3*u[k]+2)//2)
n=[k for k in range(31)]
plt . plot (n,u)
plt .show()

q1(25)
q1(37)

2. Que se passe-t-il si il existe un n tel que u = 1 ? 0 n0

Solution :
On tombe sur le cycle élémentaire (1,2,4) qui se répète.
3. Ecrire une fonction vol de paramètre d et qui renvoie le premier indice n tel que u =1 (appelé temps de vol)
pour la suite dénie plus haut avec u = d.
0 n0

def tpsvol (d):

u=[d]
cpt=0
while u[−1]!=1 :
cpt=cpt+1
if u[−1]%4==0:
u.append(u[−1]//4)

Lycée Raspail 1 PTSI2

 Mathématiques

else :
u.append((3*u[−1]+2)//2)
return cpt

print ( tpsvol (25))

print ( tpsvol (37))

4. Tracer pour d inférieur à 1000 le graphe du maximum de la suite (u ) avec u n 0 .

=d

def maximum(d):
u=[d]
while u[−1]!=1 :
if u[−1]%4==0:
u.append(u[−1]//4)
else :
u.append((3*u[−1]+2)//2)
return max(u)

#on peut aussi eviter l ' utilisation de max :

def maximum2(d):
u=[d]
result =d
while u[−1]!=1 :
if u[−1]%4==0:
u.append(u[−1]//4)
else :
u.append((3*u[−1]+2)//2)
if u[−1]> result :
result =u[−1]
return result

print (maximum(25))
print (maximum2(25))

n=[k for k in range(1,1001)]

ordo=[]
for d in range(1,1001): #il fat eviter d=0 où le programme boucle à l ' inni
ordo.append(maximum(d))
plt . plot (n,ordo)
plt .show()

5. Ecrire une fonction qui lorsque le maximum de u est supérieur à 100000, renvoie, d (la valeur intiale), le temps
de vol et la valeur du maximum. (pour d < 1000)
n

def valeurs ():

result =[]
for d in range(1,1001):
if maximum(d)>100000:
u=[d,tpsvol(d),maximum(d)]
result .append(u)
return result

print ( valeurs ())

Lycée Raspail 2 PTSI2

 Mathématiques

Remarque : La solution proposée ici est loin d'être optimale car on recalcule la suite 3 fois quand le maximum est
supérieur à 10000, mais c'est un oral de 30min...
Exercice 2 ( 2018-Derkenne) incomplet :
Il s'agit de faire le jeu du démineur.
Faire une fonction qui construit un tableau à m lignes et n colonnes rempli de 0.
Solution :

from numpy.random import randint

import matplotlib . pyplot as plt

import numpy as np

def tableau(m,n):
result =[]
for k in range(m):
result .append([0]*n)
return result

On place aléatoirement le motif '*' dans d cases (ce sont les mines).
Solution :
Ici je choisis de faire un tableau plus grand que demandé pour éviter de faire des cas particuliers si les mines sont sur les
bords.
def placemine(m,n,d):
A=tableau(m+2,n+2)
tiragesprec =[]
i=0
while i < d:
a=np.random.randint(1,m+1)
b=np.random.randint(1,n+1)
if [a,b] not in tiragesprec :
i=i+1
tiragesprec .append([a,b])
for e in tiragesprec :
A[e[0 ]][ e[1]]= ' * '
return tiragesprec ,A

Dans les cases adjacentes aux mines (y compris en diagonale) on ajoute 1 à la case.
Tout est dans la même fonction qui renvoie une liste de listes.

Lycée Raspail 3 PTSI2

 Mathématiques

def demineur(m,n,d):

Lycée Raspail 4 PTSI2

 Mathématiques

C=placemine(m,n,d)
A=C[1]
mines=C[0]
for e in mines:
a,b=e[0],e[1]
for i in range(−1,2):
for j in range(−1,2):
if A[a+i][b+j] != '* ' :
A[a+i][b+j]=A[a+i][b+j]+1
return A

def achage (m,n,p):

A=demineur(m,n,p)
B=A[1:m+1]
for e in B:
del (e[−1])
del (e[0])
print (e)
return B

D'autres questions non faites.

Exercice 3 (2018 - De Saint Germain) : n ∈ IN vérie la propriété K si lorsqu'on écrit n ∗ ∗2 on peut le décomposer
en deux nombres dont la somme est égale à n.
Exemples : 10 = 100 et 10 + 0 = 10 ou encore 99 = 9801 et 98 + 01 = 99.
2 2

1. Ecrire une fonction d'arguments n et p qui retourne le quotient et le reste de la division euclidienne de n par 10 .
p

def div(n,p):
return n//10**p,n%10**p

print (div(10000,2))

2. Ecrire une fonction kq d'argument n qui renvoie si n vérie la propriété K ou non.

Solution :
La première question doit sûrement servir, au lieu de passer par un slicing de la chaine de caractères associée à n ,
2

le sujet ici nous propose la division par 10 le reste représente les p derniers chires de ce nombre et le quotient
p

tous ceux situés avant.

Du coup la solution vient rapidement :
def kq(n):
p=1
while 10**p<n**2: #en rééchissant on peut aller moins loin
result =div(n**2,p)
if result [0]+result [1]==n:
return True
p=p+1
return False

print (kq(22))
print (kq(99))

Lycée Raspail 5 PTSI2

 Mathématiques

print (kq(100))
print (kq(98))

3. Tester kq pour quelques p avec n = 10 et n = 10 p p

−1 . Acher le couple dont la somme fait n (pour n = 10
2
−1
acher [98,01]).
for p in range(1,25):
print (kq(10**p))
print (kq(10**p−1))

def kq2(n):
p=1
while 10**p<n**2:
result =div(n**2,p)
if result [0]+result [1]==n:
return True,[ str (n**2)[0:p ], str (n**2)[p :]] #slicing ici pour garder le 0 comme dans l'exemple
p=p+1
return False
print (kq2(99))

4. Justier sur un brouillon que ∀p ∈ IN , 10 et 10 − 1 vérient la propriété K

∗ p p

Solution :
On sort du cadre informatique, si n = 10 , alors n = 10 c'est à dire 1 suivi de 2p 0, on prend le 1 et les p zéros
p 2 2p

qui suivent et si on additionne ce nombre aux 0 qui restent on retrouve 10 . p

Si n = 10 − 1 alors n = 10 − 2 ∗ 10 + 1 regardons ce qui se passe pour p = 3 c'est à dire n = 999.

p 2 2p p

10 = 1000000 , 2 ∗ 10 = 2000 et donc 10 − 2 ∗ 10 = 998000 et ce sera toujours ainsi, 10 − 2 ∗ 10 =

6 3 6 3 2p p

(10 − 2) ∗ 10 = (n − 1) ∗ 10 .
p p p

On ajoute 1 ensuite donc n = (n − 1) ∗ 10 + 1 donc le reste de la division euclidienne de n par 10 vaut 1 et le

2 p p

quotient n − 1, la some fait donc n.

Exercice 4 (2018 - Trouche) Sûrement incomplet
1. Ecrire une fonction pour tester si un entier n est un palindrome.
def test (n):
p=str(n)
invp=''
for k in range(len(p)−1,−1,−1):
invp=invp+p[k]
return p==invp

print ( test (989))

print ( test (981))

2. Ecrire une fonction qui ache les 100 premiers palindromes.

def centpremiers ():
liste =[]
k=10
while len( liste )<100:

Lycée Raspail 6 PTSI2

 Mathématiques

if test (k):
liste .append(k)
k=k+1
return liste

print (centpremiers ())

3. Ecrire une fonction d'argument un entier p qui renvoie les palindromes formés avec les entiers à p chires.
def pchires (p):
liste =[]
k=10**(p−1)
while k<10**p:
if test (k):
liste .append(k)
k=k+1
return liste

print ( pchires (3))

Exercice 5 (2018 - Booms , Zangiacomi) incomplet

1. Faire une fonction En_deux(L) qui à partir d'une liste L renvoie la liste des éléments d'indice pair suivis des
éléments d'indice impair. (Exemple si L = [ a , b , c , d , e , f ] la fonction renvoie [ a , c , e , b , d , f ])
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Solution :

def en_deux(L):
result =[]
for k in range(0, len(L),2):
result .append(L[k])
for k in range(1, len(L),2):
result .append(L[k])
return result

print (en_deux(['a' , ' b ' , ' c ' , ' d ' , ' e ' , ' f ' ]))

2. Faire une fonction per1(n) qui à partir de la taille d'une liste renvoie p, p étant le nombreminimal de fois que la
liste considérée (de taille n) 'doit passer' dans En_deux an de retrouver la liste initiale. On génèrera la liste des
npremiers entiers pour la fonction.

def per1(n):
init =[k for k in range(n)]
L=en_deux(init)
cpt=1
while L!=init :
L=en_deux(L)
cpt=cpt+1
return cpt

print (per1(135))

Lycée Raspail 7 PTSI2

 Mathématiques

3. Soit q le plus grand entier impair inférieur ou égal à n. Faire une fonction per2(n) qui renvoie un entier p, p
étant le plus petit entier supérieur à 2 tel que (2 − 1) est divisible par q.
p

per1(n) et per2(n) doivent renvoyer la même chose.

def per2(n):
q=n
if n%2==0:
q=n−1
p=2
while (2**p−1)%q !=0:
p=p+1
return p

print (per2(135))

Il y avait d'autres questions, notamment le sujet donnait une liste d'instructions permettant de récupérer une
image de la stocker dans un np.array puis d'acher l'image en la transformant en niveau de gris. Il fallait faire
des opérations sur cette image mais aucun des deux élèves n'a réussi et visiblement le programme de l'examinateur
ne fonctionnait pas non plus...
Exercice 6 (2018- Farouk - rapport 2018) :

1. Dénir une fonction f d'argument x qui renvoie 1 + b x1 c ou btc désigne la partie entière de t, si x est strictement
positif et zéro sinon.
def q1(x):
if x <= 0:
return 0
else :
return 1 + m.oor(1/x)

print (q1(1.5))

2. A toute liste B = [b , ..., b ] de n valeurs propres non nulles (n ≥ 2), on associe :

1 n

1 1 1
S(B) = (1 + (1 + ...(1 + ))
b1 b2 bn

Par exemple S([1, 3, 2] = 11 (1 + 13 (1 + 12 )) = 32 .

On pose aussi S([b ]) = b1 .
1

En remarquant que S(B) s'écrit b1 (1 + S(B )) dénir la fonction S.

1
0

Tester cette fonction sur la liste [1, 3, 2].

1

def s2(B):
if len(B)==1:
return 1/B[0]
else :
return (1+s2(B[1:]))/B[0]

print (s2 ([1,3,2 ,]))

Lycée Raspail 8 PTSI2

 Mathématiques

3. A partir d'un nombre x strictement positif, on dénit la suite (a ) par :

- a = f (x).
n

- ∀n ∈ IN , a = f (a a ...a (x − S([a , a , ..., a ]))).

0
∗

Ecrire la fonction LA de deux arguments x et n et qui renvoie les n + 1 premiers termes de la suite (a ) en
n 0 1 n−1 0 1 n−1

partant de x.
n

def LA(x,n):
result =[q1(x)]
prod=q1(x)
while len( result ) <= n :
result .append(q1(prod*(x−s(result))))
prod=prod*result[−1]
return result

print (LA(1,5))
print (s(LA(1,5)))
print (1−1/2**6)

print (LA(5/7,4))
print (s(LA(5/7,4)))

print (LA(5/7,5))

4. Tester LA(1, 5), puis S(LA(1, 5)).

Faire de même pour LA( 7 , 4) , puis S(LA( 57 , 4)).
5

Tester LA( 75 , 5). Commenter.

Solution :
Je ne sais pas trop ce qui est attendu en commentaire, à part le fait que le dernier terme de la suite est nul et
qu'on ne peut donc pas aller plus loin.
Pour les deux premiers1 tests, on remarque que la suite est constante et un calcul rapide montre que ∀n ∈
IN , S(LA(1, n)) vaut
∗
mais je ne pense pas que ce soit ça qui était attendu.
5. Ecrire une fonction S de deux arguments x et d qui renvoie la première liste [a , a , ..., a ] trouvée telle que
2 n

x − S([a , a , ..., a ]) ≤ 10 . Tester cette fonction pour x = 1 et d = 7.

rec 0 1 n
−d
0 1 n

def Srec(x,d) :
result =[q1(x)]
prod=q1(x)
while x−s(result ) > 10**(−d) :
result .append(q1(prod*(x−s(result))))
prod=prod*result[−1]
return result

print (Srec(1,7))

Exercice 7 (2018- Poussin ) :

1. Ecrire une fonction mélanger d'argument une liste L de longueur paire et qui mélange de la façon suivante :
* L1 et L2 sont de même taille et L1 représente les premiers éléments de L et L2 les derniers.
* M est une alternance entre les éléments de L2 et ceux de L1.
Exemple : L = [1, 2, 3, 4, 5, 6], L1 = [1, 2, 3], L2 = [4, 5, 6] et M = [4, 1, 5, 2, 6, 3].
Lycée Raspail 9 PTSI2
 Mathématiques

def melanger(L):
if len(L)%2==1:
return False
result =[]
n=len(L)//2
L1=L[:n]
L2=L[n:]
for k in range(n):
result .append(L2[k])
result .append(L1[k])
return result

print (melanger([1,2,3,4,5,6]))

2. Ecire une fonction d'argument une liste L de longueur multiple de 4 et qui renvoie N construite ainsi :
* L1 et L2 sont dénies comme précédemment.
* M 1 est le mélange de L1 et M 2 celui de L2.
* N est le mélange de la liste obtenue en concaténant M 1 et M 2.
def q2(L):
if len(L)%4!=0:
return False
n=len(L)//2
L1=L[:n]
L2=L[n:]
M1=melanger(L1)
M2=melanger(L2)
return melanger(M1+M2)

print (q2([1,2,3,4,5,6,7,8]))

3. Soit L de taille 52, combien de fois faut-il appliquer la fonction précédente pour le dernier élément de L retrouve
sa place?
test =[k for k in range(52)]

def q3(L):
result =q2(L)
cpt=1
while result [−1]!=L[−1]:
result =q2(result)
cpt=cpt+1
return cpt

print (q3(test ))

4. Faire de même pour chacun des éléments de la liste L. Combien de passages devra-t-on opérer pour revenir à la
liste initiale (en utilisant les périodes trouvées juste avant)
def q4(i ,L):
result =q2(L)
cpt=1
while result [ i]!=L[ i ]:

Lycée Raspail 10 PTSI2

 Mathématiques

result =q2(result)
cpt=cpt+1
return cpt

def q4suite (L):

recu=[]
for i in range(len(L)):
if q4(i ,L) not in recu:
recu.append(q4(i,L))
return recu

print ( q4suite ( test ))

Ensuite il sut de prendre le ppcm des nombres obtenus, ici :5 ∗ 11 ∗ 4 = 220. Le jury attend peut-être une
programmation de la recherche du ppcm pour les élèves arrivant rapidement au bout. Une des manières de faire est
d'utiliser l'algorithme d'Euclide pour le pgcd puis d'en déduire le ppcm avec ppcm(a, b) ∗ pgcd(a, b) = a ∗ b
Exercice 8 (2018 - Perez) 1. Identier ce que font les deux fonctions suivantes :
def mystere1(L):
n=len(L)
p=len(L[0])
result =np.zeros((n,p))
for i in range(n):
for j in range(p):
result [ i ][ j]=L[i ][ j ]
return result

def mystere2(T):
result =[]
n=np.shape(T)[0]
p=np.shape(T)[1]
for i in range(n):
ligne =[]
for j in range(p):
ligne .append(T[i][ j ])
result .append(ligne)
return result

Solution :
La première fonction transforme une liste de listes en tableau et la seconde fait l'inverse.
2. Créer une fonction de paramètre une matrice A (un tableau) et un entier k et qui supprime la première ligne et la
k-ième colonne de la matrice.
def supprime(T,k):
prov=mystere2(T)
result1 =[]
for i in range(1, len(prov )):
ligne =prov[i]
del ( ligne [k])
result1 .append(ligne)
result2 =mystere1(result1)
return result2

Lycée Raspail 11 PTSI2

 Mathématiques

A=np.array([[1,2,−3,4 ],[ 5,6,7,−8 ],[ 9,10,11,12 ],[ 13,14,15,16 ]])

print (A)

print (supprime(A,2))

3. Ecrire une fonction récursive qui calcule le déterminant d'une matrice.

def determinant(A) : if np.shape(A)[0]!=np.shape(A)[1] : return False if np.shape(A)[0]==1 : return A[0][0] s=0
for i in range(np.shape(A)[0]) : s=s+((-1)**i)*A[0][i]*determinant(supprime(A,i)) return s
print(determinant(np.array([[2,1],[3,2]])))
print(determinant(A))
Soit t
n
Exercice 9 (2017-Huillard , 2018-Girard,Etienne)
X
n = 1 + 2 + 3 + ... + n = k

1. Exprimer t en fonction de n.
n
k=1

2. On dit alors que t est un entier de type T . Ecrire une fonction qui donne la liste de tous les entiers de type T
inférieurs à 100.
n

#Méthode 1

res1=[]
a=1
k=1
while a < 100 :
res1 .append(a)
k=k+1
a=k*(k+1)/2
print (res1)

# Méthode 2

res2=[1]
k=2
while res2[−1] < 100:
res2 .append(res2[−1]+k)
k=k+1
del (res2[−1])
print (res2)

#Methode 3
n=100
res3=[k*(k+1)/2 for k in range(1,n+1]

#Il y a bien d ' autres méthodes.

3. Ecrire une fonction somme avec comme arguments deux listes L ,L et un entier n et qui renvoie la liste des
entiers, inférieurs à n, qui peuvent s'écrire comme la somme d'un élément de L et d'un élément de L , liste
1 2

rangée dans l'ordre croissant.

1 2

def somme(L1,L2,n):

Lycée Raspail 12 PTSI2

 Mathématiques

result =[]
for e1 in L1 :
for e2 in L2:
s=e1+e2
if s not in result and s < 100 :
result .append(s)
result . sort ()
return result

print (somme([1,56,86],[85,2,95],100))
#La complexité n'est surement pas optimale

4. Donner la commande qui en utilisant la fonction précédente, permet de donner la liste des entiers inférieurs à 100
pouvant s'écrire comme la somme de trois entiers de type T inférieurs à 100. Que peut-on conjecturer?
print (somme(somme(res2,res2,100),res2,100))

#Conjecture .... il y a presque tous les nombres et à partir de 30 ils semblent tous y etre .

5. Ecrire une fonction nbdecomb qui prend en entrée un entier n et qui renvoie le nombre de combinaisons possibles
de 3 entiers de type T dont la somme donne n.
def nbdecomb(n):
T=[k*(k+1)/2 for k in range(1,n)]
result =[]
for e1 in T:
for e2 in T:
for e3 in T:
if e1+e2+e3==n:
s=[e1,e2,e3]
s . sort ()
if s not in result :
result .append(s)
return len( result )

print (nbdecomb(99))

6. En déduire le premier entier N qui est la somme de 10 combinaisons de 3 entiers de type T .

def q5():
i=0
n=5
while i < 10 :
n=n+1
i=nbdecomb(n)

return i ,n

print (q5())

7. Estimer le temps de calcul de la fonction nbdecomb.

Lycée Raspail 13 PTSI2
 Mathématiques

Solution :
La complexité de la fonction proposée ici n'est clairement pas bonne (O(n )), le jury laisse-t-il le temps de rééchir
3

à une amélioration?
# Pour mesurer le temps, il sut de mettre un compteur temps :
import time

def nbdecomb2(n):
t1=time.perf_counter()
T=[k*(k+1)/2 for k in range(1,n)]
result =[]
for e1 in T:
for e2 in T:
for e3 in T:
if e1+e2+e3==n:
s=[e1,e2,e3]
s . sort ()
if s not in result :
result .append(s)
t2=time.perf_counter()
return len( result ), t2−t1

print (nbdecomb2(399))

Exercice 10 (2018 - Glaser ) 1. Créer une fonction qui prend en argument une liste ou une chaine de caractères
et qui renvoie le nombre d'éléments distincts.
def distincts (L):
result =[]
for e in L:
if e not in result :
result .append(e)
return(len( result ))

print ( distincts ([1,2,3,−1,1,2,8]))

2. Créer une fonction tirer1 d'argument n (grâce au module random.randint donné par l'énoncé) qui renvoie un
nombre entier sous la forme d'une chaine de caractère tiré dans l'intervalle [10 , 10 − 1].
n−1 n

def tirage (n):

p=randint(10**(n−1),10**n−1,dtype=np.int64) #le dtype est pour permettre d'aller au delà de 10^9
return str (p)

print ( tirage (5))

3. Créer une fonction freq d'arguments n et N (nombre de tirages successifs) qui renvoie le nombre de fois sur N
tirages où un nombre tiré au hasard dans l'intervalle [10 , 10 − 1] contient tous les chires de 0 à 9.
n−1 n

def freq (n,N):

cpt=0
for k in range(N):

Lycée Raspail 14 PTSI2

 Mathématiques

if distincts ( tirage2 (n))==10 :

cpt=cpt+1
return cpt

print ( freq (15,2000))

4. Acher freq(n,2000) en fonction de n variant de 10 à 70.

le module random.randint ne permet pas de tirer des nombres aussi grands que 10 , je vous propose le bricolage
70

suivant pour y parvenir :

#Voici une proposition pour tirer un nombre susamment grand (jusqu'à 10^108)

def tirage2 (n):

p=randint(10**(17),10**18−1,size=6,dtype=np.int64)
nombre=''
result =''
for e in p :
nombre=nombre+str(e)
for k in range(n):
result =result+nombre[k]
return result

print ( tirage2 (18), len( tirage2 (18)))

Avec ce tirage, une solution d'achage est :

def achage ():
x=[n for n in range(10,51)]
y=[]
for n in x :
y.append(freq(n,2000))
plt . plot (x,y)
plt .show()

achage ()

5. Créer une fonction LC d'argument C une chaîne de caratères qui renvoie la liste de tous les couples distincts de
deux éléments successifs de C en tenant compte de l'ordre.
Par exemple abcbcdee renvoie [ ab , bc , cb , cd , de , ee ]
0 0 0 0 0 0 0 0 0 0 0 0 0 0

def LC(C):
result =[]
for k in range(1, len(C)):
if C[k−1:k+1] not in result :
result .append(C[k−1:k+1])
return result

print (LC('abcbcdee'))

6. Acher la fréquence d'apparition des 100 couples ([00, 01, 02, ..., 98, 99]) (Cette parenthèse n'est pas dans l'énoncé
original, il faut donc comprendre de quels 100 couples l'énoncé parle et surtout ne pas hésiter à demander des
explications à l'examinateur) en fonction de n allant de 10 à 70 avec un pas de 2 et selon 200 tirages.
Lycée Raspail 15 PTSI2
 Mathématiques

def freq2(n,N):
cpt=0
for k in range(N):
if len(LC(tirage2(n)))==100 :
cpt=cpt+1
return cpt

def achage2 ():

x=[n for n in range(10,100,2)]
y=[]
for n in x :
y.append(freq(n,200))
plt . plot (x,y)
plt .show()

achage2 ()

7. une dernière question

Exercice 11 (2018-Crozat) modié On construit une liste de couple C telle que C = [[0, 0], C , C , ...., C ] avec C
et C qui sont graphiquement espacés de 1 verticalement ou horizontalement.
1 2 n i+1

donc l'une des deux coordonnées seulement change et elle change de +1 ou -1. Exemple :
i

C=[[0,0],[1,0],[1,-1],[1,0],[2,0],[2,1],[2,0],[1,0],[1,1]]
1. A l'aide du module randint de numpy.random, proposer une fonction de paramètre un entier n et qui construit une
liste de longueur n vériant la condition précédente.
Remarque : Je suppose que le jour de l'épreuve une liste était donnée pour les tests.
def constr(n):
result =[[0,0 ]]
for k in range(n):
i=randint(4)
temp=result[−1].copy()
if i==0:
temp[0]=temp[0]−1
elif i==1:
temp[0]=temp[0]+1
elif i==2:
temp[1]=temp[1]−1
else :
temp[1]=temp[1]+1
result .append(temp)
return result

Ltest=constr(20)
print (Ltest)

2. Ecrire une fonction deb(C) qui renvoie l'indice du premier couple deux fois présent dans la liste C et -1 s'il n'y
a aucune répétition.
Avec la liste précédente cette fonction doit renvoyer 1.

Lycée Raspail 16 PTSI2

 Mathématiques

def deb(L):
test =[]

Lycée Raspail 17 PTSI2

 Mathématiques

for e in L:
if e not in test :
test .append(e)
else :
return test . index(e)
return −1

print (deb(Ltest))

3. Ecrire une fonction boucle(C) qui renvoie [] si deb(C)=-1 et qui sinon renvoie le couple [d,`] avec d=deb(C) et
` le dernier indice d'apparition du même couple (celui qui apparait en d) dans la liste C.
Sur la liste donnée en exemple, la fonction renvoie [1,7]
def boucle(L):
i=deb(L)
if i==−1:
return []
prems=L[i]
for k in range(len(L)−1,i,−1):
if L[k]==prems:
return [ i ,k]

print (boucle(Ltest ))

4. Ecrire une fonction suivant(C) qui renvoie les d premiers couples de C et les couples situés au delà de l'indice `
(où d et ` sont les entiers dénis à la question précédente).
Sur l'exemple précédent cela doit renvoyer [[0,0],[1,0],[1,1]]
def suivant (L):
e=boucle(L)
if e==[]:
return L
result =[]
for k in range(e[0 ]):
result .append(L[k])
for k in range(e[1 ], len(L)):
result .append(L[k])
return result

print ( suivant (Ltest ))

5. Ecrire une fonction listenale(L) qui utilise les fonctions précédentes pour renvoyer une liste sans doublon.
def listenale (L):
C=L.copy()
while deb(C)!=−1:
C=suivant(C)
return C

print ( listenale (Ltest ))

6. Donner le code permettant de tracer la trajectoire des points représentés par C sans doublon ainsi que le code
permettant d'obtenir x , x , y , y
min max min max

Lycée Raspail 18 PTSI2

 Mathématiques

xmin=min(x)
xmax=max(x)
ymin=min(y)
ymax=max(y)
plt . plot (x,y)
plt . axis ([xmin−1,xmax+1,ymin−1,ymax+1])
plt .show()

Exercice 12 (2018-Junqueira) 1. Ecrire une fonction s d'argument p qui renvoie la somme des diviseurs de p
diérents de p lorsque p ≥ 2 et 0 sinon.
An de réduire le temps de calcul, on utilisera les nombres dont le carré est inférieur ou égal à p.
def s(p):
if p < 2:
return 0
result =1
for k in range(2,m.oor (m.sqrt(p)+1)):
if p%k==0:
result =result+k+p//k
return result

print (s(28))

2. Déterminer la liste des nombres compris entre 2 et 100000 tels que s(p) = p.
un tel nombre est appelé nombre parfait.
def parfait ():
result =[]
for k in range(2,100000):
if s(k)==k:
result .append(k)
return result

print ( parfait ())

3. Soit une suite (a ) dénie comme suit : a = p et ∀n ∈ IN, a = s(a ).

Ecrire une fonction qui renvoie les termes de la suite et qui s'arrête lorsqu'un nombre est répété.
n 0 n+1 n

def suite (p):

result =[p]
suiv=s(p)
while suiv not in result :
result .append(suiv)
suiv=s(result[−1])
result .append(suiv)
return result

print ( suite (250))

4. Déterminer les nombres dont la période est la plus longue. J'ai de gros doutes sur cette question, je l'ai interprété
comme l'écart entre deux répétitions du même nombre dans la liste. Le souci est qu'on ne donne pas de nombre
Lycée Raspail 19 PTSI2
 Mathématiques

maximal, or soit il est petit et les résultats ne sont pas 'interessants' (1 ou 2 comme période) soit il est grand et
alors certains nombres posent problème comme 276 dont la suite 'semble' croître à l'inni. Je dis bien 'semble',
une recherche internet montre qu'en eet ce nombre pose problème, on arrive a une somme de diviseurs à 100
chires (je me suis arrêté à 17) et on ne sait pas ce qui se passe ensuite..
def periode(p):
result =[p]
suiv=s(p)
while suiv not in result :
result .append(suiv)
suiv=s(result[−1])
result .append(suiv)
return len( result )− result . index( suiv)−1

#print(periode(25))

def periode2 ():

result =[]
m=0
for k in range(2,275):
p=periode(k)
if p==m :
result .append(k)
if p > m :
result =[k]
m=p

return m, result

print (periode2())

5. Déterminer les nombres dont la liste est la plus longue. Même remarque que ci-dessus même si les résultats sont
plus interessants, j'ai donc pris un max à 275.
def longmax():
result =[]
m=0
for k in range(2,275):
p=len(suite(k))
if p==m:
result .append(k)
if p > m :
result =[k]
m=p
return m, result

print (longmax())

Exercice 13 (2018 - Kedzia) :

Lycée Raspail 20 PTSI2

 Mathématiques

def L2int(L):
ch=""

Lycée Raspail 21 PTSI2

 Mathématiques

for e in L:
ch=ch + str(e)
return int (ch)

def intL2(n):
L=[]
for car in str (n):
L=L+[int(car)]
return L

1. Que font ces deux fonctions?

Solution :
La première transforme une liste (ou chaine de caractères) en entier et la seconde transforme un entier en liste.
2. Soit la suite (u ) dénie par u = a ∈ IN et ∀n ∈ IN, u = ϕ(u ) où ϕ est une application qui pour un entier
'lit' le nombre de la manière suivante :
n 0 n+1 n

 1112 → 3112 (trois "un" un "deux").

 334 → 2314 (deux "trois" un "quatre").
 29 → 1219
3. Ecrire une fonction lire qui pour un n donné renvoie ϕ(n).
def lire (n):
prov=intL2(n)
result =[]
nombr=prov[0]
cpt=1
for k in range(1, len(prov )):
if prov[k]==nombr:
cpt=cpt+1
else :
result =result+[cpt,nombr]
cpt=1
nombr=prov[k]
result =result+[cpt,nombr]
return L2int( result )

print ( lire (1112))

print ( lire (334))
print ( lire (29))

4. Donner la liste des dix premiers termes de la suite (u ) pour a = 44440.

n

def suite (n,p):

result =[n]
for k in range(p):
result .append( lire ( result [−1]))
return result

print ( suite (44440,10))

5. Existe-t-il un entier a tel que (u ) soit constante?

n
Solution :

Lycée Raspail 22 PTSI2

 Mathématiques

En rééchissant un peu 22 semble un bon candidat, on peut tester informatiquement s'il y en a d'autres en dessous
de 10000
def test ():
result =[]
for k in range(10000):
if lire (k)==k:
result .append(k)
return result

print ( test ())

Peut-être un raisonnement était-il attendu ici, j'ai choisi l'option 'informatique'.

6. Construire une fonction ecrire qui pour un entier k renvoie n tel que ϕ(n) = k ou -1 si ce n n'existe pas.
def ecrire (k):
result =[]
prov=intL2(k)
p=0
while p+1 < len(prov):
for i in range(prov[p ]):
result .append(prov[p+1])
p=p+2
test =L2int( result )
if lire ( test )==k:
return test
return −1

print ( ecrire (245190))

Exercice 14 (Maths II - 2018 - Schacht) Dans cet exercice, on considère des matrices de taille p xé,  qui sont 
0 1 2
modélisées par une liste. Par exemple, M = 02 13 est modélisée par M=[0,1,2,3] si p = 2, et M = 3 4 5
!

est modélisée par M=[0,1,2,3,4,5,6,7,8] si p = 3.

6 7 8

1. Écrire une fonction qui prend en entrée deux vecteurs de taille n modélisés par une liste, et qui renvoie leur produit
scalaire.
def prods(u,v):
result =0
n=len(u)
for i in range(n):
result =result + u[i]* v[ i ]
return result

2. Écrire une fonction ligne qui prend en entrée une matrice M de taille p et un entier i ∈ [ 1, p]], puis renvoie la
i-ème ligne de M.

def ligne (M,i):

p=int(m.sqrt(len(M)))
if 0 <= i <= p−1:
return M[(i)*p:( i+1)*p]

Lycée Raspail 23 PTSI2

 Mathématiques

return False

3. Écrire une fonction colonne qui prend en entrée une matrice M et un entier i ∈ [ 1, p]], puis renvoie la i-ème
colonne de M.
def colonne(M,i):
p=int(m.sqrt(len(M)))
result =[]
if 0 <= i <= p−1:
for k in range(p):
result .append(M[i + k*p ])
return result
return False

4. Écrire une fonction produit qui prend en entrée deux matrices de taille p et calcule leur produit.
def produit(M,N):
if len(M)!=len(N):
return False
p=int(m.sqrt(len(M)))
result =[]
for i in range(p):
for j in range(p):
result .append(prods(ligne(M,i),colonne(N,j )))
return result

print (produit ([1,2,3,4,5,6,7,8,9 ],[ 10,11,12,13,14,15,16,17,18]))

5. Écrire une fonction puissance qui prend en entrée une matrice M et un entier non nul n puis calcule M . n

On remarquera que si n = 2k est pair alors M = (M ) , et si n = 2k + 1 est impair alors M = M × (M ) .

2k 2 k 2k+1 2 k

def puissance(M,n):
if n==1:
return M
N=puissance(M,n//2)
if n%2==0:
return produit(N,N)
return produit(M,produit(N,N))

6. On considère une suite (U ) dénie par U = et ∀n ∈ IN, U Écrire une fonction qui
! !
0 0 1
n 0 n+1 = × Un .
1 1 1
prend en entrée un entier n puis calcule U . n

A=[0,1,1,1]
def suite (n):
B=puissance(A,n)
#on fait ensuite ' à la main' le produit par [0,1]
return ([B[1],B[3 ]])

Lycée Raspail 24 PTSI2

 Mathématiques

print ( suite (50))

7. Calculer U 50 .

Exercice 15 (Maths II - 2018 - Naze) On a un lot de pièces , U pièces défectueuses représentées par 1 et Z pièces
correctes représentées par 0.
Le lot contient 10 pièces défectueuses et 20 pièces correctes
from random import randint
def tirer (u,z ):
r=randint(1,u+z)
if r<=u:
return 1
else :
return 0

1. Que fait cette fonction et la recopier.

2. Ecrire une fonction FA(u,z,n) qui retourne une liste L qui contient le résultat de n tirages successifs avec remise
dans le lot de pièce. Tester avec n = 30.
def FA(u,z,n):
L=[]
for i in range(n):
L.append( tirer (u,z))
return L

3. Ecrire une fonction FS(u,z,n) qui retourne une liste L qui contient le résultat de n tirages successifs sans remise
dans le lot de pièce. Tester avec n = 10 , n = 30, n = 40. Améliorer la fonction si besoin.
def FS(u,z,n):
L=[]
u1=u
z1=z
if n > u+z :
return False
for i in range(n):
x=tirer (u1,z1)
if x==1:
if u1>0:
u1=u1−1
L.append(1)
else :
z1=z1−1 #si u1=0, il n'y a plus que des pieces correctes donc on en tire forc ément une
L.append(0)
else :
if z1>0:
z1=z1−1
L.append(0)
else :
u1=u1−1 #même chose mais avec des pieces defectueuses

Lycée Raspail 25 PTSI2

 Mathématiques

L.append(1)
return L

print (FS(10,20,10))
print (FS(10,20,40))
print (FS(10,20,30))

4. Ecrire une fonction MA(u,z,N) qui donne la moyenne des pièces défectueuses en eectuant N fois l'expérience
qui consiste à tirer 15 pièces avec remise dans le lot.
def MA(u,z,N):
som=0
for i in range(N):
x=FA(u,z,15)
som=som+x.count(1)
return som/N

print (MA(10,20,1000))

5.
6. Ecrire une fonction MS(u,z,N) qui donne la moyenne des pièces défectueuses en eectuant N fois l'expérience
qui consiste à tirer 15 pièces sans remise dans le lot.
def MS(u,z,N):
som=0
for i in range(N):
x=FS(u,z,15)
som=som+x.count(1)
return som/N

print (MS(10,20,1000))

7. Ecrire la fonction qui permet de déterminer la probabilité d'avoir plus de pièces défectueuses dans un tirage avec
remise de 15 pièces du lot.
def proba(u,z,N):
som=0
for i in range(N):
x=FA(u,z,15)
if x.count(1)>=10:
som=som+1
return som/N

print (proba(10,20,10000))

Exercice 16 (Voltaire - 2018) :

Lycée Raspail 26 PTSI2

 Mathématiques

On dénit deux suites (p ) et (q ) en posant :

n n

 

et ∀n ∈ IN, q = p2n + 2qn2

p = 1 p
0 n+1
.
q0 = 1 n+1 = 2pn qn

On admet que √
et  pn √ 
 
pn ∗ 1
lim = 2 ∀n ∈ IN , 
 − 2 ≤ 2n−1 .
n→+∞ qn qn 10
1. Écrire une fonction suite1 d'argument n qui calcule le n-ème couple (p , q ). n n

def suite1 (n):

p=1
q=1
for k in range(n):
p,q=p**2+2*q**2,2*p*q
return p,q

2. Acher les 7 premiers couples.

for k in range(7):
print ( suite1 (k))

3. Écrire une fonction suite2 d'argument r qui renvoie un couple (p , q ) tel que  pq √ 
 
n
n n − 2 ≤ r.
n
Solution :
On va utiliser la majoration donnée dans l'énoncé ici car il n'est pas question d'utiliser m.sqrt(2) qui n'est qu'une
valeur approchée.
def suite2 (r ): # reutiliser la fonction suite1 est une heresie ici .
p=1
q=1
n=0
while 1/10**(2**n−1) > r:
p,q=p**2+2*q**2,2*p*q
n=n+1
print (n)
return p,q

print ( suite2 (0.00001))

4. Tester les lignes de code suivantes :

from decimal import *
getcontext().prec = 6
print(Decimal(1) / Decimal(7))

getcontext().prec = 28
print(Decimal(1) / Decimal(7))
Solution :
Cela permet donc de savoir combien de décimales on va garder pour le calcul et l'achage.
5. Calculer ainsi les 100 premières décimales de 2.
√

Lycée Raspail 27 PTSI2

 Mathématiques

from decimal import *

getcontext (). prec = 6

print (Decimal(1) / Decimal(7))

getcontext (). prec=28

print (Decimal(1)/Decimal(7))

p,q=suite2(10**(−100))
getcontext (). prec=100
print (Decimal(p)/Decimal(q))

print (Decimal(2).sqrt ())

6. Comparer le résultat précédent avec celui donné par Decimal(2).sqrt().

Solution :
A une ou deux décimales près à la n, on obtient le même résultat.

2 Probabilités
Exercice 17 (2018-Clouzot) :
Soit D une variable aléatoire réelle à valeurs dans {−1, 1}.
On dénit la variable aléatoire réelle X = 0 puis ∀n ∈ IN, X = X + D .
n

0 n+1 n n

1. Ecrire une fonction Dsans argument renvoyant un tirage de D en utilisant random.

n
Solution :

from numpy.random import randint

def D():
d=randint(2) #renvoie 0 ou 1
if d==0:
return −1 #on remplace 0 par −1
return d

2. En déduire la liste LX(n) de X à X . 0 n

Solution :

def LX(n):
result =[0]
for k in range(n):
result .append(result[−1]+D())
return result

print (LX(25))

3. Tracer 5 courbes de 10000 points avec (0, LX(0)), ...,(n, LX(n)).

Solution :

Lycée Raspail 28 PTSI2

 Mathématiques

import matplotlib . pyplot as plt

import numpy as np

for k in range(5):
a=LX(10000)
x=[i for i in range(1,10001)]
y=[a[i ] for i in range(1,10001)]
plt . plot (x,y)
plt .show()

4. Ecrire une fonction atteindre de 2 arguments (h, m) avec k ∈ Z et m ∈ IN qui renvoie 1 si h est atteint pour un
n tel que 0 ≤ n ≤ m et 0 sinon.
Solution :

def atteindre (h,m):

x=0
i=0
while i < m :
i=i+1
x=x+D()
if x==h :
return 1
return 0

print ( atteindre (5,35))

5. Estimer la probabilité de ∃n ∈ IN \h soit atteint pour h ∈ [ − 20, 20]]. Tracer les points correspondants.
∗

Solution :

x=[i for i in range(−20,21)]

y=[]
for k in range(−20,21):
proba=0
for i in range(1000): #on repete mille fois l ' opération
proba=proba+atteindre(k,1000) #on regarde si k est atteint en 1000 coups
y.append(proba/1000)
plt . plot (x,y)
plt . saveg ()
plt .show()

Lycée Raspail 29 PTSI2

 Mathématiques

On obtient une courbe centrée en 0 ce qui semble cohérent avec le programme.

3 Intégration
Exercice 18 (2018 - De la Fouchardière) 1. Soit f (x) = e (1 + cos((4x + 1) )).
−x 2

Tracer f entre 0 et 1 puis à l'aide de scipy.integrate.quad calculer une valeur approchée de ` =

Z 1
f (t)dt
0

def fonction2(x):
return m.exp(−x)*(1+m.cos((4*x+1)**2))

x=np.linspace(0,1,150)
y=[fonction2( i ) for i in x]
plt . plot (x,y)
plt .show()

print ( ' une valeur approchée de l integrale de 0 à 1 est ' , integrate .quad(fonction2,0,1))

2. Ecrire une fonction ST d'argument n non nul qui coupe l'intervalle [0, 1] en n morceaux égaux et qui estime ` à
l'aide de la méthode des trapèzes.
def ST(n):
result =0
for k in range(n):
result =result+(fonction2(k/n)+fonction2((k+1)/n))/(2*n)
return result

print (ST(500))

Lycée Raspail 30 PTSI2

 Mathématiques

3. Ecrire une fonction M d'argument r qui renvoie une matrice M ∈ M (IR) telle que : r

∀i ∈ [ 1, r]], ∀j ∈ [ 1, r]], mij j i

def M(r):
result =np.zeros((r , r))
for i in range(r ):
for j in range(r ):
result [ i ][ j]=(j+1)**(i+1)
return result

4. Résoudre à l'aide de solve.linalg l'équation M (8)X = B avec B = (0, 121 , 0, 120

−1
, 0, 0, 0, 0).

B=np.array([0,1/12,0,−1/120,0,0,0,0])
print (np. linalg . solve (M(8),B))

Mathieu précise ne plus être sûr des valeurs, le résultat est 'moche' mais je n'ai pas vu quelles valeurs auraient
amené un résultat cohérent avec le début de l'exercice (ou sa suite d'ailleurs)
La suite de l'énoncé est sujette à caution, d'apèrs Mathieu la suite ne fonctionnait pas eti une mauvaise écriture
me fait même douter de la fonction suivante, était-ce un + ou un × entre f ( n ) et f (1 − n ?
i

5. Ecrire une fonction bouts de paramètres n et k avec n ≥ k qui renvoie X f ( ni ) + f (1 − ni )

k−1

i=1

def bouts(n,k):
result =0
for i in range(1,k):
result =result+fonction2(i/n)+fonction2(1−i/n)
return result

6. Ecrire une fonction ST cor (n) qui corrige la valeur de ` et renvoie ST (n) + bouts(8, n).

4 Gestion de Fichiers
Exercice 19 (2018-Voltaire) Le chier villes_france.csv ci-joint contient une ligne pour chaque commune de
France. Chacune de ces lignes contient dans l'ordre les données suivantes (séparées par des points-virgules) : numéro
de la ligne, numéro du département, nom de la commune, population (en 2010), densité, supercie (en km ), longitude
2

(en degré), latitude (en degré), altitude minimale (en m), altitude maximale (en m).
1. Combien y a-t-il de communes en France? On calculera ce nombre à l'aide de Python, en commençant par se
connecter au chier.
 =open(' villes_france . csv ' , ' r ' )

L=. readlines ()
 . close ()

Lycée Raspail 31 PTSI2

 Mathématiques

print (len(L))

2. Écrire une fonction prenant en entrée le nom d'une commune, et renvoyant sa supercie.
propre=[]
for ligne in L:
liste =ligne. split ( ' ; ' )
liste .pop()
liste .pop() #ces deux lignes servent à enlever les deux derniers éléments 'moches'
propre .append( liste )

#On récupère une liste de listes ou chaque liste ' interne ' correspond à une ligne du chier
#Ensuite il n ' y a plus qu'à travailler sur cette liste

print (propre)

def supercie (nom):

for ligne in propre :
if ligne [2]==nom:
return ligne [5]
return False

print ( supercie ( ' Paris ' ))

print ( supercie ( ' Clermont−Ferrand'))

3. Quelle est la ville la plus peuplée de France? La (ou les) ville(s) la (ou les) moins peuplée(s) de France (on notera
les ex aequo)?
def peuplée ():
mini=10000000
maxi=0
popmax=[]
popmin=[]
for ligne in propre :
if int ( ligne [3]) > maxi:
popmax=[(ligne[2])]
maxi=int(ligne [3])
elif int ( ligne [3])==maxi :
popmax.append((ligne[2]))
elif int ( ligne [3])<mini:
mini=int( ligne [3])
popmin=[ligne[2]]
elif int ( ligne [3])==mini:
popmin.append(ligne[2])
return popmax,maxi,popmin,mini

print (peuplée())

4. Construire la liste DPT contenant les numéros de tous les départements, classés dans l'ordre où ils apparaissent
dans ce chier. On remarquera que le numéro 20 n'est pas utilisé (il est remplacé par '2A' et '2B' pour la Corse).
Lycée Raspail 32 PTSI2
 Mathématiques

def departements():
dpt=[]
for ligne in propre :
if ligne [1] not in dpt:
dpt.append(ligne[1])
return dpt

print (departements())

5. Construire une liste contenant, pour chaque département, la ville la plus peuplée (on admet cette fois qu'il n'y a
pas d'ex aequo).
def peupledpt ():
dpt=departements()
result =[]
for num in dpt:
result .append([num,0,0])
for ligne in propre :
for element in result :
if ligne [1]==element[0]:
if int ( ligne [3])>element[2]:
element[1]=ligne [2]
element[2]=int( ligne [3])
return result

print (peupledpt())

6. Tracer la carte des villes de France métropolitaine (celles dont le numéro de département est un entier compris
entre 1 et 95). On représentera la ville de longitude ϕ et de latitude α par un point de coordonnées cartésiennes
(ϕ, sin α). (On pensera à convertir la latitude et la longitude en radians...) Qu'observe-t-on?

x=[]
y=[]
for ligne in propre :
if ligne [1]!= ' 2A' and ligne [1]!= ' 2B' :
if 1 <= int(ligne[1]) <= 95:
x.append(oat( ligne [6])* m.pi/180)
y.append(m.sin(oat ( ligne [7])* m.pi/180))

plt . plot (x,y, ' * ' )

plt .show()

Si on essaie de rajouter la Corse la carte est moins jolie.

x=[]
y=[]
for ligne in propre :
if len( ligne [1])==2:
x.append(oat( ligne [6])* m.pi/180)
y.append(m.sin(oat ( ligne [7])* m.pi/180))

Lycée Raspail 33 PTSI2

 Mathématiques

plt . plot (x,y, ' * ' )

plt .show()

Cet exercice a entièrement été reconstruit, par M.Hesse à partir des attributs du chier source fournis
par son élève.

Lycée Raspail 34 PTSI2