Accueil

Enoncé itératif

Objectifs du TD : apprendre à répéter plusieurs fois des blocs d'instructions

Dans le chapitre précédent, nous avons vu comment exécuter les blocs d'instructions en tenant compte de certaines conditions grâce à l'énoncé conditionnel if . Nous allons maintenant voir comment répéter l'exécution d'un bloc tant qu'une condition est vérifiée.

PROBLEMES

A ce stade, pour résoudre un problème vous devez vous poser les questions suivantes:
  1. Jeu de devinettes : l'ordinateur tire aléatoirement un nombre entre 1 et 100 et le joueur doit trouver ce nombre. A chaque étape, si le nombre rentré par le joueur n'est pas le bon, l'ordinateur affiche "trop grand" ou "trop petit". Si le joueur a gagné, on affiche en combien de tentatives, et s'il a perdu, on lui signale. Le joueur a au plus 7 tentatives pour trouver le nombre.
    Remarque Soyez un bon stratège si vous voulez gagner!
    Pour tirer un nombre entre 1 et 100, vous pouvez utiliser la fonction randint qui se trouve dans le module random. Un module en Python est une bibliothèque (ou boîte à outils) qui fournit des utilitaires sur un thème donné. Pour avoir accès au module random vous devez écrire :
    import random 
    en première ligne de votre programme. Pour tirer une valeur aléatoire comprise entre 1 et 100 et la mettre dans la variable x il faut écrire :
    
    x=random.randint(1,100)
    
  2. Polygones inscrits. On vous demande de dessinez des polygones inscrits les uns dans les autres.
    Votre programme demande à l'utilisateur : Voici le résultat d'exécution pour 5 pentagones de taille initiale 100, en commençant à la moitié du précédent (le point de départ du 1er polygone est en bas à gauche, on tourne dans le sens opposé aux aiguilles d'une montre) :

    et en commençant à 10% du précédent :

    Pour résoudre ce problème, vous devez faire un peu de trigonométrie (sin, arcsin et pythagore) pour trouver la longueur du prochain pentagone et l'angle avec lequel vous devez le décaler par rapport au pentagone courant. Pour cela, prenez une feuille de papier et inspirez-vous du schéma ci-dessous.

    Dans ce schéma, on a dessiné le 1er pentagone ABCDE et on cherche à dessiner le prochain pentagone FGHIJ. Etant donné le point F (calculé gràce au facteur f), et la longueur AB, on cherche l'angle alpha et la longueur du segment FG.
    Par propriété du polygone régulier, on sait que AF=BG et que l'angle GBK est 360/nbCote. En appliquant la définition de sin à l'angle GBK, on trouve la hauteur GK. Avec pythagore sur le triangle GBK on en déduit BK. Avec pythagore sur le triangle FGK on en déduit FG (en fonction de la longueur AB qui est connue). Il ne reste plus qu'à utiliser la définition de arcsin sur l'angle alpha pour calculer la valeur de alpha.
    Nota: pour avoir accès aux fonctions trigonométriques vous devez importer le module math. Attention, pour la tortue, les angles sont exprimés en degrés, et pour les fonctions sin et cos, les angles sont en radians. Pour passer de l'un à l'autre vous pouvez utiliser les fonctions de conversion degrees et radians.

  3. Développements limités
    Les développements limités (vu en analyse 2), permettent d'approcher une fonction par une fonction plus simple (fonction affine, polynome) au voisinage d'un point. Les développements limités sont utilisés par exemple en économie. Vous avez vous-meme utilisé un développement limité avec le théorème des petits angles en optique, quand vous approximez sinus x par x ou cos x par 1 quand x est petit. Voici ci-dessous le développment limité de sin x au voisinage de 0 (© wikipedia) :

    Dans cette formule, le dernier terme (le petit o) est négligeable quand x tend vers 0. On l'appelle le reste du développement. n est l'ordre du développement. Le théorème des petits angles utilise un développement à l'ordre 0.
    On vous demande d'écrire un programme qui demande à l'utilisateur un angle compris entre -Π et Π, qui demande une précision, et qui calcule le sinus en utilisant la formule du développement limité. Ensuite il affiche le sinus de l'angle calculé avec Python et le sinus calculé avec la formule, ainsi que l'ordre nécessaire pour atteindre la précision souhaitée. Voici des exemples d'exécution pour une précision de 0.001. Vous pouvez constater que plus l'angle est proche de Π, plus il faut un ordre élevé pour atteindre la précision.
    x dans [-Pi,Pi] : 0
    seuil d'arrêt (>0): 0.001
    résultat exact 0.0
    résultat approximé 0.0
    ordre du développement 0
    
    x dans [-Pi,Pi] : 1.57
    seuil d'arrêt (>0): 0.001
    résultat exact 0.9999996829318346
    résultat approximé 1.000003205866837
    ordre du développement 4
    
    x dans [-Pi,Pi] : 3.14
    seuil d'arrêt (>0): 0.001
    résultat exact 0.0015926529164868282
    résultat approximé 0.001613636033022484
    ordre du développement 6
    
    Aide :Il suffit d'écrire une boucle qui calcule le nouveau terme (ordre n) à partie du précédent (ordre (n-1)). Cette boucle s'arrete dès que le terme d'ordre n est plus petit que la précision. Attention: pour etre efficace, il ne faut pas recalculer (2n+1)! à chaque étape mais utiliser le fait que (2n+1)!=(2n+1)*2n*(2n-1)! et donc utiliser (2n-1)! qui est la factorielle calculée à l'étape précédente.