Algorithmique et Xcas - ac-lille.fr

ObjectifsAffectation

Si · · · Alors · · · Sinon · · ·

Pour · · · variantDe · · · à · · · FaireTant que · · ·

Pour aller plus loinSolutions

Algorithmique et Xcas

Auteur :Bernard Chrétien

Académie de [email protected]

7 juin 2010

Auteur : Bernard Chrétien Algorithmique

Si · · · Alors · · · Sinon · · ·

Objectifs

On trouvera :

Ce document s’adresse aux professeurs désirant obtenir une formation en algo-rithmique 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èsvoisine de celle d’un algorithme écrit en langage algorithmique. Pour chacunedes instructions suivantes :

Affectation

Si · · · Alors · · · Sinon

Pour · · · variantDe · · · à · · · Faire

Tant que · · ·sera donné un exemple simple pour comprendre rapidement la syntaxe. Ensuiteil est donné d’autres exemples avec une solution sous Xcas. Chaque algorithmeproposé est source d’idées à réinvestir dans les différentes classes du lycée.

Si · · · Alors · · · Sinon · · ·

MagiqueTour de magie bisFonctionsUn quadrilatèreÉchangeIndice 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 de-mande 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 enlangage algorithmique après avoir compléter le tableau ci-dessous quicorrespond au traitement de l’algorithme écrit en langage naturel à lavaleur n = 5 (p représente le résultat obtenu à l’étape correspondante).

Si · · · Alors · · · Sinon · · ·

Étape no Valeur de n Valeur de p

Entrée 1

Traitement234

Sortie

3. Programmer cet algorithme sur le logiciel de calcul formel Xcas, puisl’exécuter sur les exemples précédents.

4. Quelle valeur obtient-on si l’on donne la valeur initiale x ? Quelle fonctiona-t-on ainsi définie ?

Si · · · Alors · · · Sinon · · ·

On traduit tout d’abord en langage algorithmique puis sous Xcas comme suit :

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

Saisir le nombre n choisi

p ← n + 3

p ← p×n

p ← p−n2

Afficher « le nombre p obtenu »

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

fin de chaque

instruction

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Une autre façon de faire

