L2MIASH Introduction à : Exercices

Roland Becker

12 septembre 2023

Table des matières

1 Les bases 1

2 Algorithmique 3

3 Modules 4

4 Graphisme 5

5 numpy 6

1 Les bases

Exercise 1 entrée-sortie écran (Section 1)

1. Écrire un programme, qui à partir d’un rayon donné par l’utilisateur, calcule le diamètre,
le périmètre et la surface d’un cercle de rayon donné.
2. Écrire un programme, qui à partir d’un nombre entier donné par l’utilisateur, détermine
si le nombre est pair ou impair et calcule ensuite combien de fois ce nombre est divisible
par deux ou par trois.
3. Écrire un programme, qui à partir d’un nombre entier donné par l’utilisateur, détermine
si le nombre est premier ou pas.

Exercise 2 string (Section 1)

1. Les variables varEcho, varSpace et varLine sont initialisées par

varEcho="Echo" ; varSpace=" " ; varLine="\n"
En utilisant seulement les opérations *, +, parenthèses, nombres naturels et les trois va-
riables, écrire les instructions qui donnent les résultats suivants :
1. Echo Echo Echo Echo Echo
2. Echo
Echo
Echo

1
2. Écrire des fonctions qui donnent les résultats suivant (et généraliser à un nombre donné
de lignes et de colonnes)
1. *******
2. *
*
*
3. *******
*******
*******
4. *******
* *
*******
3. Soit ’alphabet=abcdefghijklmnopqrstuvwxyz’. En utilisant la syntaxe de ’slice’
(extraction) alphabet[start:stop:step] produire les chaînes caractères suivantes.
(Par exemple ’a’ est ’alphabet[0]’).
1. ’z’
2. ’zyxwvutsrqponmlkjihgfedcba’
3. ’efgh’
4. ’uvwx’
5. ’vwxyz’
6. ’fhjlnprtvxz’
7. ’yvspmjgd’

Exercise 3 list (Section 1)

1. Générer un nombre aléatoire entier entre 1000 et 9999 et le convertir en une liste de digit,
par exemple 2020 → [2, 0, 2, 0].
2. Poker (1). On représente une carte d’un jeu de 52 carte par une chaîne de caractère de
longueur deux, par example ’CD’ est la dame de coeur.
• Construire une liste qui représente le jeu complet.
• Mélanger les cartes. On peut se servir de random.shuffle().
• Distribuer cinq cartes à un nombre de joueurs donné. Attention, il ne doit pas y avoir
de doublons.
• Écrire une fonction qui affiche en clair les cartes (main) d’un joueur.
• Écrire qui trouve le paires (deux cartes de la même valeur), brelan (trois cartes de la
même valeur) et carrés (quatre cartes de la même valeur).
3. On s’intéresse à coder un texte.
• Construire une chaîne de caractères contenant l’alphabet, ’ ’ et les chiffres (alphabet
augmenté).
• Convertir (c2l) une chaîne de caractères contenant les lettres de l’alphabet, des blancs,
ou des chiffres en une liste indiquant pour chaque caractère sa position dans l’alpha-
bet augmenté.
• Écrire la conversion dans l’autre sens (l2c).

2
 • Soit k un nombre naturel, la clé. On utilise c2l, on rajoute à tous éléments de la liste k
(attention, l’indice ne doit pas dépasser le nombre d’éléments mois un) et on recon-
vertir en utilisant l2c. Voilà un texte brouiller.
• Écrire une fonction pour retrouver le texte originel.
• list a bien une fonction max, mais pas de fonction argmax qui donnerait l’indice
(ou les indices !) où se produit le maximum des valeurs. Écriez en une.
4. Générer une list l de nombre aléatoires entiers entre -20 et +20 de longueur 50. On veut
s’avoir combien de nombres différent p contient l. Pour cela, on peut transformer la liste
en set. Ce nombre est une variable aléatoire. En répétant n fois, calculer une estimation
de son espérance en fonction de n

Exercise 4 dict (Section 1)

1. Écrire une fonction qui détermine, si un dict donné correspond à une injection. Si c’est
la cas, construire le dict qui correspond à l’application inverse.
2. Tester votre fonction en construisant des dictionnaires d’entiers entre 1 et 10 et de lettre
entre ’a’ et ’j’.
3. Pour la marche aléatoire, utiliser un dictionnaire pour compter toutes les occurrences des
positions.
4. Utiliser sorted(d.items()) pour un dictionnaire d pour créer une liste des fréquences
d’une marche aléatoire.

Exercise 5 Random walk (1) (Section 1)

On s’intéresse ici à une variante de la marche aléatoire. Un point de position Pi à l’instant

i = 0, 1, · · · bouge avec un incrément aléatoire sur un cercle. On suppose que l’incrément Xi est
de la forme

P(Xi = 1) = p, P(Xi = −1) = 1 − p,

avec 0 ⩽ p ⩽ 1. La position du point est entre −M et M avec M ∈ N (par exemple M = 10) et

l’on identifie les deux extrémités pour modéliser le cercle.
1. Par quelle formule est définie Pi+1 en fonction de Pi et Xi .
2. Écrire une fonction qui construit la liste de positions (Pi )0⩽i⩽n (« une marche ») en fonction
de p, M et de n.
3. Pour une marche donnée, calculer sa moyenne et sa variance standard.
4. Pour une marche donné, calculer la fréquence de chaque k avec k ∈ [−M, M].

