Département d’informatique et d’ingénierie

INF1563 Programmation I Hiver 2024

Fiche d’exercices (Listes et dictionnaires)

Les exercices de cette fiche portent sur la manipulation de listes Python. Les exemples donnés sont
tous des listes de nombres entiers, mais les fonctions demandées devraient marcher avec des listes
d’éléments de types quelconques.

Exercice 1 : Milieu
Écrire une fonction milieu qui prend une liste de longueur impaire et retourne l’élément du
milieu.

Exemples :
- milieu([2, 9, 10, -1, 0]) donne 10;

- milieu([4, 4, -10]) donne 4;

- milieu([8]) donne 8.

Rappel : la longueur d’une liste (nombre d’éléments) est donnée par la fonction len(), et la
première position est indexée 0.

Exercice 2: Trouver une valeur

2.1 – Écrire une fonction contient(a, v) qui prend en entrée une liste a (de longueur
quelconque) et une valeur v, et retourne True si l’élément est présent dans la liste, sinon False.
Par exemple, si on passe en entrée la liste [2, 4, 9, 10, -1, 10] et la valeur 4, la
fonction doit retourner True, car 4 est bien présent dans la liste.
Si on passe la même liste et la valeur 3, la fonction doit retourner False.

2.2 – Écrire une fonction position(a, v) qui qui prend en entrée une liste a (de longueur
quelconque) et une valeur v, et retourne la première position dans a où on trouve v. Si v n’est pas
présente dans a, alors la fonction doit retourner -1.
Par exemple, si on passe en entrée la liste [2, 4, 9, 10, -1, 10] et la valeur 10, la fonction
retourne 3 car la première occurrence de la valeur 10 est à la position 3 (rappel : la première position
est indexée 0).
Pour la même liste et la valeur 3, la fonction doit retourner -1 car la valeur 3 n’est pas présente dans
la liste.
2.3 – Écrire une fonction combien(a, v) qui prend en entrée une liste a (de longueur
quelconque) et une valeur v, et retourne le nombre de fois que v apparait dans la liste a. Si v
n’est pas présente dans a, alors la fonction doit retourner 0.

page 1/6
Par exemple, si on passe en entrée la liste [2, 4, 9, 10, -1, 10] et la valeur 10, la fonction
retourne 2 car 10 apparaît deux fois dans la liste.
Pour la même liste et la valeur 3, la fonction doit retourner 0 car la valeur 3 n’est pas présente dans
la liste.

Exercice 3
On considère le code suivant:
a = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