Magique(n):={

local p ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Magique(n):={

local p ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Magique(n):={

local p ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Magique(n):={

local p ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Magique(n):={

local p ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Magique(n):={

local p ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Magique(n):={

local p ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Magique(n):={

local p ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

Algorithme Magique

Variable

n : entier naturel

p : entier naturel

Début

p ← n + 3

p ← p×n

p ← p−n2

Magique( ):={

local n, p ;

input("n",n) ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Magique(n):={

local p ;

p := n+3 ;

p := p∗n ;

p := p−n∧2 ;

return(p) ;

Si · · · Alors · · · Sinon · · ·

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 sommequ’elle a en poche (moins de 100 e).Il lui demande ensuite de montrer le papier à Margaux, qui doit le lire (sansrien 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 aurésultat de Margaux, je devine facilement l’âge et l’argent de poche deFlorine ! ». Algor dit-il vrai ?

Si · · · Alors · · · Sinon · · ·

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 etl’aire A.

1. On prend p = 20.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.

2. a. On prend A = 25.Écrire en langage naturel un algorithme qui, connaissant la dimension L dece 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.

Si · · · Alors · · · Sinon · · ·

Exemple 3 : en géométrieUne solution

Dans un repère orthonormé, on choi-sit au hasard un point I dont lescoordonnées entières sont comprisesentre −5 et 5. On donne ensuite lescoordonnées (xA, yA) d’un point A.Interpréter l’algorithme ci-contre.On pourra utiliser les listes : l’unepour les abscisses et l’autre pour lesordonnées.

Algorithme ? ? ?

Variable

xI , yI : entiers naturels compris entre 0 et 5

xA, yA, xM , yM , xN , yM , xP , yP , C : réels

Début

Saisir xA et yA.

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

C ←√

(xM − xA)2 + (yM − yA)2

Afficher les coordonnées de A, I , M, N et P

Afficher C

Si · · · Alors · · · Sinon · · ·

Exemple 4 : en arithmétique Une solution

On donne un entier naturel n à deux chiffres. Écrire un algorithme permettantd’échanger le chiffre des unités et le chiffre des dizaines.

Si · · · Alors · · · Sinon · · ·

Exemple 5 : en médecine Une solution

Pour débuter une activité sportive, il est fortement conseillé de passer le test deRuffier 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 del’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 en45 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 obtenirl’indice de chacun de ses élèves ?

Si · · · Alors · · · Sinon · · ·

Triangle isocèleTriangle équilatéral ou rectanglePrimesIndice de Ruffier bis

if · · · then · · · else · · ·

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 ] ? Onjustifiera la réponse par le calcul et on pourra vérifier le résultat enexcécutant le programme précédent.

5. En déduire la nature du quadrilatère ABDC . On pourra de nouveau seservir du programme pour valider certaines propriétés.

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

L1, L2 : listes pour les coordonnées

U, V : réels

Début

Saisir les listes L1 et L2

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Afficher « isocèle »

Afficher « non isocèle »

Isocele():={

local L1, L2, U, V ;

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

if U = V then print("isocele") ;

else print("non isocele") ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

fin de chaqueinstruction

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

if (U = V) {print("isocele") ;}

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Algorithme Isocèle

Variable

U, V : réels

Début

U ← (L1[2]−L1[1])2+(L2[2]−L2[1])2

V ← (L1[3]−L1[1])2+(L2[3]−L2[1])2

Si U = V Alors

Isocele():={

input("L1", L1,"L2", L2) ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

end_if ;

Encore une autre façon de faire(suivant la version de Xcas)

Isocele(L1,L2):={

local U, V ;

U := (L1[1]−L1[0])∧2+(L2[1]−L2[0])∧2 ;

V := (L1[2]−L1[0])∧2+(L2[2]−L2[0])∧2 ;

si (U = V) alors afficher("isocele") ;

sinon afficher("non isocele") ;

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

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 letriangle est équilatéral (on pourra utiliser sur Xcas l’un des liens logiquessuivants : and , et , &&).

2. Écrire un algorithme qui teste, trois points A, B et C étant donnés, si letriangle est rectangle en A.

3. Écrire un algorithme qui teste, trois points A, B et C étant donnés, si letriangle est équilatéral ou isocèle ou rectangle en A.

Si · · · Alors · · · Sinon · · ·

if · · · then · · · else · · ·

Exemple 2 : fonctions affines par morceaux

Un commercial peut percevoir à la fin de chaque mois deux primes, l’une sur le chiffred’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 enfonction de son chiffre d’affaires (CA) mensuel :

a. Pour un CA inférieur à 250 000 e il a une prime de 5% du CAb. De 250 000 à 500 000 e il a une prime de 7 % du CAc. 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 dechaque 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 sansaccident , on lui propose la règle suivante :

a. Pour moins de 100 kilomètres sans accident le montant de la prime est de100 e ;

Si · · · Alors · · · Sinon · · ·

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 dechaque mois.Programmer ensuite cet algorithme sur Xcas.

3. On souhaite ajouter la borne 1 000 kilomètres ; quelle sera l’instruction de calculpour 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 dechaque 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 de350 000 e et 1 200 kilomètres sans accident ?

Si · · · Alors · · · Sinon · · ·

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èsbon »),

• 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 luidéclare qu’elle a un « un cœur athlétique ». Laure, non sportive, lui répond que celan’est pas possible !Quel jugement peut-on donner à cette affirmation ? Dans la négative que faudrait-ilrajouter dans l’algorithme pour y remédier ?

Si · · · Alors · · · Sinon · · ·

Moyenne pondéréeMin et MaxSuiteCalcul approché de π

Code César

for · · · from · · · to · · · do

Pour étudier l’habitat dans une certaine région assez peu peuplée, l’Institut Géo-graphique 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 observersur chacun des N clichés. Voici les résultats de ce comptage.

Nombre d’habitations 0 1 2 3 4 5 6 7 8 9 10 11 12

Nombre de photos 3 18 42 58 77 70 55 37 19 11 5 3 2

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 lenombre moyen de maisons par photo. Programmer ensuite cet algorithme surXcas, puis l’exécuter pour obtenir N et la moyenne.

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

D ← Dim L1 {dimension de la liste L1}

Pour k variantDe 1 à D Faire

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Afficher « N et S/N »

Moyenne():={

local L1, L2, D, N, S, k ;

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

for k from 0 to D−1

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Moyenne(L1,L2):={

local D, N, S, k ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

for (k:= 0 ; k<= D − 1 ; k++)

{ S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N }

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Moyenne(L1,L2):={

local D, N, S, k ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

for (k:= 0 ; k<= D − 1 ; k++)

{ S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N }

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Moyenne(L1,L2):={

local D, N, S, k ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

for (k:= 0 ; k<= D − 1 ; k++)

{ S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N }

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Moyenne(L1,L2):={

local D, N, S, k ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

for (k:= 0 ; k<= D − 1 ; k++)

{ S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N }

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Moyenne(L1,L2):={

local D, N, S, k ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

for (k:= 0 ; k<= D − 1 ; k++)

{ S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N }

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Algorithme Moyenne

Variable

L1, L2 : listes

D, N, k : entiers

S : réel

Début

N ← 0

S ← 0

S ← L1[k] ∗ L2[k] + S

N ← N + L2[k]

FinPour

Moyenne():={

input("L1", L1,"L2", L2) ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

do S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

end_for ;

return(N, S/N) ;

Encore une autre façon de faire(suivant la version de Xcas)

Moyenne(L1,L2):={

local D, N, S, k ;

N := 0 ;

S := 0 ;

D := dim(L1) ;

pour k de 0 jusque D−1 faire

S := L1[k] ∗ L2[k] + S ;

N := L2[k] + N ;

fpour ;

return(N, S/N) ;

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Exemple 1 : en statistique Une solution

1. Écrire un algorithme qui détermine et affiche le plus petit élément d’unesérie statistique. Le programmer sur Xcas.

2. Écrire un algorithme qui détermine et affiche le plus grand élément d’unesé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.

Si · · · Alors · · · Sinon · · ·

Code César

for · · · from · · · to · · · do

Exemple 2 : suite Une solution

On définit la suite (un)n∈Npar 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 + 1premiers termes de la suite (un)n∈N

Si · · · Alors · · · Sinon · · ·

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 ainsique le quart de cercle de rayon 1 et de centre l’undes sommets du carré. Elle se place à une distanceraisonnable de telle sorte qu’elle puisse toujours at-teindre la cible lors d’un lancer de fléchettes.Déterminer, en faisant une simulation, une valeurapprochée de la fréquence des fléchettes qui abou-tissent dans le quart de disque au cours de n lancers.Vers quel nombre semble converger cette fréquence ? 1

Si · · · Alors · · · Sinon · · ·

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 substi-tution monoalphabétique : par exemple si on code la lettre A par 1, la lettre Bpar 2, · · · , la lettre Z par 26, que l’on ajoute une constante c et que l’on conservele 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 etsans 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ésardont on ne connaît pas la clé. Le programmer sur Xcas pour décoderl’auteur « RTHPG QPASPRRXCX » de la citation précédente.

Si · · · Alors · · · Sinon · · ·

n coups pour six faces !Quotient, reste, PGCD, PPCMExtremum d’une fonction

while · · ·

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 pourdé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’algorithmeNBmoyen ci-après qui permet d’estimer le nombre moyen de lancers nécessairespour 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 nombrede lancers nécessaires pour obtenir l’ensemble des six faces.

Quel algorithme peut-elle proposer à Florine ?

Si · · · Alors · · · Sinon · · ·

while · · ·

Algorithme de Florine

NBmoyen(n):={

local total, j ;

total:=0 ;

for (j:=1 ;j<=n ;j++)

{ total:=total+Lancer_de_des() } ;

return(total/n) ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Algorithme Lancers_de_des()

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

TantQue L16=L2 Faire

k← partie entière (1+6×random())

L2[k]← 0

nb←nb+1

FinTantQue

Lancers_de_des( ):={

local L1, L2, nb, k ;

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

{k:= floor(rand(1,7)) ;

L2[k−1]:= 0 ;

nb:=nb+1 ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

Une autre façon de faire(suivant la version de Xcas)

L1:=makelist(0,0,5) ;

L2:=makelist(t− >t+1,0,5) ;

nb:= 0 ;

tantque (L1 !=L2)

faire k:= floor(rand(1,7)) ;

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

Variable

L1, L2 : Listes

nb, k : entiers

Début

L1←[0,0,0,0,0,0]

L2←[1,2,3,4,5,6]

nb← 0

L2[k]← 0

nb←nb+1

FinTantQue

L1:=[0,0,0,0,0,0] ;

L2:=[1,2,3,4,5,6] ;

nb:=0 ;

while (L1 !=L2)

L2[k−1]:= 0 ;

nb:=nb+1 ;

nb:= 0 ;

tantque (L1 !=L2)

L2[k−1]:=0 ;

nb:=nb+1 ;

ftantque ;

Si · · · Alors · · · Sinon · · ·

while · · ·

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 ladivision euclidienne de a par b.

2. Écrire un algorithme qui permet de donner le PGCD de a et b, ainsi queleur PPCM.

Si · · · Alors · · · Sinon · · ·

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éfiniesur l’intervalle [−1 ; 1] par f (x) = 4x

√1 − x2. 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 ?

Si · · · Alors · · · Sinon · · ·

Nombres premiersLa voiture et les deux chèvres250 eVoteLancers de pièces

Utilisation d’algorithmes · · ·

Voici quelques exemples où l’utilisation d’algorithmes est indispensables :

On note, pour n ∈ N, P(n) = n2 + 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.

Si · · · Alors · · · Sinon · · ·

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èrel’une des portes, choisie par tirage au sort, se trouve une voiture et derrièrechacune des deux autres une chèvre. Lorsque le candidat a choisi une porte, leprésentateur, qui connaît la porte gagnante, ouvre l’une des deux autres, quicache une chèvre. Le candidat peut alors : soit maintenir son choix, soit changerde porte.Le joueur augmente-t-il ses chances de gagner la voiture en changeant son choixinitial ?Pour répondre à cette question on pourra tout d’abord commencer par unesimulation du jeu.

Si · · · Alors · · · Sinon · · ·

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 billetsde 5 e. De combien de façons peut-elle obtenir la somme de 250 e avec l’argentde 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 ?

Si · · · Alors · · · Sinon · · ·

Exemple 4 : en statistique Une solution

Dans un établissement scolaire, les élèves désirent changer de système de restau-ration. La direction, à l’écoute de cette revendication, propose qu’un sondage soiteffectué. Pour cela, elle demande à l’informaticien de programmer un algorithmequi respecte les critères suivants :

• on doit pouvoir saisir le vote de chaque électeur sachant qu’il peutrépondre par O (oui), N (non) ou B (blanc) à la question « êtes-vouspour » ;

• 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 ?

Si · · · Alors · · · Sinon · · ·

Exemple 5 : pour l’échantillonnage Une solution

On souhaite répéter N fois la simulation de n lancers de pièces à deux faces etvérifier l’affirmation des statisticiens :« Lorsqu’on fabrique des échantillons aléatoires relevant du modèle de Ber-noulli (deux issues possibles) de probabilité p (succès) et de taille n, alorspour environ 95 % d’entre eux la fréquence f de succès appartient à l’inter-

p − 1√n

; p +1√n

(lorsque n ≥ 25 et 0, 2 ≤ p ≤ 0, 8) ».

Écrire un algorithme qui illustre cette propriété.

Si · · · Alors · · · Sinon · · ·

Fin de la formationFin de la formation

Si · · · Alors · · · Sinon · · ·

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) ;

Si · · · Alors · · · Sinon · · ·

Fonctions Énoncé

Aire(Peri,Largeur):={

local l, p, L, A ;

l:=Largeur ;

p:= Peri ;

L:=p/2−l ;

A:=L∗l ;

print("Longueur="+L) ;

print("Aire="+A) ;

Perimetre(Aire,Largeur):={

local l, A, L, P ;

l:=Largeur ;

A:= Aire ;

L:=A/l ;

P:=2∗(L+l) ;

print("Longueur="+L) ;

print("Périmètre="+P) ;

Si · · · Alors · · · Sinon · · ·

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])) ;

Si · · · Alors · · · Sinon · · ·

Échange Énoncé

Première méthode

Echange(A,B):={

local a, b, c ;

print("le nombre choisi est "+(10∗A+B)) ;

c:=A ;

a:=B ;

b:=c ;

print("le nouveau nombre est "+(10∗a+b)) ;

Deuxième méthode

Echange(nombre):={

local A, B ;

A:=floor(nombre/10) ;

B:=nombre−10∗A ;

print("le nouveau nombre est "+(10∗B+A)) ;

Si · · · Alors · · · Sinon · · ·

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) ;

Si · · · Alors · · · Sinon · · ·

Triangle équilatéral ou rectangle Énoncé

Lorqu’on n’utilise pas l’écriture décimale dans les coordonnées il faut rajouterevalf 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 ;

Si · · · Alors · · · Sinon · · ·

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 ;

Si · · · Alors · · · Sinon · · ·

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) ;

Isocele(L1,L2) ;

Rectangle(L1,L2) ;

Ce programme fait appelaux 3 précédents

Si · · · Alors · · · Sinon · · ·

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 ;

print("le taux est de "+(100∗t)+"%") ;

Si · · · Alors · · · Sinon · · ·

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 ;

print("prime sans accident "+p+" e") ;

Si · · · Alors · · · Sinon · · ·

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 ;

print("prime sans accident "+p+" e") ;

Si · · · Alors · · · Sinon · · ·

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

Si · · · Alors · · · Sinon · · ·

RuffierBis():={

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) ;

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 ;

Indice de Ruffier bis Énoncé

Si · · · Alors · · · Sinon · · ·

Min et Max Énoncé

Min(L):={

local n, m, k ;

n:=dim(L) ;

m:=L[0] ;

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 ;

n:=dim(L) ;

m:=L[0] ;

for (k:=1 ;k<=n−1 ;k++) {if L[k]>=m then m:=L[k] ;

end_if

print("Le plus grand élément est "+m) ;

MinMax(L):={

Min(L) ;

Max(L) ;

Ce programme fait

appel aux 2 autres

Min et Max Énoncé

Si · · · Alors · · · Sinon · · ·

TermesUn(n,u0):={

local k, temp ;

temp:=u0 ;

for (k:=1 ;k<=n ;k++) { temp:=temp+2∗k−1 } ;

return(temp) ;

SommeTermesUn(n,u0):={

local S, k ;

S:= 0 ;

for (k:=1 ;k<=n ;k++) { S:=S+TermesUn(k,u0)} ;

return(S) ;

Suites Énoncé

Ce programmefait appel

au précédent

Si · · · Alors · · · Sinon · · ·

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) ;

Si · · · Alors · · · Sinon · · ·

Cesar(message,cle):={

local s, messcode, c, k, j, r ;

s:=size(message) ;

messcode:="" ;

code(c):=asc(c)−64 ;

decode(k):=char(k+64) ;

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

Code Cesar

Énoncé

Si · · · Alors · · · Sinon · · ·

Quotient(a,b):={

local k ;

k:=0 ;

while (k∗b<=a) {k:=k+1} ;

return(k−1) ;

Reste(a,b):={

local k ;

while (k∗b<=a) {k:=k+1} ;

return(a−b∗(k−1)) ;

PGCD(a,b):={

local r ;

while (b !=0) {r:=Reste(a,b) ; a:=b ; b:=r} ;

return(a) ;

PPCM(a,b):={

a∗b/PGCD(a,b) ;

Quotient, reste, PGCD, PPCM Énoncé

Les deux derniers programmes font appel à celui qui les précède

Si · · · Alors · · · Sinon · · ·

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) ;

Si · · · Alors · · · Sinon · · ·

Premier(n):={

local k ;

for (k:=0 ;k<=n ;k++){ if isprime(k∧2+k+41) ;

then print("P("+k+") est premier") ;

end_if ;

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 ") ;

Nombrespremiers

Énoncé

Si · · · Alors · · · Sinon · · ·

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)]) ;

Si · · · Alors · · · Sinon · · ·

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) ;

Si · · · Alors · · · Sinon · · ·

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) ;

Si · · · Alors · · · Sinon · · ·

Sondage():={

local o, n, b, compteur, V, c ;

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 ;

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")+" %") ;

Vote Énoncé

Si · · · Alors · · · Sinon · · ·

PileFace(taille,essais):={

local T, I, J, X ;

L1:=seq(A,A,1..essais) ;

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))) ;

Lancers de piècesÉnoncé

Algorithmique et Xcas - ac-lille.fr

Documents

Transcript of Algorithmique et Xcas - ac-lille.fr