2 Algorithmique

Exercise 6 algorithmique (Section 2)

1. Écrire un programme en python pour calculer

1. 1 + 2 + 3 + · · · + 100

3
 2. 1 + 3 + 5 + · · · + 99
3. 1 × 2 × 3 × · · · × 22
2. Écrire une fonction en python pour calculer la somme des nombres entiers entre a et b
avec a, b ∈ N et a ⩽ b.

Exercise 7 Tables de multiplication (Section 2)

Écrire un programme en python pour réviser les tables de multiplication. Le programme

tire deux entiers au hasard et demande à l’utiliser le résultat de la multiplication. On interroge
l’utilisateur dix fois et on affiche le nombre de bonnes réponses à la fin.

Exercise 8 Jeu du plus ou moins (Section 2)

L’ordinateur tire un nombre entier entre 0 at 100 au hasard. L’utilisateur doit le trouver en
proposant des valeurs. L’ordinateur indique pour chaque nombre proposé s’il est juste, trop
petit ou trop grand. A la fin, il affiche le nombre de propositions faites par l’utilisateur.

Exercise 9 Jeu de hasard (Section 2)

Le joueur paie 2 euros par jeu, qui consiste au lancement de deux dés. Si le joueur obtient un
double, il garde sa mise et gagne la somme des des points marqués. Écrire un programme pour
simuler ce jeu. Conseilleriz-vous ce jeu ?

Exercise 10 Valeur de π (Section 2)

1. Écrire un programme pour trouver un valeur approchée de π par balayage.

2. Écrire un programme pour trouver un valeur approchée de π par dichotomie.
3. Écrire un programme pour trouver un valeur approchée de π par la méthode de Monte-
Carlo.

Exercise 11 Random walk (3) (Section 2)

On considère la marche aléatoire du cours (marche aléatoire standard, loi de Bernoulli avec
p = 1/2).
1. Écrire une fonction pour la génération d’une marche aléatoire de longueur m ∈ N.
2. Écrire une fonction, qui, pour une marche aléatoire donnée, calculer le premier indice i∗
tel que le marche retourne à zéro.
3. Écrire une fonction qui, pour n ∈ N donné, calcule une approximation de l’espérance de
i∗ pour n marches aléatoire.

3 Modules

4
 Exercise 12 poker (2) (Section 3)

On reprend le travail fait dans l’exercice 3.2.

1. Créer un nouveau repertoire et placer les fonctions déjà écrites dans un fichier "cartes.py".
Rajouter dans ce fichier une fonction test() et exécuter la.
2. Rajouter un fichier "main.py", le programme principal. Dans ce fichier fait import cartes.
Que se passe-t-il si vous éxécuter "main.py" ?
3. Modifier "cartes.py" comme dans le cours (en utilisant if __name__=="__main__")
pour que le test soit seulement fait si l’on exécute "cartes.py".
4. Rajouter à votre fonction d’évaluation le cas de la quinte (les cinq cartes forment une
séquence) et le cas du full (un brelan et une paire).
5. Écrire un programme qui distribue les cartes à n joueurs et détermine qui a la meilleure
main.
6. Écrire un programme pour mesurer les fréquences des combinaisons de cartes considé-
rées.

4 Graphisme

Exercise 13 (Section 4)

1. Utiliser plt.plot() pour tracer un triangle de sommets (−2, −6), (2, −4), (1, 3).
2. Placer des croix bleues aux sommets.

Exercise 14 (Section 4)

Soit n ∈ N et pn la probabilité que parmis n personnes il n’y a pas deux personnes nées le
même jour. On sait que

Y
n−1
k

pn = 1− .
k=1
365

1. Tracer la probabilité en fonction de n.

2. Pour quel n la probabilité est-elle inférieure à 1/2 ?
3. Remplacer les jours de l’année par les mois.

Exercise 15 Random walk (3) (Section 4)

On continue l’exercice 5.
1. Tracer une marche aléatoire.
2. Tracer ses fréquences comme un histogramme.
3. Comment dépendent la moyenne et la variance de n ?

5
5 numpy

Exercise 16 vecteurs (Section 5)

1. Réécrire l’exercice 3.4 à l’aide de numpy, en utilisant un vecteur aléatoire de taille 50 avec
entrées entiers entre -20 et 20. Calculer p, le nombre de nombres différents contenus dans
ce vecteur. Calculer le nombre d’éléments supérieur à 10.
Généralisation : soit m, n ∈ N. On remplace « 50 » par n et « 20 » par m. Faites des simula-
tions pour estimer l’espérance de p en fonction de n et de m.
2. Créer une matrice A de taille 3×3 au hasard. Calculer les valeurs propres de AT A. Estimer
l’espérance de la plus petite valeur propre.

Exercise 17 Random walk (4) (Section 5)

On continue l’exercice 15.

1. Réécrire vos fonctions avec numpy.
2. Comparer les temps d’exécution des deux variantes en fonction de n. Pour mesurer un
temps d’execution on peut utiliser le module time. Par example

import time
t0 = time.time()
appel_de_la_fct()
dt = time.time()-t0

Utiliser plt.plot pour visualiser votre comparaison.

3. Maintenant on va utiliser m marches aléatoires pour d’abord estimer l’espérance, puis la
variance. Qu’est-ce qu’on observe en fonction de m ?
4. Même question pour les fréquences.