Algorithmique Et Programmation 787733

duscol
Ressources pour le lyce

Ressources pour le lyce gnral et technologique
Mathmatiques
Algorithmique et
programmation
Ces documents peuvent tre utiliss et modifis librement dans le cadre des
activits d'enseignement scolaire, hors exploitation commerciale.
Toute reproduction totale ou partielle dautres fins est soumise une
autorisation pralable du Directeur gnral de lenseignement scolaire.
La violation de ces dispositions est passible des sanctions dictes larticle
L.335-2 du Code la proprit intellectuelle.
Ministre de lEducation Nationale Juin

http://eduscol.education.fr 2017
Prsentation gnrale
La circulaire n 2017-082 du 2 mai 2017 apporte des amnagements au programme de

mathmatiques de seconde gnrale et technologique. Elle prvoit une partie ddie lalgorithmique
et la programmation dont la rdaction a t remanie et rappelle que le travail correspondant doit tre
rinvesti dans les trois autres parties (fonctions, gomtrie, statistiques et probabilits). la diffrence
du programme de mathmatiques du cycle 4 du collge, il sagit donc dadosser explicitement les
activits de la partie algorithmique et programmation aux mathmatiques.
Cet enseignement a un double objectif : faire travailler des notions mathmatiques du programme
dans un contexte diffrent, et poursuivre chez les lves le dveloppement des comptences
1
suivantes, dj travailles au cycle 4 :
dcomposer un problme ;
reconnatre des schmas ;
gnraliser et abstraire ;
concevoir des algorithmes et les traduire dans un langage de programmation.
Les modalits de lapprentissage correspondant peuvent tre varies : travail individuel ou en groupe,
en salle informatique ou en salle banale, au tableau ou sur papier, sur tablette ou sur ordinateur.
Il sagit de consolider les acquis du cycle 4 autour de deux ides essentielles : la notion universelle de
fonction dune part et la programmation comme production dun texte dans un langage informatique
d'autre part.
Les notions mathmatique et informatique de fonction relvent du mme concept universel.
En informatique, une fonction prend un ou plusieurs arguments et renvoie une valeur issue
dun calcul.
Le choix dun langage textuel, comme Python, au lieu dun langage par blocs, comme
Scratch, permet aux lves de se confronter la prcision et la rigidit dune syntaxe proche
de celle des expressions mathmatiques, avec lavantage de pouvoir bnficier du contrle
apport par lanalyseur syntaxique.
Prsentation de la ressource
Ce document prsente des activits permettant d'clairer des rsultats et des mthodes
mathmatiques au travers d'algorithmes simples. La plupart de ces activits nont pas t conues
pour tre donnes telles quelles des lves. Leur objectif est de montrer aux enseignants
comment on peut utiliser le langage Python pour faire des mathmatiques autrement et leur
proposer des situations pour se former et dans lesquelles ils pourront puiser des ides pour
concevoir des activits de longueurs et de difficults varies, allant des questions flash aux mini-
projets. Mme si les amnagements de programme ne concernent que la classe de seconde, les
activits couvrent un spectre plus large et les professeurs sont libres de les adapter aux
classes du cycle terminal.
Les programmes de ce document sont crits dans le langage Python, choisi pour la concision et la
simplicit de sa syntaxe, la taille de la communaut dutilisateurs (en particulier dans le cadre
ducatif), ainsi que la richesse des ressources disponibles. On trouvera en annexe des indications sur
linstallation de Python sur tablette ou sur ordinateur.
Le professeur gardera lesprit que lenseignement de la partie algorithmique et programmation na
pas pour objectif de former des experts dans tel ou tel langage de programmation ou dans la
connaissance dtaille de telle ou telle bibliothque de programme. Il sagit de prolonger
lenseignement de la pense algorithmique initi au cycle 4, qui trouve une place naturelle dans tous
les champs du programme de mathmatiques. Lcriture, la comprhension et la modification
1
1 cf. la ressource daccompagnement du programme de mathmatiques du cycle 4 Algorithmique et
programmation.
Ministre de lEducation Nationale 1

Algorithmique et programmation
http://eduscol.education.fr
dalgorithmes et de petits programmes permettent aux lves dacqurir de bonnes habitudes de
rigueur, tout en revisitant les notions de variables et de fonctions.
Quelques concepts importants
Algorithmes
Un algorithme est une procdure de rsolution de problme, abstraction faite des caractristiques
spcifiques quil peut revtir. Par exemple, un algorithme de tri ne rsout pas le problme du tri dun
jeu particulier de donnes mais a pour objectif de trier nimporte quel jeu de donnes : le problme du
tri sapplique diffrentes instances, cest--dire diffrents jeux de donnes.
Un algorithme sapplique donc une famille dinstances dun problme et produit, en un nombre fini
dtapes constructives, effectives, non-ambiges et organises, la rponse au problme pour toute
instance de cette famille.
De la mme faon quun script Scratch se construit en accolant des briques lmentaires, un
algorithme sappuie sur un ensemble trs rduit de constructions : laffectation dune variable, la
squence dinstructions, linstruction conditionnelle, les boucles (bornes ou non bornes), les
fonctions.
Ci-aprs sont dcrites ces diffrentes constructions. Toutefois, il nest pas recommand de les
prsenter de faon magistrale aux lves, qui les ont dj rencontres au cycle 4, mais de les
mobiliser de faon naturelle dans les activits travailles, en introduisant progressivement leur
imbrication.
Affectation dune variable
La ressource daccompagnement du thme Algorithmique et programmation du programme de

mathmatiques au cycle 4 explique la diffrence entre les notions mathmatique et informatique de la
variable.
En mathmatiques, la variable apparat dans des formules comme celle du primtre dun cercle ou
lexpression symbolique des fonctions. On distingue :
les variables, comme dans les formules du type = 2 ou lexpression symbolique
() dune fonction ;
les indtermines, comme dans une identit remarquable ( + )2 = 2 + 2 + 2 , qui
indique que lgalit est vraie pour toutes les valeurs donnes et ;
les inconnues, comme dans lquation 2 + 3 = 4 7, o il sagit cette fois de dterminer
pour quelles valeurs de la variable lgalit est vraie ;
les paramtres, qui conservent une valeur fixe, mais de porte gnrale, comme qui
dsigne le coefficient de la fonction linaire .
En informatique, on est amen crire des instructions comme x = x+1 qui sont dune nature
totalement diffrente : il ne sagit pas l dune galit, ni dune quation, mais dune instruction
daffectation, qui va modifier le contenu de la variable x. Il est dailleurs recommand de lire cette
instruction x reoit la valeur x+1 et surtout pas x gale x+1 .
Cest la smantique particulire de laffectation, qui na pas danalogue en mathmatiques, qui conduit
les informaticiens une notion diffrente de la variable.
Un modle rigoureux de la variable informatique consiste dire quune variable est une tiquette
colle sur une bote qui peut contenir diffrentes valeurs. Le contenu de chaque bote varie au cours
de lexcution dun programme (ce qui nest pas le cas dune variable mathmatique). Quand
lordinateur value une expression dans laquelle figure une variable, comme x+4, le rsultat de
lvaluation est la somme du nombre contenu dans la bote dtiquette x et de 4.