for i in range(20):
if (i%2==0):
a[i//2] = i+1

Donner le contenu de la liste a après l’exécution du programme.

a = _________________________________________

Exercice 4: miroir
4.1 – Écrire une fonction miroir(a) qui prend une liste (de longueur quelconque n) et modifie
la liste pour qu’elle contienne les éléments de a suivis des n -1 premiers éléments dans l’ordre
opposé.

Par exemple, si on passe en entrée la liste [1, 2, 3], après exécution de la fonction la liste doit
contenir [1, 2, 3, 2, 1]. Si la liste donnée en entrée est vide ou de longueur 1, la liste reste
doit rester inchangée.

4.2 – Écrire une fonction miroir2(a) qui fait la même chose que la fonction miroir, sauf qu’au
lieu de modifier la liste d’entrée, la fonction doit retourner une nouvelle liste contenant les
éléments en miroir, de sorte que la liste donnée en entrée soit toujours inchangée.

Exercice 5: rotation
Écrire une fonction rotation(a, k) qui prend en entrée une liste a de longueur quelconque,
et décale les éléments de k positions (vers l’avant ou l’arrière selon le signe de k). Le décalage
doit « boucler » au début et à la fin de la liste, c’est-à-dire que si le dernier élément de la liste est
décalé « vers l’avant » d’une position, il se retrouve au début de la liste.

Exemples :
- si on passe en entrée la liste [1, 2, 3, 4, 5, 6] et la valeur 2, les éléments sont
décalés de 2 positions « vers l’avant » : on obtient la liste [5, 6, 1, 2, 3, 4].
Remarquer que les deux derniers éléments se sont retrouvés au début.
- Si on passe en entrée la liste [9, 2, 0, 0, 6, 6] et la valeur -1, les valeurs de la
liste sont décalées d’une position vers l’arrière, et on obtient :
[2, 0, 0, 6, 6, 9]
page 2/6
Si la liste donné en entrée est vide ou de longueur 1, elle doit rester inchangée.

Indication : pour cet exercice, il est difficile de modifier la liste « en place ». Il y a deux
approches possibles : soit on crée une nouvelle liste qu’on remplit avec les valeurs décalées, avant
de toutes les recopier dans la liste initiale, soit on décale les valeurs d’une position à la fois (ce qui
est gérable « en place »), et on fait plusieurs passes.

Exercice 6: Uniques
Écrire une fonction uniques qui prend une liste en entrée et retourne True si tous les éléments
de la liste sont uniques, et False s’il y a des duplicata.

Par exemple, si on passe en entrée la liste [2, 4, 9, 10, -1, 0], la fonction doit retourner
True, car aucune valeur n’est répétée. Si on passe la liste [3, 1, 5, 1, -9] en entrée, alors
la fonction retourne False car le nombre 1 est répété. Note : selon cette définition, pour une liste
de longueur 0 ou 1, la fonction doit retourner True.

Exercice 7
On considère la fonction maFonction() donnée ci-dessous :
def maFonction(a):
b = []
for v in a:
z = (v > 0 and v%2==0)
b.append(z)
return b

On appelle cette fonction sur plusieurs listes différentes. Pour chaque liste, écrire à droite
le contenu de la liste retourné par la fonction.
Code Contenu de la liste retournée
a1 = [3, 2, 1]
b1 = maFonction(a1) b1=________________________________________

a2 = [1, 2, 3, 4]
b2 = maFonction(a2) b2=________________________________________

a3 = [5, 2, 5, 0, 4, 0]
b3 = maFonction(a3) b3=________________________________________

Exercice 8: Notes de patinage (exercice type examen)

Dans une compétition de patinage artistique, les compétiteurs exécutent un enchaînement
de mouvements acrobatiques (sauts, tours, etc.), et leur performance est notée par un comité
de juges. Chaque mouvement exécuté par un patineur rapporte des points, selon sa difficulté
(qui rapporte un nombre fixe de points) et sa qualité d’exécution (évaluée par les juges).

page 3/6
Le but de cet exercice est d’écrire une fonction qui calcule les points attribués pour un
mouvement. Les données d’entrée (paramètres de la fonction) sont la « valeur de base » (un
nombre décimal qui reflète la difficulté du mouvement) et les notes des différents juges
(une liste d’entiers : il y a 9 notes, et leurs valeurs sont comprises entre -3 et +3).
La fonction du calcul est la suivante : on prend les 9 notes des juges, on enlève la note la
plus haute et la note la plus basse (quand il y a plusieurs fois la même note haute ou basse,
on l’enlève une seule fois), puis on fait la moyenne des 7 notes restantes. Cette moyenne
est ajoutée à la « valeur de base » du mouvement, et le total est le nombre de points attribué
au mouvement.
Par exemple, pour un mouvement dont la valeur de base est de 3.2 et les notes d’exécution
sont [3, 2, 1, 2, 3, 3, 2, 2, 3] on enlèverait le 1 (note la plus basse) et un
des 3 (note la plus haute) et on obtiendrait la moyenne d’exécution de 17 / 7 = 2.43. Ajoutée
à la valeur de base, on obtiendrait la note finale de 5.63 pour le mouvement.
Écrire une fonction points(vbase, notes) qui calcule les points attribués pour un
mouvement, selon le calcul décrit ci-dessus. Le paramètre vbase est un nombre décimal
correspondant à la valeur de base, et notes est une liste contenant les notes des juges.
Indications :
- On peut identifier la note la note la plus haute et la note la plus basse dans un par-
cours de la liste (calcul du max / min, sachant que les notes sont comprises entre -
3 et 3), et faire en même temps (dans le même parcours de la liste) la somme de
toutes les notes. On pourra ensuite soustraire la note la plus haute et la note la plus
basse de la somme.
- La moyenne des notes doit être une valeur exacte (décimale) et non arrondie.

Exercice 9: Dictionnaire de diviseurs

On prend comme point de départ une liste de nombres entiers supérieurs à 10.
liste = [10, 25, 18, 33, 48, 24, 17]
9.1 – Construire une liste contenant toutes les paires de nombres de cette liste :
paires = [(10, 25), (10,18), (10,33), … , (24, 17)]
9.2 – Construire un dictionnaire qui associe à chaque paire le PGCD des deux nombres. Le
PGCD est le plus grand dénominateur commun et se calcule par l’algorithme d’Euclide
donné schématiquement ci-dessous :

page 4/6
Exercice 10: clés longues
On considère un dictionnaire associant comme des chaines de caractères (clés) à des nombres en-
tiers (valeurs).
10.1 – Faire la liste des clés (string) qui ont plus de caractères que le nombre associé.
10.2 – Faire la somme des valeurs (nombres) associées à des clés de moins de 5 caractères.

Exercice 11: Fusion de dictionnaires

11.1 – Écrire une fonction fusion(d1, d2) qui prend deux dictionnaires en paramètre et re-
tourne un nouveau dictionnaire contenant la fusion des deux : la fusion de deux dictionnaires est
un nouveau dictionnaire dont les clés sont l’union des clés des deux dictionnaires. Pour chaque clé,
si elle est présente dans un seul des dictionnaires d1 et d2, la valeur est celle qui existe dans ce
dictionnaire, et si elle est présente dans les deux dictionnaires, alors on prend celle de d1 (il y aurait
d’autres manières de résoudre les conflits, qu’on explore dans les questions ci-dessous).
11.2 – Écrire une fonction fusion_xor(d1, d2) qui prend en paramètre deux dictionnaires et
qui retourne la fusion de ces deux dictionnaires, mais avec seulement les clés qui apparaissent dans
un seul des deux dictionnaires. Les clés qui sont dans les deux dictionnaires d1 et d2, ne doivent
pas apparaitre dans le nouveau dictionnaire retourné.
11.3 – Écrire une fonction fusion_liste(d1, d2) qui prend en paramètre deux dictionnaires,
et qui retourne la fusion des deux, mais cette fois pour chaque clé on associe la liste de valeurs pour
les différents dictionnaires. Exemple : pour une clé k qui se trouve seulement dans d1, le diction-
naire retourné associe à k la liste d’un élément [d1[k]]. Si k se trouve dans les deux dictionnaires
d1 et d2, alors le dictionnaire retourné associe à k la liste [d1[k], d2[k]].

Exercice 12: Index

Le but de l’exercice est d’écrire un « index inversé », comme on en trouve à la fin des livres : pour
chaque mot-clé du livre, on indique la liste des pages dans lesquelles le mot-clé apparait.
12.1 – On suppose que le texte est fourni sous forme de liste de String : chaque String représente
une page du livre. Écrire une fonction dict_pages qui transforme cette liste de String en dic-
tionnaire qui associe à chaque position dans la liste (de string) la liste de mots qui apparaissent dans
le string.
Exemple : texte = ["un agneau se désaltérait", "dans le courant d'une
onde pure", "un loup survient à jeun qui cherchait aventure", "et
que la faim en ces lieux attirait"]
Cette liste contient 4 éléments, et le dictionnaire doit alors contenir 4 clés qui sont les nombres 0,
1, 2, et 3. Le dictionnaire obtenu doit donc ressembler à ceci :
{0 : ['un', 'agneau', 'se', 'désaltérait'],
1 : ['dans', 'le',…],
2 : …,
3 : …}
12.2 – Écrire une fonction index qui prend en paramètre un dictionnaire de la forme ci-dessus
(nombre vers liste), et retourne un index : un index est un dictionnaire dont les clés sont l’ensemble
des éléments dans les listes (ci-dessus à droite, soit les mots du texte), et les valeurs sont des listes
page 5/6
de nombres, soit la liste de clés où le mot apparait dans la liste associée à cette clé dans le diction-
naire original.
Dans l’exemple précédent, l’index doit contenir les clés 'un', 'agneau', 'se', 'dé-
saltérait', etc. et la liste de nombres associée à la clé 'un' est [0, 2] puisque le mot 'un'
apparait dans les listes 0 et 3.

page 6/6