Exercices Types Algorithmique et simulation numérique Oral Mathématiques et Algorithmique Banque PT Propositions de réponses

Exercices Types Algorithmique et simulation numérique Oral Mathématiques et Algorithmique Banque PT Propositions de réponses Exercice 0 print('\n ') 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') print('\n ') s = r**3 + r1**3 # contiendra la somme des cubes des chiffres q2 = q1 // 10 s += (q1 % 10)**3 s += (q2 % 10)**3 print('somme des cubes des chiffres de {} : {}'.format(n, s)) n = 1234, q = 123, r = 4, q1 = 12, r1 = 3 Les restes successifs contiendront les chiffres de n Somme des cubes des chiffres de 1234 : 100 Somme des cubes de 1234 : 100 Les chiffres inférieurs à 1000 égaux à la somme des cubes de leurs chiffres : 0, 1, 153, 370, 371, 407, --- Question 5 --- Somme des cubes de 1234 : 100 print('\n ') 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)) print('\n ') 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() #--- question 5 ---------------------------------------------------------------- print('\n --- Question 5 --- ') def somcube2(n): n : entier naturel renvoie la somme des cubes des chiffres de l'écriture décimale de n Katia.barre@laposte.net 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 import matplotlib.pyplot as plt import scipy.integrate as integ print('\n ') #------------- 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() #------------- 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() 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 print('\n ') plt.plot(lx, LY, marker = 'D') plt.xlabel('$x$') plt.ylabel('$y$') plt.grid() plt.show() print('\n ') 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 Valeur de trapeze(lx, LY) : 1.3187761047555 Valeur avec trapz de scipy.integrate : 1.31877610476 Katia.barre@laposte.net 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('\n ') print('valeur avec trapz de scipy.integrate :') print(integ.trapz(ly, LX)) Exercice 2 print('\n ') # --- 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() print('\n ') 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) print('\n ') def voisin(i): i : entier sommet de [0,4] retourne la liste vois_i des voisins du sommet i global M vois_i = [] 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 Liste des voisins du sommet 4 : [0, 2] Liste des voisins du sommet 0 : [1, 2, 4] Liste des voisins du sommet 1 : [0, 2, 3] Liste des voisins du sommet 2 : [0, 1, 3, 4] Liste des voisins du sommet 3 : [1, 2] Liste des voisins du sommet 4 : [0, 2] Degré du sommet 0 : 3 Degré du sommet 1 : 3 Degré du sommet 2 : 4 Degré du sommet 3 : 2 Degré du sommet 4 : 2 --- Question 5 --- Longueur du trajet de [0] : -1 Longueur du trajet de [0, 0] : -1 Longueur du trajet de [0, 1, 0] : 18 Longueur du trajet de [0, 1, 4, 0] : -1 Longueur du trajet de [0, 1, 3, 2, 4] : 23 Longueur du trajet de [0, 1, 4] : -1 Katia.barre@laposte.net 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))) print('\n ') 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))) #--- question 5 ---------------------------------------------------------------- print('\n --- Question 5 --- ') 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]) Katia.barre@laposte.net 4

Exercice 3 #--------------- 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) print('\n ') 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] i 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 nombrezeros(t1, i) 1 0 0 0 3 2 1 0 1 0 0 4 3 2 1 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 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). 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('\n ') 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) # contiendra le résultat for i in range(1,n): m = nombrezeros(t,i) Katia.barre@laposte.net 5

if m > maxi : maxi = m return maxi print('nombre maximal de 0 contigus de t1 :', nombrezerosmax(t1)) print('\n ') print('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).') print('\n ') 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 # contiendra le résultat 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)) Katia.barre@laposte.net 6

Exercice 4 import math as m import scipy.misc as spm print('\n ') 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)] print('\n ') def Py(k, n, p): n : entier naturel >0 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])) print('\n ') def Ecart(n, p): n : entier naturel >0 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 # contiendra le résultat 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 Ecart(30, 0.1) = 0.01204612457695553 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. Katia.barre@laposte.net 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]. print('\n ') 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))) #--- question 5 ---------------------------------------------------------------- print('\n --- Question 5 --- ') 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 # Katia Barré - Lycée Lesage Vannes import numpy as np import matplotlib.pyplot as plt import scipy.optimize as spo print('\n ') Katia.barre@laposte.net 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() print('\n ') def f(x): if (x >=0) and (x < 2): return g(x) elif (x >= 2): return (x**0.5) * f(x-2) f_v = np.vectorize(f) print('\n ') 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('\n ') 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: On lit graphiquement que alpha est dans [5, 6], intervalle sur lequel f est croissante. Katia.barre@laposte.net 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('\n ') 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))) print('\n ') def DNT(n): n : entier naturel non nul 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] 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] DNT(4) = [2] DNT(9) = [3] DNT(10) = [2, 5] DNT(11) = [] sommecarresdnt(4) = 4 sommecarresdnt(9) = 9 sommecarresdnt(10) = 29 sommecarresdnt(11) = 0 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))) Katia.barre@laposte.net 10