Une instruction daffectation comme y = x+4 est donc excute de la faon suivante :
valuer lexpression x+4 en ajoutant 4 la valeur contenue dans la bote tiquete par x ;
jeter le contenu de la bote tiquete par y, et le remplacer par la valeur calcule ltape
prcdente.
On vrifie que linstruction x = x+1 sexplique alors exactement de la mme faon.
On observe galement que le symbole = a t choisi pour lopration daffectation en Python. Le
symbole = nest donc pas disponible pour le test dgalit qui scrit ==. On sera attentif cette
diffrence : laffectation est absente en mathmatiques et omniprsente en informatique, le test
dgalit dun usage moins frquent en informatique.
Squence dinstructions
En Python, une squence dinstructions sobtient en crivant simplement la suite, dans un ordre
dtermin, diffrentes instructions, chacune sur une ligne, avec la mme indentation (on reviendra sur
lutilisation et la place essentielle de lindentation).
Par exemple :
a = 4
b = 5
c = maFonction(a+b,a-b)
affecte 4 la variable a, puis 5 la variable b. Enfin, on affecte la variable c la valeur renvoye par
la fonction maFonction en prenant comme arguments la somme et la diffrence de a et b.
Il est noter quon aurait pu condenser les deux premires affectations en une seule, en utilisant une
affectation multiple : a, b = 4, 5.
Dans le cas dune affectation multiple, on value dabord les expressions droite du symbole = puis
on affecte les rsultats aux variables qui figurent gauche. On peut crire simplement a, b = b, a
pour changer les valeurs des deux variables a et b.
Instruction conditionnelle
En Scratch, on a le choix entre une instruction conditionnelle avec ou sans clause sinon . Il en est
de mme avec Python. Voici un exemple sans clause sinon :
delta = b*b 4*a*c
if delta > 0:
x1 = (-b+sqrt(delta))/(2*a)
x2 = (-b-sqrt(delta))/(2*a)
s = -b/a
p = c/a
Les deux points (symbole :) annoncent louverture dun bloc, contenant ventuellement plusieurs
instructions. Le bloc est signal par lindentation : on ajoute en tte de chaque ligne du bloc le mme
nombre despaces (ou de tabulations). Le retour lindentation prcdente signale ainsi tout
naturellement la fin du bloc.
Cette utilisation de lindentation est obligatoire.
Il y a ici deux affectations ( x1 et x2) dans le bloc, cest--dire que ces deux affectations ne sont
excutes que si la condition delta>0 est vrifie. En revanche les affectations s et p sont
toujours effectues.
Les environnements de programmation usuels aident maintenir une indentation cohrente.
On dispose galement dune instruction conditionnelle avec une clause sinon (else), et mme
dune abrviation pour sinon si (elif).

Voici un exemple, permettant de dfinir une fonction dfinie par morceaux.
def f(x):
if x < 0:
y = 2*x+3
elif x < 2: # ici 0 <= x < 2
y = 3-x
else: # ici 2 <= x
y = x*x-3
return y
On a ajout des commentaires pour expliciter les trois cas diffrents : ces commentaires sont
annoncs par le symbole #. Les environnements usuels de programmation colorent automatiquement
les commentaires pour les distinguer du reste du code.
Boucles bornes
Python propose une instruction for variable in liste : qui permet dexcuter un bloc dinstructions
(dont louverture est signale par le symbole :) en donnant successivement la variable les diffrentes
valeurs de la liste.
Pour retrouver le comportement du bloc rpter 6 fois de Scratch, il suffira dutiliser linstruction
for i in range(6): puisque range(6) permet ditrer sur la liste [0,1,2,3,4,5]. Plus
gnralement range(a,b) permet ditrer sur la liste des entiers compris entre a (inclus) et b
(exclu).
Par exemple le programme suivant permet de calculer la moyenne des 100 premiers nombres entiers
impairs.
somme,n = 0,100
for x in range(n):
somme = somme + 2*x+1
moyenne = somme/n
Boucle non borne
Scratch propose un bloc rpter jusqu , Python propose plutt des boucles while (cest--
dire tant que ).
Le programme suivant permet par exemple de chercher lindice du premier terme dune suite
gomtrique suprieur ou gal 10000.
def indicePremierTerme(q,M):
u = 1
n = 0
while u < M:
u = u * q
n = n + 1
return n
Lappel indicePremierTerme(1.25,10000) renvoie par exemple 42.
Fonctions
Quelques exemples de fonctions ont dj t donns, dont la dfinition commence par le mot-cl def.
Prcisons quune fonction peut avoir un nombre quelconque darguments (on dit aussi paramtres).
Elle peut renvoyer zro, une ou plusieurs valeurs laide dune instruction return qui stoppe
lexcution de la fonction. Par exemple, voici comment renvoyer la moyenne et la variance dune liste
de nombres.

Les listes ne font pas lobjet dun enseignement spcifique en seconde, mais peuvent tre utilises
comme objets simples et pratiques. Une liste L scrit entre crochets, L = [2,3,5,7,11,13,17]
par exemple ; sa longueur est simplement len(L).
def moyenneVariance(L):
s,s2 = 0,0
for x in L:
s = s + x
s2 = s2 + x ** 2 # on note **2 le carr
# ici s est la somme et s2 la somme des carrs
n = len(L) # la longueur de la liste
return s/n, s2/n (s/n)**2 # la fonction renvoie deux valeurs
(m,v) = moyenneVariance([12,343,11,14,43,62])
Il existe une faon trs commode dcrire des fonctions sans nommage, comme en mathmatiques
quand on crit 2 3 + 5.On utilise en Python la notation lambda x : x*x - 3*x + 5.
Imaginons quon ait crit une fonction minimumLocal de recherche dun minimum dune fonction sur
un intervalle.
On pourra valuer minimumLocal(lambda x : x*x - 3*x + 5,0,6) sans avoir besoin de
dfinir et nommer une fonction par def
Le mode console
Il est important de distinguer trs clairement la conception des algorithmes et leur utilisation. Les
lves criront des fonctions qui pourront tre enregistres dans des fichiers, appels scripts ou
modules, quon peut dvelopper, enrichir et rutiliser lors de sances successives.
Ces modules peuvent tre excuts dans un mode console, afin de tester et mettre au point les
algorithmes et les programmes. Lexcution dun module comportant la dfinition dune fonction f ne
produit aucun affichage particulier dans la console, mme si la dfinition a t prise en compte : on
peut maintenant, dans la console, faire des appels du type f(2) et la console affiche la valeur
renvoye par la fonction.
On notera que les notions dentres-sorties (fonctions input et print) ne sont pas dveloppes
dans ce document : elles ne relvent pas de la pense algorithmique et laccent mis par le programme
sur la notion de fonction permet de sen librer compltement.
La copie dcran suivante montre, gauche, un module dont lexcution est lance par un clic sur le
bouton ; droite on voit la console, o on excute quelques instructions pour tester la correction du
module. Les commandes de la console sont annonces par linvite >>>. En revanche, le module est
un simple fichier texte, qui pourrait tre retravaill dans nimporte quel diteur de texte.

De Scratch Python
Les lves de seconde ont suivi au collge un enseignement d'algorithmique et de programmation,

dans le cadre des mathmatiques et de la technologie. En mathmatiques, laide de Scratch, ils ont
utilis des boucles, des instructions conditionnelles.
En classe de seconde, le passage de Scratch Python peut tre immdiat ou progressif, suivant les
choix pdagogiques de lenseignant. Les deux langages comportent, au-del des diffrences
videntes de forme, des similitudes qui facilitent la transition.
Voici un exemple : un trac gomtrique en Scratch, et son analogue en Python.
L'utilisation de la bibliothque turtle de Python permet d'crire un programme trs similaire.

