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 de cette page, l'interaction entre l'utilisateur et le programme est effectuée au moyen d'un mécanisme appelé "interaction par lignes de commandes" ("command line interaction" ou CLI, en anglais). 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 faciliter l'écriture de programme mettant en oeuvre ce principe, on vous fournit le module Python ezCLI qui sera détaillé en cours, et qui contient des outils permettant de simplifier au maximum les opérations nécessaires à la saisie des commandes et à l'affichage des résultats.

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 :

Les codes sources disponibles dans la rubrique "Exemples Niveau A" permettent de partir dans une bonne direction, en proposant un squelette standardisé pour l'écriture de programmes mettant en oeuvre une boucle d'interaction par interpréteur de commandes, à l'aide du module ezCLI.
La lecture des chapitre 1 à 7 du livre de Gérard Swinnen, "Apprendre à programmer avec Python" constitue un préalable indispensable à ces exercices.
Les 5 premiers chapitres du "Tutoriel Python" de Guido Van Rossum fournissent un éclairage complémentaire des éléments fondamentaux du langage.

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" :

Modifier le programme euclid (cf. exemple A1) pour que l'utilisateur puisse entrer plusieurs couples "numerator,denominator" sur la ligne de commande, en les séparant par des espaces.
Modifier le programme squares (cf. exemple A2) pour qu'il n'affiche que la liste des carrés de valeurs paires.
Modifier le programme squares (cf. exemple A2) pour qu'il affiche la somme des carrés de 1*1 à n*n au lieu d'afficher leur liste.
Modifier le programme multable (cf. exemple A3) pour qu'il affiche la table en effectuant une symétrie de 180 degrés par rapport à la table originale (i.e. n*n est dans la case en haut à gauche et 1*1 en bas à droite).
Modifier le programme multable (cf. exemple A3) pour qu'il sépare la table en deux (ou plus) lorsque la longueur d'une ligne dépasse 80 caractères.

Exercice A1

En s'inspirant du programe squares (cf. Exemples Niveau A), écrire 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 parser(command) qui doit analyser la saisie de l'utilisateur, récupérer la valeur de n (ou renvoyer un message d'erreur en cas de mauvaise saisie) et enfin, renvoyer 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 sequence of factorial terms from 0! to n!

User input: <n> (where n:int >= 0)
App output: sequence of factorial terms from 0! to n!

Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter value for <n>: 8
0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
<> Enter value for <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.

Rappel : la suite de Fibonacci est définie par : u₀= 0, u₁ = 1, u_k = u_k-1 + u_k-2 avec k > 1.

Exemple d'exécution :

────────────────────────────────────────────────────────────────────────────────
FIBO : compute the n first terms of the Fibonacci sequence

User input: <n> (where n:int >= 0)
App output: sequence of the n first Fibonacci terms

Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter value for <n>: 12
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
fibo(9) = 34
fibo(10) = 55
fibo(11) = 89
fibo(12) = 144
<> Enter value for <n>:

Exercice A3

Ecrire un programme bino qui calcule le coefficient binomial C_n,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 importera la fonction facto(n) définie dans le programme facto ci-dessus, 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)