print('\n ') def sommecarresdnt(n): n : entier naturel non nul 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))) print('\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 print('\n ') 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) print('\n ') def decalage(n): n : entier Renvoie l'alphabet après décalage de n vers la gauche global lettres decale = '' abcdefghijklmnopqrstuvwxyz decalage(1) = bcdefghijklmnopqrstuvwxyza decalage(3) = defghijklmnopqrstuvwxyzabc indices(e, "phrase originale avec des e ") = [5, 15, 19, 23, 26] indices(y, "phrase originale avec des e ") = [] codage(3, 'oralensam') : rudohqvdp dico(0) = {'c': 'c', 'b': 'b', 'a': 'a', 'g': 'g', 'f': 'f', 'e': 'e', 'd': 'd', 'k': 'k', 'j': 'j', 'i': 'i', 'h': 'h', 'o': 'o', 'n': 'n', 'm': 'm', 'l': 'l', 's': 's', 'r': 'r', 'q': 'q', 'p': 'p', 'w': 'w', 'v': 'v', 'u': 'u', 't': 't', 'z': 'z', 'y': 'y', 'x': 'x'} dico(3) = {'c': 'f', 'b': 'e', 'a': 'd', 'g': 'j', 'f': 'i', 'e': 'h', 'd': 'g', 'k': 'n', 'j': 'm', 'i': 'l', 'h': 'k', 'o': 'r', 'n': 'q', 'm': 'p', 'l': 'o', 's': 'v', 'r': 'u', 'q': 't', 'p': 's', 'w': 'z', 'v': 'y', 'u': 'x', 't': 'w', 'z': 'c', 'y': 'b', 'x': 'a'} Katia.barre@laposte.net 11

for i in range(26): decale += lettres[(i + n) % 26] return decale # ou bien : # global ord_a # return ''.join([chr(ord_a + (i + n) % 26) for i in range(26)]) for i in [1, 3]: print('decalage({}) = {}'.format(i, decalage(i))) codage_dico(3, 'oralensam') : rudohqvdp --- 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 print('\n ') 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)) print('\n ') def codage(n, phrase): n : entier phrase : chaîne de caractères 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)} Katia.barre@laposte.net 12

print('dico(0) = ', dico(0)) print('dico(3) = ', dico(3), '\n') def codage_dico(n, phrase): n : entier phrase : chaîne de caractères 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')) #--- question 5 ---------------------------------------------------------------- print('\n --- Question 5 --- ') 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 import numpy as np import matplotlib.pyplot as plt M, m = 20, 10 print('\n ') 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 Katia.barre@laposte.net 13

print('\n ') f_v = np.vectorize(f) LX = np.linspace(-2, 2, 401) fx = f_v(lx) 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() print('\n ') 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) print('\n ') 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 Katia.barre@laposte.net 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 # Katia Barré - Lycée Lesage Vannes import numpy as np print('\n ') R = np.arange(1, 7).reshape(2, 3) print('r = \n', R) S = np.arange(1, 10).reshape(3, 3) R = [[1 2 3] [4 5 6]] S = [[1 2 3] [4 5 6] [7 8 9]] Katia.barre@laposte.net 15

print('s = \n', S) print('\n ') 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)) print('\n ') test(r) = 0 test(s) = 3 M1 = [[ 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 0.16666667 0.16666667] [ 0.16666667 0.16666667 0.16666667 0.33333333 0.16666667] [ 0.16666667 0.16666667 0.16666667 0.16666667 0.33333333]] test(m1) = 5 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('\n ') 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) #--- question 5 ---------------------------------------------------------------- print('\n --- Question 5 --- ') def dansintervalle(l, a, b): L : liste de nombres complexes a, b : float Renvoie True si tous les éléments de L sont dans [a, b] False sinon for x in L: if abs(x.imag) > 1e-16 or x.real > b or x.real < a: return False return True print('dansintervalle(valp_m1, 0, 1) = ', dansintervalle(valp_m1, 0, 1)) Katia.barre@laposte.net 16

Exercice 10 # Katia Barré - Lycée Lesage Vannes import random print('\n ') 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 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] 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] 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)) print('\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('\n ') print(' L = ', ml) print('tri(l, 5) = ', tri(ml, N)) print('\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)).') Katia.barre@laposte.net 17

Exercice 11 import numpy as np import matplotlib.pyplot as plt import scipy.integrate as integ b, w = 0.5, 6.0 print('\n ') 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 b, w wt = w * t bw = b * w return -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) print('\n ') 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') --- Question 5 --- plt.show() print('\n ') print('\n ') def c(t): Katia.barre@laposte.net 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() #--- question 6 ---------------------------------------------------------------- print('\n --- Question 6 --- ') 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) Katia.barre@laposte.net 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() Katia.barre@laposte.net 20