import turtle
def figure():
turtle.hideturtle()
turtle.clear()
turtle.up()
turtle.setheading(0)
turtle.goto(0,100)
longueur = 40
for i in range(12):
triangle(longueur)
turtle.right(8)
longueur = longueur + 20
def triangle(cote):
turtle.down()
for i in range(3):
turtle.forward(cote)
turtle.left(120)
turtle.up()
Il suffit de taper figure() dans la console pour lancer l'excution.

Exemples de situations
Ce document est une ressource pour la formation des professeurs.

Il ne prtend aucunement prescrire telle ou telle pratique pdagogique dans les classes.
Il prsente quelques exemples de situations qui peuvent inspirer les professeurs. Il appartient
chaque enseignant, dans le cadre de sa libert pdagogique, de construire des activits mener en
classe, en sinspirant au besoin des situations dcrites dans ce document.
Les exemples proposs sont de niveaux de difficult diffrents, tant du point de vue mathmatique
que du point de vue algorithmique. Les concepts mathmatiques utiliss relvent du programme de
seconde ou des programmes du cycle terminal. Certains algorithmes proposs peuvent tre crits
diffremment. Certains peuvent tre simplifis, dautres peuvent donner lieu des prolongements.
Les modalits de mise en uvre peuvent tre varies : utilisation ponctuelle d'heures ddoubles
pour un travail sur machine, utilisation de tablettes ou classes mobiles, vido-projection en classe
entire, travail sur papier ou au tableau, intgration des sances daccompagnement personnalis,
mini-projets pouvant tre raliss en groupe
Statistiques descriptives
Cette situation peut donner lieu des activits en classe de seconde.
Les statistiques descriptives sont travailles depuis le cycle 4. Le tableur constitue un outil important,
mais le recours la programmation prsente deux grands intrts :
Comprendre et manipuler la dfinition des concepts : crer une fonction moyenne ncessite
d'avoir compris la dfinition de lindicateur.
Manipuler de grandes sries qui peuvent tre issues de donnes relles, et qui sont bien plus
facilement manipulables que sur un tableur.
Pour calculer la moyenne dune srie, on somme ses lments grce une boucle for x in
serie :
def moyenne(serie):
n = len(serie)
s = 0
for x in serie:
s = s + x
return s/n
Pour dterminer la mdiane, le plus simple est de commencer par trier les termes de la srie en ordre
croissant, grce linstruction serie.sort(), qui modifie la liste serie en la triant, et de choisir
ensuite le terme mdian, selon la parit de leffectif.
Quand on divise deux entiers a et b, a % b et a//b renvoient respectivement le reste et le quotient
dans la division euclidienne alors que a/b renvoie le quotient dcimal.
On rappelle que le symbole = est rserv laffectation, et doit tre distingu du symbole == qui
ralise le test dgalit.
Attention : en Python, on indexe partir de 0, donc serie[0] est le premier terme de la srie,
serie[1] le deuxime, etc.
def mediane(serie):
n = len(serie)
serie.sort()
if n%2 == 0:
return (serie[n//2]+serie[n//2 - 1])/2
else:
return serie[n//2]
Pour tirer au hasard une srie dentiers entre 1 et 50, on peut utiliser la fonction randint de la
bibliothque random. On commence par ouvrir la bibliothque par linstruction import random, lappel
de fonction est alors random.randint(1,50).
Sinspirant de lcriture mathmatique dun ensemble en comprhension, par exemple
{ 2 + 2, 0,15 },
Python propose une syntaxe utile pour la cration dune liste en comprhension :
[ k**2 + 1 for k in range(16) ].
On peut ainsi utiliser lexpression [random.randint(1,50) for i in range(1000)] pour crer
la liste simulant un chantillon de taille 1000 pour la loi uniforme sur 1,50.
On ouvre de mme le module de trac de la bibliothque matplotlib par linstruction import
matplotlib.pyplot as plt de sorte quon peut utiliser labrviation plt.hist pour la fonction
de trac dun histogramme. Le deuxime argument de cette fonction prcise le nombre de classes de
lhistogramme.
import matplotlib.pyplot as plt
import random
# on cre une srie de 1000 entiers alatoires entre 1 et 50
L = [random.randint(1,50) for i in range(1000)]
La commande plt.show() permet dafficher une figure, aprs quon a excut toutes les
commandes de trac quon souhaitait.
plt.hist(L,50) plt.hist(L,10)
plt.show() plt.show()
Algorithme dEuclide
L'arithmtique ne constitue pas une partie du programme de seconde en tant que telle, mais la
division euclidienne et les nombres premiers ont t rencontrs au cycle 4 du collge. Larithmtique
permet de faire travailler les lves sur les proprits des nombres et la logique, et de les entraner au
raisonnement travers lutilisation des nombres entiers. Les trois exemples qui suivent permettent
d'illustrer ces ides.
On considre deux entiers naturels non nuls et . Supposons par exemple .
On crit la division euclidienne : = + o le reste vrifie 0 < .
Si un entier divise la fois et , alors il divise galement et = .
Inversement si un entier divise la fois et , alors il divise galement = + et .
Autrement dit : les diviseurs communs et sont exactement les mmes que les diviseurs
communs et . Lide de lalgorithme est donc de remplacer le couple (, ) par le couple (, ) =
(, ) et ditrer jusqu ce que le reste soit nul : les diviseurs communs du couple de dpart sont les
diviseurs communs du couple obtenu chaque tape. Comme les diviseurs communs et 0 sont
les diviseurs de , le plus grand dentre eux, soit lui-mme, est le PGCD du couple de dpart.

Remarquons que si < , la division euclidienne scrit = 0 + de sorte que la premire tape
de la boucle intervertit et .
def euclide(a,b) :
assert(a>0 and b>0)
while b!=0:
a,b = b,a%b
# a%b est le reste dans la division euclidienne de a par b
return a
La boucle sarrte coup sr car la suite des deuximes lments des couples conscutifs est une
suite strictement dcroissante dentiers naturels.
On a utilis linstruction assert() qui permet de vrifier que les valeurs donnes en argument la
fonction vrifient bien les hypothses prvues. Dans le cas contraire, Python interrompra
immdiatement lexcution en affichant un message derreur.
Changement de base de numration
On se propose dcrire une fonction ecritureBinaire qui prend en argument un entier naturel n
non nul et qui renvoie la liste des bits de son criture en base 2, ainsi que la fonction rciproque
ecritureDecimale.
Par exemple, la liste des bits de lcriture binaire de 23 est [1,0,1,1,1] car 23 = 16 + 4 + 2 + 1 =
24 + 22 +21 + 20 .
Lcriture binaire de est [ , 1 , , 2 , 1 , 0 ] o chaque bit vaut 0 ou 1 quand on peut crire :

= =0 2 . Ainsi 0 = 1 si et seulement si est impair, et [ , 1 , , 2 , 1 ] est lcriture dcimale
du quotient entier de par 2.
On en dduit lcriture de la fonction ecritureBinaire. Linstruction L = [] cre une liste vide.
L.append(x) ajoute un lment x en fin de la liste L. Enfin L.reverse() retourne la liste.
def ecritureBinaire(n):
L = []
while n>0:
L.append(n%2) # n%2 est le reste dans la division par 2
n = n//2 # n//2 est le quotient
L.reverse()
return L
Lappel ecritureBinaire(23) renvoie la liste [1,0,1,1,1].
La fonction rciproque sobtient de faon analogue :
def ecritureDecimale(L):
n = 0
for x in L:
n = 2*n + x
return n
Lappel ecritureDecimale([1,0,1,1,1]) renvoie lentier 23.
Logarithme entier en base 2
Il sagit en fait de calculer le nombre de bits de lcriture binaire dun entier naturel non nul .
def nombreBits(n) :
l = 1
while n>1 :
n,l = n//2,l+1
return l
Lappel nombreBits(23) renvoie ainsi 5.
On peut pareillement calculer la somme des bits dun entier.
def sommeBits(n):
s=0
while n>0:
s = s + n%2
n = n//2
return s
Lappel sommeBits(23) renvoie ainsi 4.
Test de primalit
Soit un entier suprieur ou gal 2. Si nest pas premier, et si est son plus petit diviseur
suprieur ou gal 2, on peut crire = avec puisque on a choisi le plus petit diviseur ;
on constate alors que .
Pour tester si est premier, il suffit donc de tester sa divisibilit par les entiers plus petits ou gaux
sa racine carre.
On obtient le programme suivant en Python.
On a utilis linstruction assert(n>=2) pour vrifier lhypothse faite sur largument.
La fonction renvoie une valeur boolenne, cest--dire ou bien True ou bien False.
On remarque que ds quon trouve un diviseur d on peut renvoyer False : linstruction return
permet la fois de renvoyer le rsultat attendu et dinterrompre litration.
def estPremier(n):
assert(n>=2)
d = 2
while d*d <= n:
if n%d == 0:
return False
d = d +1
# on n'a trouv aucun diviseur
return True
Dcomposition en produit de facteurs premiers

En sinspirant de la fonction prcdente, on peut crire une fonction qui renvoie une liste de facteurs
premiers dont le produit est le nombre fourni en argument.
def factorisation(n):
L = []
d = 2
while n>1:
if n%d == 0:
# on a trouv un diviseur !
while n%d == 0:
# on le factorise autant que possible et
# on lajoute chaque fois dans la liste
L.append(d)
n = n//d
d = d + 1
return L
Lindentation est ici tout fait cruciale.

Lappel factorisation(2018) renvoie [2, 1009] alors que lappel factorisation(2016)
renvoie [2, 2, 2, 2, 2, 3, 3, 7]. Un exercice un peu plus difficile consiste renvoyer une
liste de couples (, ) o est lexposant du facteur premier dans la dcomposition.
factorisationPlus(2016) doit renvoyer [(2,5),(3,2),(7,1)].
Longueur dun arc de courbe

Les fonctions et leur reprsentation constituent un des lments essentiels de la culture
mathmatique que les lves doivent acqurir au lyce. L'activit ici propose constitue un dtour
original pour faire travailler ces notions, en dehors des classiques tracs de courbe. Elle constitue
aussi une ouverture vers les problmes d'approximation numrique.
On considre une fonction continment drivable dfinie sur un intervalle [, ], et on cherche une
valeur approche de la longueur de la courbe reprsentative de .

Pour cela, on subdivise lintervalle en petits intervalles [ , +1 ] de mme longueur +1 = ,

avec 0 = , = . Notons le point de coordonnes ( , ( )) de la courbe.
On approche alors sur [ , +1 ] la courbe par le segment [ +1 ].
On prend comme valeur approche de la somme des longueurs de ces segments. Quand tend
vers linfini, on peut prouver que la somme de ces longueurs tend vers .
from math import *
def distance(x1,y1,x2,y2):
return sqrt((x1-x2)**2 + (y1-y2)**2)
def longueurCourbe(f,a,b,n):
longueur = 0
x1,y1 = a,f(a)
h = (b-a)/n
for i in range(n):
x2 = x1 + h
y2 = f(x2)
longueur = longueur + distance(x1,y1,x2,y2)
x1,y1 = x2,y2
return longueur
La commande from math import * permet dutiliser de faon aise les fonctions mathmatiques
usuelles, comme la racine carre (sqrt), le cosinus (cos), etc. La commande help(math)
permet davoir la liste des fonctions disponibles avec leur description.
Si on avait seulement ouvert la bibliothque math avec la commande import math, il faudrait crire
math.sqrt au lieu de sqrt.
On remarque que Python admet sans difficult de prendre en argument une fonction.

On peut tester la fonction sur le quart de cercle unit, de longueur , en utilisant la notation
2
lambda x : expression pour dnoter une fonction sans la nommer.
Lappel 2*longueurCourbe(lambda x: sqrt(1-x**2),0,1,10) renvoie
3.1415832833677633, alors que lappel 2*longueurCourbe(lambda x: sqrt(1-
x**2),0,1,1000) renvoie 3.141591493294789.
Rsolution approche dune quation par dichotomie

La mthode de dichotomie constitue un procd dont la comprhension et la mise en uvre peuvent
tre particulirement dlicates pour les lves. Le dtour par l'algorithmique permet de faire
fonctionner la mthode et de l'observer en acte. Cette activit peut se dcliner de faons multiples
pour les lves. Il peut tre simplement question de relier les blocs d'instructions aux lments
correspondant dans le texte qui dcrit l'algorithme.
Soit une fonction continue sur un intervalle .
Soit et deux points de tels que < et () () < 0.
On sait quil existe au moins une solution de lquation () = 0 sur lintervalle lintervalle [, ]. Le
+
principe de lalgorithme de dichotomie consiste considrer le point = . Si () () 0, on
2
sait quil existe une solution sur lintervalle [, ]. Sinon, on a () () 0, et il existe une solution
sur lintervalle [, ]. Ainsi, chaque tape on passe dun intervalle contenant une solution un
intervalle de longueur moiti contenant une solution.
On itre le procd jusqu obtenir un intervalle de longueur infrieure la prcision requise.
def dichotomie(f,a,b,epsilon=0.0001):
assert(f(a)*f(b) < 0 and a < b)
while b-a > epsilon:
c = (a+b)/2
if f(a)*f(c) <= 0:
a,b = a,c
else:
a,b = c,b
return (a+b)/2
La commande assert() permet de sassurer que lon est bien dans les hypothses requises.
On remarque que dans la dfinition de la fonction, une valeur par dfaut est fournie pour epsilon.
Cela signifie que lappel dichotomie(f,a,b) est quivalent lappel
dichotomie(f,a,b,0.0001). Pour imposer une prcision diffrente de la valeur par dfaut, il suffit
de la prciser dichotomie(f,a,b,0.0000001) par exemple.
Aprs avoir ouvert la bibliothque math par la commande from math import * on peut par
exemple demander dichotomie(cos,0,2,0.01) qui renvoie 1.57421875 alors que lappel
dichotomie(cos,0,2) utilise la valeur par dfaut de epsilon et renvoie 1.570770263671875.
Un ordinateur ne travaille pas avec des nombres rels, mais avec des flottants, cest--dire un sous-
ensemble des nombres dcimaux dont la prcision est limite par des contraintes lies au codage en
mmoire.
Cest ainsi quen Python, le test dgalit 3+10**(-16)==3 svalue en True alors que le test
3+10**(-15)==3 svalue en False. On retiendra quil faut viter de tester lgalit entre deux
flottants, et prfrer la recherche dune prcision donne. En revanche, bien sr, il ny a aucun
problme comparer deux nombres entiers.
Stabilisation des frquences
En probabilits, on est amen utiliser des gnrateurs pseudo-alatoires, proposs par la

bibliothque random, quon ouvre avec la commande import random.
Les fonctions dusage le plus frquent sont :
random.random() qui renvoie un nombre rel (pseudo)-alatoire de lintervalle semi-ouvert
[0,1[ ;
random.randint(a,b) qui renvoie un nombre entier (pseudo)-alatoire compris entre a et
b (bornes incluses) ;
random.choice(L) qui renvoie un lment tir au sort de la liste L.

Considrons lexprience alatoire qui consiste jeter un d quilibr et dfinir ainsi la variable
alatoire : si le d donne 1, = 1; si le d donne 5 ou 6, = 4 ; sinon = 2.
def experience():
de = random.randint(1,6)
# on tire au hasard un nombre entier parmi 1,2,3,4,5,6
if de < 2:
X = 1
elif de < 5:
X = 2
else:
X = 4
return X
On souhaite observer la moyenne des valeurs prises par la variable alatoire sur un nombre
quelconque dexpriences, et plus prcisment lvolution de cette moyenne en fonction du nombre
dexpriences.
On utilise la bibliothque matplotlib.pyplot pour donner une reprsentation graphique de cette
volution. Il est pratique de louvrir en lui donnant un nom abrg, par la commande import
matplotlib.pyplot as plt.
Les diffrentes commandes graphiques travaillent sur une mme figure, quon fait apparatre par
linstruction plt.show(). On peut ainsi tracer une courbe, dessiner une grille, ajouter une lgende,
etc. sur une mme figure.
def evolutionMoyenne(experience,nExperiences):
s = experience()
n = 1
L = [s] # moyenne sur 1 exprience
while n < nExperiences:
n = n+1
s = s + experience()
L.append(s/n) # on ajoute la moyenne sur n expriences
plt.plot(list(range(1,nExperiences+1)),L,'b.')
plt.plot([1,nExperiences],[2.5, 2.5],'r-')
plt.grid()
plt.show()
Linstruction plt.plot(listeX,listeY,motif)
reprsente graphiquement des points dont la liste
des abscisses est listeX, la liste des ordonnes
listeY. Largument motif permet de prciser la
couleur (b pour bleu, r pour rouge) et le type de
trac (. pour des points isols, - pour une ligne
continue).
Ainsi on a trac en rouge un segment horizontal qui
correspond la valeur autour de laquelle se stabilise
la moyenne : cest lesprance, gale 2.5, de la
variable alatoire .
Cest ainsi que lexcution de la commande
evolutionMoyenne(experience,1000) permet
dobtenir le graphique ci-contre (videmment,
chaque appel on aura un rsultat lgrement diffrent car les tirages alatoires seront diffrents, mais
on observera la stabilisation de la moyenne autour de lesprance).

Aiguille de Buffon
On considre lexprience consistant jeter une aiguille sur un parquet et observer si laiguille
traverse la frontire entre deux lattes du parquet.
Dans notre modle, les lattes seront considres comme des bandes parallles de largeur unit, et on
repre le plan de sorte que les frontires des lattes sont les droites dquations = , o est un
entier relatif. Laiguille est de longueur .
On tire au hasard la position dune extrmit de laiguille, obtenant des coordonnes (, ). En fait
na aucune importance dans notre modle. Pour lordonne, on peut se ramener tirer dans
lintervalle [0,1[, la situation tant invariante par translation de vecteur (0, ) pour tout entier relatif .
Une fois choisie cette extrmit de laiguille, il reste dterminer langle que fait laiguille avec la

direction (). Cet angle sera tir au hasard dans lintervalle [ , [ laide de lexpression
2 2
random.random()*pi - pi/2.
Lordonne de la deuxime extrmit de laiguille sera alors = + sin .
Laiguille traverse la frontire entre deux lattes si et seulement si les parties entires de et sont
distinctes.
La fonction partie entire est en Python la fonction floor de la bibliothque math.
On crit donc la fonction suivante pour modliser lexprience.
def buffon(l):
y1 = random.random()
theta = random.random()*pi pi/2
y2 = y1 + l*sin(theta)
if floor(y1) != floor(y2):
return 1
else:
return 0
En Python, le test dgalit scrit == et le test contraire !=.
On peut vrifier la stabilisation vers la probabilit que laiguille traverse la frontire entre deux lattes en
utilisant la fonction evolutionMoyenne prcdente.
La notation lambda : buffon(0.7) permet de reprsenter une fonction sans argument, requise par
evolutionMoyenne.
Lappel evolutionMoyenne(lambda : buffon(0.7),1000) produit la figure suivante.

Voici les figures obtenues avec des longueurs daiguille respectivement gales 1 et 2.5.
l=1 l=2.5
On peut chercher tudier comment la probabilit autour de laquelle se stabilisent les frquences de
succs dpend de la longueur de laiguille.
Pour cela on va identifier la probabilit avec la frquence au bout de 5000 expriences.
def probaBuffon(l):
s = 0
for i in range(5000):
s = s + buffon(l)
return s/5000
On peut alors taper les lignes suivantes dans la console :
x = [t/100 for t in range(1,300)]
y = [probaBuffon(t) for t in x]
plt.plot(x,y,'r.')
plt.grid()
plt.show()
et on obtient la figure suivante.
On observe que la probabilit dpend linairement de tant que 1, puis que la courbe change
daspect, une asymptote dquation = 1 apparaissant : en effet, quand la longueur de laiguille tend
vers linfini, il est clair que la probabilit quelle coupe la frontire entre deux lattes tend vers 1.

2
On peut dmontrer que le coefficient directeur de la partie linaire est et quensuite la probabilit

vaut
2 1
1 (arcsin ( 2 1)) ,

mais cest videmment plus difficile.
Intervalle de fluctuation dune frquence au seuil de 95 %

On considre un chantillon de taille constitu des rsultats de rptitions indpendantes de la
mme exprience, qui a une probabilit de succs, et on relve la frquence du succs de
lexprience.
def echantillon(p,n):
'''simule n rptitions indpendantes d'une exprience
dont le succs est de probabilit p,
et renvoie la frquence des expriences russies'''
succes = 0
for i in range(n):
if random.random() <= p:
succes = succes+1
f = succes /n
return f
On a utilis ici un type particulier de commentaire, '''commentaire''' qui peut stendre sur
plusieurs lignes, qui suit immdiatement la ligne def () : et qui permet dexpliquer lobjectif
dune fonction. Ce commentaire sert daide pour lutilisateur, qui peut le retrouver en valuant
help(echantillon).
Une valuation echantillon(0.2,10000) peut renvoyer 0.1981, par exemple (le rsultat est
videmment alatoire).
Le programme de mathmatiques invite observer avec quelle probabilit la frquence se retrouve
1 1
dans lintervalle de fluctuation [ , + ].

def fluctuation(p,n):
'''renvoie (a,b) bornes de l'intervalle de fluctuation
au seuil de 95 % pour des chantillons de taille n
et une proportion p du caractre'''
return(p-1/sqrt(n),p+1/sqrt(n))
On peut crire la fonction suivante pour en avoir un aperu graphique.
def grapheFluctuation(p,n,nbEchantillons):
a,b = fluctuation(p,n)
L = []
for i in range(nbEchantillons):
L.append(echantillon(p,n))
plt.plot(list(range(0,nbEchantillons)),L,'b.')
plt.grid()
plt.plot([0,nbEchantillons-1],[a,a],'r-')
plt.plot([0,nbEchantillons-1],[b,b],'r-')
plt.show()
Ici p est la probabilit de succs dune exprience, n est la taille de chaque chantillon et
nbEchantillons le nombre dchantillons sur lesquels on mne lobservation.
On trace en rouge les horizontales correspondant aux bornes de lintervalle de fluctuation considr,
et chaque point bleu reprsente la frquence obtenue pour un chantillon.

Voici ce que produit lappel grapheFluctuation(0.4,100,1000).
On peut aussi choisir dvaluer la proportion des chantillons tels que la frquence observe est
dans lintervalle de fluctuation en fonction du nombre dchantillons simuls.
On observe que cette proportion est rapidement suprieure 0,95.
Cest ce que fait la fonction suivante, qui utilise un compteur dchantillons corrects, cest--dire tels
que la frquence correspondante est dans lintervalle souhait.
def grapheProportionDansIntervalleFluctuation(p,n,nbEchantillons):
a,b = fluctuation(p,n)
L = []
corrects = 0
for i in range(1,nbEchantillons):
f = echantillon(p,n)
if f >= a and f <= b:
corrects = corrects + 1
proportion = corrects/i
L.append(corrects/i)
plt.plot(list(range(1,nbEchantillons)),L,'b.')
plt.grid()
plt.show()
Voici le rsultat de lappel grapheProportionDansIntervalleFluctuation(0.4,100,10000)

Casser un bton

On considre la situation suivante : on prend un bton, quon casse en 3 morceaux. Lexprience est
russie si les 3 morceaux constituent les cts dun triangle.
La condition vrifier pour trois longueurs , , est la conjonction :
+ et + et + .
def correct(a,b,c):
return a+b>=c and b+c>=a and c+a>=b
On peut considrer que le bton a une longueur unit.
Il y a plusieurs faons de procder : on tire au hasard deux rels de ]0,1[, on note le plus petit et le
plus grand. et y sont les abscisses des points de casse. Les trois segments sont alors de longueurs
, et 1 .
def casseBaton1():
x = random.random()
y = random.random()
if x > y:
x,y = y,x # permet dchanger les valeurs de x et y
return correct(x,y-x,1-y)
La fonction casseBaton1 renvoie True si lexprience est russie et False dans le cas contraire.
La fonction suivante permet dobserver la stabilisation de la frquence des succs vers une probabilit
1
gale (cest un exercice intressant de le dmontrer).
4
def chercheProbabilite(experience,nExperiences):
n,succes = 0,0
L = []
while n < nExperiences:
n = n+1
if experience():
succes = succes+1
L.append(succes/n)
plt.plot(list(range(1,nExperiences+1)),L,'b.')
plt.grid()
plt.show()
Lappel chercheProbabilite(casseBaton1,10000) produit la figure suivante.

Considrons un autre modle de lexprience : on casse le bton une premire fois (en tirant au
hasard une abscisse ), puis on casse le plus gros morceau (en tirant nouveau au hasard labscisse
de casse).
def casseBaton2():
x = random.random()
if x > 1/2: # le grand morceau est gauche
x,y = x * random.random(), x
else: # le grand morceau est droite
x,y = x, x + (1-x) * random.random()
return correct(x,y-x,1-y)
Lappel chercheProbabilite(casseBaton2,10000) produit la figure suivante.
Quelle est la probabilit de succs ?

On pourrait encore envisager un autre modle dexprience : on casse le bton une premire fois,
puis on choisit au hasard lun ou lautre morceau, quon casse son tour.
Marche alatoire une dimension
On considre un mobile qui se dplace sur un axe des tops dhorloge. Son abscisse initiale est
= 0. chaque top dhorloge, son abscisse augmente ou diminue dune unit, de faon
quiprobable.
On peut simuler ce comportement ainsi :
def marche(nbPas):
'''renvoie l'abscisse d'arrive, partant de 0,
aprs nbPas pas de +1 ou -1'''
x = 0
for i in range(nbPas):
if random.random()<0.5:
x = x + 1
else:
x = x - 1
return x
On peut sintresser la position du mobile aprs un certain nombre de pas. Chaque simulation est
susceptible de donner une position darrive diffrente. Pour mettre en vidence la distribution de
probabilit de la position darrive, on simule un grand nombre de marches, et on trace lhistogramme
correspondant des positions darrive.
def histogrammeMarche1d(nbPas,nbMarches):
L = []
for i in range(nbMarches):
L.append(marche(nbPas))
plt.hist(L,100)
plt.show()

On obtient par exemple la figure suivante par lappel histogrammeMarche1d(100,3000).
On peut aussi sintresser au nombre de retours la position de dpart lors dune marche.
def nbRetoursOrigine(nbPas):
'''nombre de retours l'origine aprs une marche'''
x,r = 0,0
for i in range(nbPas):
if random.random()<0.5:
x = x+1
else:
x = x-1
if x==0:
r = r+1
return r
En utilisant la fonction evolutionMoyenne introduite dans lactivit stabilisation des frquences ,
on crit, aprs avoir fix un nombre de pas pour chaque marche, evolutionMoyenne(lambda :
nbRetoursOrigine(nbPas), 3000) pour estimer lesprance du nombre de retours lorigine.
On obtient les figures suivantes.
pour des marches de 100 pas pour des marches de 400 pas
Cela donne envie de chercher comment volue lesprance du nombre de retours lorigine dune
marche alatoire en fonction du nombre de pas de la marche.

On approche pour cela lesprance la moyenne du nombre de retours sur 3000 marches, ce qui
amne crire les fonctions suivantes.
def esperanceNbRetours(nbPas):
n = 0
n = n+nbRetoursOrigine(nbPas)
return n/3000
def evolutionNbRetours(nbPasMaximum):
x,L = [],[]
for nbPas in range(1,nbPasMaximum+1):
x.append(nbPas)
L.append(esperanceNbRetours(nbPas))
plt.plot(x,L,'b.')
plt.grid()
plt.show()
Lappel evolutionNbRetours(200) produit la figure suivante.
Urnes de Poly
On considre une urne. On y introduit au dpart boules rouges et boules bleues. Les boules sont
indiscernables au toucher. chaque tape, on tire au hasard une boule, on la remet dans l'urne en
ajoutant une nouvelle boule de mme couleur. On cherche connatre la rpartition des couleurs au
cours du temps, selon les valeurs initiales de et .
La simulation de plusieurs tapes se programme aisment. On introduit une liste L qui contiendra les
proportions successives de boules rouges (la proportion de boules bleues tant toujours le
complment 1).
def urnesPolya(r,b,etapes):
assert(r+b >= 1) # il faut au moins une boule au dpart !
L = [r/(r+b)]
for i in range(etapes):
n = random.randint(1,r+b)
if n <= r:
r,b = r+1,b
else:
r,b = r,b+1
L.append(r/(r+b))
x = list(range(0,etapes+1))
plt.plot(x,L,'r-')
plt.grid()
plt.show()
On a utilis la fonction randint de la bibliothque random : random.randint(a,b) renvoie un
entier alatoire de lintervalle ferm dentiers , . Pour chaque tirage, on imagine avoir numrot les
boules, dabord les rouges, puis les bleues. On choisit un numro de boule au hasard : sil est plus
petit que , cest quon a choisi une boule rouge, sinon cest une boule bleue.
Voil plusieurs figures produites par le mme appel urnesPolya(1,1,1000).
En partant de la mme proportion initiale, en loccurrence 50 %, on observe une stabilisation vers des
proportions trs diffrentes : environ 30 %, environ 60 %, environ 90 %.
On aimerait avoir une ide de la distribution des proportions limites. Pour cela on va considrer la
proportion obtenue au bout de 1000 tirages et approcher ainsi la proportion limite. On crit donc la
fonction suivante.
def uneExperiencePolya(r,b):
if random.randint(1,r+b) <= r:
r,b = r+1,b
else:
r,b = r,b+1
return r/(r+b)
On peut maintenant raliser plusieurs expriences et observer lhistogramme des proportions limites
obtenues.
def experiencesPolya(r,b,nombre):
L = []
for i in range(nombre):
L.append(uneExperiencePolya(r,b))
plt.hist(L,10)
plt.show()
Lappel experiencesPolya(1,1,1000) produit la figure suivante.
On peut dmontrer que, partant dune boule rouge et une boule bleue, toutes les proportions limites
sont quiprobables. Mais il ne faudrait pas croire que cela soit vrai quand on part par exemple de
5 boules rouges et 5 boules bleues, ce qui fait pourtant la mme proportion de 50 %.

En effet, lappel experiencesPolya(5,5,1000) produit une figure trs diffrente.
Moins inattendue peut-tre, voici la figure obtenue en partant dune distribution non quitable : lappel
experiencesPolya(1,5,1000) produit la figure suivante.
Rfraction dun rayon lumineux

On considre deux milieux d'indices de rfraction 1 et 2 , un point (1 , 1 ) dans le premier milieu, un
point (2 , 2 ) dans le deuxime. Les deux milieux sont spars par une courbe dont on connat une
quation de la forme = ().
On cherche le point (, ()) de la sparatrice par lequel passe un rayon lumineux allant de .
Le principe de Fermat indique qu'il ralise le minimum (local) du chemin optique
() = 1 + 2
Considrons une fonction quon va supposer pour simplifier continue et unimodale sur un
intervalle [, ]: elle atteint un minimum labscisse , elle dcrot strictement sur [, ] et crot
strictement sur [, ].
On se donne une abscisse 0 de lintervalle [, ] et une prcision . On cherche dterminer une
valeur approche prs de labscisse du minimum de .
On choisit un pas > 0 et on value (0 ). Si cette valeur est infrieure (0 ), on est sr que
< 0 et on peut recommencer en remplaant 0 par 0 . On arrive finalement, force de reculer,
une valeur 0 telle que (0 ) > (0 ). On sait alors que 0 < 0 .
Si on a pu se dplacer vers la gauche, on a atteint une valeur approche de prs.
Sinon, il faut aller vers la droite en comparant (0 ) (0 + ).
Remarquons que pour une valeur fixe de , on se dplace soit vers la gauche, soit vers la droite.

Pour garantir une prcision , il suffit ditrer le procd en remplaant par jusqu ce quon ait
10
bien .

Voici le programme correspondant.
def chercheMinimum(phi,x,h,precision=0.00001):
while h > precision:
while phi(x-h) < phi(x):
x = x - h
while phi(x+h) < phi(x):
x = x + h
h = h/10
return x
Le droulement de cet algorithme est tel que, pour chaque valeur de , une seule des deux boucles
while intrieures est rellement active.
On a utilis une valeur par dfaut de la prcision requise.
Le calcul du point de la sparatrice par lequel passe le rayon rfract est maintenant facile crire.
return sqrt((x1-x2)**2+(y1-y2)**2)
def refraction(f,x1,y1,x2,y2,n1,n2):
assert(f(x1)>y1 and f(x2)<y2)
phi = lambda x:
n1*distance(x1,y1,x,f(x))+n2*distance(x,f(x),x2,y2)
x = chercheMinimum(phi,(x1+x2)/2,0.1)
return (x,f(x))
Testons diffrents types de sparatrice, en faisant un dessin.
Envisageons dabord le cas dune sparatrice rectiligne.
separatrice = lambda x: 1-2*x
# on trace les points de dpart et darrive
plt.plot([0,1],[0,1],'bo') # gros points bleus
# trac de la sparatrice elle-mme
vx = [t/100 for t in range(-5,105)]
plt.plot(vx,[separatrice(t) for t in vx],'g-') # en vert (green)
# on trace ensuite le rayon lumineux (ligne brise)
(x,y) = refraction(separatrice, 0,0, 1,1, 2.5,1)
plt.plot([0,x,1],[0,y,1],'r-') # en rouge (red)
plt.show()

Passons maintenant un autre type de sparatrice.
separatrice = lambda x: cos(5*x)
plt.plot([0,1],[0,1],'bo')
vx = [t/100 for t in range(-5,105)]
plt.plot(vx,[separatrice(t) for t in vx],'g-')
(x,y) = refraction(separatrice, 0,0, 1,1, 2.5,1)
plt.plot([0,x,1],[0,y,1],'r-')
plt.show()
Recherche dun minimum par une autre mthode

Considrons une fonction continue et unimodale sur un intervalle [, ], qui atteint un minimum
labscisse , dcrot strictement sur [, ] et crot strictement sur [, ]. On cherche dterminer
une prcision fixe.
Lide de lalgorithme est la suivante : on suppose donn un triplet (, , ) qui vrifie les trois
conditions suivantes :
<<
() > ()
() < ()
Dans ces conditions on est certain que ], [. On va remplacer le triplet (, , ) par un nouveau
triplet (, , ) qui vrifie galement les trois conditions ci-dessus et tel que < . En itrant
suffisamment le procd, on espre avoir < et ainsi obtenir une valeur approche satisfaisante
de .
+ +
Soit = et = .
2 2
Cas 1 : si () > () et () < (), on peut poser ( , , ) = (, , ).

La fonction tant unimodale, on ne peut pas avoir () < (). Donc dans le cas contraire du cas 1,
on a () > () > ().
On vrifiera que lon se retrouve ncessairement dans lun ou lautre de ces trois cas.

La programmation en Python ne pose pas de problme particulier : ici, cest ltude mathmatique
systmatique des diffrents cas qui est difficile.
def chercheMinimum(phi,a,c,b,epsilon=0.0001):
assert(phi(a)>phi(c) and phi(c)<phi(b) and a<c<b)
while b-a > epsilon:
u = (a+c)/2
v = (c+b)/2
if phi(a)>phi(u) and phi(u)<phi(c):
a,c,b = a,u,c
elif phi(u)>phi(c) and phi(c)<phi(v):
a,c,b = u,c,v
elif phi(c)>phi(v) and phi(v)<phi(b):
a,c,b = c,v,b
return c
-4
Lappel chercheMinimum(cos,2,3,4) renvoie 3.1416015625 (prcision par dfaut de 10 ).
Lappel chercheMinimum(cos,2,3,4,0.0000001) renvoie 3.141592651605606.
Dtermination des coordonnes des sommets dun triangle dont on

connat les longueurs des trois cts
On se donne trois longueurs , , vrifiant les conditions + > , + > et + > .
On sait quil existe des triangles tels que les longueurs de ses cts soient = , =
et = . Il est facile de construire un tel triangle laide de GeoGebra, mais il est plus difficile de
dterminer les coordonnes des trois sommets.
On conviendra que, dans un repre bien choisi, est de coordonnes (0,0), est de coordonnes
(, 0), et est de coordonnes (, ), avec > 0. Il sagit dcrire une fonction qui renvoie le couple
de coordonnes (, ) pour les arguments (, , ) pour une prcision fixe.
On va procder par amliorations successives.
On renverra les coordonnes du point candidat quand on aura obtenu
| | + | | .
On part dun point plac un peu au hasard (en fait on a choisi ici de le placer de sorte que soit
un triangle quilatral), et chaque tape de lalgorithme, on va rapprocher le point de sa position
idale.
On commence par calculer la longueur = . Sur la demi-droite [[ on peut placer le point tel
que = , la distance dsire. On dplace alors le point vers le point , par exemple en prenant
9
limage de par lhomothtie de centre et de rapport (on pourrait choisir un autre rapport dans
10
lintervalle ]0,1[) obtenant ainsi une nouvelle position .
On fait alors de mme de lautre ct, en posant = , en choisissant sur la demi-droite [ [ tel
que = . On dplace alors le point vers le point , en prenant son image par lhomothtie de
9
centre et de rapport obtenant ainsi une nouvelle position .
10
On itre le procd jusqu obtenir la prcision requise.

On crit tout dabord une fonction qui renvoie les coordonnes de en fonction des coordonnes de
, des coordonnes de et de la distance . La mme fonction permettra de dterminer les
coordonnes de en utilisant les arguments correspondants.
9 9 1
On a :
=
et
=
= (1 )
donc finalement
= (9 + )
.
10 10 10

Ces formules se traduisent immdiatement dans le programme Python ci-dessous.
from math import *
import matplotlib.pyplot as plt
return sqrt((x1-x2)**2 + (y1-y2)**2)
def deplacement(xA,yA,xC,yC,b):
l = distance(xA,yA,xC,yC)
k = (9+b/l)/10
x = xA + k * (xC-xA)
y = yA + k * (yC-yA)
return (x,y)
On crit alors la fonction qui renvoie la position des trois points , , pour une prcision donne.
def troisLongueurs(a,b,c,epsilon):
assert(a+b>c and b+c>a and c+a>b)
xA,yA = 0,0
xB,yB = c,0
# position de dpart de C
xC,yC = c/2,c*sqrt(3)/2
while abs(distance(xA,yA,xC,yC) - b) +
abs(distance(xB,yB,xC,yC) - a) > epsilon:
xC,yC = deplacement(xA,yA,xC,yC,b)
xC,yC = deplacement(xB,yB,xC,yC,a)
return((xA,yA),(xB,yB),(xC,yC))
(Remarque la commande while doit tre crite sur une seule ligne, on la coupe pour des raisons
de lisibilit.)
On rcrit cette fonction pour raliser en mme temps la figure et mettre en vidence les
amliorations successives de la position du point .
def troisLongueursGraphe(a,b,c,epsilon):
assert(a+b>c and b+c>a and c+a>b)
xA,yA = 0,0
xB,yB = c,0
plt.axis('equal') # pour utiliser un repre orthonorm
plt.plot([xA,xB],[yA,yB],'r-') # AB en rouge
plt.plot([xA],[yA],'ro') # gros point A rouge
plt.plot([xB],[yB],'ro') # gros point B rouge
# position de dpart de C
xC,yC = c/2,c*sqrt(3)/2
while abs(distance(xA,yA,xC,yC) - b) +
abs(distance(xB,yB,xC,yC) - a) > epsilon:
plt.plot([xC],[yC],'b.') # point C temporaire bleu
xC,yC = deplacement(xA,yA,xC,yC,b)
xC,yC = deplacement(xB,yB,xC,yC,a)
plt.plot([xA,xC,xB],[yA,yC,yB],'r-') # AC et CB en rouge
plt.plot([xC],[yC],'ro') # gros point C final
plt.show()
return((xA,yA),(xB,yB),(xC,yC))

La figure suivante montre quelques excutions de cette fonction (on ne montre que les graphiques
produits, mais pas les coordonnes calcules).
troisLongueursGraphe(3,4,5,0.00001) troisLongueursGraphe(4,4,5,0.00001)
troisLongueursGraphe(8,5,5,0.00001) troisLongueursGraphe(3,7,5,0.00001)

Annexe
Installation de Python 3.6.x
Sur ordinateur
Le plus simple est sans doute dinstaller Python 3.6.x depuis le site de rfrence : linstallation offre un
environnement de programmation un peu spartiate mais efficace, nomm IDLE. On peut ajouter les
bibliothques de son choix, comme matplotlib par exemple, en tapant dans un terminal la commande
pip install matplotlib.
On peut prfrer la distribution pyzo, qui offre un environnement de programmation plus riche, nomm
Conda, et qui prinstalle la plupart des bibliothques usuelles. Les autres peuvent sinstaller en tapant
directement dans la console de pyzo la commande conda install matplotlib (par exemple).
Une alternative est dinstaller Jupyter, qui permet de travailler dans un navigateur internet.
Toutes ces distributions sont gratuites et libres.
Sur une tablette Android
Il existe plusieurs applications disponibles sur la boutique GooglePlay, dont certaines sont gratuites.
Une application souvent utilise est QPython3.
Sur une tablette iOS
Il existe plusieurs applications disponibles sur AppStore, dont certaines sont gratuites.
Lapplication Pythoni3 est gratuite et rpond aux besoins. Lapplication Pythonista3 cote une dizaine
deuros mais est certainement une des plus pratiques.


Algorithmique Et Programmation 787733

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algorithmique Et Programmation 787733

Uploaded by

Copyright:

Available Formats

duscol

Ressources pour le lyce

Ministre de lEducation Nationale Juin

La circulaire n 2017-082 du 2 mai 2017 apporte des amnagements au programme de

Ministre de lEducation Nationale 1

Quelques concepts importants

Affectation dune variable

La ressource daccompagnement du thme Algorithmique et programmation du programme de

Ministre de lEducation Nationale 2

Ministre de lEducation Nationale 3

Boucle non borne

Ministre de lEducation Nationale 4

Ministre de lEducation Nationale 5

Les lves de seconde ont suivi au collge un enseignement d'algorithmique et de programmation,

L'utilisation de la bibliothque turtle de Python permet d'crire un programme trs similaire.

Il suffit de taper figure() dans la console pour lancer l'excution.

Ministre de lEducation Nationale 6

Ce document est une ressource pour la formation des professeurs.

Ministre de lEducation Nationale 8

Changement de base de numration

Logarithme entier en base 2

Dcomposition en produit de facteurs premiers

Ministre de lEducation Nationale 10

Longueur dun arc de courbe

Cette situation peut donner lieu des activits en classe de seconde.

Rsolution approche dune quation par dichotomie

Cette situation peut donner lieu des activits en classe de seconde.

Stabilisation des frquences

En probabilits, on est amen utiliser des gnrateurs pseudo-alatoires, proposs par la

Ministre de lEducation Nationale 12

Ministre de lEducation Nationale 13

Ministre de lEducation Nationale 14

Ministre de lEducation Nationale 15

Intervalle de fluctuation dune frquence au seuil de 95 %

Ministre de lEducation Nationale 16

Ministre de lEducation Nationale 17

Cette situation peut donner lieu des activits en classe de seconde.

Ministre de lEducation Nationale 18

Quelle est la probabilit de succs ?

Marche alatoire une dimension

Ministre de lEducation Nationale 19

Ministre de lEducation Nationale 20

Ministre de lEducation Nationale 22

Rfraction dun rayon lumineux

Ministre de lEducation Nationale 23

Ministre de lEducation Nationale 24

Recherche dun minimum par une autre mthode

Cas 1 : si () > () et () < (), on peut poser ( , , ) = (, , ).

Ministre de lEducation Nationale 25

Dtermination des coordonnes des sommets dun triangle dont on

On itre le procd jusqu obtenir la prcision requise.

Ministre de lEducation Nationale 26

Ministre de lEducation Nationale 27

Ministre de lEducation Nationale 28

Sur une tablette Android

Sur une tablette iOS

Ministre de lEducation Nationale 29

You might also like