Enoncé 1

Q1

Ecrire une fonction qui prend une chaîne de caractères en argument et la retourne sans ses voyelles.

In [ ]:
def pas_de_voyelle(mot):
s = ""
for c in mot :
if c not in "aeiouy" :
s += c
return s

pas_de_voyelle("bonjour"), pas_de_voyelle("au revoir")

Cette réponse n'est qu'une réponse parmi d'autres. Certains utilisaient la méthode [replace], d'autres un
test c == "a" or c == "e" ... .

Q2

Transformer une matrice représentée sous forme de double liste (exemple : [[0,1,0],[0,0,1]] ) en
un dictionnaire dont les clés sont les coordonnées et les valeurs les coefficients (soit autant d'éléments
que de valeurs non nulles).

In [ ]:
mat = [[0,1,0],[0,0,1]]

mat_dict = { }
for i,line in enumerate(mat) :
for j,c in enumerate(line) :
if c != 0 :
mat_dict[i,j] = c

mat_dict

Pour cette question, le code écrit fonction doit fonctionner pour n'importe quelle matrice.

Q3
10 1
Calculer ∑𝑖=1 𝑖

In [ ]:
sum ( 1/i for i in range(1,11) )

Q4

Quel le coût du programme suivant en 𝑂(𝑁) ?

In [ ]:
from math import log
s = 0
 N = 100
while N > 1 :
for i in range(1, N):
s += log(i)
N //= 2
print(s)

La première boucle s'exécute pour les valeurs 𝑁 , 𝑁/2 , 𝑁/4 , ... jusqu'à ce que 𝑁 ⩽ 1. La boucle
imbriquée fait la somme des 𝑙𝑜𝑔 de 1 à 𝑁 . Le nombre des opérations est en 𝑂(𝑁 + 𝑁/2 + 𝑁/4+. . . ),
ln 𝑁 1
soit quelque chose comme 𝑁 ∑𝑖=1
2
⩽ 𝑁 ∑∞
𝑖=1
1
⩽ 2𝑁 (c'est une somme géométrique). On
2𝑖 2𝑖
vérifie avec le code suivant qui compte le nombre de fois où on ajoute un logarithme.

In [ ]:
def calcul(N):
s = 0
c = 0
while N > 1 :
for i in range(1, N):
s += log(i)
c += 1
N //= 2
return c
for i in range(10000,100000, 10000) :
print( i, calcul(i), i * 2 )

Enoncé 2

Q1

On considère un mot abcdef , puis on construit un autre mot selon le schéma :

• 1ère lettre, dernière lettre, 2ème lettre, avant-dernière lettre, 3ème lettre, ...
• Exemple 1 : abcdef → afbecd
• Exemple 2 : kayak → kkaay

In [ ]:
def strange(mot):
s = ""
for i in range(len(mot)//2) :
s += mot[i] + mot[-i-1]
if len(mot)%2 == 1 :
s += mot[len(mot)//2]
return s

strange("abcdef"), strange("kayak")

Q2

Retourner un dictionnaire : les clés deviennent les valeurs et les valeurs deviennent les clés (on suppose
que les clés et valeurs sont uniques).

In [ ]:
dictionnaire_depart = { "cle1":"valeur1", "cle2":"valeur2" }
dictionnaire_retourne = { }
for k,v in dictionnaire_depart.items():
 dictionnaire_retourne[v] = k

dictionnaire_retourne

La méthode [items] retourne un [itérateur] et non une liste. Un itéreur n'est pas un ensemble mais une
façon de parcourir tous les éléments d'un ensemble.

In [ ]:
dictionnaire_depart = { "cle1":"valeur1", "cle2":"valeur2" }

print ( dictionnaire_depart.items() )
print ( list ( dictionnaire_depart.items() ) )

Le python est un langage paresseux car très lent. Il faut lui demander de façon explicite de construire un
ensemble ou de copier un ensemble. Par défaut, il ne copie jamais un dictionnaire ou une liste et il
préfère retourner un itérateur plutôt qu'une copie d'un ensemble. La plupart du temps, on ne s'en aperçoit
pas à moins de vouloir accéder à un élément précis de l'ensemble :

In [ ]:
dictionnaire_depart.items() [0]

La fonction ensemble suivante retourne une liste d'éléments, la fonction iterateur retourne une
façon de parcourir un ensemble. On appelle ce type ce fonction un [générateur].

In [ ]:
def ensemble(a,b):
res = [ ]
while a < b :
res.append ( a )
a += 1
return res

def iterateur(a,b):
while a < b :
yield a
a += 1

print( iterateur(0,10) )
print( ensemble(0,10) )

On ne peut accéder aux éléments d'un générateur car cela n'a pas de sens :

In [ ]:
iterateur(0,10) [0]

Mais on peut parcourir les éléments générés :

In [ ]:
for x in iterateur(0,10):
print(x)

Q3
𝑖
1 1000
Calculer 1000 ∑𝑖=1 𝑒 1000 .
In [ ]:
from math import exp
1/1000 * sum ( exp ( i / 1000 ) for i in range(1,1001) )

Q4

Quel le coût du programme suivant en 𝑂(𝑁) ?

In [ ]:
from math import log
s = 0
ii = 1
N = 7
for i in range(1,N):
ii *= 2
for k in range(1,ii):
s += log(k)
print(s)

A chaque itération 𝑖, on calcule 2𝑖 logarithmes. On fait 𝑁 itérations soit 1 + 2 + 4+. . . +2𝑁 calculs,
c'est-à-dire environ 𝑂(1 + 21 + 22 + 23 +. . . +2𝑁 ) = 𝑂(2𝑁+1 ) = 𝑂(2𝑁 ) (c'est une somme
géométrique).

In [ ]:
from math import log

def calcul(N):
s = 0
ii = 1
c = 0
for i in range(1,N):
ii *= 2
for k in range(1,ii):
s += log(k)
c += 1
return c

for N in range(10,20):
print(calcul(N), 2**N)