Algorithmique et Xcas
publicité
Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Algorithmique et Xcas Auteur : Bernard Chrétien Académie de Lille [email protected] 7 juin 2010 Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Objectifs On trouvera : Ce document s’adresse aux professeurs désirant obtenir une formation en algorithmique au travers d’exemples simples et variés de la seconde à la terminale. Pour cela, on utilisera le logiciel de calcul formel Xcas dont la syntaxe est très voisine de celle d’un algorithme écrit en langage algorithmique. Pour chacune des instructions suivantes : Affectation Si · · · Alors · · · Sinon Pour · · · variantDe · · · à · · · Faire Tant que · · · sera donné un exemple simple pour comprendre rapidement la syntaxe. Ensuite il est donné d’autres exemples avec une solution sous Xcas. Chaque algorithme proposé est source d’idées à réinvestir dans les différentes classes du lycée. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas Commençons par l’exemple suivant : Lors d’un spectacle, Algor le magicien choisi une personne au hasard et lui demande d’effectuer mentalement les procédures suivantes : Choisir un nombre sans le dire. Lui ajouter 3 . Multiplier le résultat par le nombre choisi au départ. Soustraire au nombre obtenu le carré du nombre choisi au départ. Donner le nombre obtenu. Algor dit abracadabra et donne le nombre choisi au départ par la personne. 1. Est-ce possible ? Vérifier sur quelques exemples. 2. Donner en langage naturel l’algorithme que la personne effectue ; puis en langage algorithmique après avoir compléter le tableau ci-dessous qui correspond au traitement de l’algorithme écrit en langage naturel à la valeur n = 5 (p représente le résultat obtenu à l’étape correspondante). Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas Entrée Traitement Étape no 1 2 3 4 Valeur de n Valeur de p Sortie 3. Programmer cet algorithme sur le logiciel de calcul formel Xcas, puis l’exécuter sur les exemples précédents. 4. Quelle valeur obtient-on si l’on donne la valeur initiale x ? Quelle fonction a-t-on ainsi définie ? Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( ):={ local n, p ; Variable n : entier naturel input("n",n) ; p : entier naturel p := n+3 ; p := p∗n ; Début p := p−n∧ 2 ; Saisir le nombre n choisi p←n+3 return(p) ; p ← p×n }; p ← p−n2 Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( ):={ local n, p ; Variable n : entier naturel input("n",n) ; p : entier naturel p := n+3 ; p := p∗n ; Début p := p−n∧ 2 ; Saisir le nombre n choisi p←n+3 return(p) ; p ← p×n }; p ← p−n2 Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( ):={ local n, p ; Variable n : entier naturel input("n",n) ; p : entier naturel p := n+3 ; p := p∗n ; Début p := p−n∧ 2 ; Saisir le nombre n choisi p←n+3 return(p) ; p ← p×n }; p ← p−n2 Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( ):={ local n, p ; Variable n : entier naturel input("n",n) ; p : entier naturel p := n+3 ; p := p∗n ; Début p := p−n∧ 2 ; Saisir le nombre n choisi p←n+3 return(p) ; p ← p×n }; p ← p−n2 Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( ):={ local n, p ; Variable n : entier naturel input("n",n) ; p : entier naturel p := n+3 ; p := p∗n ; Début p := p−n∧ 2 ; Saisir le nombre n choisi p←n+3 return(p) ; p ← p×n }; p ← p−n2 Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( ):={ local n, p ; Variable n : entier naturel input("n",n) ; p : entier naturel p := n+3 ; p := p∗n ; Début p := p−n∧ 2 ; Saisir le nombre n choisi p←n+3 return(p) ; p ← p×n }; p ← p−n2 Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( ):={ local n, p ; Variable n : entier naturel input("n",n) ; p : entier naturel p := n+3 ; p := p∗n ; Début p := p−n∧ 2 ; Saisir le nombre n choisi p←n+3 return(p) ; p ← p×n }; p ← p−n2 Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( ):={ local n, p ; Variable n : entier naturel input("n",n) ; p : entier naturel p := n+3 ; p := p∗n ; Début p := p−n∧ 2 ; Saisir le nombre n choisi p←n+3 return(p) ; p ← p×n }; p ← p−n2 Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( ):={ local n, p ; Variable n : entier naturel input("n",n) ; p : entier naturel p := n+3 ; p := p∗n ; Début p := p−n∧ 2 ; Saisir le nombre n choisi p←n+3 return(p) ; p ← p×n }; p ← p−n2 fin de chaque Afficher « le nombre p obtenu » Fin instruction Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( Magique(n):={ ):={ p;p; local n, Variable n : entier naturel p := n+3 ; ; input("n",n) p : entier naturel p∗n ;; p := n+3 p−n;∧ 2 ; p := p∗n Début return(p) p := p−n;∧ 2 ; Saisir le nombre n choisi p←n+3 } ;return(p) ; p ← p×n }; p ← p−n2 Une autre façon de faire Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( Magique(n):={ ):={ p;p; local n, Variable n : entier naturel p := n+3 ; ; input("n",n) p : entier naturel p∗n ;; p := n+3 p−n;∧ 2 ; p := p∗n Début return(p) p := p−n;∧ 2 ; Saisir le nombre n choisi p←n+3 } ;return(p) ; p ← p×n }; p ← p−n2 Une autre façon de faire Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( Magique(n):={ ):={ p;p; local n, Variable n : entier naturel p := n+3 ; ; input("n",n) p : entier naturel p∗n ;; p := n+3 p−n;∧ 2 ; p := p∗n Début return(p) p := p−n;∧ 2 ; Saisir le nombre n choisi p←n+3 } ;return(p) ; p ← p×n }; p ← p−n2 Une autre façon de faire Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( Magique(n):={ ):={ p;p; local n, Variable n : entier naturel p := n+3 ; ; input("n",n) p : entier naturel p∗n ;; p := n+3 p−n;∧ 2 ; p := p∗n Début return(p) p := p−n;∧ 2 ; Saisir le nombre n choisi p←n+3 } ;return(p) ; p ← p×n }; p ← p−n2 Une autre façon de faire Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( Magique(n):={ ):={ p;p; local n, Variable n : entier naturel p := n+3 ; ; input("n",n) p : entier naturel p∗n ;; p := n+3 p−n;∧ 2 ; p := p∗n Début return(p) p := p−n;∧ 2 ; Saisir le nombre n choisi p←n+3 } ;return(p) ; p ← p×n }; p ← p−n2 Une autre façon de faire Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( Magique(n):={ ):={ p;p; local n, Variable n : entier naturel p := n+3 ; ; input("n",n) p : entier naturel p∗n ;; p := n+3 p−n;∧ 2 ; p := p∗n Début return(p) p := p−n;∧ 2 ; Saisir le nombre n choisi p←n+3 } ;return(p) ; p ← p×n }; p ← p−n2 Une autre façon de faire Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( Magique(n):={ ):={ p;p; local n, Variable n : entier naturel p := n+3 ; ; input("n",n) p : entier naturel p∗n ;; p := n+3 p−n;∧ 2 ; p := p∗n Début return(p) p := p−n;∧ 2 ; Saisir le nombre n choisi p←n+3 } ;return(p) ; p ← p×n }; p ← p−n2 Une autre façon de faire Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( Magique(n):={ ):={ p;p; local n, Variable n : entier naturel p := n+3 ; ; input("n",n) p : entier naturel p∗n ;; p := n+3 p−n;∧ 2 ; p := p∗n Début return(p) p := p−n;∧ 2 ; Saisir le nombre n choisi p←n+3 } ;return(p) ; p ← p×n }; p ← p−n2 Une autre façon de faire Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Magique Magique( Magique(n):={ ):={ p;p; local n, Variable n : entier naturel p := n+3 ; ; input("n",n) p : entier naturel p∗n ;; p := n+3 p−n;∧ 2 ; p := p∗n Début return(p) p := p−n;∧ 2 ; Saisir le nombre n choisi p←n+3 } ;return(p) ; p ← p×n }; p ← p−n2 Une autre façon de faire Afficher « le nombre p obtenu » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas Voici quelques exemples d’applications : Exemple 1 : tour de magie bis Une solution Algor le magicien demande à Florine d’écrire sur un papier son âge et la somme qu’elle a en poche (moins de 100 e). Il lui demande ensuite de montrer le papier à Margaux, qui doit le lire (sans rien dire), puis effectuer à l’abri des regards les calculs suivants : • Multiplier l’âge par 2 ; • Ajouter au résultat 5 ; • Multiplier le nombre obtenu par 50 ; • Ajouter le montant de la somme en poche ; • Soustraire le nombre de jours que contient une année ; • Dire le résultat ainsi obtenu au public. Algor dit : « le nombre 115 est vraiment abracadabrant car si je l’ajoute au résultat de Margaux, je devine facilement l’âge et l’argent de poche de Florine ! ». Algor dit-il vrai ? Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas Exemple 2 : Périmètre et aire Une solution On donne un rectangle dont la longueur est L, la largeur ℓ, le périmètre est p et l’aire A. 1. On prend p = 20. 2. a. Écrire en langage naturel un algorithme qui, connaissant la dimension L de ce rectangle, donne la deuxième dimension ℓ et son aire A. b. Écrire cet algorithme en langage algorithmique. c. Programmer l’algorithme sur Xcas. a. On prend A = 25. Écrire en langage naturel un algorithme qui, connaissant la dimension L de ce rectangle, donne la deuxième dimension ℓ et son périmètre p. b. Écrire cet algorithme en langage algorithmique. c. Programmer l’algorithme sur Xcas. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas Algorithme ??? Variable xI , yI : entiers naturels compris entre 0 et 5 xA , yA , xM , yM , xN , yM , xP , yP , C : réels Exemple 3 : en géométrie Début Une solution Saisir xA et yA . Dans un repère orthonormé, on choisit au hasard un point I dont les coordonnées entières sont comprises entre −5 et 5. On donne ensuite les coordonnées (xA , yA ) d’un point A. Interpréter l’algorithme ci-contre. On pourra utiliser les listes : l’une pour les abscisses et l’autre pour les ordonnées. xI ← partie entière (6× random ()) yI ← partie entière (6× random ()) xM ← −yA + xI + yI yM ← xA − xI + yI xN ← −yM + xI + yI yN ← xM − xI + yI xP ← −yN + xI + yI yP ← xN − xI + yI p C ← (xM − xA )2 + (yM − yA )2 Afficher les coordonnées de A, I , M, N et P Afficher C Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas Exemple 4 : en arithmétique Une solution On donne un entier naturel n à deux chiffres. Écrire un algorithme permettant d’échanger le chiffre des unités et le chiffre des dizaines. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Magique Tour de magie bis Fonctions Un quadrilatère Échange Indice de Ruffier L’affectation sous Xcas Exemple 5 : en médecine Une solution Pour débuter une activité sportive, il est fortement conseillé de passer le test de Ruffier qui permet de connaître l’indice R de résistance de son coeur à l’ effort. Pour l’évaluer, on mesure la fréquence cardiaque à trois moments importants de l’adaptation du coeur : au repos, que ce soit assis ou couché, on relève la fréquence cardiaque F1 , après l’exercice de Ruffier, qui consiste à faire 30 flexions sur les jambes en 45 secondes, on relève la fréquence cardiaque F2 , après une minute de repos, on relève finalement la fréquence cardiaque F3 . On calcule ensuite l’indice R par la formule : R = [(F1 + F2 + F3 ) − 200]/10 Un professeur de sport décide de faire le test de Ruffier à ses élèves. Quel algorithme doit-il écrire et programmer, sur le logiciel Xcas, pour obtenir l’indice de chacun de ses élèves ? Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · Commençons par l’exemple suivant : Dans un repère (O, I , J) orthonormal , on donne les points A(3 ; −1), B(3 ; 4) et C (−1 ; 2). 1. Placer les points. 2. Quelle est la nature du triangle ABC ? 3. Proposer un algorithme qui, trois points A, B et C étant donnés en entrée, dit si le triangle ABC est isocèle en A en sortie. Programmer cet algorithme sur Xcas. 4. Le point D(4 ; −3) appartient-il à la médiatrice du segment [BC ] ? On justifiera la réponse par le calcul et on pourra vérifier le résultat en excécutant le programme précédent. 5. En déduire la nature du quadrilatère ABDC . On pourra de nouveau se servir du programme pour valider certaines propriétés. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele():={ Variable local L1, L2, U, V ; L1, L2 : listes pour les coordonnées input("L1", L1,"L2", L2) ; U, V : réels U := (L1[1]−L1[0])∧ 2+(L2[1]−L2[0])∧ 2 ; Début V := (L1[2]−L1[0])∧ 2+(L2[2]−L2[0])∧ 2 ; Saisir les listes L1 et L2 if U = V then print("isocele") ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon fin de chaque instruction Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ ∧ V if (U := (L1[2]−L1[0]) = V) {print("isocele") 2+(L2[2]−L2[0]) ;} 2; Saisir les listes L1 et L2 else if U= print("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else } ; print("non isocele") ; 2 Si U = V Alors end_if ; }; Afficher « isocèle » Sinon Une autre façon de faire Afficher « non isocèle » FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Isocèle Isocele(L1,L2):={ Isocele():={ Variable local L1, U, VL2, ; U, V ; L1, L2 : listes pour les coordonnées ∧ ∧ input("L1", L1,"L2", L2) ; U := (L1[1]−L1[0]) 2+(L2[1]−L2[0]) 2; U, V : réels U V := (L1[1]−L1[0]) (L1[2]−L1[0])∧ 2+(L2[1]−L2[0]) 2+(L2[2]−L2[0])∧ 2 ; Début ∧ V si := (U (L1[2]−L1[0]) = V) alors afficher("isocele") 2+(L2[2]−L2[0]) ; ∧2 ; Saisir les listes L1 et L2 if sinon U =afficher("non V then print("isocele") isocele") ; ; U ← (L1[2]−L1[1])2 +(L2[2]−L2[1])2 2 V ← (L1[3]−L1[1]) +(L2[3]−L2[1]) else fsi ; print("non isocele") ; 2 Si U = V Alors end_if }; ; }; Afficher « isocèle » Sinon Encore une autre façon de faire Afficher « non isocèle » (suivant la version de Xcas) FinSi Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · Voici quelques exemples d’applications : Exemple 1 : en géométrie repérée Une solution 1. Écrire un algorithme qui teste, trois points A, B et C étant donnés, si le triangle est équilatéral (on pourra utiliser sur Xcas l’un des liens logiques suivants : and , et , &&). 2. Écrire un algorithme qui teste, trois points A, B et C étant donnés, si le triangle est rectangle en A. 3. Écrire un algorithme qui teste, trois points A, B et C étant donnés, si le triangle est équilatéral ou isocèle ou rectangle en A. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · Exemple 2 : fonctions affines par morceaux Un commercial peut percevoir à la fin de chaque mois deux primes, l’une sur le chiffre d’affaires mensuel et l’autre sur le nombre de kilomètres parcourus sans accident. 1. Prime sur le chiffre d’affaires Voici les règles de gestion permettant au commercial de calculer sa remise en fonction de son chiffre d’affaires (CA) mensuel : a. Pour un CA inférieur à 250 000 e il a une prime de 5% du CA b. De 250 000 à 500 000 e il a une prime de 7 % du CA c. Au delà de 500 000 e il a une prime de 10 % du CA. Écrire un algorithme qui détermine le taux de remise du commercial à la fin de chaque mois selon son chiffres d’affaires. Programmer ensuite cet algorithme sur Xcas. 2. Prime sans accident Pour le calcul de sa prime en fonction du nombre de kilomètres parcourus sans accident , on lui propose la règle suivante : a. Pour moins de 100 kilomètres sans accident le montant de la prime est de 100 e ; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · Exemple 2 : fonctions affines par morceaux Une solution b. Entre 100 et 500 kilomètres sans accident la prime est donnée par la formule (K − 100) × 0, 10 + 500 où K est le nombre de kilomèttres parcourus ; c. Au delà de 500 kilomètres la prime est donnée par la formule (K − 500) × 0, 20 + 540. Écrire un algorithme qui détermine la prime sans accident du commercial à la fin de chaque mois. Programmer ensuite cet algorithme sur Xcas. 3. On souhaite ajouter la borne 1 000 kilomètres ; quelle sera l’instruction de calcul pour la prime au delà de 1 000 kilomètres ? Modifier le programme précédent 4. Le commercial désire connaître directement la somme des deux primes à la fin de chaque mois. Écrire un algorithme qui détermine la prime totale. Programmer ensuite cet algorithme sur Xcas. Quelle prime obtient le commercial à la fin du mois pour un chiffre d’affaires de 350 000 e et 1 200 kilomètres sans accident ? Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle isocèle Triangle équilatéral ou rectangle Primes Indice de Ruffier bis if · · · then · · · else · · · Exemple 3 : en médecine Une solution Le professeur de sport sait que lorsque l’indice de Ruffier R est : • inférieur à 0, l’élève a une très bonne adaptation à l’effort (cœur « athlétique »), • compris entre 0 et 5, l’élève a une bonne adaptation à l’effort (cœur « très bon »), • compris entre 5 et 10, l’élève a une adaptation à l’effort moyenne (cœur « bon »), • compris entre 10 et 15, l’élève a une adaptation à l’effort insuffisante (cœur « moyen »), • supérieur à 15, l’élève a une mauvaise adaptation à l’effort (cœur « faible »). Le professeur a saisi pour Laure les fréquences F1 = 60, F2 = 50 et F3 = 80. Il lui déclare qu’elle a un « un cœur athlétique ». Laure, non sportive, lui répond que cela n’est pas possible ! Quel jugement peut-on donner à cette affirmation ? Dans la négative que faudrait-il rajouter dans l’algorithme pour y remédier ? Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do Commençons par l’exemple suivant : Pour étudier l’habitat dans une certaine région assez peu peuplée, l’Institut Géographique National décide de partager cette zone en N parcelles carrées d’aires égales et de réaliser une photographie aérienne de chacune de ces N parcelles. Après agrandissement, on compte le nombre d’habitations que l’on peut observer sur chacun des N clichés. Voici les résultats de ce comptage. Nombre d’habitations Nombre de photos 0 3 1 18 2 42 3 58 4 77 5 70 6 55 7 37 8 19 9 11 10 5 11 3 Ainsi, il y a 77 photos, sur les N, sur lesquelles on a compté 4 habitations. Écrire un algorithme qui permette de donner le nombre de clichés réalisés et le nombre moyen de maisons par photo. Programmer ensuite cet algorithme sur Xcas, puis l’exécuter pour obtenir N et la moyenne. Auteur : Bernard Chrétien Algorithmique 12 2 Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne():={ Variable local L1, L2, D, N, S, k ; L1, L2 : listes input("L1", L1,"L2", L2) ; D, N, k : entiers N := 0 ; S : réel S := 0 ; Début D := dim(L1) ; Saisir les listes L1 et L2 for k from 0 to D−1 N←0 do S := L1[k] ∗ L2[k] + S ; S←0 N := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} end_for ; Pour k variantDe 1 à D Faire return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] fin de chaque instruction FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne(L1,L2):={ Moyenne():={ Variable local localD, L1,N,L2, S, D, k ; N, S, k ; L1, L2 : listes L1,"L2", L2) ; Ninput("L1", := 0 ; D, N, k : entiers SN:=:=0 0; ; S : réel := dim(L1) 0; ; DS := Début D (k:= := dim(L1) for 0 ; k<= ; D − 1 ; k++) Saisir les listes L1 et L2 for { kS from := L1[k] 0 to∗D−1 L2[k] + S ; N←0 := L1[k] L2[k] ∗+L2[k] N } + S; do SN := S←0 ; D ← Dim L1 {dimension de la liste L1} N := L2[k] + N ; return(N, end_forS/N) ; ; Pour k variantDe 1 à D Faire } ;return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] Une autre façon de faire FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne(L1,L2):={ Moyenne():={ Variable local localD, L1,N,L2, S, D, k ; N, S, k ; L1, L2 : listes L1,"L2", L2) ; Ninput("L1", := 0 ; D, N, k : entiers SN:=:=0 0; ; S : réel := dim(L1) 0; ; DS := Début D (k:= := dim(L1) for 0 ; k<= ; D − 1 ; k++) Saisir les listes L1 et L2 for { kS from := L1[k] 0 to∗D−1 L2[k] + S ; N←0 := L1[k] L2[k] ∗+L2[k] N } + S; do SN := S←0 ; D ← Dim L1 {dimension de la liste L1} N := L2[k] + N ; return(N, end_forS/N) ; ; Pour k variantDe 1 à D Faire } ;return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] Une autre façon de faire FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne(L1,L2):={ Moyenne():={ Variable local localD, L1,N,L2, S, D, k ; N, S, k ; L1, L2 : listes L1,"L2", L2) ; Ninput("L1", := 0 ; D, N, k : entiers SN:=:=0 0; ; S : réel := dim(L1) 0; ; DS := Début D (k:= := dim(L1) for 0 ; k<= ; D − 1 ; k++) Saisir les listes L1 et L2 for { kS from := L1[k] 0 to∗D−1 L2[k] + S ; N←0 := L1[k] L2[k] ∗+L2[k] N } + S; do SN := S←0 ; D ← Dim L1 {dimension de la liste L1} N := L2[k] + N ; return(N, end_forS/N) ; ; Pour k variantDe 1 à D Faire } ;return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] Une autre façon de faire FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne(L1,L2):={ Moyenne():={ Variable local localD, L1,N,L2, S, D, k ; N, S, k ; L1, L2 : listes L1,"L2", L2) ; Ninput("L1", := 0 ; D, N, k : entiers SN:=:=0 0; ; S : réel := dim(L1) 0; ; DS := Début D (k:= := dim(L1) for 0 ; k<= ; D − 1 ; k++) Saisir les listes L1 et L2 for { kS from := L1[k] 0 to∗D−1 L2[k] + S ; N←0 := L1[k] L2[k] ∗+L2[k] N } + S; do SN := S←0 ; D ← Dim L1 {dimension de la liste L1} N := L2[k] + N ; return(N, end_forS/N) ; ; Pour k variantDe 1 à D Faire } ;return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] Une autre façon de faire FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne(L1,L2):={ Moyenne():={ Variable local localD, L1,N,L2, S, D, k ; N, S, k ; L1, L2 : listes L1,"L2", L2) ; Ninput("L1", := 0 ; D, N, k : entiers SN:=:=0 0; ; S : réel := dim(L1) 0; ; DS := Début D (k:= := dim(L1) for 0 ; k<= ; D − 1 ; k++) Saisir les listes L1 et L2 for { kS from := L1[k] 0 to∗D−1 L2[k] + S ; N←0 := L1[k] L2[k] ∗+L2[k] N } + S; do SN := S←0 ; D ← Dim L1 {dimension de la liste L1} N := L2[k] + N ; return(N, end_forS/N) ; ; Pour k variantDe 1 à D Faire } ;return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] Une autre façon de faire FinPour Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Moyenne Moyenne(L1,L2):={ Moyenne():={ Variable local localD, L1,N,L2, S, D, k ; N, S, k ; L1, L2 : listes L1,"L2", L2) ; Ninput("L1", := 0 ; D, N, k : entiers SN:=:=0 0; ; S : réel := dim(L1) 0; ; DS := Début D :=k dim(L1) pour de 0 jusque ; D−1 faire Saisir les listes L1 et L2 for kS from := L1[k] 0 to ∗D−1 L2[k] + S ; N←0 := L1[k] L2[k] ∗+L2[k] N; + S; do SN := S←0 fpour N ; := L2[k] + N ; D ← Dim L1 {dimension de la liste L1} return(N, end_forS/N) ; ; Pour k variantDe 1 à D Faire } ;return(N, S/N) ; S ← L1[k] ∗ L2[k] + S }; N ← N + L2[k] Encore une autre façon de faire FinPour (suivant la version de Xcas) Afficher « N et S/N » Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do Voici quelques exemples d’applications : Exemple 1 : en statistique Une solution 1. Écrire un algorithme qui détermine et affiche le plus petit élément d’une série statistique. Le programmer sur Xcas. 2. Écrire un algorithme qui détermine et affiche le plus grand élément d’une série statistique. Le programmer sur Xcas. 3. Écrire un algorithme qui détermine et affiche le plus petit et plus grand élément d’une série statistique. Le programmer sur Xcas. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do Exemple 2 : suite Une solution On définit la suite (un )n∈N par un+1 = un + 2n − 1 avec u0 = 0. 1. Écrire un algorithme qui permet de calculer le ne terme de la suite (un )n∈N . 2. Écrire un algorithme qui permet de calculer la somme Sn des n + 1 premiers termes de la suite (un )n∈N . Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do Exemple 3 : Approche fréquentiste de π Une solution Flora a construit une cible carrée de côté 1 ainsi que le quart de cercle de rayon 1 et de centre l’un des sommets du carré. Elle se place à une distance raisonnable de telle sorte qu’elle puisse toujours atteindre la cible lors d’un lancer de fléchettes. Déterminer, en faisant une simulation, une valeur approchée de la fréquence des fléchettes qui aboutissent dans le quart de disque au cours de n lancers. Vers quel nombre semble converger cette fréquence ? Auteur : Bernard Chrétien Algorithmique 1 Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Moyenne pondérée Min et Max Suite Calcul approché de π Code César for · · · from · · · to · · · do Exemple 4 : Cryptographie Une solution Le code de César est un chiffrement par décalage c’est à dire une simple substitution monoalphabétique : par exemple si on code la lettre A par 1, la lettre B par 2, · · · , la lettre Z par 26, que l’on ajoute une constante c et que l’on conserve le résultat modulo 26, on obtient le texte codé. La constante c s’appelle la clé. 1. Écrire un algorithme qui, étant donnés un message écrit en majuscule et sans accent et une clé, donne le codage de César. Le programmer sur Xcas. 2. En prenant c = 15 coder chacun des mots de la citation : « RECOMMENCER, CE N EST PAS REFAIRE ». 3. Écrire un algorithme simple qui permet de décoder un message de César dont on ne connaît pas la clé. Le programmer sur Xcas pour décoder l’auteur « RTHPG QPASPRRXCX » de la citation précédente. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · Commençons par l’exemple suivant : Dans une fête forraine , on propose le jeu de dés suivant : • Triplez votre mise en obtenant les six numéros en six lancers ; • Doublez votre mise en obtenant les six numéros en dix lancers ; • Gagnez votre mise en obtenant les six numéros en douze lancers ; • Au delà de douze lancers vous perdez votre mise. Romane et Florine, intriguées par ce jeu, se proposent de faire un algorithme pour déterminer le nombre moyen de lancers nécessaires pour obtenir les six faces. Les deux amies se partagent le travail. Florine propose, sous Xcas, l’algorithme NBmoyen ci-après qui permet d’estimer le nombre moyen de lancers nécessaires pour obtenir les six faces au cours de n séries de lancers. Et charge à Romane à écrire, sous Xcas, l’algorithme Lancer_de_des qui permet de compter le nombre de lancers nécessaires pour obtenir l’ensemble des six faces. Quel algorithme peut-elle proposer à Florine ? Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · NBmoyen(n):={ local total, j ; total:=0 ; for (j:=1 ;j<=n ;j++) { total:=total+Lancer_de_des() } ; return(total/n) ; }; Algorithme de Florine Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( ):={ local L1, L2, nb, k ; Variable L1, L2 : Listes L1:=[0,0,0,0,0,0] ; nb, k : entiers L2:=[1,2,3,4,5,6] ; nb:=0 ; Début L1←[0,0,0,0,0,0] while (L1 !=L2) L2←[1,2,3,4,5,6] {k:= floor(rand(1,7)) ; nb← 0 L2[k−1]:= 0 ; TantQue L16=L2 Faire nb:=nb+1 ; k← partie entière (1+6×random()) }; L2[k]← 0 }; nb←nb+1 FinTantQue Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( ):={ local L1, L2, nb, k ; Variable L1, L2 : Listes L1:=[0,0,0,0,0,0] ; nb, k : entiers L2:=[1,2,3,4,5,6] ; nb:=0 ; Début L1←[0,0,0,0,0,0] while (L1 !=L2) L2←[1,2,3,4,5,6] {k:= floor(rand(1,7)) ; nb← 0 L2[k−1]:= 0 ; TantQue L16=L2 Faire nb:=nb+1 ; k← partie entière (1+6×random()) }; L2[k]← 0 }; nb←nb+1 FinTantQue Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( ):={ local L1, L2, nb, k ; Variable L1, L2 : Listes L1:=[0,0,0,0,0,0] ; nb, k : entiers L2:=[1,2,3,4,5,6] ; nb:=0 ; Début L1←[0,0,0,0,0,0] while (L1 !=L2) L2←[1,2,3,4,5,6] {k:= floor(rand(1,7)) ; nb← 0 L2[k−1]:= 0 ; TantQue L16=L2 Faire nb:=nb+1 ; k← partie entière (1+6×random()) }; L2[k]← 0 }; nb←nb+1 FinTantQue Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( ):={ local L1, L2, nb, k ; Variable L1, L2 : Listes L1:=[0,0,0,0,0,0] ; nb, k : entiers L2:=[1,2,3,4,5,6] ; nb:=0 ; Début L1←[0,0,0,0,0,0] while (L1 !=L2) L2←[1,2,3,4,5,6] {k:= floor(rand(1,7)) ; nb← 0 L2[k−1]:= 0 ; TantQue L16=L2 Faire nb:=nb+1 ; k← partie entière (1+6×random()) }; L2[k]← 0 }; nb←nb+1 FinTantQue Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( ):={ local L1, L2, nb, k ; Variable L1, L2 : Listes L1:=[0,0,0,0,0,0] ; nb, k : entiers L2:=[1,2,3,4,5,6] ; nb:=0 ; Début L1←[0,0,0,0,0,0] while (L1 !=L2) L2←[1,2,3,4,5,6] {k:= floor(rand(1,7)) ; nb← 0 L2[k−1]:= 0 ; TantQue L16=L2 Faire nb:=nb+1 ; k← partie entière (1+6×random()) }; L2[k]← 0 }; nb←nb+1 FinTantQue Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( ):={ local L1, L2, nb, k ; Variable L1, L2 : Listes L1:=[0,0,0,0,0,0] ; nb, k : entiers L2:=[1,2,3,4,5,6] ; nb:=0 ; Début L1←[0,0,0,0,0,0] while (L1 !=L2) L2←[1,2,3,4,5,6] {k:= floor(rand(1,7)) ; nb← 0 L2[k−1]:= 0 ; TantQue L16=L2 Faire nb:=nb+1 ; k← partie entière (1+6×random()) }; L2[k]← 0 }; nb←nb+1 FinTantQue Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( ):={ local L1, L2, nb, k ; Variable L1, L2 : Listes L1:=[0,0,0,0,0,0] ; nb, k : entiers L2:=[1,2,3,4,5,6] ; nb:=0 ; Début L1←[0,0,0,0,0,0] while (L1 !=L2) L2←[1,2,3,4,5,6] {k:= floor(rand(1,7)) ; nb← 0 L2[k−1]:= 0 ; TantQue L16=L2 Faire nb:=nb+1 ; k← partie entière (1+6×random()) }; L2[k]← 0 }; nb←nb+1 FinTantQue Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( ):={ local L1, L2, nb, k ; Variable L1, L2 : Listes L1:=[0,0,0,0,0,0] ; nb, k : entiers L2:=[1,2,3,4,5,6] ; nb:=0 ; Début L1←[0,0,0,0,0,0] while (L1 !=L2) L2←[1,2,3,4,5,6] {k:= floor(rand(1,7)) ; nb← 0 L2[k−1]:= 0 ; TantQue L16=L2 Faire nb:=nb+1 ; k← partie entière (1+6×random()) }; L2[k]← 0 }; nb←nb+1 FinTantQue Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( ):={ local L1, L2, nb, k ; Variable L1, L2 : Listes L1:=[0,0,0,0,0,0] ; nb, k : entiers L2:=[1,2,3,4,5,6] ; nb:=0 ; Début L1←[0,0,0,0,0,0] while (L1 !=L2) L2←[1,2,3,4,5,6] {k:= floor(rand(1,7)) ; nb← 0 L2[k−1]:= 0 ; TantQue L16=L2 Faire nb:=nb+1 ; k← partie entière (1+6×random()) }; L2[k]← 0 }; nb←nb+1 fin de chaque instruction FinTantQue Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit : Algorithme Lancers_de_des() Lancers_de_des( Lancers_de_des( ):={ ):={ L1,L1, L2,L2, nb,nb, k; k; local local Variable L1:=makelist(0,0,5) L1:=[0,0,0,0,0,0] ; L1, L2 : Listes L2:=[1,2,3,4,5,6] >t+1,0,5) ; ; L2:=makelist(t− nb, k : entiers nb:= 0; ; nb:=0 Début L1←[0,0,0,0,0,0] tantque while (L1 (L1 !=L2) !=L2) L2←[1,2,3,4,5,6] faire {k:= k:=floor(rand(1,7)) floor(rand(1,7)); ; nb← 0 L2[k−1]:=0 L2[k−1]:= ; 0; TantQue L16=L2 Faire nb:=nb+1 nb:=nb+1 ; ; k← partie entière (1+6×random()) ftantque }; ; L2[k]← 0 }; }; nb←nb+1 Une autre façon de faire FinTantQue (suivant la version de Xcas) Fin Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · Voici quelques exemples d’applications : Exemple 1 : en arithmétique Une solution Soient a et b deux entiers naturels non nuls tels que a > b. 1. Écrire un algorithme qui permet de donner le quotient et le reste de la division euclidienne de a par b. 2. Écrire un algorithme qui permet de donner le PGCD de a et b, ainsi que leur PPCM. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions n coups pour six faces ! Quotient, reste, PGCD, PPCM Extremum d’une fonction while · · · Exemple 2 : Valeur approchée d’un maximum Une solution Aurélien a tracé graphiquement la courbe √ représentative de la fonction f définie sur l’intervalle [−1 ; 1] par f (x) = 4x 1 − x 2 . Il a repéré que f semble atteindre son maximum en x0 = 0, 7. Il désire obtenir une approximation de ce maximum à 10−p près. Quel algorithme peut-il écrire, la fonction f , x0 et p étant donnés ? Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Nombres premiers La voiture et les deux chèvres 250 e Vote Lancers de pièces Utilisation d’algorithmes · · · Voici quelques exemples où l’utilisation d’algorithmes est indispensables : Exemple 1 : en arithmétique Une solution 2 On note, pour n ∈ N, P(n) = n + n + 41. 1. Les nombres P(n), pour n variant de 0 à 100 sont-ils premiers ? 2. Peut-on conjecturer que pour tout entier n « P(n) est premier » ? Justifier. 3. Donner le 2010e nombre P(n) premier. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Nombres premiers La voiture et les deux chèvres 250 e Vote Lancers de pièces Utilisation d’algorithmes · · · Exemple 2 : en probabilité (le problème de Monty Hall) Une solution Lors d’un jeu télévisé, un candidat doit désigner une porte parmi trois. Derrière l’une des portes, choisie par tirage au sort, se trouve une voiture et derrière chacune des deux autres une chèvre. Lorsque le candidat a choisi une porte, le présentateur, qui connaît la porte gagnante, ouvre l’une des deux autres, qui cache une chèvre. Le candidat peut alors : soit maintenir son choix, soit changer de porte. Le joueur augmente-t-il ses chances de gagner la voiture en changeant son choix initial ? Pour répondre à cette question on pourra tout d’abord commencer par une simulation du jeu. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Nombres premiers La voiture et les deux chèvres 250 e Vote Lancers de pièces Utilisation d’algorithmes · · · Exemple 3 : pour dénombrer Une solution Romane possède dans sa tirelire 100 pièces de 1 e, 50 pièces de 2 e et 20 billets de 5 e. De combien de façons peut-elle obtenir la somme de 250 e avec l’argent de sa tirelire : • après avoir pris les 20 billets et les 50 pièces de 2 e ? • après avoir pris 100 pièces de 1 e et 10 pièces de 2 e ? • à partir de ses 300 e ? Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Nombres premiers La voiture et les deux chèvres 250 e Vote Lancers de pièces Utilisation d’algorithmes · · · Exemple 4 : en statistique Une solution Dans un établissement scolaire, les élèves désirent changer de système de restauration. La direction, à l’écoute de cette revendication, propose qu’un sondage soit effectué. Pour cela, elle demande à l’informaticien de programmer un algorithme qui respecte les critères suivants : • on doit pouvoir saisir le vote de chaque électeur sachant qu’il peut répondre par O (oui), N (non) ou B (blanc) à la question « êtes-vous pour » ; • la lettre « F » indiquera que le vote est terminé ; • afficher le nombre de votants, le pourcentage de oui, de non, de blancs. Quel algorithme l’informaticien peut-il suggérer à la direction ? Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Nombres premiers La voiture et les deux chèvres 250 e Vote Lancers de pièces Utilisation d’algorithmes · · · Exemple 5 : pour l’échantillonnage Une solution On souhaite répéter N fois la simulation de n lancers de pièces à deux faces et vérifier l’affirmation des statisticiens : « Lorsqu’on fabrique des échantillons aléatoires relevant du modèle de Bernoulli (deux issues possibles) de probabilité p (succès) et de taille n, alors pour environ 95 % d’entre eux la fréquence f de succès appartient à l’inter1 1 valle p − √ ; p + √ (lorsque n ≥ 25 et 0, 2 ≤ p ≤ 0, 8) ». n n Écrire un algorithme qui illustre cette propriété. Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Nombres premiers La voiture et les deux chèvres 250 e Vote Lancers de pièces Fin de la formation Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Tour de magie bis Énoncé Tour_de_magie(Age,Somme):={ local p ; p:=Age∗2 ; p:= p + 5 ; p:= 50∗p ; p:=p+Somme ; p:=p−365 ; return(p) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Fonctions Énoncé Aire(Peri,Largeur):={ Perimetre(Aire,Largeur):={ local l, p, L, A ; local l, A, L, P ; l:=Largeur ; l:=Largeur ; p:= Peri ; A:= Aire ; L:=p/2−l ; L:=A/l ; A:=L∗l ; P:=2∗(L+l) ; print("Longueur="+L) ; print("Longueur="+L) ; print("Aire="+A) ; print("Périmètre="+P) ; }; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Un quadrilatère Énoncé Quadrilatere(xA,yA):={ local xI, yI, L1, L2, C ; L1:= [xA, 0, 0, 0, 0] ; L2:= [yA, 0, 0, 0, 0] ; L1[1] :=floor(6∗rand(0,1)) ; L2[1] :=floor(6∗rand(0,1)) ; L1[2]:= −L2[0]+L1[1]+L2[1] ; L2[2]:=L1[0]−L1[1]+L2[1] ; L1[3]:= −L2[2]+L1[1]+L2[1] ; L2[3]:=L1[2]−L1[1]+L2[1] ; L1[4]:= −L2[3]+L1[1]+L2[1] ; L2[4]:=L1[3]−L1[1]+L2[1] ; C:=sqrt((L1[2]−L1[1])2 +(L2[2]−L2[1])2 ) ; return(C,transpose([L1,L2])) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Échange Énoncé Echange(A,B):={ local a, b, c ; print("le nombre choisi est "+(10∗A+B)) ; c:=A ; Première méthode a:=B ; b:=c ; print("le nouveau nombre est "+(10∗a+b)) ; }; Echange(nombre):={ local A, B ; Deuxième méthode A:=floor(nombre/10) ; B:=nombre−10∗A ; print("le nouveau nombre est "+(10∗B+A)) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Indice de Ruffier Énoncé Ruffier():={ local F1, F2, F3, S, I ; input("F1", F1, "F2", F2 ,"F3", F3) ; S:=F1+F2+F3 ; I:=(S−200)/10 ; print("F1 = "+F1) ; print("F2 = "+F2) ; print("F3 = "+F3) ; print("Indice de Ruffier = "+I) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle équilatéral ou rectangle Énoncé Lorqu’on n’utilise pas l’écriture décimale dans les coordonnées il faut rajouter evalf pour pouvoir comparer deux valeurs numériques. Isocele(L1,L2):={ local d1, d2 ; d1:=evalf((L1[1]−L1[0])2 +(L2[1]−L2[0])2 ) ; d2:=evalf((L1[2]−L1[0])2 +(L2[2]−L2[0])2 ) ; if d1=d2 then print("isocèle") ; else print("non isocèle") ; end_if ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle équilatéral ou rectangle Énoncé Equilateral(L1,L2):={ local d1, d2, d3 ; d1:=evalf((L1[1]−L1[0])2 +(L2[1]−L2[0])2 ) ; d2:=evalf((L1[2]−L1[0])2 +(L2[2]−L2[0])2 ) ; d3:=evalf((L1[2]−L1[1])2 +(L2[2]−L2[1])2 ) ; if (d1==d2)and(d1==d3) then print("équilatéral") ; else print("non équilatéral") ; end_if ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Triangle équilatéral ou rectangle Énoncé Rectangle(L1,L2):={ local d1, d2, d3 ; d1:=evalf((L1[1]−L1[0])2 +(L2[1]−L2[0])2 ) ; d2:=evalf((L1[2]−L1[0])2 +(L2[2]−L2[0])2 ) ; d3:=evalf((L1[2]−L1[1])2 +(L2[2]−L2[1])2 ) ; if (d1+d2==d3) then print("rectangle") ; else print("non rectangle") ; end_if ; }; EquiRecIso(L1,L2):={ Equilateral(L1,L2) ; Ce programme fait appel aux 3 précédents Isocele(L1,L2) ; Rectangle(L1,L2) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Primes Énoncé PrimeCA(ca):={ local t ; if ca <= 250000 then t:=0.05 ; else if ca <=500000 then t:=0.07 ; else t:=0.10 ; end_if ; end_if ; print("le taux est de "+(100∗t)+"%") ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Primes Énoncé PrimeSans(K):={ local p ; if K <= 100 then p:=100 ; else if K<=500 then p:=(K−100)∗0.10+500 ; else p:=(K−500)∗0.20+540 ; end_if ; end_if ; print("prime sans accident "+p+" e") ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Primes Énoncé PrimeSans2(K):={ local p ; if K <= 100 then p:=100 ; else if K<=500 then p:=(K−100)∗0.10+500 ; else if K<=1000 then p:=(K−500)∗0.20+540 ; else p:=(K−1000)∗0.30+638 ; end_if ; end_if ; end_if ; print("prime sans accident "+p+" e") ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Primes Énoncé Prime(ca,K):={ local p1, P ; PrimeCA(ca) ; p1:=t∗ca ; PrimeSans2(K) ; P:=p1+p ; print("prime totale "+P+" e") ; }; Ce programme fait appel aux précédents Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions RuffierBis():={ local F1, F2, F3, S, I ; Indice de Ruffier bis Énoncé input("F1",F1,"F2",F2,"F3",F3) ; S:=F1+F2+F3 ; I:=(S−200)/10 ; print("F1 = "+F1) ; print("F2 = "+F2) ; print("F3 = "+F3) ; if (F2<=F3) or (F2<=F1) then print("erreur de saisie") ; else if I<= 0 then print("coeur athlétique") ; else if I<=5 then print("coeur très bon") ; else if I<=10 then print("coeur bon") ; else if I<=15 then print("coeur moyen") ; else print("coeur faible") ; end_if ; end_if ; end_if ; end_if ; end_if ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Min(L):={ Min et Max m, k ; local n, Énoncé n:=dim(L) ; m:=L[0] ; Min et Max Énoncé for (k:=1 ;k<=n−1 ;k++) {if L[k]<=m then m:=L[k] ; end_if }; print("Le plus petit élément est "+m) ; }; Max(L):={ local n, m, k ; MinMax(L):={ n:=dim(L) ; Min(L) ; m:=L[0] ; Max(L) ; for (k:=1 ;k<=n−1 ;k++) {if L[k]>=m then m:=L[k] ; }; end_if }; Ce programme fait print("Le plus grand élément est "+m) ; appel aux 2 autres }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions TermesUn(n,u0):={ local k, temp ; temp:=u0 ; for (k:=1 ;k<=n ;k++) { temp:=temp+2∗k−1 } ; Suites Énoncé return(temp) ; }; SommeTermesUn(n,u0):={ local S, k ; Ce programme fait appel au précédent S:= 0 ; for (k:=1 ;k<=n ;k++) { S:=S+TermesUn(k,u0)} ; return(S) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Calcul approché de π Énoncé Lancers(n):={ local k, X, Y, d, compteur ; for (k:=1 ;k<=n ;k++) { X:=rand(0,1) ; Y:=rand(0,1) ; d:=sqrt(X∧ 2+Y∧ 2) ; compteur:=compteur+1−floor(d) ; }; return(compteur/n) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Cesar(message,cle):={ local s, messcode, c, k, j, r ; s:=size(message) ; messcode:="" ; code(c):=asc(c)−64 ; Code Cesar decode(k):=char(k+64) ; Énoncé for (j:=0 ;j<s ;j++) {r:=irem(cle+code(message[j]),26) ; messcode:=append(messcode,decode(r)) }; return(messcode) ; }; DecoCesar(message):={ local k ; for (k:=1 ;k<=26 ;k++) {afficher("cle no "+k+":"+Cesar(message,k))} ; }; Ce programme fait appel au précédent Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Quotient, reste, PGCD, PPCM Énoncé Quotient(a,b):={ Reste(a,b):={ local k ; local k ; k:=0 ; while (k∗b<=a) {k:=k+1} ; while (k∗b<=a) {k:=k+1} ; return(a−b∗(k−1)) ; return(k−1) ; }; }; PGCD(a,b):={ PPCM(a,b):={ local r ; a∗b/PGCD(a,b) ; while (b !=0) {r:=Reste(a,b) ; a:=b ; b:=r} ; return(a) ; }; Les deux derniers programmes font appel à celui qui les précède Auteur : Bernard Chrétien Algorithmique }; Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Extremum d’une fonction Une solution Maximum(f,x0,p):={ local X,Y,compteur ; X:=x0+10∧ (−p) ; Y:=f(x0) ; compteur:=0 ; while (evalf(f(X))>Y and compteur<10∧ p) {Y:=evalf(f(X)) ; X:=X+10∧ (−p) ; compteur:=compteur+1} ; X−10∧ (−p) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Premier(n):={ local k ; for (k:=0 ;k<=n ;k++){ if isprime(k∧ 2+k+41) ; then print("P("+k+") est premier") ; end_if ; Nombres premiers Énoncé }; }; Recherche(p):={ local r,k ; k:=0 ; while (r<p−1){ if isprime(k∧ 2+k+41) ; then r:=r+1 ; k:=k+1 ; else k:=k+1 ; end_if ; }; print("P("+k+")="+(k∧ 2+k+41)+" est le "+p+" ieme nombre P(n) premier ") ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions La voiture et les deux chèvres Énoncé Chevre(n):={ local a, v, ng1, ng2, k ; ng1:=0 ; ng2:=0 ; for (k:=1 ;k<=n ; k++){ v:=floor(rand(0,3)) ; a:=floor(rand(0,3)) ; if a==v then ng1:=ng1+1 ; else ng2:=ng2+1 ; end_if ; }; return([evalf(ng1/n),evalf(ng2/n)]) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions 250 e Énoncé Denombrement2():={ local compteur, k, l ; compteur:=0 ; for (k:=0 ;k<=40 ;k++) ; for (l:=0 ;l<=20 ;l++) ; if 2∗k+5∗l=130 then compteur:=compteur+1 ; end_if ; ; ; return(compteur) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions 250 e Énoncé Denombrement3():={ local compteur, k, l, m ; compteur:=0 ; for (k:=0 ;k<=100 ;k++) ; for (l:=0 ;l<=50 ;l++) ; for (m:=0 ;m<=20 ;m++) ; if k+2∗l+5∗m=250 then compteur:=compteur+1 ; end_if ; ; ; ; return(compteur) ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions Sondage():={ Vote local o, n, b, compteur, V, c ; Énoncé o:=0 ; n:=0 ; b:=0 ; compteur:=0 ; while (V !="F"){textinput("votre vote",V) ; compteur:=compteur+1 ; if V =="O" then o:=o+1 ; else if V =="N" then n:=n+1 ; else b:=b+1 ; end_if ; end_if ; }; c:=compteur−1 ; print("Nombre de votants = "+c) ; print("Nombre de Oui = "+format((o/c)∗100,"f2")+" %") ; print("Nombre de Non = "+format((n/c)∗100,"f2")+" %") ; print("Nombre de Blanc = "+format((c−o−n)/c∗100,"f2")+" %") ; }; Auteur : Bernard Chrétien Algorithmique Objectifs Affectation Si · · · Alors · · · Sinon · · · Pour · · · variantDe · · · à · · · Faire Tant que · · · Pour aller plus loin Solutions PileFace(taille,essais):={ Lancers de pièces local T, I, J, X ; L1:=seq(A,A,1..essais) ; Énoncé L2:=seq(0,A,1..essais) ; T:=taille ; for (J:=1 ;J<=essais ;J++) ; {X:=0 ; for (I:=1 ;I<=taille ;I++) ; { if alea(2)<0.5 then X:=X+1 ; end_if ; }; L2[J−1]:=X/taille ; }; return(nuage_points(seq([L1[A],L2[A]],A,0,..49)), droite(y=0.5), droite(y=0.5+1/sqrt(T)), droite(y=0.5−1/sqrt(T))) ; }; Auteur : Bernard Chrétien Algorithmique
