Une introduction à Python 3

Image non disponible


précédentsommairesuivant

14. Exercices corrigés

14-1. Énoncés des exercices

Les exercices suivants sont fournis à titre d'exemple et de modèles.

Ils sont soit simples, soit moins simples (notés ✠ dans le titre) soit plus difficiles (notés ✠✠).

14-2. Exercices

14-2-1. Numéro 1

Écrire un programme qui, à partir de la saisie d'un rayon et d'une hauteur, calcule le volume d'un cône droit.

14-2-2. Numéro 2

Une boucle while : entrez un prix HT (entrez o pour terminer) et affichez sa valeur TTC.

14-2-3. Numéro 3

Une autre boucle while : calculez la somme d'une suite de nombres positifs ou nuls. Comptez combien il y avait de données et combien étaient supérieures à 100.

Entrer un nombre inférieur ou égal à 0 indique la fin de la suite.

14-2-4. Numéro 4

L'utilisateur donne un entier positif kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp et le programme affiche PAIR s'il est divisible par 2, IMPAIR sinon.

14-2-5. Numéro 5

L'utilisateur donne un entier positif et le programme annonce combien de fois de suite cet entier est divisible par 2.

14-2-6. Numéro 6 ✠

L'utilisateur donne un entier supérieur à 1 et le programme affiche, s'il y en a, tous ses diviseurs propres sans répétition ainsi que leur nombre. S'il n'y en a pas, il indique qu'il est premier. Par exemple :

 
Sélectionnez
Entrez un entier strictement positif : 12
Diviseurs propres sans répétition de 12 : 2 3 4 6 (soit 4 diviseurs propres)
Entrez un entier strictement positif : 13
Diviseurs propres sans répétition de 13 : aucun ! Il est premier

14-2-7. Numéro 7

Écrire un programme qui approxime par défaut la valeur de la constante mathématique kitxmlcodeinlinelatexdvpefinkitxmlcodeinlinelatexdvp, pour kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp assez grand(56), en utilisant la formule :

kitxmlcodelatexdvpe \approx \frac{\sum\limits_{i=0}^{n}1}{i!}finkitxmlcodelatexdvp

Pour cela, définissez la fonction factorielle et, dans votre programme principal, saisissez l'ordre kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp et affichez l'approximation correspondante de kitxmlcodeinlinelatexdvpefinkitxmlcodeinlinelatexdvp.

14-2-8. Numéro 8

Un gardien de phare va aux toilettes cinq fois par jour. Or les WC sont au rez-de-chaussée…

Écrire une procédure (donc sans return) hauteurParcourue qui reçoit deux paramètres, le nombre de marches du phare et la hauteur de chaque marche (en cm), et qui affiche :

 
Sélectionnez
Pour x marches de y cm, il parcourt z.zz m par semaine.

On n'oubliera pas :

  • qu'une semaine comporte 7 jours ;
  • qu'une fois en bas, le gardien doit remonter ;
  • que le résultat est à exprimer en m.

14-2-9. Numéro 9

Un permis de chasse à points remplace désormais le permis de chasse traditionnel. Chaque chasseur possède au départ un capital de 100 points. S'il tue une poule, il perd 1 point, 3 points pour un chien, 5 points pour une vache et 10 points pour un ami. Le permis coûte 200 euros.

Écrire une fonction amende qui reçoit le nombre de victimes du chasseur et qui renvoie la somme due.

Utilisez cette fonction dans un programme principal qui saisit le nombre de victimes et qui affiche la somme que le chasseur doit débourser.

14-2-10. Numéro 10

Je suis ligoté sur les rails en gare d'Arras. Écrire un programme qui affiche un tableau me permettant de connaître l'heure à laquelle je serai déchiqueté par le train parti de la gare du Nord à 9 h (il y a 170 km entre la gare du Nord et Arras).

Le tableau prédira les différentes heures possibles pour toutes les vitesses de 100 km/h à 300 km/h, par pas de 10 km/h, les résultats étant arrondis à la minute inférieure.

  • Écrire une procédure tchacatchac qui reçoit la vitesse du train et qui affiche l'heure du drame ;
  • Écrire le programme principal qui affiche le tableau demandé.

