Transcript PC - Informatique Corrigé du DS1 Exercice 1 Echange dans une

PC - Informatique
Corrigé du DS1
Exercice 1
Echange dans une pile des deux éléments au sommet :
def echange(pile):
d = depiler(pile)
e = depiler(pile)
empiler(pile,d)
empiler(pile,e)
return pile
def suite geometrique(u, q, n):
if n == 0:
return u
return q * suite geometrique(u,q,n-1)
# dépilage de l’élément au sommet
# dépilage de l’élément suivant
# Rempilage de d
# Rempilage de e
(2) Celui de complexité logarithmique est modelé sur l’algorithme d’exponentiation rapide :
def suite geometrique(u, q, n):
if n == 0:
return u
if
n
% 2 == 0:
Exercice 2
return
suite geometrique(u, q**2, n//2)
L’algorithme vu en cours, utilisant une pile, s’appliquait à la notion polonaise (non inelse:
versée). Il suffit de l’adapter : il faut parcourir la liste, cette fois-ci, de gauche à droite ;
return q * suite geometrique(u, q**2, n//2)
et faire attention aux cas des deux opérations non-commutatives − et ÷.
def polonaise inverse(L):
pile = creer pile()
for e in L:
if isinstance(e,int):
empiler(pile, e)
elif e == ’+’:
a = depiler(pile)
b = depiler(pile)
empiler(pile, a +
elif e == ’-’:
a = depiler(pile)
b = depiler(pile)
empiler(pile, b elif e == ’*’:
a = depiler(pile)
b = depiler(pile)
empiler(pile, a *
elif e == ’/’:
a = depiler(pile)
b = depiler(pile)
empiler(pile, b /
return depiler(pile)
Exercice 4
L’algorithme d’écriture binaire par récursivité :
def bin rec(N):
if N == 0:
return "0"
elif N == 1:
return "1"
return bin rec(N//2) + str(N%2)
b)
Exercice 5
Le code python de la fonction Tri rapide() décroissant est :
a)
def Tri rapide(T):
N = len(T)
if N <= 1: # Appel terminal
return T
e = T.pop(N//2) # Retirer l’élément au milieu du tableau
T1, T2 = [ ], [ ]
for x in T: # Constitution de T1 et T2
if x <= e:
T1.append(x)
else:
T2.append(x)
return Tri rapide(T2) + [e] + Tri rapide(T1) # Appel rec.
b)
a)
Exercice 3
(1) Le code, de complexité linéaire est :
1
PC - Informatique
Corrigé du DS1
Exercice 6
Le code à employer est le suivant :
def trapeze(a,b,n,puissance):
# Méthode des trapèzes
pas=(b-a)/n
fa=puissance(a)
fb=puissance(b)
somme=fa
for i in range(n):
# calcul de la somme
temps=a+(i+1)*pas
somme=somme+puissance(temps)
resultat += pas*((-fa-fb)/2+somme)
return(resultat)
import numpy as ny # pour les listes, l’exponentielle et le log
R=1000
C=10**(-9)
# Définition de l’équation-différentielle :
phi=lambda x,y : -y/(R*C)
# Définition de {Uc/(RC), écriture
# générique (y désigne ici Uc), on pourrait aussi écrire
# phi=lambda y: -y/(R*C)
Obtention de la puissance dissipée au temps t = 1s :
N = 100
trapeze(0,1,N,puissance)
# Fonction réalisant l’intégration :
def Euler(n,a,b,phi,Uo):
x=ny.linspace(a,b,n+1)
# vecteur qui contiendra les temps
#régulièrement espacés de a à b (n+1 valeurs)
y=ny.empty(n+1)
#création d’un vecteur vide qui contiendra
# les valeurs des tensions (n+1 valeurs)
y[0]=Uo
# Premier élément de la liste c’est Uo tension initiale
pas=(b-a)/n
for i in range(n):
#Attention ! boucle de i=0 à n-1
y[i+1]=y[i]+phi(x[i],y[i])*pas
# méthode d’Euler-Cauchy
return(x,y)
# On appelle la fonction Euler :
(x1,y1)=Euler(100,0,0.0001,phi,1)
# n=100 , de 0 à 0,1ms avec Uc(0)=1V
# On effectue le tracé :
import matplotlib.pyplot as plt
plt.plot(x1,y1)
plt.show()
Exercice 7
Intégration par la méthode des trapèzes (appelle une fonction puissance(tau)), renvoie
puissance intégrée entre t = a et t = b :
2