Exercices Types – Algorithmique et simulation

Transcription

Exercices Types – Algorithmique et simulation numérique – Oral Mathématiques et Algorithmique – Banque PT – Propositions de réponses
Exercice 0
# -*- coding: utf-8 -*#--- question 1 ---------------------------------------------------------------print('\n --- Question 1 --- ')
n = 1234
q = 1234 // 10
# quotient de n par 10
r = 1234 % 10
# reste de n par 10 = chiffre des unités
q1 = q // 10
# reste de q par 10
r1 = q % 10
# reste de q1 par 10 = chiffre des dizaines
print('n = {}, q = {}, r = {}, q1 = {}, r1 = {}'.format(n, q, r, q1, r1))
print('Les restes successifs contiendront les chiffres de n')
#--- question 2 ---------------------------------------------------------------print('\n --- Question 2 --- ')
s = r**3 + r1**3
# contiendra la somme des cubes des chiffres
q2 = q1 // 10
s += (q1 % 10)**3
s += (q2 % 10)**3
--- Question 1 --n = 1234, q = 123, r = 4, q1 = 12, r1 = 3
Les restes successifs contiendront les chiffres de n
--- Question 2 --Somme des cubes des chiffres de 1234 : 100
--- Question 3 --Somme des cubes de 1234 :
--- Question 4 --Les chiffres inférieurs à
0, 1, 153, 370, 371, 407,
--- Question 5 --Somme des cubes de 1234 :
100
1000 égaux à la somme des cubes de leurs chiffres :
100
print('Somme des cubes des chiffres de {} : {}'.format(n, s))
def somcube(n):
"""
n : entier naturel
renvoie la somme des cubes des chiffres de l'écriture décimale de n
"""
s = 0
# contiendra la somme des cubes des chiffres
q = n
# contiendra les quotients successifs par 10
# la boucle stoppe lorsque q = 0
while q:
s += (q % 10)**3
q = q // 10
# que l'on peut écrire q //= 10
return s
print('Somme des cubes de 1234 : ', somcube(1234))
maxi = 1000
print('Les chiffres inférieurs à {} égaux à la somme des cubes de leurs\
chiffres :'.format(maxi))
for i in range(maxi + 1):
if i == somcube(i):
print(i, end = ', ')
print()
def somcube2(n):
"""
n : entier naturel
renvoie la somme des cubes des chiffres de l'écriture décimale de n
"""
[email protected]
1
chiffres_str = str(n)
# chaîne de caractères des chiffres de n
somme = 0
for c in chiffres_str:
somme += int(c)**3
return somme
# ou bien : return sum(int(c)**3 for c in chiffres_str )
print('Somme des cubes de 1234 : ', somcube(1234))
Exercice 1
# -*- coding: utf-8 -*import matplotlib.pyplot as plt
import scipy.integrate as integ
#------------- lecture des données ------------fichier = open('data/ex_001.csv', 'r')
LX = []
LY = []
# liste des abscisses
# liste des ordonnées
for ligne in fichier:
donnee = ligne.split(';')
LX.append(float(donnee[0]))
LY.append(float(donnee[1]))
fichier.close()
--- Question 1 --abscisses x | ordonnées y
------------------------0.0
| 1.00988282142
0.1
| 1.07221264497
0.2
| 1.11111111111
0.3
| 1.21212212121
0.4
| 1.0101010101
0.5
| 0.99999991111
0.6
| 0.95000011111
0.7
| 0.82323232323
0.8
| 0.66666666666
0.9
| 0.42323232323
1.0
| 0.55555555555
1.1
| 0.88888888888
1.2
| 0.96969696969
1.3
| 1.22222222222
1.4
| 1.55555555555
--- Question 2 ---
#------------- affichage des données -----------print('abscisses x | ordonnées y ')
print('-' * 25)
for i in range(len(LX)):
print('{}
| {}'.format(LX[i], LY[i]))
print()
plt.plot(LX, LY, marker = 'D')
plt.xlabel('$x$')
plt.ylabel('$y$')
plt.grid()
plt.show()
def trapeze(x, y):
"""
x et y : deux listes numériques de même longueur n
renvoie la somme des (x_i-x_(i-1)) * (y_i + y_(i-1)) / 2 pour 0 < i < n
"""
trap = 0
# contiendra la somme voulue
[email protected]
--- Question 3 --Valeur de trapeze(LX, LY) :
1.3187761047555
--- Question 4 --Valeur avec trapz de scipy.integrate :
1.31877610476
2
for i in range(1,len(x)):
trap += (x[i] - x[i-1]) * (y[i] + y[i-1]) / 2
return trap
'''
# que nous pourrions remplacer par :
return sum(x[i] - x[i-1]) * (y[i] + y[i-1]) / 2 for i in range(1,n))
'''
print('Valeur de trapeze(LX, LY) : ')
print(trapeze(LX, LY), end = '\n\n')
print('Valeur avec trapz de scipy.integrate :')
print(integ.trapz(LY, LX))
Exercice 2
# --- création de la matrice M des distances du graphe G --M = [[0, 9, 3, -1, 7],[9, 0, 1, 8, -1],[3, 1, 0, 4, 2],[-1, 8, 4, 0, -1],[7, -1, 2, -1, 0]]
# --- affichage de la matrice M --print('Matrice M des distances du graphe G : ')
for ligne in M:
for coeff in ligne:
print('{:>2}'.format(coeff), end = ' ')
print()
print()
voisins_4 = []
for j in range(5):
if M[4][j] > 0:
voisins_4.append(j)
print('Liste des voisins du sommet 4 :', voisins_4)
def voisin(i):
"""
i : entier sommet de [0,4]
retourne la liste vois_i des voisins du sommet i
"""
global M
vois_i = []
[email protected]
--- Question 1 --Matrice M des distances du graphe G :
0 9 3 -1 7
9 0 1 8 -1
3 1 0 4 2
-1 8 4 0 -1
7 -1 2 -1 0
--- Question 2 --Liste des voisins du sommet 4 : [0, 2]
--- Question 3 --Liste des voisins du
Liste des voisins du
--- Question 4
Degré du sommet
Degré du sommet
Degré du sommet
Degré du sommet
Degré du sommet
--0 :
1 :
2 :
3 :
4 :
sommet
sommet
sommet
sommet
sommet
0
1
2
3
4
:
:
:
:
:
[1,
[0,
[0,
[1,
[0,
2, 4]
2, 3]
1, 3, 4]
2]
2]
3
3
4
2
2
--- Question 5 --Longueur du trajet de
Longueur du trajet de
[0]
[0,
[0,
[0,
[0,
[0,
: -1
0] : -1
1, 0] : 18
1, 4, 0] : -1
1, 3, 2, 4] : 23
1, 4] : -1
3
for j in range(5):
if M[i][j] > 0:
vois_i.append(j)
return vois_i
for i in range(5):
print('Liste des voisins du sommet {} : {}'.format(i, voisin(i)))
def degre(i):
"""
i : entier sommet de [0,4]
retourne le nombre de voisins du sommet i
"""
global M
deg_i = 0
for j in range(5):
if M[i][j] > 0:
# ou bien deg_i += (M[i][j] > 0) - confusion bool <-> int
deg_i += 1
return deg_i
for i in range(5):
print('Degré du sommet {} : {}'.format(i, degre(i)))
def longueur(L):
"""
L : liste de sommets
renvoie la longueur du trajet décrit par la liste -si possible """
global M
n = len(L)
if n <= 1:
return -1
long = 0
for i in range(n-1):
dist = M[L[i]][L[i+1]]
if dist > 0:
long += dist
else :
return -1
return long
def affiche_longueur(L):
print('Longueur du trajet de {} : {}'.format(L, longueur(L)))
affiche_longueur([0])
affiche_longueur([0,0])
affiche_longueur([0,1,0])
affiche_longueur([0,1,4,0])
affiche_longueur([0,1,3,2,4])
affiche_longueur([0,1,4])
[email protected]
4
Exercice 3
# -*- coding: utf-8 -*#--------------- données de test ----------------------------------------------t1 = [0,1,1,1,0,0,0,1,0,1,1,0,0,0,0]
print('t1 = ', t1)
long_t1 = len(t1)
def nombreZeros(t,i):
"""
t : tableau de 0 et 1
i : indice du tableau
renvoie le nombre de 0 consécutifs à partir de t[i] si t[i] = 0
renvoie 0 sinon
"""
n = len(t)
if t[i]:
return 0
else:
s = 1
# contiendra le résultat
j = i+1
while (j < n) and (t[j] == 0):
s += 1
j += 1
return s
t1 =
[0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0]
--- Question 1 --i |
nombreZeros(t1, i) |
0 |
1 |
1 |
0 |
2 |
0 |
3 |
0 |
4 |
3 |
5 |
2 |
6 |
1 |
7 |
0 |
8 |
1 |
9 | 10 | 11 | 12 | 13 | 14 |
0 | 0 | 4 | 3 | 2 | 1 |
--- Question 2 --Le nombre maximal de zéros contigus d'une liste t de longueur 1 est le maximum de la
liste des nombreZeros(t,i) pour i dans [0,n-1]
Nombre maximal de 0 contigus de t1 : 4
--- Question 3 --En notant N la longueur du tableau t, la complexité de nombreZeros est en O(N) et
nombreZerosMax y fait N appels ;la complexité de nombreZerosMax est donc en O(N**2).
--- Question 4 --Idée : parcourir le tableau une seule fois.
Si t[z] = 0, alors le premier 0 de la série suivante est au plus tôt
en t[z + nombreZeros(t, z) + 1].
Conserver la valeur maximale des nombreZeros calculés.
Nombre maximal de 0 contigus de t1 : 4
print('
i | ', end = '')
for i in range(long_t1):
print('{:>2} | '.format(i), end = '')
print()
print('nombreZeros(t1, i) | ', end = '')
for i in range(long_t1):
print('{:>2} | '.format(nombreZeros(t1, i)), end = '')
print()
print('Le nombre maximal de zéros contigus d\'une liste t de longueur 1 est\
le maximum de la liste des nombreZeros(t,i) pour i dans [0,n-1]\n')
def nombreZerosMax(t):
"""
t : liste de 0 et 1
renvoie le nombre maximal de 0 contigus de t
"""
n = len(t)
maxi = nombreZeros(t,0)
for i in range(1,n):
m = nombreZeros(t,i)
[email protected]
5
if m > maxi :
maxi = m
return maxi
print('Nombre maximal de 0 contigus de t1 :', nombreZerosMax(t1))
print('En notant N la longueur du tableau t, \
la complexité de nombreZeros est en O(N) et nombreZerosMax
la complexité de nombreZerosMax est donc en O(N**2).')
y fait N appels ;\
print('Idée : parcourir le tableau une seule fois.')
print('Si t[z] = 0, alors le premier 0 de la série suivante est au plus tôt')
print('en t[z + nombreZeros(t, z) + 1].')
print('Conserver la valeur maximale des nombreZeros calculés.\n')
#--- calcul du nombre maximal de 0 contigus - algorithme linéaire, en O(N) ----def nombreZerosMax2(t):
"""
t : liste de 0 et 1
Renvoie le nombre maximal de 0 contigus de t
"""
n = len(t)
maxi = 0
z = 0
while z < n:
if t[z]:
z += 1
# t[z] = 1 ; on passe à l'indice suivant
else:
m = nombreZeros(t, z)
if m > maxi:
maxi = m
z += (m + 1)
# t[z] = 0
# et t[i] = 0 pour i dans [z, z + m -1]
# tandis que t[z + m] = 1
# le premier 0 suivant est au plus tôt t[z + m + 1]
return maxi
print('Nombre maximal de 0 contigus de t1 :', nombreZerosMax2(t1))
[email protected]
6
Exercice 4
# -*- coding: utf-8 -*-
--- Question 1 ---
import math as m
import scipy.misc as spm
--- Question 2 --Listes des P(X=k) et des P(Y=k) pour n = 30, p = 0.1 et k dans [0, 30] :
k | P(X=k)
| P(Y=k)
------------------------------------------------0 | 0.049787068367863944
| 0.04239115827521624
1 | 0.14936120510359183
| 0.14130386091738778
2 | 0.22404180765538775
| 0.22765622036689948
3 | 0.22404180765538775
| 0.23608793223234328
4 | 0.16803135574154082
| 0.1770659491742562
5 | 0.10081881344492448
| 0.10230477063401491
6 | 0.05040940672246225
| 0.04736331973796974
7 | 0.02160403145248382
| 0.0180431694239884
8 | 0.008101511794681432
| 0.0057637902326629605
9 | 0.002700503931560477
| 0.0015654738903529075
10 | 0.0008101511794681432 | 0.0003652772410823458
11 | 0.00022095032167312998 | 7.379338203683735e-05
12 | 5.5237580418282494e-05 | 1.298216906203625e-05
13 | 1.2747133942680574e-05 | 1.997256778774803e-06
14 | 2.7315287020029804e-06 | 2.694711526918383e-07
15 | 5.46305740400596e-07
| 3.1937321800513934e-08
16 | 1.0243232632511176e-07 | 3.3268043542202017e-09
17 | 1.8076292880902075e-08 | 3.044134703208064e-10
18 | 3.0127154801503463e-09 | 2.4428241445496697e-11
19 | 4.756919179184757e-10 | 1.7142625575787149e-12
20 | 7.135378768777135e-11 | 1.0476048962981064e-13
21 | 1.0193398241110193e-11 | 5.542883049196318e-15
22 | 1.3900088510604809e-12 | 2.5194922950892144e-16
23 | 1.8130550231223663e-13 | 9.737168290199917e-18
24 | 2.266318778902958e-14 | 3.1555637977499687e-19
25 | 2.71958253468355e-15
| 8.414836793999927e-21
26 | 3.1379798477117877e-16 | 1.7980420499999867e-22
27 | 3.48664427523532e-17
| 2.9597400000000102e-24
28 | 3.735690294894985e-18 | 3.523499999999959e-26
29 | 3.864507201615502e-19 | 2.7000000000000107e-28
30 | 3.864507201615502e-20 | 1.0000000000000017e-30
def Px(k, n, p):
"""
k : entier naturel
n : entier naturel >0
p : float de ]0, 1[
La v.a.r X suit une loi de Poisson P(n*p)
Renvoie P(X = k)
"""
np = n * p
return (np)**k * m.exp(- np) / m.factorial(k)
n, p = 30, 0.1
lX = [Px(k, n, p) for k in range(n + 1)]
def Py(k, n, p):
"""
k : entier naturel de [0,n]
p : float de ]0, 1[
La v.a.r Y suit une loi binomiale B(n, p)
Renvoie P(Y = k)
"""
return spm.comb(n, k) * p**k * (1-p)**(n-k)
lY = [Py(k, n, p) for k in range(n + 1)]
print('Listes des P(X=k) et des P(Y=k) pour n = {0}, p = {1}\
et k dans [0, {0}] :\n'.format(n, p))
print(' k | P(X=k)
| P(Y=k)')
print('-------------------------------------------------')
for k in range(n + 1):
print('{:>2} | {:<22} | {}'.format(k, lX[k], lY[k]))
def Ecart(n, p):
"""
p : float de ]0, 1[
La v.a.r. X suit la loi de Poisson P(n*p)
La v.a.r. Y suit la loi binomiale B(n, p)
Renvoie le plus grand des nombres |P(Y=k)-P(X=k)| pour k dans [0, n]
"""
maxi = 0
[email protected]
--- Question 3 --Ecart(30, 0.1) = 0.01204612457695553
--- Question 4 --N(Ecart(30, 0.1), 0.1) = 1
--- Question 5 --N(0.008, 0.075) = 1
N(0.005, 0.075) = 124
N(0.008, 0.1) = 71
Dans le cas p = 0.1 et e = 0.005, la réponse du programme (à l'appel de la ligne 19)
est :
"OverflowError: long int too large to convert to float".
Aucune valeur de n telle que n! soit plus petit que le plus grand float codable sur 64
bits (n <= 170) ne satisfait Ecart(n, 0.1) < 0.005.
7
for k in range(n+1):
distance = abs(Px(k, n, p) - Py(k, n, p))
if distance > maxi:
maxi = distance
return maxi
eps = Ecart(n, p)
print('Ecart({}, {}) = {}'.format(n, p, eps))
float(m.factorial(170))= 7.257415615307999e+306
Cependant, on considère quelquefois que de bonnes conditions d'approximation de B(n,p)
par P(n*p)
sont : p <= 0.1, n >= 30 et n * p <= 15.
Pour p = 0.1, il suffirait que n soit dant [30, 150].
def N(e, p):
"""
e : float > 0
p : float de ]0,1[
Renvoie le plus petit entier naturel n > 0 tel que Ecart(n, p) <= e
"""
n = 1
while Ecart(n, p) > e:
n += 1
return n
print('N(Ecart({0}, {1}), {1}) = {2}'.format(n, p, N(eps, p)))
for (p, e) in [(0.075, 0.008), (0.075, 0.005), (0.1, 0.008)]:
print('N({}, {}) = {}'.format(e, p, N(e, p)))
print('Dans le cas p = 0.1 et e = 0.005, la réponse du programme\
(à l\'appel de la ligne 19) est : \n\
"OverflowError: long int too large to convert to float".')
print('Aucune valeur de n telle que n! soit plus petit\
que le plus grand float codable sur 64 bits (n <= 170)\
ne satisfait Ecart(n, 0.1) < 0.005.')
print('float(m.factorial(170))=',float(m.factorial(170)) )
print('\nCependant, on considère quelquefois que de bonnes conditions\
d\'approximation de B(n,p) par P(n*p)')
print('sont : p <= 0.1, n >= 30 et n * p <= 15.')
print('Pour p = 0.1, il suffirait que n soit dant [30, 150].')
Exercice 5
# -*- coding: utf-8 -*# Katia Barré - Lycée Lesage Vannes
--- Question 1 ---
import numpy as np
import matplotlib.pyplot as plt
import scipy.optimize as spo
[email protected]
8
def g(x):
if (x >= 0) and (x < 1):
return x
elif (x >= 1) and (x < 2):
return 1
g_v = np.vectorize(g)
lx = np.arange(0, 1.99, 0.01)
gx = g_v(lx)
plt.figure(1)
plt.plot(lx, gx)
plt.xlabel('$x$')
plt.ylabel('$g(x)$')
plt.axis([-0.1, 2.1, -0.1, 1.1])
plt.title('Graphe de $g$')
plt.grid()
plt.show()
def f(x):
if (x >=0)
return
elif (x >=
return
--- Question 2 ----- Question 3 ---
and (x < 2):
g(x)
2):
(x**0.5) * f(x-2)
f_v = np.vectorize(f)
lx1 = np.linspace(0, 6, 500)
fx = f_v(lx1)
plt.figure(2)
plt.plot(lx1, fx, linestyle = 'None', marker = '.', ms = 3)
plt.xlabel('$x$')
plt.ylabel('$f(x)$')
plt.axis([-0.1, 6.1, -0.1, 5.1])
plt.title('Graphe de $f$')
plt.grid()
plt.show()
print('On lit graphiquement que alpha est dans [5, 6], intervalle sur lequel
f est croissante.')
# --- programmons la méthode de dichotomie
eps = 0.01
a, b = 5, 6
fa, fb = f(a), f(b)
while b-a > eps:
[email protected]
--- Question 4 --On lit graphiquement que alpha est dans [5, 6], intervalle sur lequel f est croissante.
9
c = (a+b) / 2
fc = f(c)
if f(c) > 4:
b = c
fb = fc
else :
a = c
fa = fc
print('Une valeur approchée à {} près de la plus petite valeur alpha > 0\
telle que f(alpha) > 4 est :\n {}\n'.format(eps, b))
Une valeur approchée à 0.01 près de la plus petite valeur alpha > 0 telle que f(alpha)
> 4 est :
5.125
f(alpha-0.01) = 3.9916443979893805, f(alpha) = 4.001952648395531
(Recherche du zéro de f-4 dans [5, 5.5] par méthode de dichotomie de scipy :
5.123105625617427 ).
print('f(alpha-{}) = {}, f(alpha) = {}\n\n'.format(eps, f(b - eps), f(b)))
print('(Recherche du zéro de f-4 dans [5, 5.5] par méthode de dichotomie de
scipy :')
print(spo.bisect(lambda x : f(x) - 4, 5, 5.5), ').')
Exercice 6
print('La fonction d retourne la liste croissante des diviseurs de l\'entier n')
def d(n):
"""
n : entier naturel non nul
Renvoie la liste croissante des diviseurs de l\'entier n
"""
L = [1]
for nombre in range(2, n+1):
if n % nombre == 0:
L.append(nombre)
return L
for n in [4, 9, 10, 11]:
print('d({}) = {}'.format(n, d(n)))
def DNT(n):
"""
Renvoie la liste croissante des diviseurs "non-trivaux" de l\'entier n
"""
L = []
for nombre in range(2, n):
if n % nombre == 0:
L.append(nombre)
return L
# ou bien : return d(n)[1:-1]
--- Question 1 --La fonction d retourne la liste croissante des diviseurs de l'entier n
d(4) = [1, 2, 4]
d(9) = [1, 3, 9]
d(10) = [1, 2, 5, 10]
d(11) = [1, 11]
--- Question 2 --DNT(4) = [2]
DNT(9) = [3]
DNT(10) = [2, 5]
DNT(11) = []
--- Question 3 --sommeCarresDNT(4) = 4
sommeCarresDNT(9) = 9
--- Question 4 --Les nombres <= 1000 et égaux à la somme de leurs diviseurs non triviaux sont :
4, 9, 25, 49, 121, 169, 289, 361, 529, 841, 961,
On peut conjecturer, à la lecture de cette liste, que les nombres égaux à la somme
de leurs diviseurs non triviaux sont les carrés des nombres premiers.
for n in [4, 9, 10, 11]:
print('DNT({}) = {}'.format(n, DNT(n)))
[email protected]
10
def sommeCarresDNT(n):
"""
Renvoie la somme des carrés des diviseurs "non-trivaux" de l\'entier n
"""
s = 0
for nombre in range(2, n):
if n % nombre == 0:
s += nombre**2
return s
for n in [4, 9, 10, 11]:
print('sommeCarresDNT({}) = {}'.format(n, sommeCarresDNT(n)))
maxi = 1000
print('Les nombres <= {} et égaux à la somme de leurs \
diviseurs non triviaux sont :'.format(maxi))
for i in range(2, maxi + 1):
if i == sommeCarresDNT(i):
print(i, end = ', ')
print('\n\nOn peut conjecturer, à la lecture de cette liste,\
que les nombres égaux à la somme de leurs diviseurs non triviaux sont\
les carrés des nombres premiers.')
Exercice 7
ord_a = ord('a')
lettres = ''
for i in range(ord_a, ord_a + 26):
lettres += chr(i)
# ou bien : lettres = ''.join([chr(ord_a + i) for i in range(26)])
print(lettres)
def decalage(n):
"""
n : entier
Renvoie l'alphabet après décalage de n vers la gauche
"""
global lettres
decale = ''
[email protected]
--- Question 1 --abcdefghijklmnopqrstuvwxyz
--- Question 2 --decalage(1) = bcdefghijklmnopqrstuvwxyza
decalage(3) = defghijklmnopqrstuvwxyzabc
--- Question 3 --indices(e, "phrase originale avec des e ") =
indices(y, "phrase originale avec des e ") =
--- Question 4 --codage(3, 'oralensam') :
dico(0) =
'k': 'k',
's': 's',
'z': 'z',
dico(3) =
'k': 'n',
's': 'v',
'z': 'c',
[5, 15, 19, 23, 26]
[]
rudohqvdp
{'c': 'c', 'b': 'b', 'a': 'a', 'g': 'g', 'f': 'f', 'e': 'e', 'd': 'd',
'j': 'j', 'i': 'i', 'h': 'h', 'o': 'o', 'n': 'n', 'm': 'm', 'l': 'l',
'r': 'r', 'q': 'q', 'p': 'p', 'w': 'w', 'v': 'v', 'u': 'u', 't': 't',
'y': 'y', 'x': 'x'}
{'c': 'f', 'b': 'e', 'a': 'd', 'g': 'j', 'f': 'i', 'e': 'h', 'd': 'g',
'j': 'm', 'i': 'l', 'h': 'k', 'o': 'r', 'n': 'q', 'm': 'p', 'l': 'o',
'r': 'u', 'q': 't', 'p': 's', 'w': 'z', 'v': 'y', 'u': 'x', 't': 'w',
'y': 'b', 'x': 'a'}
11
for i in range(26):
decale += lettres[(i + n) % 26]
return decale
codage_dico(3, 'oralensam') :
# ou bien :
# global ord_a
# return ''.join([chr(ord_a + (i + n) % 26) for i in range(26)])
--- Question 5 --Pour décoder un mot codé de décalage n, il suffit d'appliquer un décalage de -n
(ou de 26-n, ...)
codage(-3, codage(3, 'oralensam')): oralensam
codage(23, codage(3, 'oralensam')): oralensam
for i in [1, 3]:
print('decalage({}) = {}'.format(i, decalage(i)))
rudohqvdp
def indices(x, phrase):
"""
x : caractère
phrase : chaîne de caractères
Retourne la liste des indices de x dans la phrase (vide si x n'y figure pas)
"""
ind = []
long = len(phrase)
for i in range(long):
if phrase[i] == x:
ind.append(i)
return ind
ee, pphrase = 'e', "phrase originale avec des e "
print('indices({}, "{}") = '.format(ee, pphrase), indices(ee, pphrase))
yy = 'y'
print('indices({}, "{}") = '.format(yy, pphrase), indices(yy, pphrase))
def codage(n, phrase):
"""
n : entier
Renvoie la chaîne phrase codée avec un décalage de n lettres
"""
global ord_a
if n % 26 == 0:
return phrase
else:
long = len(phrase)
lettre_codee = ''
for lettre in phrase:
lettre_codee += chr(ord_a + (ord(lettre) - ord_a + n) % 26)
return lettre_codee
print("codage(3, 'oralensam') : ", codage(3, 'oralensam'), '\n')
#---- seconde idée : usage d'un dictionnaire
def dico(n):
global ord_a
return {chr(ord_a + i) : chr(ord_a + (i + n) % 26) for i in range(26)}
[email protected]
12
print('dico(0) = ', dico(0))
print('dico(3) = ', dico(3), '\n')
def codage_dico(n, phrase):
"""
n : entier
Renvoie la chaîne phrase codée avec un décalage de n lettres
"""
if n % 26 == 0:
return phrase
else:
dico_n = dico(n)
return ''.join(dico_n[lettre] for lettre in phrase)
print("codage_dico(3, 'oralensam') : ", codage_dico(3, 'oralensam'))
print('Pour décoder un mot codé de décalage n, il suffit d\'appliquer un décalage
de -n (ou de 26-n, ...)')
print("codage(-3, codage(3, 'oralensam')): ", codage(-3, codage(3, 'oralensam')))
Exercice 8
# -*- coding: utf-8 -*import numpy as np
M, m = 20, 10
def f(c):
"""
c : nombre
On considère la suite récurrente définie par :
u_0 = 0 et u_{n+1} = u_n **2 + c pour tout entier naturel n
Renvoie : le plus petit entier k de [0, m] tel que |u_k| > M s'il existe
m + 1 sinon
"""
global M, m
u = 0
k = 0
while k < m:
u = u**2 + c
k += 1
if abs(u) > M:
return k
# renvoie k de [0, m] tel | u_k| > M
return m + 1
# renvoie m + 1
#--- question 2 ---------------------------------------------------------------Katia.barre@laposte.net
13
print('\n --- Question 2 --- ')
f_v = np.vectorize(f)
LX = np.linspace(-2, 2, 401)
fX = f_v(LX)
--- Question 3 ----- Question 4 --Pour augmenter la résolution, on peut augmenter les paramètres M, m et K.
plt.figure(1)
plt.plot(LX, fX, linestyle = 'None', marker = '.', ms = 3)
plt.axis([-2.1, 2.1, -0.1, m + 1.1])
plt.grid()
plt.xlabel('$c$')
plt.ylabel('$f(c)$')
plt.title('Graphe de $f$')
plt.show()
K = 101
x = np.linspace(-2, 0.5, K)
y = np.linspace(-1.1, 1.1, K)
X, Y = np.meshgrid(x, y)
tableau_valeurs = f_v(X + 1j * Y)
plt.figure(2)
plt.imshow(tableau_valeurs, extent = [-2, 0.5,-1.1 ,1.1])
plt.title('$M = $ {}, $m$ = {}, $K$ = {}'.format(M, m, K))
plt.axis('scaled')
plt.show()
print('Pour augmenter la résolution, on peut augmenter les paramètres M, m et K.')
#--- tests --------------------------------------------------------------------def f1(c, m, M):
u = 0
k = 0
while k < m:
u = u**2 + c
k += 1
if abs(u) > M:
return k
return m + 1
f1_v = np.vectorize(f1)
def resolution(m, M, K):
"""
m : entier limite l'indice de la suite
M : limite le module de la suite
K : nombre de points sur les axes
Trace l'image du code du tableau f(x + jy)
où x dans [-2, 0.5] (K valeurs)
y dans [-1.1, 1.1] (Ka valeurs)
f fonction qui à un nombre complexe c
associe le plus petit entier k de [0, m] tel que |u_k| > M s'il existe
[email protected]
14
m + 1 sinon
avec (u_n) la suite récurrente définie par :
u_0 = 0 et u_{n+1} = u_n **2 + c pour tout entier naturel n
"""
x = np.linspace(-2, 0.5, K)
y = np.linspace(-1.1, 1.1, K)
X, Y = np.meshgrid(x, y)
tableau_valeurs = f1_v(X + 1j * Y, m, M)
plt.imshow(tableau_valeurs, extent = [-2, 0.5,-1.1 ,1.1])
plt.title('$M = $ {}, $m$ = {}, $K$ = {}'.format(M, m, K))
plt.axis('scaled')
plt.show()
resolution(20, 30, 200)
resolution(30,50, 500)
Exercice 9
import numpy as np
R = np.arange(1, 7).reshape(2, 3)
print('R = \n', R)
S = np.arange(1, 10).reshape(3, 3)
[email protected]
--- Question 1 --R =
[[1 2 3]
[4 5 6]]
S =
[[1 2 3]
[4 5 6]
[7 8 9]]
--- Question 2 --15
print('S = \n', S)
test(R) =
test(S) =
def test(M):
"""
M : matrice
Renvoie n si M est carrée d'ordre n
0 sinon
"""
n = len(M)
if n == len(M[0]):
return n
else:
return 0
print('test(R) = ', test(R))
print('test(S) = ', test(S))
0
3
--- Question 3 --M1 =
[[ 0.33333333 0.16666667
[ 0.16666667 0.33333333
[ 0.16666667 0.16666667
[ 0.16666667 0.16666667
[ 0.16666667 0.16666667
test(M1) = 5
0.16666667
0.16666667
0.33333333
0.16666667
0.16666667
0.16666667
0.16666667
0.16666667
0.33333333
0.16666667
0.16666667]
0.16666667]
0.16666667]
0.16666667]
0.33333333]]
--- Question 4 --La matrice est symétrique réelle donc toutes ses valeurs propres sont réelles.
Valeurs propres de M1 :
[ 1.
0.16666666 0.16666667 0.16666667 0.16666667]
--- Question 5 --dansIntervalle(valp_M1, 0, 1) =
True
fichier = open('data/ex_009.txt', 'r')
matrice = []
for ligne in fichier:
matrice.append(list(eval(ligne)))
fichier.close()
M1 = np.array(matrice)
print('M1 = \n', M1)
print('test(M1) = ', test(M1))
print('La matrice est symétrique réelle donc toutes ses valeurs propres sont
réelles.')
valp_M1, vecp_M1 = np.linalg.eig(M1)
print('Valeurs propres de M1 : \n ', valp_M1)
def dansIntervalle(L, a,
"""
L : liste de nombres
a, b : float
Renvoie True si tous
False sinon
"""
for x in L:
if abs(x.imag) >
return False
return True
b):
complexes
les éléments de L sont dans [a, b]
1e-16 or x.real > b or x.real < a:
print('dansIntervalle(valp_M1, 0, 1) = ', dansIntervalle(valp_M1, 0, 1))
[email protected]
16
Exercice 10
import random
--- Question 1 --Liste L = [0, 0, 4, 0, 4, 0, 3, 3, 1, 1, 2, 4, 3, 1, 3, 4, 0, 1, 3, 3]
Comptage(L, 5) = [5, 4, 1, 6, 4]
--- Question 2 ---
def comptage(L, N):
"""
N : entier > 10
L : liste d'entiers de [0, N - 1]
Renvoie une liste P telle que P[k] est le nombre d'occurence de k dans L
"""
P = [0] * N
for x in L:
P[x] += 1
return P
--- Question 3 --L = [0, 0, 4, 0, 4, 0, 3, 3, 1, 1, 2, 4, 3, 1, 3, 4, 0, 1, 3, 3]
tri(L, 5) = [0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4]
--- Question 4 --En notant M = len(L),
La fonction comptage est de complexité O(M + N), de même que la fonction tri.
Le tri par insertion est de complexité O(N^2).
Le tri par fusion est de complexité O(N ln(N)).
N = 5
mL = [random.randint(0, N - 1) for i in range(20)]
print('Liste L = ', mL)
print('Comptage(L, 5) = ', comptage(mL, N))
def tri(L, N):
"""
N : entier
L : liste d'entiers de [0, N - 1]
Renvoie la liste L triée par ordre croissant
"""
P = comptage(L, N)
Q = []
for i in range(N):
for k in range(P[i]):
Q.append(i)
return Q
print('
L = ', mL)
print('tri(L, 5) = ', tri(mL, N))
print('En notant M = len(L),')
print('La fonction comptage est de complexité O(M + N), de même que la
fonction tri.')
print('Le tri par insertion est de complexité O(N^2).')
print('Le tri par fusion est de complexité O(N ln(N)).')
[email protected]
17
Exercice 11
--- Question 1 --# -*- coding: utf-8 -*import numpy as np
import scipy.integrate as integ
b, w = 0.5, 6.0
def p(t):
global b, w
wt = w * t
return np.cos(t) + b * np.cos(wt), np.sin(t) + b * np.sin(wt)
def v(t):
global
wt = w
bw = b
return
b, w
* t
* w
-np.sin(t) - bw * np.sin(wt), np.cos(t) + bw * np.cos(wt)
def a(t):
global b, w
wt = w * t
bw2 = b * w**2
return -np.cos(t) - bw2 * np.cos(wt), -np.sin(t) - bw2 * np.sin(wt)
dt = np.pi * 0.01
t = np.arange(-np.pi, np.pi + dt, dt)
pt = p(t)
plt.figure(1)
plt.plot(pt[0], pt[1])
plt.xlabel('$x(t)$')
plt.ylabel('$y(t)$')
plt.title('Trajectoire')
plt.grid()
plt.axis('scaled')
plt.show()
def c(t):
[email protected]
18
x, y = p(t)
x1, y1 = v(t)
x2, y2 = a(t)
d = (x1**2 + y1**2) / (x1 * y2 - y1 * x2)
return x - d * y1, y + d * x1
ct = c(t)
plt.figure(2)
plt.plot(pt[0], pt[1])
plt.plot(ct[0], ct[1])
#--- tracé de quelques segments [p(t)c(t)]
for u in np.linspace(-np.pi + dt, -dt, 5):
xp, yp = p(u)
xc, yc = c(u)
plt.plot([xp, xc], [yp, yc], marker = 'o', color = 'r')
plt.grid()
plt.legend(['Point $p$', 'Centre de courbure $c$'])
plt.title('Trajectoire et développée')
plt.axis('scaled')
plt.show()
def distance(A, B):
"""
A et B : deux points du plan (couples de float)
retourne la longueur du segment [AB]
"""
xA, yA = A
xB, yB = B
return ((xB - xA)**2 + (yB - yA)**2)**0.5
--- Question 6 ---
def longueur(N):
"""
N : entier naturel > 0
Renvoie la longueur de la ligne polygonale reliant les points p(t)
pour t dans [-pi, pi] pour le pas de discrétisation delta_t = pi / N
"""
t = np.linspace(-np.pi, np.pi, 2 * N)
long = 0
A = p(t[0])
for i in range(1, 2 * N):
B = p(t[i])
long += distance(A, B)
A = B
return long
longueur_v = np.vectorize(longueur)
#---------- tracé de la longueur de la ligne polyngonale en fonction du nombre de points
n = range(20, 301, 3)
[email protected]
19
long_n = longueur_v(n)
plt.plot(n, long_n, linestyle = 'None', marker = 'o', ms = 3)
norme_v = lambda u : (1 + (b * w)**2 + 2 * b * w * np.cos((w-1) * u))**0.5
longueur_p, err = integ.quad(norme_v, -np.pi, np.pi)
plt.plot([20, 300], [longueur_p, longueur_p], color = 'r')
plt.xlabel('$N$')
plt.ylabel('Longueur en fonction de $N$')
plt.legend(['Longueur du polygône avec $2N$ points', 'Longueur de la courbe'],\
loc = 'lower right')
plt.grid()
plt.show()
[email protected]
20

Exercices Types – Algorithmique et simulation

Transcription

Documents pareils

Stratégie et actions commerciales Web to Print

stage graphisme et communication (web et print) h/f entreprise

17.00 - Flamenco Export

Exporter - Agence de communication

Communication Commerciale

FORMA TION EXPÉRIENCE AUTRES

Standox Téléchargements

Grenoble INP-Pagora - Stratégie et action commerciale Web-to

Voir CV - portfolio 2013

David del Olmo Expósito