PYTHON : EXERCICES NIVEAU A

Les exercices proposés sur cette page permettent une mise en oeuvre des éléments fondamentaux du langage Python. Pour tous les exercices, l'interaction entre l'utilisateur et le programme est effectuée au moyen d'un mécanisme appelé "boucle d'interaction par interpréteur de commandes". Dans ce mécanisme, l'utilisateur commence par saisir une commande sous la forme d'une chaîne de caractères, comprenant éventuellement plusieurs mots et/ou valeurs numériques. Ensuite le programme va analyser cette commande, y récupérer les différents paramètres, avant d'effectuer les actions correspondantes. Les résultats obtenus sont affichés à l'écran, également sous la forme d'une chaîne de caractères alphanumériques, puis le programme se remet en attente d'une nouvelle commande de la part de l'utilisateur. Une commande spécifique (par exemple, une ligne vide) permet à l'utilisateur d'arrêter la boucle d'interaction et de quitter le programme.

Pour tous les exercices, un soin particulier devra aussi être porté sur la "robustesse du programme", une propriété qui garantit que le programme ne s'arrête pas brutalement lorsque l'utilisateur effectue une saisie de données invalides, mais au contraire va identifier ces données invalides, afficher un message et permettre à l'utilisateur d'effectuer une nouvelle saisie.

Pour bien démarrer, il est fortement conseillé de s'inspirer de quelques exemples de programmes. Trois sources de documentation sont fournies :

Exercice A0

L'objectif de cet exercice d'introduction est de réaliser une série de modifications simples sur les codes sources fournis dans la rubrique "Exemples Niveau A" :

Exercice A1

Ecrire un programme facto qui affiche les valeurs de la fonction factorielle de 0! à n! où la valeur de n est entrée par l'utilisateur. Pour une meilleure lisibilité du code source, créer une fonction facto(n) qui renvoie la valeur de la factorielle de son paramètre d'entrée, ainsi qu'une fonction str_facto(n) qui renvoie la chaîne de caractères correspondant au texte que doit afficher le programme, comme indiqué dans l'exemple d'exécution ci-dessous.

Exemple d'exécution :
================================================================================
FACTO : compute the factorial function from 0! to n!
Input : value of 'n'
Note : enter empty line to stop interaction loop
================================================================================
<> Enter value of 'n' : 8
0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
<> Enter value of 'n' :

Exercice A2

En utilisant le même squelette que l'exercice précédent, écrire un programme fibo qui affiche les n premiers termes de la suite de Fibonacci, où la valeur de n est entrée par l'utilisateur.
La suite de Fibonacci est définie par : u0= 0, u1 = 1, uk = uk-1 + uk-2 avec k > 1.

Exemple d'exécution :
================================================================================
FIBO : compute the 'n' first terms of the Fibonacci sequence
Input : value of 'n'
Note : enter empty line to stop interaction loop
================================================================================
<> Enter value of 'n' : 8
fibo(0) = 0
fibo(1) = 1
fibo(2) = 1
fibo(3) = 2
fibo(4) = 3
fibo(5) = 5
fibo(6) = 8
fibo(7) = 13
fibo(8) = 21
<> Enter value of 'n' :

Exercice A3

Ecrire un programme bino qui calcule le coefficient binomial Cn,p = n! / p!(n-p)! où les valeurs de n et p sont entrées par l'utilisateur. Dans une première version, le programme utilisera la fonction facto(n) définie dans l'exercice précédent pour calculer les trois factorielles mises en oeuvre. Quel est l'inconvénient de cette manière de procéder en terme de performance du programme ? Proposer une seconde version permettant d'éviter tous les calculs inutiles.

Exemple d'exécution :
================================================================================
BINO : compute the binomial coefficient C(n,p)
Input : value of 'n', value of 'p'
Note : enter empty line to stop interaction loop
================================================================================
<> Enter n,p : 5,2
bino(5,2) = 10
<> Enter n,p : 654,321
bino(654,321) = 208862495338376097148824392621598331466800707904057584045885
2317553835286687166542234979310586620807550210480099247071146340471456463666
098110787162439679333032277411632733692493464039370070191000
<> Enter n,p :

Exercice A4

Ecrire un programme framewords qui encadre (au moyen des caractères '+', '- ' et '|') chacun des mots d'une phrase entrée par l'utilisateur.

Exemple d'exécution :
================================================================================
FRAMEWORDS : frame each word of a user-provided list of words
Input : list of words
Note : enter empty line to stop interaction loop
================================================================================
<> Enter list of words : We are the GREATEST Champions!
+----+-----+-----+----------+------------+
| We | are | the | GREATEST | Champions! |
+----+-----+-----+----------+------------+
<> Enter list of words : 

Exercice A5

Ecrire un programme numtolit qui convertit la valeur décimale d'un nombre entier entré par l'utilisateur, en sa valeur littérale en français. Pour simplifier, on se limitera aux nombres entre 0 et 999999. Pour éviter de traiter un trop grand nombre de cas particuliers, une manière astucieuse est de définir un tableau de chaînes de caractères contenant les mots ['un','deux', ... ,'dix huit','dix neuf','vingt','trente', ... ,'soixante','soixante','quatre vingt','quatre vingt'].