14-2-11. Numéro 11 ✠

Un programme principal saisit une chaîne d'ADN valide et une séquence d'ADN valide (valide signifie qu'elles ne sont pas vides et sont formées exclusivement d'une combinaison arbitraire de "a", "t", "g" ou "c").

Écrire une fonction valide qui renvoie vrai si la saisie est valide, faux sinon.

Écrire une fonction saisie qui effectue une saisie valide et renvoie la valeur saisie sous forme d'une chaîne de caractères.

Écrire une fonction proportion qui reçoit deux arguments, la chaîne et la séquence et qui retourne la proportion de séquence dans la chaîne (c'est-à-dire son nombre d'occurrences).

Le programme principal appelle la fonction saisie pour la chaîne et pour la séquence et affiche le résultat.

Exemple d'affichage :

 
Sélectionnez
chaîne : attgcaatggtggtacatg
séquence : ca
Il y a 10.53 % de "ca" dans votre chaîne.

14-2-12. Numéro 12

Il s'agit d'écrire, d'une part, un programme principal et, d'autre part, une fonction utilisée dans le programme principal.

La fonction listAleaInt(n, a, b) retourne une liste de n entiers aléatoires dans [a .. b] en utilisant la fonction randint(a, b) du module random.

Dans le programme principal :

  • construire la liste en appelant la fonction listAleaInt() ;
  • calculer l'index de la case qui contient le minimum ;
  • échangez le premier élément du tableau avec son minimum.

14-2-13. Numéro 13

Comme précédemment, il s'agit d'écrire, d'une part, un programme principal et, d'autre part, une fonction utilisée dans le programme principal.

La fonction listAleaFloat(n) retourne une liste de n flottants aléatoires en utilisant la fonction random() du module random.

Dans le programme principal :

  • saisir un entier n dans l'intervalle : [2 .. 100] ;
  • construire la liste en appelant la fonction listAleaFloat() ;
  • afficher l'amplitude du tableau (écart entre sa plus grande et sa plus petite valeur) ;
  • afficher la moyenne du tableau.

14-2-14. Numéro 14

Fonction renvoyant plusieurs valeurs sous forme d'un tuple.

Écrire une fonction minMaxMoy() qui reçoit une liste d'entiers et qui renvoie le minimum, le maximum et la moyenne de cette liste. Le programme principal appellera cette fonction avec la liste : [10, 18, 14, 20, 12, 16].

14-2-15. Numéro 15

Saisir un entier entre 1 et 3999 (pourquoi cette limitation ?). L'afficher en nombre romain.

14-2-16. Numéro 16 ✠

Améliorer le script précédent en utilisant la fonction zip().

14-2-17. Numéro 17

Un tableau contient kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp entiers (kitxmlcodeinlinelatexdvp2 < n < 100finkitxmlcodeinlinelatexdvp) aléatoires tous compris entre 0 et 500. Vérifier qu'ils sont tous différents.

14-2-18. Numéro 18

Proposer une autre version plus simple du problème précédent en comparant les longueurs des tableaux avant et après traitement ; le traitement consiste à utiliser une structure de données contenant des éléments uniques.

14-2-19. Numéro 19

L'utilisateur donne un entier kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp entre 2 et 12, le programme donne le nombre de façons de faire kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp en lançant deux dés.

14-2-20. Numéro 20

Même problème que le précédent, mais avec kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp entre 3 et 18 et trois dés.

14-2-21. Numéro 21 ✠✠