User input : <n>,<p> (where n:int >= 0, p:int >= 0)
App output : binomial coefficient C(n,p)

Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the 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 utilise la fonction grid' du module ezCLI, pour encadrer les mots d'une phrase selon quatre modes différents (encadrement d'une phrase complète, encadrement des mots en ligne, encadrement des mots en colonne, encadrement des lettres). L'exemple d'exécution ci-dessous, donne un aperçu du résultat souhaité pour les différents modes d'encadrements.

Exemple d'exécution :

────────────────────────────────────────────────────────────────────────────────
FRAMEWORDS : frame each word of a user-provided list of words

User input : <word> [word ...] (where word:str without whitespaces)
App output : several framing modes for the list of words

Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter <word> [word ...]: I want my money back
┌────────────────────┐
│I want my money back│
└────────────────────┘
┌─────┬─────┬─────┬─────┬─────┐
│  I  │ want│  my │money│ back│
└─────┴─────┴─────┴─────┴─────┘
┌─────┐
│  I  │
├─────┤
│ want│
├─────┤
│  my │
├─────┤
│money│
├─────┤
│ back│
└─────┘
┌───┬───┬───┬───┬───┐
│ I │   │   │   │   │
├───┼───┼───┼───┼───┤
│ w │ a │ n │ t │   │
├───┼───┼───┼───┼───┤
│ m │ y │   │   │   │
├───┼───┼───┼───┼───┤
│ m │ o │ n │ e │ y │
├───┼───┼───┼───┼───┤
│ b │ a │ c │ k │   │
└───┴───┴───┴───┴───┘
<> Enter <word> [word ...]:

Exercice A5

Ecrire un programme binhex qui convertit les valeurs décimales d'une série de nombres entiers entrés par l'utilisateur, dans leur représentation binaire (base 2) et leur représentation hexadécimale (base 16). Pour l'affichage, on utilisera la notation standard de Python (et de la plupart des langages de programmation), en ajoutant le préfixe '0B' pour la valeur binaire et le préfixe '0X' pour la valeur hexadécimale.

Rem: Python fournit les fonctions standards bin(n) et hex(n) qui réalisent ces deux conversions. Le but de l'exercice est évidemment de ne pas utiliser ces fonctions, mais de créer vos propres fonctions dec2bin(n) et dec2hex(n) qui se comportent de manière similaire.

Exemple d'exécution :

────────────────────────────────────────────────────────────────────────────────
BINHEX : show decimal, binary and hexadecimal representations for integers

User input : <value> [value...] where value:int is given in decimal
App output : show decimal, binary and hexa representation for all values

Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter <value> [value...]: 1 12 123 1234 12345
1 = 0B1 = 0X1
12 = 0B1100 = 0XC
123 = 0B1111011 = 0X7B
1234 = 0B10011010010 = 0X4D2
12345 = 0B11000000111001 = 0X3039
<> Enter <value> [value...]:

Exercice A6

En s'inspirant du programme multable (cf. Exemples Niveau A), écrire un programme muldiv qui affiche la table des PGCD/PPCM des nombres entre 1 et n pour une valeur de n entrée par l'utilisateur. La partie triangulaire supérieure de cette table contiendra les GCD (Greatest Common Divisor = PGCD) des deux nombres p et q correspondant aux indices de ligne et de colonne. De même, la partie triangulaire inférieure de cette table contiendra les LCM (Least Common Multiple = PPCM) de ces deux indices. On définira deux fonctions auxiliaires gcd(p,q) et lcm(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 : table of GCD/LCM (Greatest Common Divisor/Least Common Multiple)

User input : <n> (where n:int > 0)
App output: table of GCD/LCM from 1 to n

Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter value for <n>: 12
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│  1│  2│  3│  4│  5│  6│  7│  8│  9│ 10│ 11│ 12│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  2│  2│  1│  2│  1│  2│  1│  2│  1│  2│  1│  2│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  3│  6│  3│  1│  1│  3│  1│  1│  3│  1│  1│  3│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  4│  4│ 12│  4│  1│  2│  1│  4│  1│  2│  1│  4│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  5│ 10│ 15│ 20│  5│  1│  1│  1│  1│  5│  1│  1│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  6│  6│  6│ 12│ 30│  6│  1│  2│  3│  2│  1│  6│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  7│ 14│ 21│ 28│ 35│ 42│  7│  1│  1│  1│  1│  1│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  8│  8│ 24│  8│ 40│ 24│ 56│  8│  1│  2│  1│  4│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  9│ 18│  9│ 36│ 45│ 18│ 63│ 72│  9│  1│  1│  3│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 10│ 10│ 30│ 20│ 10│ 30│ 70│ 40│ 90│ 10│  1│  2│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 11│ 22│ 33│ 44│ 55│ 66│ 77│ 88│ 99│110│ 11│  1│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 12│ 12│ 12│ 12│ 60│ 12│ 84│ 24│ 36│ 60│132│ 12│
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
<> Enter value for <n>:

Exercice A7

En s'inspirant du programme multable (cf. Exemples Niveau A), écrire un programme pascal qui affiche le triangle de Pascal jusqu'au rang n pour une valeur de n entrée par l'utilisateur. Dans une première implémentation, les cases du triangle seront directement calculées avec la fonction bino(n,p) définie dans l'Exercice A2. Puis, dans une seconde implémentation, on calculera chaque case comme la somme des deux cases se trouvant respectivement au nord et au nord-ouest de la case courante.

Exemple d'exécution :

────────────────────────────────────────────────────────────────────────────────
PASCAL : create Pascal's triangle (triangle of binomial terms)

User input : <n> (where n:int > 0)
App output: Grid containing Pascal's triangle up to rank n

Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter value for <n>: 9
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│  1│   │   │   │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  1│  1│   │   │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  1│  2│  1│   │   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  1│  3│  3│  1│   │   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  1│  4│  6│  4│  1│   │   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  1│  5│ 10│ 10│  5│  1│   │   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  1│  6│ 15│ 20│ 15│  6│  1│   │   │   │
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  1│  7│ 21│ 35│ 35│ 21│  7│  1│   │   │
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  1│  8│ 28│ 56│ 70│ 56│ 28│  8│  1│   │
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│  1│  9│ 36│ 84│126│126│ 84│ 36│  9│  1│
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
<> Enter value for <n>:

Exercice A8

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 2 to n

User input : <n> (where n:int > 1)
App output : sequence of prime numbers from 2 to n

Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter value for <n>: 999
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ 2 │ 3 │ 5 │ 7 │ 11│ 13│ 17│ 19│ 23│ 29│ 31│ 37│ 41│ 43│ 47│ 53│ 59│ 61│ 67│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│ 71│ 73│ 79│ 83│ 89│ 97│101│103│107│109│113│127│131│137│139│149│151│157│163│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│167│173│179│181│191│193│197│199│211│223│227│229│233│239│241│251│257│263│269│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│271│277│281│283│293│307│311│313│317│331│337│347│349│353│359│367│373│379│383│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│389│397│401│409│419│421│431│433│439│443│449│457│461│463│467│479│487│491│499│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│503│509│521│523│541│547│557│563│569│571│577│587│593│599│601│607│613│617│619│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│631│641│643│647│653│659│661│673│677│683│691│701│709│719│727│733│739│743│751│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│757│761│769│773│787│797│809│811│821│823│827│829│839│853│857│859│863│877│881│
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
│883│887│907│911│919│929│937│941│947│953│967│971│977│983│991│997│   │   │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
<> Enter value for <n>:

Exercice A9

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 a list of numerical values

User input : <operator> <value> [value...]
             where operator = 'min'|'max'|'sum'|'mean'|'variance'|'deviation'
             and value:int|float
App output : apply operator on the set of values

Enter 'help' or '?' to display some user instructions
Enter 'about' or '!' to display some info about the application
Enter 'exit' or an empty line to stop the interaction loop
────────────────────────────────────────────────────────────────────────────────
<> Enter <operator> <value> [value...]: sum 1 2 3 4 5
sum 1 2 3 4 5 = 15.0
<> Enter <operator> <value> [value...]: mean 1 2 3 4 5
mean 1 2 3 4 5 = 3.0
<> Enter <operator> <value> [value...]: variance 1 2 3 4 5
variance 1 2 3 4 5 = 2.0
<> Enter command :

...

Christophe Schlick