Exemple d'exécution :
================================================================================
NUMTOLIT : convert an integer value 'n' into its literal equivalent
Input : value of 'n'
Note : enter an empty line to stop the interaction loop
================================================================================
<> Enter value of 'n': 0
zero
<> Enter value of 'n': 321
trois cent vingt et un
<> Enter value of 'n': 654321
six cent cinquante quatre mille trois cent vingt et un
<> Enter value of 'n': 999999
neuf cent quatre vingt dix neuf mille neuf cent quatre vingt dix neuf
<> Enter value of 'n' : 

Exercice A6

Ecrire un programme lcd qui affiche la valeur décimale d'un nombre entier entré par l'utilisateur, en simulant le graphisme d'un afficheur LCD. En terme de stockage, le programme n'a besoin d'utiliser qu'une seule chaîne de caractères multiligne, représentant la concaténation des chiffres de 0 à 9 (cf. Exemple d'exécution), dans laquelle il faudra extraire judicieusement des intervalles de caractères, en fonction de la valeur numérique entrée par l'utilisateur.

Exemple d'exécution :
================================================================================
LCD : display an integer value 'n' using a pseudo-LCD font
Input : value of 'n'
Note : enter an empty line to stop the interaction loop
================================================================================
<> Enter value of 'n': 0123456789
+---+    +    +---+  +---+  +   +  +---+  +---+  +---+  +---+  +---+
|   |    |        |      |  |   |  |      |          |  |   |  |   |
+   +    +    +---+  +---+  +---+  +---+  +---+      +  +---+  +---+
|   |    |    |          |      |      |  |   |      |  |   |      |
+---+    +    +---+  +---+      +  +---+  +---+      +  +---+  +---+
<> Enter value of 'n' : 

Exercice A7

Ecrire un programme prime qui affiche tous les nombres premiers inférieurs à une valeur n entrée par l'utilisateur. Dans une première version, le programme stockera dans une liste extensible, les nombres premiers au fur et à mesure de leur identification. Pour chaque nouveau nombre considéré, cette liste permettra de fournir la liste de diviseurs à utiliser pour le test de primalité. Dans une seconde version, le programme implémentera l'algorithme du crible d'Erathostène. Avec cet algorithme, on stocke, pour chaque nouveau nombre premier p identifié, l'ensemble des multiples de p dont la valeur est inférieure à n. Ainsi, tous les nombres non-premiers sont immédiatement identifiés, et les nombres premiers sont obtenus par complément.

Exemple d'exécution :
================================================================================
PRIME : compute all prime numbers from 1 to 'n'
Input : value of 'n'
Note : enter an empty line to stop the interaction loop
================================================================================
<> Enter value of 'n' : 120
002 003 005 007 011 013 017 019 023 029 031 037 041 043 047
053 059 061 067 071 073 079 083 089 097 101 103 107 109 113
<> Enter value of 'n' :

Exercice A8

Ecrire un programme stat qui permet de réaliser une opération statistique op sur une série de données numériques. Pour cela, l'utilisateur saisit une commande sous la forme op val1 val2 ... valN dans laquelle l'argument op peut prendre les valeurs suivantes : min, max, sum, mean, variance, deviation permettant respectivement de calculer le minimum, le maximum, la somme, la moyenne, la variance et l'écart-type des données numériques val1 ... valN. Le programme utilisera une fonction min qui renvoie le minimum d'une liste de valeurs numériques passée en argument. De la même manière, on définira les fonctions max, sum, mean, variance, deviation de prototype similaire.

Exemple d'exécution :
================================================================================
STAT : perform some statistical operations on numerical values
Input : operator value [value...]
        where operator = min | max | sum | mean | variance | deviation
        and value = integer value | real value
Note : enter an empty line to stop the interaction loop
================================================================================
<> Enter command : sum 1 2 3 4 5
sum 1 2 3 4 5 = 15.0
<> Enter command : mean 1 2 3 4 5
mean 1 2 3 4 5 = 3.0
<> Enter command : variance 1 2 3 4 5
variance 1 2 3 4 5 = 2.0
<> Enter command :

Exercice A9

En s'inspirant du programme multable vu dans les exemples de programmes, écrire un programme muldiv qui affiche la table des PGCD/PPCM des nombres entre 1 et n où la valeur de n est entrée par l'utilisateur. La partie triangulaire supérieure (resp. inférieure) de cette table contiendra les PGCD (resp. PPCM) des deux nombres p et q correspondant aux indices de ligne et de colonne. On définira deux fonctions auxiliaires pgcd(p,q) et ppcm(p,q) qui permettent de calculer les deux éléments demandées sur les deux nombres passés en paramètre.

Exemple d'exécution :
================================================================================
MULDIV : show table of GCD/LCM (Greatest Common Divisor/Least Common Multiple)
Input : value of 'n'
Note : enter empty line to stop interaction loop
================================================================================
<> Enter command : 6
+---+---+---+---+---+---+
| 1 | 2 | 3 | 4 | 5 | 6 |
+---+---+---+---+---+---+
| 2 | 2 | 1 | 2 | 1 | 2 |
+---+---+---+---+---+---+
| 3 | 6 | 3 | 1 | 1 | 3 |
+---+---+---+---+---+---+
| 4 | 4 | 12| 4 | 1 | 2 |
+---+---+---+---+---+---+
| 5 | 10| 15| 20| 5 | 1 |
+---+---+---+---+---+---+
| 6 | 6 | 6 | 12| 30| 6 |
+---+---+---+---+---+---+
<> Enter command :
...
Christophe Schlick