Généralisation des deux questions précédentes. L'utilisateur saisit deux entrées, d'une part le nombre de dés, kitxmlcodeinlinelatexdvpnbdfinkitxmlcodeinlinelatexdvp (que l'on limitera pratiquement à 10) et, d'autre part la somme, kitxmlcodeinlinelatexdvpsfinkitxmlcodeinlinelatexdvp, comprise entre kitxmlcodeinlinelatexdvpnbdfinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp6.nbdfinkitxmlcodeinlinelatexdvp. Le programme calcule et affiche le nombre de façons de faire kitxmlcodeinlinelatexdvpsfinkitxmlcodeinlinelatexdvp avec les kitxmlcodeinlinelatexdvpnbdfinkitxmlcodeinlinelatexdvp dés.

14-2-22. Numéro 22 ✠✠

Même problème que le précédent, mais codé récursivement.

14-2-23. Numéro 23 ✠

Nombres parfaits et nombres chanceux.

  • On appelle nombre premier tout entier naturel supérieur à 1 qui possède exactement deux diviseurs, lui-même et l'unité.
  • On appelle diviseur propre de n, un diviseur quelconque de n, n exclu.
  • Un entier naturel est dit parfait s'il est égal à la somme de tous ses diviseurs propres.
  • Un entier kitxmlcodeinlinelatexdvpnfinkitxmlcodeinlinelatexdvp tel que : kitxmlcodeinlinelatexdvp(n+i+i^2)finkitxmlcodeinlinelatexdvp est premier pour tout kitxmlcodeinlinelatexdvpifinkitxmlcodeinlinelatexdvp dans kitxmlcodeinlinelatexdvp[0, n-2]finkitxmlcodeinlinelatexdvp est dit chanceux.

Écrire un module (parfait_chanceux_m.py) définissant quatre fonctions : somDiv, estParfait, estPremier, estChanceux et un autotest.

  • La fonction somDiv retourne la somme des diviseurs propres de son argument.
  • Les trois autres fonctions vérifient la propriété donnée par leur définition et retourne un booléen. Si par exemple la fonction estPremier vérifie que son argument est premier, elle retourne True, sinon elle retourne False.

La partie de test doit comporter quatre appels à la fonction verif permettant de tester somDiv(12), estParfait(6), estPremier(31) et estChanceux(11).

 
Sélectionnez
# !/usr/bin/env python
# -*- coding : utf8 -*-
"""Module de vérification."""

#==============================================================================
# fichier : verif.py
#
# auteur : Bob Cordeau
#==============================================================================

# Import ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from sys import exit

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def verif(entree, reference, precision=0, comment="") :
    """Vérifie que <entree> est égal à <référence>, à la précision près."""
    print("{} [{}, {}]".format(comment, entree, reference), end="")
    if abs(entree - reference) <= precision :
        print(" *** ok")
    else :
        print(" ### ko")

# Auto-test ===================================================================
if __name__=='__main__' :
    verif(abs(-6/2), 3, comment="\nTeste la fonction 'abs' :")

    pi = 3.142
    print("\npi = {}".format(pi))
    verif(pi, 3.14, 1e-2, comment="à 1e-2 :") # Ok
    verif(pi, 3.14, 1e-3, comment="à 1e-3 :") # Erreur

Puis écrire le programme principal (parfait_chanceux.py) qui comporte :

  • l'initialisation de deux listes : parfaits et chanceux ;
  • une boucle de parcours de l'intervalle kitxmlcodeinlinelatexdvp[2, 1000]finkitxmlcodeinlinelatexdvp incluant les tests nécessaires pour remplir ces listes ;
  • enfin l'affichage de ces listes.

14-3. Solutions des exercices

Exercice 1
CacherSélectionnez
Exercice 2
CacherSélectionnez
Exercice 3
CacherSélectionnez
Exercice 4
CacherSélectionnez
Exercice 5
CacherSélectionnez
Exercice 6
CacherSélectionnez
Exercice 7
CacherSélectionnez
Exercice 8
CacherSélectionnez
Exercice 9
CacherSélectionnez
Exercice 10
CacherSélectionnez
Exercice 11
CacherSélectionnez
Exercice 12
CacherSélectionnez
Exercice 13
CacherSélectionnez
Exercice 14
CacherSélectionnez
Exercice 15
CacherSélectionnez
Exercice 16
CacherSélectionnez
Exercice 17
CacherSélectionnez
Exercice 18
CacherSélectionnez
Exercice 19
CacherSélectionnez
Exercice 20
CacherSélectionnez
Exercice 21
CacherSélectionnez
Exercice 22
CacherSélectionnez
Exercice 23-1
CacherSélectionnez
Exercice 23-2
CacherSélectionnez

précédentsommairesuivant
Mais pas trop pour éviter le dépassement de capacité : OverflowError: long int too large to convert to float.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2015 Kordeo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.