Barbazo Cahier DAlgo Mathématiques Terminales Spécialité Corrigés

le
SPÉCIALITÉ
PROGRAMME 2020 C O L L E C T I O N B A R B A Z O
CAHIER d’ALGO
Algorithmique
et programmation en Python
Sous la direction d’Éric Barbazo
Fanny Plassin
Nathalie Teulié
Sommaire
Introduction Découvrir l’algorithmique et la programmation ................... 4
PARTIE 1 Démarrage
1 Variables, fonctions et instruction conditionnelle ...................................................... 8
2 Boucles bornées et non bornées...................................................................................... 10
3 Listes ......................................................................................................................................... 12
PARTIE 2 Entraînement et TP
1 Fonctions de référence : logarithme et exponentielle............................................... 14
2 Dénombrement et permutation ........................................................................................ 16
TP Algèbre Dénombrements................................................................................................... 18
3 Suites et limites ..................................................................................................................... 20
TP Suites numériques Suites, limites et recherche de seuils ......................................... 22
TP Suites numériques Approximation de ln(2)..................................................................... 24
4 Méthode de la sécante et de Newton .............................................................................. 26
TP Logarithme Algorithme de Briggs ................................................................................... 28
TP Équation différentielle Méthode d’Euler .......................................................................... 30
5 Calcul approché d’intégrales (rectangles, trapèzes) ................................................. 32
TP Probabilités Méthode de Monte Carlo ............................................................................ 34
6 Planche de Galton et simulation d’une variable aléatoire binomiale................... 36
TP Probabilités Marche aléatoire .......................................................................................... 38
© Hachette Livre 2020,

58 rue Jean Bleuzen, CS 700007, 92178 Vanves Cedex.
www.hachette-education.com
ISBN 978-2-01-786623-7
450 g éq. CO2
Tous droits de traduction, de reproduction
et d’adaptation réservés pour tous pays.
2 › Sommaire
Sommaire
PARTIE 3 Vers l’épreuve du Bac

1 Exercice type 1 ....................................................................................................................... 40
• Limite de suites • Boucle bornée
2 Exercice type 2 ....................................................................................................................... 40

3 Exercice type 3 ....................................................................................................................... 41

• Logarithme • Boucle non bornée • Langage naturel
4 Exercice type 4 ....................................................................................................................... 41

5 Exercice type 5 ....................................................................................................................... 42

• Algorithme de dichotomie • Boucles non bornée et bornée • Variables et affectation
6 Exercice type 6 ....................................................................................................................... 43

• Limite de suites • Boucles bornée et non bornée
7 Exercice type 7 ....................................................................................................................... 44

• Comparaison de suites • Boucle non bornée
8 Exercice type 8 ....................................................................................................................... 45

• Méthode des rectangles • Intégration • Boucle bornée
9 Exercice type 9 ....................................................................................................................... 46

• Limite de suites • Boucle bornée • Variables et affectation
10 Exercice type 10..................................................................................................................... 46

• Théorème des valeurs intermédiaires • Équation • Langage naturel
11 Exercice type 11..................................................................................................................... 47

• Intégration • Boucle bornée
12 Exercice type 12..................................................................................................................... 48

• Factorielle • Permutation • Boucle bornée
Les fichiers des scripts sont disponibles dans le manuel numérique et sur le site
lycee.hachette-education.com/Barbazo/cahier-tle
Fabrication : Miren Zapirain

Mise en pages & schémas : STDI
Couverture : Guylaine Moi
Maquette intérieure : Anne-Danielle Naname
Édition : Alexandre Bertin
Introduction
Découvrir l’algorithmique et la programmation

1 Les notions de base en algorithmique et en programmation
▶ Un algorithme est un ensemble d’instructions langage informatique (structure logique écrite
qui s’enchainent les unes après les autres, dans dans un langage spécifique que les ordinateurs
un ordre logique et bien déterminé. peuvent interpréter).
▶ Une instruction est une série d’actions ▶ La programmation est la mise au point d’un
contenant des mots clés et des connecteurs programme (aussi appelé script) dans un
logiques. Les instructions font également langage informatique pouvant être compris
intervenir des variables. et utilisé par un ordinateur. Il existe plusieurs
▶ Un algorithme peut s’écrire en langage naturel langages de programmation : Python, Scilab,
(structure logique écrite en français) ou en C++, etc.
2 Les principales structures algorithmiques en langage naturel

L’affectation de variable
▶ Pour affecter une valeur à une variable, c’est-à-dire donner une valeur à une variable, on utilise, en
langage naturel, la syntaxe variable ← valeur.
Exemple : base ← 10 signifie que la variable base reçoit la valeur 10.
Les instructions conditionnelles
▶ Pour aiguiller dans différentes La syntaxe d’une instruction

directions l’exécution d’un algo- conditionnelle en langage naturel Exemple :
rithme, on peut avoir recours à des Si condition alors Si prix > 200 alors
instructions conditionnelles qui instruction(s) 1 prix ← prix × 0,8
permettent de déterminer si les ins- Sinon Sinon
tructions qui suivent doivent être, ou instruction(s) 2 prix ← prix × 0,9
Fin Si Fin Si
non, exécutées.
La boucle bornée
▶ Lorsqu’on doit répéter une ou plusieurs instructions un nombre défini de fois connu à l’avance, on
utilise une boucle bornée.
La syntaxe d’une boucle bornée en langage naturel Exemple :
Pour variable allant de valeur minimale à valeur maximale Pour i allant de 3 à 100
instruction(s) somme = somme + i
Fin Pour Fin Pour
La boucle non bornée

▶ Lorsqu’on doit répéter une ou plusieurs instructions un nombre inconnu de fois, on utilise une boucle
non bornée qui est parcourue jusqu’à ce qu’une certaine condition ne soit plus vraie.
La syntaxe d’une boucle non bornée en langage naturel Exemple :
Tant que condition faire Tant que M > 0 faire
instruction(s) M←M–1
Fin Tant que Fin Tant que
4 › Découvrir l’algorithmique et la programmation

Introductio
n
3 Le logiciel EduPython et le langage Python

▶ Python est un langage de programmation qui ▶ Dans ce cahier, l’environnement utilisé est celui
peut être utilisé dans plusieurs environnements : d’EduPython, un logiciel gratuit et téléchargeable
EduPython, Pyso, Spyder, etc. en ligne à l’adresse :
https://edupython.tuxfamily.org/
L’interface du logiciel EduPython
Bouton permettant
d’exécuter le script
Éditeur : zone
d’écriture des
programmes
et des fonctions
Console : zone
où le programme
s’exécute
▶ L’éditeur permet d’écrire des programmes. Après l’écriture d’un programme ou d’une fonction, on
l’exécute avec l’icône . Après l’exécution d’un programme, on peut utiliser la console pour connaître
le contenu des variables calculées.
▶ La console permet de dialoguer directement avec le programme à l’aide du clavier. L’utilisateur saisit
des instructions dans la console, tape sur la touche entrée et le programme affiche une donnée à
l’écran en réponse.
La console est ainsi le lieu où s’affichent les données des programmes écrits dans l’éditeur.
Exemple :
Programme saisi dans l’éditeur et exécuté Instruction saisie dans la console et affichage
La console peut aussi être utilisée comme une puissante calculatrice.

Exemple : calcul de 2450
Introduction ‹ 5
Introduction
4 Les principales structures algorithmiques en Python

▶ Un langage informatique utilise une syntaxe qui lui est propre. Certains mots utilisés en langage
naturel se traduisent en langage informatique par des mots clés, uniquement employés par ce langage.
▶ Python est un langage dont la base linguistique est anglo-saxonne. Sa syntaxe est donc constituée
de mots anglais.
L’instruction conditionnelle if
▶ Le mot français Si du langage naturel se traduit par le mot anglais if en langage Python.
▶ Le mot français Alors du langage naturel ne se traduit pas par un mot en anglais en langage Python,
mais par un retour à la ligne, appelé indentation.
▶ Le mot français Sinon du langage naturel se traduit par le mot anglais else en langage Python.
▶ Une instruction conditionnelle peut exécuter une, deux ou plusieurs instructions selon la situation
étudiée.
• L’instruction conditionnelle en langage Exemple :
Python ci-dessous n’a qu’une seule
condition. Si la condition n’est pas réalisée,
le script n’effectue pas l’instruction.
Le programme affecte à la variable y une valeur égale à

quatre fois celle de la variable x lorsque cette variable
x est inférieure ou égale à 3. Rien ne se produit si la
variable x est strictement supérieure à 3.
• L’instruction conditionnelle en langage Exemple :
Python ci-dessous a une condition et une
alternative. Si la condition est réalisée, le
script effectue l’instruction 1 ; si la condition
n’est pas réalisée, il effectue l’instruction 2.
Le programme affecte à la variable y une valeur égale à

quatre fois celle de la variable x lorsque cette variable x
est inférieure ou égale à 3. Sinon, il affecte à y la valeur
3x + 6. Dans cette instruction conditionnelle, tous les
cas sur x sont étudiés.
La boucle bornée for

▶ Le mot français Pour du langage naturel se traduit par le mot anglais for en langage Python.
▶ La fonction range() permet d’énumérer le nombre de passages dans la boucle.
La boucle non bornée while
▶ Le mot français Tant que en langage naturel se traduit par le mot anglais while en langage Python.
6 › Découvrir l’algorithmique et la programmation

Introductio
n
5 Les bibliothèques de Python

▶ Certaines fonctions spécifiques au langage Python sont rangées dans des bibliothèques. Pour pouvoir
les utiliser, on peut importer entièrement la bibliothèque ou seulement la ou les fonction(s) souhaitée(s).
• L’étoile * permet d’importer toutes les fonctions d’une bibliothèque.
Exemple : from math import* importe toutes les fonctions de la bibliothèque math.
• On peut importer d’une bibliothèque seulement les fonctions dont on a besoin.

Exemple : from math import sqrt importe la fonction racine carrée de la bibliothèque math.
▶ Lorsque le nom de la bibliothèque est très long, on peut lui définir un alias en ajoutant as suivi de
quelques lettres formant l’alias. On peut ensuite utiliser toutes les fonctions de la bibliothèque en faisant
précéder leur nom de l’alias.
Exemple : import matplotlib.pyplot as plt
L’instruction plt.plot(x,y) permet d’importer la fonction plot de la bibliothèque matplotlib.pyplot en utilisant
l’alias plt.
Type de bibliothèque Nom de la bibliothèque Syntaxe d’importation

Principales fonctions mathématiques math from math import*
Fonctions des probabilités random from random import*
Fonctions graphiques matplotlib.pyplot import matplotlib.pyplot as plt
pylab import pylab as pb

numpy import numpy as np
6 Les graphiques
▶ Le langage Python est un langage informatique
qui permet de réaliser des calculs qui sont trop
longs et compliqués à faire manuellement, mais
c’est également un traceur de courbes. Les
graphiques permettent en général de conjecturer
des solutions d’équations ou d’inéquations, de
déterminer des coordonnées de points ou de
faire de la géométrie.
▶ Pour réaliser des graphiques avec le langage
Python, il faut utiliser plusieurs bibliothèques :
matplotlib.pyplot, ou pylab et numpy.
▶ Lorsqu’on exécute un script de tracé de
graphique, l’affichage se réalise dans une fenêtre
qui s’ouvre indépendamment de l’environnement
EduPython. Il faut fermer cette fenêtre après
l’avoir visualisée.
Introduction ‹ 7
papier & crayon
Démarrage d é b ra
nché
1. Variables, fonctions et instruction conditionnelle

MÉMO
Quand on programme en Python, on utilise des variables, des fonctions et des instructions. Les variables
peuvent être de types différents : numériques entières, numériques flottantes (rationnelles ou réelles), listes,
chaînes de caractères ou booléennes.
Ne pas oublier l’indentation, c’est-à-dire le décalage du texte vers la droite, qui indique le début et la fin des
instructions conditionnelles, des boucles et des instructions de la fonction.
Langage naturel Python
Variable
De type numérique rayon ← 2
De type chaîne de caractères jour ← "lundi"
De type booléen resultat ← vrai
Instruction conditionnelle
Si condition1 Faire
……..
Sinon Si condition2 Faire
……..
Sinon Faire
………
Fin Si
Fonction informatique
Chaque fonction possède un nom, renvoie un résultat et peut
avoir aucun, un ou plusieurs arguments.
1 Un magasin propose des réductions à ses clients. 2 On considère la

Si un client vient strictement plus de 4 jours par fonction f définie par le
semaine, il a 15 % de réduction sur ses achats. S’il programme ci-contre.
vient entre 2 et 4 jours compris, il a 8 %. S’il vient
seulement 1 jour, il n’a que 1 % et s’il ne vient pas du 1. Compléter
tout, il n’a pas de réduction. Compléter la fonction l’expression de f (x)
reduction, d’arguments le nombre de jours déclarés ci-dessous.
par le client pour une semaine et le montant total ⎧2e x si x > 0
⎪
de ses achats cette même semaine et qui renvoie f ( x ) = ⎨−e − x si − 3 ! x ! 0
le montant payé par le client après la réduction ⎪⎩0 si x < −3
associée ou l’expression « Client pas venu ». 2. Modifier la fonction ci-dessus pour qu’elle
retourne l’image d’un réel x par la fonction f définie
1 def reduction(jours,total):
⎧ xe x −1 si x ! 0
2 if 4<jours<=7: pour tout réel x par f ( x ) = ⎨ 2 .
3 total=0.85*total ⎩−x −1 si x < 0
4 elif 2<=jours<=4 :
5 total=0.92*total
6 elif jours==1:
7 total=0.99*total
8 else:
9 total=»Client pas venu»
10 return total
8 › Variables, fonctions et instruction conditionnelle

ordinateur
3 1. On considère la fonction ci-dessous. 2. Quel est le résultat renvoyé par l’instruction

?
‘positif’
Recopier le script et écrire le résultat ci-dessous. 3. Que réalise la fonction signe ?
a. Elle renvoie le signe de f ( x ) avec la fonction f
True donnée et le réel x donné.
b.
False 4. On écrit dans la console l’expression suivante.
c. Que teste cette fonction ?

Que permet l’instruction lambda ?
Elle teste si un nombre est compris entre 2 et 6 inclus.
Elle permet de définir ponctuellement une fonction
2. On a modifié la fonction précédente comme
ci-dessous. au lieu de la redéfinir dans l’éditeur.
Recopier le script et écrire le résultat ci-dessous. 5. Écrire le script d’une fonction que l’on appellera
racine qui renvoie comme résultat la valeur
a.
2 f ( x ) −1 pour une fonction f donnée calculée en
True un réel x donné lorsque le calcul est possible et
renvoie comme résultat le mot ‘non défini’ sinon.
b.
On n’oubliera pas d’importer la fonction sqrt de la
False bibliothèque math.
3. Expliquer ce que renvoie la fonction test2.
Elle teste si un nombre est compris entre 2 et 6 inclus.
Une instruction conditionnelle n’est pas nécessaire
ici car le test renvoie un booléen.
4 On considère le programme ci-dessous écrit avec

deux fonctions.
6. On donne f définie pour tout réel x par :

f ( x ) = 5 − 2x .
Utiliser la fonction racine pour déterminer les
valeurs de 2 f ( x ) −1 avec les valeurs de x données.
a. x = −5
1. Combien la fonction signe possède-t-elle

d’arguments ? Lesquels ?
La fonction signe possède deux arguments : une b. x = 10
fonction f et un nombre x.
Démarrage ‹ 9
papier & crayon
nché
2. Boucles bornées et non bornées

MÉMO
Pour écrire certains programmes, il est parfois utile de répéter une ou plusieurs instructions un nombre défini
de fois. Lorsque le nombre de répétitions est connu à l’avance, on utilise une boucle bornée for.
Pour d’autres programmes, il est parfois nécessaire de répéter une ou plusieurs instructions un nombre
inconnu de fois. Lorsque le nombre de répétitions n’est pas connu à l’avance, on utilise une boucle non bornée
qui est parcourue jusqu’à ce qu’une certaine condition ne soit plus vérifiée. Tant que cette condition est vérifiée,
la boucle continue.
Langage naturel Python
Boucle bornée
Boucle avec des valeurs Pour variable allant de … à … Faire
numériques Instructions
Fin Pour
Boucle dans une chaîne de Pour caractere dans chaine Faire

caractères Instructions
Fin Pour
Boucle non bornée
Tant que condition Faire
…
Fin Tant que
1 On veut calculer une valeur approchée de la somme 3 On considère la fonction ci-dessous.

1+ e −1 + e −2 + …+ e −20 .
Compléter la fonction pour qu’elle renvoie cette
somme.
1 from math import exp
2 def somme():
3 S=1
4 for i in range( 1 , 21 ):
5 S+exp(-i)
Expliquer ce que fait la boucle non bornée while.
6 return S Tant que la variable cinq est différente de 5, on
2 Compléter la fonction suivante qui compte le nombre choisit un nombre aléatoire entier entre 1 et 6.
d’espaces dans une phrase écrite par l’utilisateur. La variable nbre compte donc le nombre de coup
1 def compte_espace(phrase): réalisé avant d’obtenir 5.
2 nbre=0
3 for caractere in phrase :
4 if caractere=="":
5 nbre=nbre+1
6 return nbre
10 › Boucles bornées et non bornées

ordinateur
4 On veut calculer, pour toute entier naturel n ! 0, la 6 On considère l’équation e x = x + 2.

somme S égale à : D’après le graphique ci-dessous, cette équation
1 1 1 possède une unique solution positive.
S = 1+ + + …+ n .
2 4 2
Compléter la fonction somme ci-dessous. 6
y = e2
5
1 def somme(n): y=x+2
4
2 S=1
3 A
3 for k in range( 1 , n+1)
2
4 S=S+(1/2**k)
1
5 return S
–2 –10 1 2 3 4 5 6
–1
5 Dans une culture bactérienne constituée de N
1. On considère la fonction ci-dessous.
bactéries, on suppose qu’à chaque seconde, 4 %
des bactéries meurent.
© Pornsuda Thaisa/Shutterstock
a. Recopier cette fonction dans un éditeur et indi-

quer l’affichage.
(1.0999999999999999, 1.2)
1. Écrire une fonction bacteries qui renvoie le

nombre de bactéries encore vivantes après n
secondes, n entier naturel.
b. Que fait cette fonction ?
La fonction détermine un encadrement de la
solution de l’équation e x = x + 2 au dixième.
2. Une culture contient 5 millions de bactéries.
Combien de bactéries sont encore vivantes après
10 secondes ? Arrondir le résultat à l’unité.
3 324 163 sont encore vivantes après 10 s. 2. Compléter la fonction ci-dessous, pour qu’elle
détermine un encadrement de la solution de l’équa-
3. En écrivant une fonction appelée moitie, tion à 10− p près.
déterminer le nombre de secondes qu’il faut au
minimum pour que le nombre de bactéries soit 1 from math import exp
strictement inférieur à la moitié de la population 2 def racine():
initiale. 3 x=0
4 y=-1
5 while y<0 :
6 x=x+0.1
7 y=exp(x)-(x+2)
8 return x-0.1 ,x
Démarrage ‹ 11
papier & crayon
nché
3. Listes
MÉMO
Lorsqu’on a besoin de garder et d’utiliser plusieurs variables au cours d’un programme, on utilise des listes
pour les stocker. Une liste est une collection d’objets de différents types (variables numériques, chaînes de
caractères, booléens, listes, etc.). Une liste est une variable que l’on peut nommer comme on le souhaite. Dans
les exemples ci-dessous, la variable liste est nommée L.
Python
Listes
Liste vide
Liste contenant des objets de types différents
Premier objet de la liste ou objet de rang 0
k +1-ième objet de la liste ou objet de rang k
Dernier objet de la liste

Longueur ou nombre d’objets d’une liste
Ajouter un objet en fin de liste
Insérer un objet au rang k
Concaténer (rassembler) deux listes
Remarques :
• Les listes contiennent des objets de types différents, contrairement aux chaînes de caractères qui ne
contiennent que des objets de type chaîne.
• La boucle bornée for element in liste possède la même syntaxe que pour la chaîne de caractères. La
variable element va prendre les valeurs successives des objets de la liste.
1 On considère la liste suivante, écrite dans la console. 3 On considère la fonction ci-dessous.
1. Qu’affichent les instructions suivantes lorsqu’elles

sont écrites dans la console ?
a. ‘nuit’ b. 4
2. Que faut-il écrire dans la console pour que la
liste soit la suivante lorsqu’on l’affiche ?
1. Écrire ce que pourrait renvoyer les instructions
jeu(4) et jeu(9) écrites dans la console.
2 On considère les deux listes suivantes.

2. Que réalise cette fonction ?
Qu’affiche l’instruction ? Elle renvoie la liste des n tirages entre 1 et 6 et

compte le nombre de 2 obtenus.
12 › Listes
ordinateur
4 1. a. Écrire dans l’éditeur l’instruction Compléter la fonction ci-dessous qui renvoie la liste
des n lancers et la somme des faces des dés obtenue.
On utilisera la fonction lancers de la question 1.
b. Quel est le contenu de la liste L ?
1ƒ def somme_dés(n):
Cette instruction crée la liste des dix premiers
2 L=lancers(n)
nombres impairs positifs. 3 somme=0
2. Créer la liste appelée cubes, des cubes des cinq 4 for i in range( len(L) ):
premiers nombres impairs positifs. 5 somme=somme+L[i]
6 return L,somme
7 1. On a écrit en langage naturel l’affectation de la

liste suivante à une variable L de type liste :
5 1. Compléter la fonction produit ci-dessous pour
qu’elle calcule le produit des éléments d’une liste L ← 4,2,8,5,1,0,45,12,4,1,32,17]
de nombre.
Que faut-il écrire dans la console pour créer la
1 def produit(liste): variable L et lui affecter la liste ci-dessus ?
2 P=1
3 for i in range( len(liste) ): 2. Écrire dans la console l’instruction
4 P=P*liste[i] et recopier ci-dessous le résultat
5 return P obtenu. Que fait cette instruction ?
Elle ajoute le nombre 43 en fin de liste.
2. Compléter la fonction moyenne ci-dessous qui
calcule la moyenne d’une liste L1 de valeurs dont 3. Que contient la liste suivante, crée dans la console ?
les effectifs sont dans une liste L2.
1 def moyenne(liste,effectifs):
Elle contient deux listes, la liste L précédente et la
2 m=0
liste contenant les caractères A et B.
3 for i in range( len(liste) ):
4 m=m+liste[i]*effectifs[i]
4. On écrit dans la console, l’instruction :
5 m=m/somme(effectifs)
Que renvoie-t-elle ?
6 return m
Elle renvoie l’élément de rang 1 de la liste liste
6 On considère la fonction suivante. soit L ,

5. On écrit dans la console l’instruction :
Que renvoie cette fonction lorsqu’on écrit dans la
console l’instruction ? Elle renvoie le dernier objet de la liste liste,
soit la liste L .
6. On écrit dans la console l’instruction :
2. Que réalise cette fonction ?

Elle simule n lancers d’un dé cubique équilibré.
Elle renvoie le contenu de la liste liste, ainsi que
3. On lance n fois un dé équilibré, où n est un entier
naturel. la liste contenant les caractères t et u.
Démarrage ‹ 13
papier & crayon
Entraînement déb r
anch
é
1. Fonctions de référence : logarithme et exponentielle

1 On considère la fonction fonc1 ci-dessous. ln(2,3) + ln(4 ) − ln(2,3 × 4 )
ln(e) + ln(5,63) − ln(e × 5,63)
2. Expliquer les résultats obtenus.
Dans la console on obtient les résultats suivants. ln(2) + ln(3) − ln(2 × 3) = ln(6) − ln(6) = 0
ln(2,3) + ln(4 ) − ln(2,3 × 4 ) = ln(2,3 × 4 ) − ln(2,3 × 4 ) = 0
ln(e) + ln(5,63) − ln(e × 5,63) = ln(5,63e) − ln(5,63e) = 0

3. Les résultats sont-ils toujours nuls quelles que
soient les valeurs de a et b choisies par l’utilisateur ?
Oui, car ln( a ) + ln( b ) = ln( ab ) , donc fonc1(a,b)=0.
1. Écrire les calculs qui ont été effectués.
ln(2) + ln(3) − ln(2 × 3)
a+b
a+b
2 On considère la fonction incomplète fonc2 écrite en a< x! ⇔ e a < e x < e 2 et
2
Python. a+b a+b
! x < b ⇔ e 2 ! e x < eb .
1 from math import * 2
b. Compléter l’algorithme en langage naturel
2 def fonc2(a,b):
ci-dessous afin que a ! x ! b.
3 return exp(a+b)-exp(a)*exp(b)
a, b, m, M ← 0,1,1,e
1. Compléter la fonction afin que, quels que soient Tant que M − m >10−3 :
les valeurs a et b choisies par l’utilisateur, le résul- a+b
Si x ! :
tat dans la console suite à l’appel de fonc2(a,b) 2
fasse toujours 0. a+b
b ←
2
2. a. Soient a , b et x trois réels tels que a < x < b. M ← m×M
a+b Sinon :
Prouver que, si a < x ! , alors e a <e x ! e a × e b .
2 a+b
De la même façon, déterminer un encadrement de a ←
2
a+b m← m×M
e x lorsque !x<b.
2
La fonction exponentielle est croissante c. Que représente [ m ; M ] pour le réel x ?
a+b
C’est un encadrement de e x à 10−3 près.
strictement et e 2 = e a × e b , donc on a :
3 Le logarithme de base a , où a est un réel stricte- 1. a. Exprimer, en fonction de a, b et c, le calcul réa-

ment positif, est défini sur ]0; +∞[ par : lisé.
ln( x )
loga ( x ) : x ! , et se note en Python log(x,a). logc ( a ) + logc ( b ) − logc ( ab )
ln( a )
On dispose de la fonction fonc3 ci-dessous. b. Quelle résultat obtient-on ? Expliquer.
ln( a ) ln( ab ) ln( ab )
logc ( a ) + logc ( b ) − logc ( ab ) = + −
ln( c ) ln( c ) ln( c )
ln( ab ) − ln( ab )
= =0
ln( c )
14 › Fonctions de référence : logarithme et exponentielle

ordinateur
4 La notion de magnitude a été créée par le physicien b. Proposer une fonction energie qui, connaissant la
américain Richter en 1935. La magnitude permet magnitude M d’un séisme, renvoie l’énergie libérée
d’estimer l’énergie (en joule) libérée par un séisme. en joule.
Richter proposa comme loi liant la magnitude M
d’un séisme avec l’énergie (E en joule (J)) libérée
par celui-ci la formule log( E ) = 4,8 +1,5M.
a. Proposer une fonction magnitude sous Python c. Utiliser les fonctions ci-dessus pour compléter le
qui, connaissant l’énergie, en joule, libérée par un tableau ci-dessous (arrondir au dixième).
séisme, renvoie sa magnitude arrondie à 10−1 près.
Lieu E (joules) M
Haïti 2010 2 ×1015 7
Japon 2011 1,4 ×1018 8,9
Bordeaux 2016 4 ×1012 5,2
5 Le scrobicularia plana est un mollusque bivalve qui vit

dans la vase des estuaires. Après l’étude d’une popu-
lation de ces petits coquillages, on a pu en déduire, en
utilisant le modèle de croissance de von Bertalanffy
(biologiste canadien, 1901-1972) que la longueur du 2. Utiliser la fonction précédente pour déterminer le
coquillage, en mm, est donné par la formule nombre de mois nécessaires pour que le coquillage
L ( t ) = 37,2260(1− e−0,9789t ) , où t représente le temps, dépasse les 18 mm. On pourra vérifier le résultat en
en année. effectuant un calcul direct.
1. Écrire une fonction, age sous Python qui, connais- >>> age(18)*12
sant la longueur du coquillage en mm, permet
d’obtenir son âge en années. 8.09983343220983 Il faudra 9 mois.
ln( x ) 9 x2=x2+prec
6 Soit f la fonction définie sur ]0; +∞[ par f ( x ) = .
x2 10 res=x1,x2
Le tableau de variation de f est donné ci-dessous.
11 elif alpha
: <=0 :
x 0 e0,5 −∞ 12 while f(x)-alpha>=0
: :
0,5e −1 13 x=x-prec
Variation de f 14 res=x
−∞ 0
15 else : res=[]
On cherche à déterminer une valeur approchée, 16 return res
avec une précision donnée par l’utilisateur, de(s)
solution(s) de l’équation f ( x ) = α , où α ∈R . 2. Écrire dans un éditeur Python la fonction f et la
1. Compléter la fonction sol(prec,alpha) ci-des- fonction sol et déterminer le(s) solutions(s) à 10−4
sous afin qu’elle réponde au problème. près de f ( x ) = 0,01 puis f ( x ) = −2,3.
>>> sol(0.0001,0.01)
1 def sol(prec,alpha):
2 x=sqrt(e) (1.0102212707001985, 16.79632127067449)
3 if 0<alpha <= f(x): Pour f ( x ) = 0,01, les solutions sont 1,0102 et 16,7963.
4 x1 = x
>>> sol(0.0001,-2.3)
5 while f(x1)-alpha >=0:
6 x1=x1-prec 0.5273212707002517
7 x2=x Pour f ( x ) = −2,3 , la solution est 0,5273.
8 while f(x2)-alpha >=0:
Entraînement ‹ 15
papier & crayon
anch
é
2. Dénombrement et permutation
1 On considère dans un repère orthonormé, les points 3. Modifier la fonction précédente en une fonction
M ( x ; y ) avec x et y entiers naturel tels que 0 ! x ! 8 points2, avec quatre arguments, pour qu’elle affiche
et 0 ! y !10. la liste des points M ( x ; y ) avec xmin ! x ! xmax et
ymin ! y ! ymax et également le nombre de points
1. Combien y a-t-il de points M ( x ; y ) ?
M ( x ; y ) affichés.
Pour tout entier x compris entre 0 et 8, il y a
9 points M ( x ; 0) . Comme il y a 11 lignes de points,
on a alors en tout 99 points.
2. Compléter la fonction suivante, nommée points,
sans argument, pour qu’elle renvoie la liste de tous
les points M ( x ; y ) avec x et y entiers naturel tels
que 0 ! x ! 8 et 0 ! y !10.
1 def points():
2 L=[]
3 for i in range( 9 ):
4 for j in range(11) :
5 L.append( [i,j] )
6 return L
2 Écrire une fonction nommée factorielle, qui renvoie

n! pour un entier naturel n entré en argument de la
fonction.
3 On considère les algorithmes suivants écrits en lan- 2. Écrire un calcul direct de la valeur de la variable
gage naturel. resultat renvoyée par cet algorithme.
20 ×19 ×18
N ← 20
resultat ← 20
Pour i allant de 1 à 3
resultat ← resultat × ( N − i )
3. Compléter la fonction Python suivante pour
qu’elle renvoie la valeur N × ( N −1)…× ( N −10)
1. Quelle est la valeur de la variable resultat lorsque pour un entier N !10 entré en argument.
cet algorithme a été utilisé ?
1 def produit(N):
La variable résultat contient la valeur 6 840.
2 resultat=N
3 for i in range( 1 , 11 ):
4 resultat=resultat*(N-i)
5 return resultat
16 › Dénombrement et permutation
ordinateur
4 Une association veut élire son bureau constitué d’un président,

d’un trésorier et d’un secrétaire. Il y a sept candidats qui postulent
pour le bureau. On nomme les candidats A, B, C , D, E et F .
Un candidat ne peut postuler que sur un seul poste du bureau.
Afin de choisir au hasard les trois personnes du bureau, on
procède en utilisant la fonction Python ci-contre.
1. Expliquer ce que renvoie cette fonction.
La fonction renvoie trois lettres choisies au hasard dans la liste des 7 lettres.
2. Écrire cette fonction dans un éditeur et la tester plusieurs fois. Expliquer pourquoi elle ne peut pas servir
pour constituer un bureau.
Lorsqu’on l’utilise plusieurs fois, on trouve que la même lettre est renvoyée parfois. Or, personne ne peu
postuler sur plusieurs postes dans le bureau. Il faut donc que les lettres renvoyées soient toutes distinctes.
3. On a transformé la fonction précédente comme ci-contre.

Expliquer les lignes 7, 8, 9 et 10.
La ligne 7 définit un entier aléatoire entre 0 et le rang
maximal de la liste.
La ligne 8 ajoute l’élément de la liste L de rang x et l’ajoute
à la liste bureau.
La ligne 9 élimine l’élément précédent de la liste L.
La ligne 10 diminue le rang qui permettra de choisir un élément dans la liste L diminuée.
5 La fonction Python chr renvoie la lettre correspon- pour les lettres. On a, pour chacun de ces choix,
dant au code ASCII donné selon le tableau suivant. 102 choix possibles pour les deux chiffres.
Code On a alors en tout 1 757 600 codes possibles.
65 66 67 … 90
ASCII
Lettre A B C … Z
b. Compléter la fonction code ci-contre pour qu’elle
1. Que renvoie l’instruction chr(67) ?
génère un code sous la forme d’une liste à envoyer
Elle renvoie la lettre C par sms lors d’une demande de paiement en ligne.
2. Pour sécuriser un paiement par carte bleu en 1 from random import randint
ligne, on doit recevoir par sms un code constitué 2 def code():
de trois lettres de l’alphabet (pas nécessairement
distinctes) et deux chiffres compris entre 0 et 9 pas 3 i=randint(65,90)
nécessairement distincts. 4 j=randint(65,90)
a. Combien de codes peut-on générer avec cette 5 k=randint(65,90)

méthode ? 6 l=randint(0,9)
On a 26 possibilités pour chaque lettre et on a trois 7 m=randint(0,9)
lettres possibles. Il y a donc 263 choix possibles 8 return [chr(i),chr(j),chr(k),l,m]
Objectifs
Travaux pratiques • Retrouver les propriétés des différents

dénombrements.
Algèbre Dénombrements
PARTIE 1 Factorielle et combinaison
1 On rappelle que, pour tout entier naturel n , 1 def factorielle(n):

n! = 1× 2 × …× n. 2 resultat=1
a. Compléter la fonction suivante, nommée 3 for k in range( 1 , n+1 ):
factorielle, d’argument un entier naturel, pour 4 resultat=resultat*k
qu’elle renvoie la valeur de n!.
5 return resultat
b. Que valent 7! ? 13! ?
7! = 5040 et 13! = 6227020800
2 On considère la nouvelle fonction factorielle2 ci-dessous.
a. Que renvoie cette fonction avec n = 13 ?

La fonction renvoie 6227020800 comme la fonction précédente.
b. Justifier que l’instruction de la ligne 5 permet d’affirmer que la fonction affichera n!.
La fonction factorielle2 s’appelle elle-même. Elle s’appellera elle-même jusqu’à ce que
la valeur de n −1 soit égale à 0. Alors elle multipliera le dernier résultat par 1
et le programme s’arrêtera.
n
3 Compléter la fonction suivante, afin qu’elle renvoie la valeur de ⎛ ⎞ pour tous entiers natu-
⎝ k⎠
rels k et n entrés en arguments. On utilisera l’une des fonctions factorielles des questions
précédentes.
1 def factorielle(n):
2 resultat=1
3 for k in range(1,n+1):
4 resultat=resultat*k
5 return resultat
6
7 def combinaison(k,n):
8 if k>n:
9 resultat=False
10 else:
11 resultat=factorielle(n)/(factorielle(k)*factorielle(n-k))
12 return resultat
18 › Dénombrements
PARTIE 2 Nombre de parties d’un ensemble à n éléments
1 On considère un ensemble Ω à n éléments.
a. Combien y a-t-il de parties de Ω à k éléments, pour un entier naturel k compris entre 0 et n ?
n
Il y a ⎛ ⎞ parties à k éléments.
⎝ k⎠
2 Compléter la fonction nbre_parties suivante, d’argument un entier naturel n , pour qu’elle
renvoie le nombre total de parties de Ω . On utilisera les fonctions factorielle et combinai-
son écrites plus haut.
2 resultat=1
4 resultat=resultat*k
5 return resultat
6
7 def combinaison(k,n):
8 if k>n:
9 resultat=False
10 else:
11 resultat=factorielle(n)/(factorielle(k)*factorielle(n-k))
12 return resultat
13
14 def nbre_parties(n):
15 N=0
16 for k in range(n+1) :
17 N= N+combinaison(k,n)
18 return N
PARTIE 3 Triangle de Pascal

On considère la fonction suivante.
Recopier cette fonction dans un éditeur et la tester avec n = 3 et n = 5. Qu’obtient-on ?
On obtient le triangle de Pascal jusqu’à la ligne n .
Travaux pratiques ‹ 19
papier & crayon
anch
é
3. Suites et limites
1 On considère la suite ( un ) définie par u0 = 0 et, pour
tout entier naturel n, un+1 = un + 3n − 7.
Quel sera l’affichage lorsqu’on saisit dans la console
1. Calculer u1, u2, u3 et u4 .
Python ?
u1 = −7, u2 = −11, u3 = −12, u4 = −10 .
[0, -7, -11, -12, -10]
2. Compléter la fonction rangsuite ci-dessous pour
4. On admet que lim un = +∞. Écrire une fonction
qu’elle affiche le terme de rang n. n→+∞
seuil qui permet de déterminer le plus petit entier n
1 def rangsuite(n):
tel que un >1000.
2 u=0
3 for k in range ( n ):
4 u = u + 3*k - 7
5 return u
3. On considère la fonction ci-après écrite dans

l’éditeur Python.
2 On considère la suite ( un ) définie par u0 = 9, u1 = 5 et, 1 def suiteu(n):

1
pour tout entier naturel n non nul, un+1 = (4un − un−1) 2 u0,u1=9,5
3
11 29 83 3 for k in range(2,n+2 ):
1. Calculer u2 , u3 et u4 . u2 = , u3 = , u4 = .
3 9 27 4 u0,u1=u1,1/3*(4*u1-u0)
2. Compléter la fonction suiteu ci-contre pour qu’elle 5 return u0
affiche le terme de rang n.
3. Que permettent de conjecturer les affichages donnés par les instructions ci-contre
écrites dans la console Python ?
On conjecture que la suite converge vers 3.
3 Soit ( un ) la suite géométrique de premier terme 3. Quelle est la limite de la suite ( S n ) ?

u0 = 400 et de raison q = 0,6 . lim S n = 1000
On pose,pour tout entier naturel n, S n = u0 + u1 + …+ un . n→+∞
4. Écrire une fonction seuilS qui retourne le rang n
1. Quelle est la limite de la suite ( un ) ?
à partir duquel S n > 998 . Cette fonction pourra uti-
lim un = 0 liser sommesuite.
n→+∞
2. Compléter la fonction sommesuite suivante pour
qu’elle affiche le terme de rang n de la suite ( S n ) .
1 def sommesuite(n):
2 u,S=400,400
4 u=u*0.6
5 S=S+u
6 return S
20 › Suites et limites
ordinateur
4 1. Donner la définition de la suite ( un ) définie par la 5. On considère la suite ( v n ) définie pour tout entier
fonction ci-dessous. naturel n par v n = un+1 − un .
Écrire une fonction v qui prend pour paramètre n
et qui affiche les n + 1 premiers termes de la suite
( vn ) .
u0 = 0 et un+1 = un + 2n + 2
2. Compléter et recopier la fonction plotu qui affiche 6. Que peut-on conjecturer sur la nature de la suite
la représentation graphique des n + 1 premiers ( vn ) ? Donner son expression explicite.
termes la suite ( un ) . On conjecture que la suite est arithmétique.
1 import matplotlib.pyplot as plt v n = 2 + 2n
2 def plotu(n): 7. En déduire l’expression explicite de la suite ( S n )
n
3 for k in range( n+1 ):
définie par S n = ∑v k .
4 plt.plot( k , u(k) ,'r.') k=0
5 plt.show() ( n +1)(4 + 2n )
Sn = = ( n +1)(2 + n )
2
3. En utilisant la fonction plotu, conjecturer le sens 8. En déduire l’expression explicite de un et démon-
de variation de la suite ( un ) . trer le résultat par récurrence.
On conjecture que la suite est croissante. On obtient un = S n−1 = n ( n +1)
4. Sous quelle forme semble être l’expression expli- Preuve par récurrence.
cite de un ?
Sous la forme d’un polynôme de degré 2.
5 On se place dans un repère orthonormé et, pour tout 2. Montrer que pour tout entier naturel n,
entier naturel n, on définit les points ( An ) par leurs An An+1 = OAn+1.
coordonnées ( x n ; yn ) de la façon suivante : x 2 y2
An An+12 = ( x n+1 − x n ) + ( yn+1 − yn ) = n + n = OAn+12
2 2
⎧ x = x n − yn 2 2
{x0 = 4
y0 = 0
⎪ n+1 2 2
et, pour tout entier naturel n, ⎨
x y
⎪ yn+1 = n + n
. 3. Écrire une fonction longueurligne qui prend pour
paramètre n et qui retourne la longueur ℓ n de la
⎩ 2 2 ligne brisée A0 A1… An .
1. Compléter la fonction ci-dessous afin de
construire les points A0 à An
1 import matplotlib.pyplot as plt
2 def points(n):
3 x,y = 4,0
4 plt.plot(x,y,'r.')
5 for k in range( n+1 ):
6 x,y = x/2-y/2,x/2+y/2
7 plt.plot(x,y,'r.')
8 plt.show()
4. Conjecturer alors la limite de ℓ n lorsque n tend
vers +∞.
On conjecture que la suite tend vers environ 9,66.
Objectif
Travaux pratiques • Utiliser des boucles bornées et non

bornées
Suites numériques Suites, limites et recherche de seuils

L’objet du travail ci-dessous est d’étudier l’évolution du stockage des caddies présents en fin de
journée dans un supermarché. Ce supermarché dispose sur son parking de trois points d’at-
tache (les points A et B situés aux abords du supermarché et le point C situé au fond du parking).
Pour modéliser les flux de caddies, on fait les hypothèses suivantes.
• Le nombre total de caddies reste constant.
• Chaque jour, le point A perd 12 % de ses caddies mais reçoit 12 % des caddies du point B
et 2 % des caddies du point C.
• Chaque jour, le point B perd 12 % de ses caddies mais reçoit 12 % des caddies du point A
et 2 % des caddies du point C.
• Chaque jour, le point C perd 4 % de ses caddies.
La veille de l’ouverture du supermarché, il y avait 450 caddies au point A, 250 au point B et
300 au point C.
On désigne par an , bn et cn les nombres de caddies respectifs présents dans les points A, B
et C le soir à la fermeture du supermarché n jours après la veille de l’ouverture.
On admettra, pour l’étude mathématique, que les réels an , bn et cn peuvent ne pas être entiers.
PARTIE 1 Modélisation
1 Calculer le nombre de caddies présents le soir dans chaque point un jour et deux jours
après la veille de l’ouverture.
a1 = 432, b1 = 280 et c1 = 288 a2 = 419,52, b2 = 304 et c2 = 276,48
2 Compléter la fonction caddies qui affiche les représentations graphiques des trois suites ain-
si que les nombres de caddies dans chaque point le soir, n jours après la veille de l’ouverture.
2 def caddies(n):
3 a,b,c = 450,250,300
4 plt.plot(0,a,'r.')
5 plt.plot(0,b,'k.')
6 plt.plot(0,c,'b.')
8 a,b,c = 0.88*a+0.12*b+0.02*c , 0.12*a+0.88*b+0.02*c , 0.96*c
9 plt.plot(k,a,'r.')
10 plt.plot(k,b,'k.' )
11 plt.plot(k,c,'b.')
12 plt.show()
13 return a,b,c
3 Exécuter ce programme plusieurs fois pour différentes valeurs de n.

a. Quelles conjectures peut-on faire sur le sens de variation et les limites des suites ?
La suite ( an ) est croissante à partir d’un certain rang et converge vers 500. La suite ( bn )
est croissante et converge vers 500 et la suite ( cn ) est décroissante et converge vers 0.
b. Quelles sont les valeurs affichées lorsqu’on saisit caddies(100) ?
22 › Suites, limites et recherche de seuils

PARTIE 2 Expressions explicites des suites ( an ) , ( bn ) et ( c n )
On appelle d n la différence du nombre de caddies entre les points A et B, n jours après la
veille de l’ouverture.
1 Compléter la fonction python suitedn de paramètre n qui retourne les valeurs prises par d k
pour k allant de 0 à n. On pourra faire afficher les termes de la suite arrondis à 10−2 .
1 def suitedn(n):
2 a,b,c = 450,250,300
3 d = [a - b ]
4 for k in range ( 1,n+1 ):
5 a,b,c = 0.88*a+0.12*b+0.02*c, 0.12*a+0.88*b+0.02*c, 0.96*c
6 d.append(round(a-b,2))
7 return d
2 On a modifié la fonction précédente afin de pouvoir conjecturer la nature de la suite ( d n ) .

Voici l’affichage obtenu dans la console Python lorsqu’on donne à n la valeur 5.
Écrire ci-dessous cette fonction suitedn modifiée.
3 a. Donner les expressions explicites des suites ( cn ) et ( d n ) .

cn = 300 × 0,96n et d n = 200 × 0,76n
b. En déduire les expressions explicites des suites ( an ) et ( bn ) puis leurs limites respectives.
an = 500 +100 × 0,76n −150 × 0,96n bn = 500 −100 × 0,76n −150 × 0,96n
PARTIE 3 Un seuil
1 Écrire une nouvelle fonction nommée seuilcaddies de paramètre M qui retourne le nombre
de jours nécessaires après la veille de l’ouverture du supermarché à partir desquels le
nombre de caddies dans les points A et B dépassera M.
2 Au bout de combien de jours après la veille de l’ouverture du supermarché y aura-t-il plus

de 490 caddies dans les points A et B ?
Au bout de 67 jours.
Objectif
Travaux pratiques • Utiliser des boucles bornées et non

bornées
Suites numériques Approximation de ln(2)

L’objectif de ce TP est de donner une approximation de ln(2) par deux méthodes différentes.
PARTIE 1 Utilisation d’une suite

On considère la fonction suite ci-contre écrite dans
l’éditeur Python où n est un entier naturel non nul.
1 Quelle est parmi les propositions suivantes, la somme
que cet algorithme permet de calculer ?
n n n n+1
1 1 1 1
a. ∑ b. ∑n c. ∑n+k d. ∑n+k
k=1
k k=1 k=1 k=1
Dans la suite de cette partie, on notera, pour n entier naturel non nul, un la somme précédente.
1 1 1 7 1 1 1 37
2 Donner les valeurs exactes de u1, u2 et u3 . u1 = , u2 = + = et u3 = + + = .
2 3 4 12 4 5 6 60
3 Recopier la fonction suite dans l’éditeur Python. Quel est le résultat affiché lorsqu’on écrit
dans la console Python ?
a. suite(10) ? b. suite(100) ?
c. suite(1000) ?
4 Comparer les résultats précédents à ln(2).
ln(2) ≈ 0,693. Les résultats précédents sont d’autant plus proches de ln(2) que n est grand.
1
5 Dans cette question, on admet que pour tout réel x strictement positif, 1− ! ln( x ) ! x −1.
x
k +1
a. En appliquant cet encadrement à x = , avec k entier naturel non nul, montrer que
1 1 k
! ln( k +1) − ln( k ) ! .
k +1 k
k k +1⎞ k +1 1 1
On a 1− ! ln⎛ ! −1, soit, ! ln( k +1) − ln( k ) ! .
k +1 ⎝ k ⎠ k k +1 k
b. Additionner les inégalités de la question 4. a. pour k allant de n à 2n −1 et en déduire un
encadrement de ln(2) .
1 1 1
On obtient un ! ln(2n ) − ln( n ) ! un + − , soit, un ! ln(2) ! un + .
n 2n 2n
1
c. En déduire que 0 ! ln(2) − un ! et justifier alors lim un .
2n n→+∞
1
En soustrayant un à l’encadrement précédent, on obtient 0 ! ln(2) − un ! .
2n
En utilisant le théorème des gendarmes, on en déduit que lim un = ln(2) .
n→+∞
6 a. Écrire ci-contre et dans l’éditeur Python,

une fonction valeurapprochée qui prend
pour paramètre un entier naturel non nul p
et qui renvoie le rang n ainsi que la valeur de
un telle que ln(2) − un !10− p .
24 › Approximation de ln(2)
b. Quelle est la valeur affichée lorsqu’on
écrit dans la console Python valeurappo-
chée(3) ? valeurapprochée(5) ?
PARTIE 2 Utilisation de l’algorithme de Brouncker

William Brouncker est un linguiste et
mathématicien anglais du XVIIe siècle. Il
est l’un des premiers mathématiciens à y=
travailler sur l’aire du domaine D déli-
mité par l’hyperbole, l’axe des abscisses
et les droites d’équations x = 1 et x = 2.
1 Donner la valeur exacte de l’aire de ce do-
maine D.
21
A ( D) = ∫ dx = ln(2)
1x
Il approche l’aire du domaine D par la
somme des aires des rectangles comme 1 1,5 2 x
dessinés ci-contre.
On définit pour tout entier naturel n non nul, la suite ( v n ) par :
n
1 1 1
vn = + …+ =∑ .
1× 2 (2n −1)2n k=1 (2k −1)2k
2 a. Calculer v1, v2 et v3 .
1 1 1 1 7 1 1 1 37
v1 = = , v2 = + = et v3 = + + = .
1× 2 2 1× 2 3 × 4 12 1× 2 3 × 4 5 × 6 60
b. Quelle remarque peut-on faire ? On obtient les mêmes valeurs que u1, u2 et u3 .
3 a. Compléter et recopier dans l’éditeur 1 def suite_Brouncker(n):

Python la fonction suite_Brouncker ci-contre 2 v=0
de paramètre n entier naturel non nul afin
3 for k in range( 1,n+1: ):
qu’elle renvoie une valeur approchée de v n .
4 v=v+1/((2*k-1)*2*k):
5 return v
b. Quels sont les résultats affichés lors-

qu’on écrit dans la console Python suite_
Brouncker(10) ? suite_Brouncker(100) ?
suite_Brouncker(1000) ?
4 a. Écrire ci-contre et dans l’éditeur Python

une fonction valeurapprochée_Brouncker
qui prend pour paramètre un entier naturel
non nul p et qui renvoie tous les termes de
la suite ( v n ) et le plus petit rang n tel que
ln(2) − v n !10− p .
Cette fonction utilisera une liste et la fonc-
tion suite_Brouncker précédente.
b. Quel est le résultat affiché lorsqu’on saisit dans la console Python valeurapprochée_
Brouncker(1) ?
papier & crayon
anch
é
4. Méthodes de la sécante et de Newton

1 Soit f la fonction définie par f ( x ) = x 2 −10. et de l’axe des abscisses avec An ( an ; f ( an )) .
On note 𝒞f sa courbe représentative dans un repère Compléter la fonction ci-dessous afin qu’elle retourne
du plan. la valeur de an , n étant choisi par l’utilisateur.
Dans l’éditeur de Python, on a écrit la fonction suivante :
1 def secante(n):
2 a=0
3 for i in range( n ):
1. Justifier rapidement que l’équation f ( x ) = 0
admet une unique solution ℓ sur l’intervalle [0; 4 ]. 4 a=(a*f(4)-4*f(a))/(f(4)-f(a))
5 return a
f est strictement croissante et continue sur [0; 4 ].
De plus, f (0) < 0 et f (0) > 0. On peut alors 4. On admet que la suite ( an ) précédente converge
vers ℓ. Écrire ci-dessous une fonction nommée
appliquer le TVI. erreur de paramètre p, entier naturel, et qui retourne
2. Soit A ( a ; f ( a )) avec a ∈[0; 4 ] tel que f ( a ) < 0 et la plus petite valeur de n telle que an − ℓ <10− p.
B (4 ; f (4 )). Noter ci-dessous l’abscisse du point
d’intersection de la droite ( AB ) et de l’axe des abs-
cisses. Faire les recherches au brouillon.
af (4 ) − 4 f ( a )
On obtient x = .
f (4 ) − f ( a )
3. Algorithme de la sécante
On construit la suite ( an ) telle que a0 = 0 et an+1 est
l’abscisse du point d’intersection de la droite ( An B )
2 Soit f la fonction définie par f ( x ) = x 3 − 3x +1. On d’intersection de la tangente à la courbe 𝒞f au point

note 𝒞f sa courbe représentative dans un repère du An et de l’axe des abscisses.
plan. Dans l’éditeur de Python, on a écrit la fonction Compléter la fonction ci-dessous afin qu’elle
suivante. retourne les valeurs de u0 à un , n étant choisi par
l’utilisateur.
1 def newtonliste(n):
1. Justifier rapidement que l’équation f ( x ) = 0 2 u=1.1
admet une unique solution ℓ dans l’intervalle [1; +∞[ . 3 L=[u]
f est strictement croissante et continue sur [1; +∞[ . 4 for i in range( n ):
De plus, f (1) < 0 et lim f ( x ) = +∞ . On peut alors 5 u=u-f(u)/(3*u**2-3)
x→+∞
appliquer le TVI. 6 L.append( u )
7 return L
2. Soit A ( u ; f ( u )) avec u >1. Noter ci-dessous
l’abscisse du point d’intersection de la tangente à la 4. On admet que la suite
courbe 𝒞f en A avec l’axe des abscisses. Faire les ( un ) converge vers ℓ. Voici
recherches au brouillon. l’affichage obtenu lors-
f (u ) qu’on saisit dans la console
On obtient x = u − 2 .
3u − 3 Python newtonliste(6).
3. Algorithme de Newton Quelle conjecture peut-on
On construit la suite de points An ( un ; f ( un )) tels faire ?
que u0 = 1,1 et un+1 est l’abscisse du point On conjecture que ℓ ≈ 1,53
26 › Méthodes de la sécante et de Newton

ordinateur
3 On considère la fonction f définie sur ]0; + ∞[ par 3. En s’inspirant de l’algorithme de la sécante pré-
f (x) + ln( x ) . On admet que l’équation f ( x ) = 0
= e− x cédent, écrire une fonction nommée secanteliste de
admet une unique solution dans l’intervalle ]0;2] . paramètre n qui retourne les valeurs de b0 à bn , où
b0 = 2 et bn+1 est l’abscisse du point d’intersection
1. Écrire dans l’éditeur de Python une fonction f de
de la droite ( ABn ) et de l’axe des abscisses.
paramètre x qui retourne l’image de x par f, puis,
compléter ci-dessous la fonction qui permet d’obtenir
la courbe de la fonction f sur l’intervalle ]0;2] .

2 def graphef(): 4. Écrire le dernier élément de la liste lorsqu’on sai-
3 plt.axis([0,2,-1,1]) sit dans la console Python secanteliste(5).
4 plt.grid()
5. x=[ k*1/100 for k in range( 1,201 )] 5. Écrire une fonction nommée plusieursécantes
6 y=[f(i) for i in x] de paramètre n entier naturel non nul qui permet
7 z=[ 0 for i in x] d’afficher la courbe de f, les n sécantes ( ABn−1) et la
valeur de bn . Cette fonction utilisera les trois fonc-
8 plt.plot(x,y,'r',linewidth=2)
tions précédentes.
9 plt.plot(x,z,'k')
10 plt.show()
2. Recopier et compléter la fonction ci-dessous qui

permet de tracer la droite passant par les points
A (0,2; f (0,2)) et B ( b ; f ( b )) .
1 def secante(b):
2 x=[0.2,b ] 6. Quel est le résultat affiché lorsqu’on saisit dans la
3 y=[f(0.2) ,f(b) ] console Python plusieursécantes(7) ?
4 plt.plot(x,y,'b--')
4 On considère la fonction f définie sur ℝ par 2. En vous inspirant de l’algorithme de Newton précé-
f ( x ) = 2 − x 3 . On admet que l’équation f ( x ) = 0 dent, écrire une fonction newtonliste de paramètres
admet une unique solution sur l’intervalle [ −1; 3]. u et n qui retourne les valeurs de u0 à un , où u0 = u.
1. En s’inspirant de l’exercice précédent, écrire une
fonction graphef qui affiche la courbe de f sur [ −1; 3].
3. Quel est le résultat affiché lorsqu’on saisit dans la

console newtonliste(-0.5,3) ? newtonliste(-1,1) ?
Objectif
Travaux pratiques • Calculer des logarithmes
Logarithme Algorithme de Briggs

Briggs a travaillé sur le logarithme de base 10 (log). Le principe de l’algorithme de Briggs
est le suivant.
1
2
1
1( )
On prend x >1. On sait que ln( x ) = ln( x ) c’est-à-dire ln x 2 = ln( x ) .
2
( )
1
On en déduit : ln x 4 = ln ( 1
2
) 1
x = ln( x ) = ln( x ) .
4
1
1 ( )
En itérant le procédé, on obtient ln x 2 = n ln( x ) . Pour n assez grand ce résultat est proche
n
2
1 1
de 0, donc x 2n sera proche de 1. Comme x >1, on a x 2n = 1+ h , avec h proche de 0.
ln(1+ h )
Comme lim = 1, on en déduit que lorsque h est proche de 0, on a ln(1+ h ) ≈ h , donc
h
( )
h→0
1
ln x 2n ≈ h, d’où ln( x ) ≈ 2n h . Résultat qui constitue l’approximation de ln( x ) selon Briggs.
PARTIE 1 Utilisation d’une suite

On considère la suite ( un ) , définie par u0 = x et un+1 = un , où x >1.
On montre par récurrence que, pour tout n , un >1. On en déduit que ( un ) est décroissante,
et converge donc vers un réel l . On prouve ensuite que l = 1.
1 Cas particulier : x = 2 1 from math import sqrt
a. Compléter la fonction suite(prec) ci-contre afin qu’elle 2 def suite(prec):
renvoie le nombre d’itérations nécessaires pour que
un −1< prec, ainsi que le terme un correspondant. 3 u=2
b. En utilisant la fonction suite(prec), quelle instruction doit-on 4 n=0
saisir dans la console pour que seul l’affichage de un se fasse ? 5 while u-1>=prec :
suite(prec)[0] 6 u=sqrt(u)
c. Quel résultat obtient-on si on utilise l’instruction suite(prec)[1] ? 7 n=n+1
On n’obtient que la valeur de n telle que un −1< prec. 8 return u,n
d. Implanter la fonction dans l’éditeur Python et compléter le tableau (arrondir à 10−9 près).
prec 0,01 0,0001 10–8 10–9
suite(prec)[0 ] 1,000677131 1,000084616 1,000000005 1,000000001
suite(prec)[1] 10 13 27 30
e. Compléter les égalités suivantes.
= 0,6933818297000016
= 0,6933818297000016
En utilisant l’algorithme de Briggs, de quelle valeur obtient-on des valeurs approchées ?
( )1
On a, pour x = 2, ln 22n ≈ h, où n = suite(prec)[1] et 1 + h = suite(prec)[0],
donc h = suite(prec)[0]-1. On a des approximations de ln(2).
2 Cas général
Modifier la fonction précédente en créant une fonction
suite(prec,x) afin qu’elle affiche le plus petit entier n
ainsi que la valeur de un en ayant comme paramètre la
précision souhaitée ainsi qu’une valeur de x , où x >1.
28 › Algorithme de Briggs
PARTIE 2 Algorithme de Briggs
1 def briggs(x,prec):
2 n=suite(prec,x)[1]
1 Compléter la fonction briggs ci-contre afin qu’elle ren-
3 h=suite(prec,x)[0]-1
voie une valeur approchée de ln( x ) avec la précision
prec. 4 return h*2**n
2 Dans le préambule on a choisi d’éliminer les

réels x tels que x ∈ ]0;1] .
Utiliser la fonction briggs afin de créer une fonc-
tion briggs_tout qui renvoie une valeur appro-
chée de ln( x ) pour tout x de ]0; +∞[ .
PARTIE 3 Avec calculatrice

Dans les années 1950, les premiers calculateurs « de poche » sont apparus. Afin d’optimi-
ser des algorithmes pour que les calculs puissent se faire rapidement, Volder, ingénieur
américain, créa le premier algorithme de CORDIC (COordinate Rotation Digital Computing)
pour le logarithme, algorithme implanté dans les calculatrices et qui utilise les techniques
de Briggs.
Le principe de l’algorithme de CORDIC est le suivant.
Soit x ∈ ]1;10[ .
On suppose connu les valeurs de ln(10) et ln(1+10−i ) , où i est un entier compris entre 0 et
10. Grace à ces valeurs on peut calculer tous les autres logarithmes.
Pour tout entier i compris entre 0 et 10, on a lim (1+10−i ) = +∞ , on en déduit qu’il existe
n
n→+∞
un entier naturel N tel que x (1+10−i ) !10 ! x (1+10−i ) .
N N +1
On peut démontrer que N !10. y ← ln(10)

D’où ln(10) − ( N +1)ln(1+10−i ) ! ln( x ) ! ln(10) − Nln(1+10−i ) . Pour i allant de 0 à 10 :
1 L’algorithme de CORDIC, pour x ∈ ]1;10[ . z ←1+10−i
L’appel de la variable y permet d’obtenir une valeur approchée Tant que xz !10:
de ln( x ) . x ← xz
a. Dans cet algorithme, combien de logarithmes sont utilisés ? y ← y − ln( z )
Quels sont ces logarithmes ? Fin Tant que
Fin pour
ln(10) ;ln(1+100 ) = ln(2) ;ln(1,01) ;ln(1,01) ;… ; ln(1+10−10 ) ,
soit 12 logarithmes.
b. Implanter cet algorithme dans un éditeur Python sous
forme d’une fonction cordic(x).
2 On souhaite utiliser l’algorithme de CORDIC pour calculer
une valeur approchée de n’importe quelle valeur de x où
x ∈ ]0; +∞[ .
Pour pallier les valeurs de x telles que x >10, on propose la fonction
reduc ci-contre.
a. Sans écrire la fonction dans un éditeur Python, prévoir ce que va
retourner l’appel dans la console de l’instruction
(on pourra proposer un tableau d’états).
x 103,24 10,324 1,0324
k 1 2 3
Résultats : 1,0324 , 2.
b. Écrire la fonction reduc dans un éditeur Python et retrouver le
résultat précédent.
Objectifs
Travaux pratiques • Approximation de la courbe représen-

tative d’une solution d’une équation diffé-
rentielle
Équation différentielle Méthode d’Euler

Un circuit électrique comprend un générateur de force électromotrice E = 5 volts, un dipôle
(R, C) (association d’un condensateur de capacité C = 1 farad et d’un conducteur ohmique
R = 100 ohms) et un interrupteur.
À tout instant t en secondes, on note q(t) la charge du condensateur en coulombs.
1
On admet que la charge q du condensateur est telle que : R q ′ ( t ) + q ( t ) = E avec q (0) = 0
C
(on admet que cette équation différentielle admet une unique solution q définie sur [0; +∞[ ).
Mettre cette équation sous la forme q ′ ( t ) = m q ( t ) + b où m et b sont des constantes à préciser.
On obtient q ′ ( t ) = −0,01 q ( t ) + 0,05. (*)
PARTIE 1 Méthode d’Euler

Cette méthode nous permet d’obtenir une approximation de la courbe représentative de la
fonction q. On va construire un nuage de points de coordonnées ( t n ; yn ) tels que les réels t n
appartiennent à l’intervalle [0 ; 600] et yn proche de q ( t n ) .
1 Quelques rappels
On considère la figure ci-contre dans
𝒞
laquelle C est la courbe représentative
d’une fonction f dérivable sur [0; +∞[ et d M d
est la tangente à C au point A d’abscisse a.
a. Donner l’équation réduite de la droite d. N
y = f ′ ( a )( x − a ) + f ( a )
b. En déduire l’ordonnée du point N de la A
droite d d’abscisse a + h avec h non nul. f(a)
L’ordonnée de N est f ( a ) + hf ′ ( a ) .
0 a a+h
c. Donner l’ordonnée du point M.
L’ordonnée de M est f ( a + h ).
d. Que peut-on dire des deux valeurs précédentes lorsque h tend vers 0 ?
Lorsque h tend vers 0, les deux valeurs précédentes sont très proches.
e. En déduire une approximation de f ( a + h ) qui utilise f ( a ) , f ′ ( a ) et h.

f ( a + h ) ≈ f ( a ) + hf ′ ( a )
2 Retour au problème
a. Soit t un réel positif et h un réel strictement positif, en utilisant l’équation (*) et le résultat
de la question 5, donner une approximation de q ( t + h ) qui utilise q ( t ) et h.
On obtient q ( t + h ) ≈ q ( t ) + h (0,05 − 0,01q ( t )) .
b. Compléter alors le tableau ci-dessous.
n tn q(tn) ≈ yn
0 t0 = 0 q(t0) = q(0) = 0 = y0
1 t1 = t0 + h = h q(t1) = q(t0 + h) ≈ y0 + h(0,05 − 0,01y0) = y1
2 t2 = t1 + h = 2h q(t2) = q(t1 + h) ≈ y1 + h(0,05 − 0,01y1) = y2
30 › Méthode d’Euler
PARTIE 2 Programmation de la méthode en Python
1 Écrire ci-dessous une fonction nommée Euler_
liste qui prend pour paramètre h et qui renvoie
dans une liste les termes de la suite ( yn ) pour n
600 ⎞
allant de 0 à N où N = E ⎛ .
⎝ h ⎠
2 Écrire ci-dessous le dernier élément de la liste

lorsqu’on saisit dans la console Python euler_
liste(10).
La dernière valeur est 4.991014948500428.
3 On souhaite afficher une approximation de la courbe de la fonction q sur l’intervalle [0 ; 600].

Compléter la fonction graphe_q ci-dessous. Cette fonction utilisera la fonction euler_liste
précédente.
1 def graphe_q(h):
2 N=floor( 600/h )
3 x=[k*h for k in range( N+1 )]
4 y=euler_liste(h)
5 plt.plot(x,y)
6 plt.show()
4 Saisir dans la console Python graphe_q(5). Quelle conjecture peut-on faire sur la limite de
la fonction q lorsque t tend vers +∞ ?
On conjecture que lim q ( t ) = 5.
t→+∞
PARTIE 3 La constante de temps

La tension maximale du condensateur est Q = EC.
Le temps nécessaire pour atteindre 63 % de la tension maximale du condensateur est
appelé la constante de temps, notée τ .
1 Écrire ci-dessous une fonction nommée constante_temps de paramètre h qui retourne une
approximation de cette constante de temps τ .
Cette fonction utilisera la fonction euler_liste précédente.
2 Quelles sont les valeurs retournées lorsqu’on saisit dans la console Python constante_
temps(5) ? constante_temps(1) ?
Pour constante_temps(5), il s’affiche 100 et pour constante_temps(1), il s’affiche 99.
3 On sait que la formule permettant de calculer cette constante de temps est τ = RC .

Les résultats obtenus à la question 2 sont-ils cohérents avec cette formule ?
Oui, car τ = RC = 100.
papier & crayon
anch
é
5. Calcul approché d’intégrales (rectangles, trapèzes)

1 Soit la fonction f définie sur [ −1;1] par f ( x ) = e− x . 1 def rectangle_sup(n):
On note 𝒞 sa courbe représentative F E 2 aire=0
dans un repère du plan. On note 𝒟 D C
3 for k in range( n ):
le domaine délimité par la
courbe 𝒞, l’axe des abscisses et les 4 aire=aire+2/n*f(-1+k*2/n)
droites d’équations x = −1 et x = 1. 5 return aire
On partage l’intervalle [ −1;1] en n
2 3. Voici l’affichage obtenu lorsqu’on écrit dans la
intervalles de même amplitude
n console Python rectangle_sup(1000).
A B
et on construit sur chacun de ces
a
intervalles deux rectangles comme a+
sur la figure ci-contre. Quelle conjecture peut-on faire ?
1. Compléter la phrase ci-dessous. L’aire du domaine 𝒟 est d’environ 2,35 unité d’aire.
2
Sur l’intervalle ⎡⎢ a ; a + ⎤⎥ , l’aire « sous la courbe de 4. a. Donner ci-dessous la valeur exacte de l’aire du
⎣ n⎦ domaine 𝒟.
f » est comprise entre les aire des rectangles ABCD A ( D) = e1 − e −1
2 2
et ABEF . Ces rectangles ont pour aires f ⎛ a + ⎞ b. Écrire ci-dessous une fonction erreur de para-
n ⎝ n⎠
2
et f ( a ) . mètre p qui retourne le nombre minimal n de rec-
n tangle à construire afin que la différence entre la
2. On a écrit dans l’éditeur Python la fonction f somme des aires des n rectangles et l’aire exacte
ci-dessous. du domaine 𝒟 soit strictement inférieure à 10− p .
Compléter la fonction rectangle_sup ci-contre de

paramètre n le nombre de rectangles construits sur
l’intervalle [ −1;1] et qui retourne une valeur
approchée par excès de l’aire du domaine 𝒟.
2 1. On écrit dans l’éditeur Python la fonction ci-dessous. Écrire ci-dessous une fonction trapèze de
paramètres n et a qui retourne la somme des aires
de ces n trapèzes.
Quelle est l’expression de la fonction ainsi définie ?

2
1 − x2
f (x) = e
2π
2. On note 𝒞 sa courbe représentative sur l’intervalle
[ −a ; a ], où a est un entier naturel non nul. On note Da
le domaine délimité par la courbe 𝒞, D
l’axe des abscisses et les droites C 3. Voici l’affichage obtenu
d’équations x = −a et x = a. dans la console Python.
On partage l’intervalle [ −a ; a ] en n Que peut-on conjecturer ?
intervalles de même amplitude et on
On conjecture que l’aire
construit sur chacun de ces
intervalles un trapèze comme sur la sous la courbe de f sur ℝ vaut 1.
figure ci-contre. A B
32 › Calcul approché d’intégrales (rectangles, trapèzes)

ordinateur
3 1. Recopier dans l’éditeur Python, la fonction f de 3. Écrire ci-contre

0,5
paramètre x de l’exercice 2 de la page précédente. une fonction nom-
Recopier et compléter la fonction graphe_f de mée graphe_tra- 0,4
paramètre a entier naturel non nul qui permet pèze de paramètres 0,3
d’afficher la courbe de f sur l’intervalle [ −a ; a ]. n et a qui permet
d’afficher comme 0,2
sur la figure 0,1
2 def graphe_f(a): ci-contre la courbe 0
3 plt.axis([-a,a,0,0.5]) de la fonction f sur –3 –2 –1 0 1 2 3
l’intervalle [ −a ; a ],
4 x=[-a+k/1000 for k in range(2000*a )]
les n trapèzes de même hauteur sur [ −a ; a ] et ren-
5 y=[f(i) for i in x ] voie la somme des aires de ces n trapèzes.
6 plt.plot(x,y,'k',linewidth=3) Cette fonction utilisera les fonctions graphe_f et
7 plt.show() un_trapèze précédentes.
2. Recopier et compléter la fonction D

un_trapèze de paramètres a et b C
qui permet de tracer comme sur la
figure ci-contre le trapèze ABCD, où
A et B ont pour abscisses respectives
a et b et C et D sont sur la courbe de
la fonction f.
A B
4. Quel est l’affichage obtenu lorsqu’on saisit dans
1 def un_trapèze(a,b): la console Python graphe_trapèze(8,3) ?
2 plt.plot([ a , a , b , b ],[ 0, f(a) , f(b) , 0],'r')
4 1. Recopier dans l’éditeur Python la fonction f de

paramètre x de l’exercice 1 de la page précédente
puis recopier et compléter la fonction graphe_f qui
permet d’afficher la courbe de la fonction f sur 3. Écrire ci-dessous une fonction nommée graphe_
l’intervalle [ −1;1]. rectangle de paramètre n qui permet d’afficher
comme sur la figure ci-dessous la courbe de la
1 import matplotlib.pyplot as plt fonction f, les n rectangles « inférieurs » sur l’inter-
2 def graphe_f(): valle [ −1;1] et renvoie une valeur approchée de l’aire
3 plt.axis([-1,1,0,3]) du domaine délimité par la courbe de f, l’axe des
4 x=[-1+k/1000 for k in range(2001 )] abscisses et les droites d’équation x = −1 et x = 1.
5 y=[f(i) for i in x ] Cette fonction utilisera les fonctions précédentes.
6 plt.plot(x,y,'k',linewidth=3)
7 plt.show()
2. Écrire ci-après une fonction

nommée un_rectangle_inf de D C
paramètres a et b et qui per-
mettent de tracer (sans afficher)
comme sur la figure ci-contre
le rectangle ABCD, où A et B ont
pour abscisses respectives a et b
et les points C est sur la courbe de A B
la fonction f. a b
Objectif
Travaux pratiques • Approximer Pi et le volume d’une boucle
Probabilités Méthode de Monte Carlo
PARTIE 1 Méthode de Monte Carlo dans le plan

On considère une cible carrée de centre O comme dessinée 1
sur la figure ci-contre. À l’intérieur est tracé un disque de
centre O et de rayon 1.
1 On lance au hasard sur cette cible une fléchette. Quelle est la
probabilité p que cette fléchette « tombe » dans le disque ?
aire du disque π –1 O 1
p= =
aire du carré 4
2 On lance au hasard sur cette cible N fléchettes, où N est un
entier naturel non nul. On note d le nombre de fléchettes
obtenues dans le disque parmi les N fléchettes lancées. En –1
supposant N « grand », donner une approximation de p en
fonction de N et d.
d
p≈
N
3 Déduire des deux questions précédentes une approximation de π en fonction de d et N.
π d d
≈ ⇔ π ≈4×
4 N N
PARTIE 2 Simulation de l’expérience avec Python

1 On écrit dans la console Python les deux lignes
ci-contre.
Quelles sont les valeurs prises par les
variables x et y ?
x et y prennent des valeurs réelles aléatoires comprises entre −1 et 1.
Que permet de simuler la deuxième ligne ?
Elle simule le lancer au hasard d’une fléchette dans la cible carrée ci-dessus.
2 a. Après avoir importé le module random de la bibliothèque random, écrire dans l’éditeur
Python une fonction nommée monte_carlo de paramètre N, nombre de fléchettes lancées
dans la cible carrée ci-dessus, et qui retourne une approximation de pi.
b. Donner une valeur affichée lorsqu’on écrit dans la console Python monte_
carlo(5000000) ?
Une valeur affichée possible est 3.1416776.
34 › Méthode de Monte Carlo

3 On souhaite visualiser la cible
carrée dessinée dans la par-
tie 1. Pour cela, on écrit dans
l’éditeur Python la fonction ci-
contre.
Expliquer le rôle des trois der-
nières lignes du programme.
La première des trois dernières lignes permet de tracer le carré dont les sommets ont
pour coordonnées ( −1; −1) , (1; −1) , (1;1) et ( −1;1) . La deuxième des trois dernières lignes
permet de tracer le demi-cercle « supérieur » de centre O et de rayon 1. La dernière ligne
permet de tracer le demi-cercle « inférieur » de centre O et de rayon 1.
4 a. Recopier la fonction 1 def graphe_monte_carlo(N):
cible dans l’éditeur Py-
2 cible()
thon. En s’inspirant de
3 d=0
la fonction monte_carlo
précédente, compléter la 4 for k in range(N):
fonction graphe_monte_ 5 x,y=random()*2-1 ,random()*2-1
carlo(N) ci-contre afin 6 if x**2+y**2<=1 :
qu’elle affiche dans un 7 d=d+1
graphique la cible car- 8 plt.plot(x,y,'r.' )
rée, les points obtenus 9 else :
dans le disque en rouge 10 plt.plot(x,y,'b.')
et ceux hors du disque en 11 plt.show ()
bleu et qu’elle retourne
12 return d/N*4
une approximation de pi.
b. Donner un résultat lorsqu’on saisit dans la console Python graphe_monte_carlo(3000).
Un résultat affiché est par exemple 3,2066666666 ou 3,13866666666.
PARTIE 3 Méthode de Monte Carlo dans l’espace

L’objectif de cette partie est d’écrire une fonction qui donne une approximation du volume
de la boule de centre O et de rayon 1 avec la méthode de Monte Carlo. Dans un repère ortho-
normé de l’espace d’origine O, on considère un cube de centre O dont les arêtes mesurent
2 unités de longueur. On place dans ce cube une boule de centre O et de rayon 1 unité.
4
π
1 On place au hasard un point de coordon- p= 3
nées ( x ; y ; z ) dans le cube. Quelle est la 8
probabilité p qu’il soit dans la boule ?
2 a. Écrire ci-contre
une fonction nommée
monte_carlo_boule de
paramètre N (nombre
de points placés au
hasard dans le cube)
et qui retourne une ap-
proximation du volume
de la boule.
b. Quel résultat s’affiche lorsqu’on écrit dans la console monte_carlo_boule(1000000) ?
Il s’affiche par exemple 4,188424.
papier & crayon
anch
é
6. Planche de Galton et simulation

d’une variable aléatoire binomiale
1 La planche de Galton est constituée de rangées horizontales de clous déca-
lées d’un demi-cran par rapport à la précédente. On lâche les billes au som-
met et celles-ci rebondissent de clou en clou jusqu’à la base de la planche où
elles sont collectées dans des réservoirs.
Le diamètre des billes et l’écartement entre chaque clou est choisi de telle
sorte qu’une bille a exactement autant de chance de rebondir à droite ou à
gauche du clou.
1. On considère un système à deux rangées de clous, et on note D si le rebond
de la bille est à droite et G sinon. 0 1 1 8 5 10 9 7 1 0 0
a. Écrire ci-dessous les séquences possibles. GG, GD, DG, DD
b. Quelle est la probabilité que la bille finisse dans le réservoir de gauche ? de droite ? du milieu ?
1 1 1
, et
4 4 2
2. On considère un système à dix rangées de clous. On a donc 11
réservoirs.
On a écrit la fonction ci-contre dans l’éditeur de Python.
a. Quelles sont les valeurs prises par la variable position ?
La variable position peut prendre toutes les valeurs réelles
de l’intervalle [0 ; 1[.
b. Que simule la condition position<0.5 ?
Si la variable position prend une valeur inférieure à 0,5 alors la bille rebondit à droite, sinon elle
rebondit à gauche.
c. Quelles sont les valeurs prises par la variable D ?
D peut prendre toutes les valeurs entières comprises entre 0 et 10.
d. Que simule la fonction droite ?
Elle retourne le nombre total de rebonds à droite qu’à fait la bille en parcourant les dix rangés de clous.
e. En allant de gauche à droite, on nomme « 0 » le premier réservoir, « 1 » le second, et ainsi de suite jusqu’au
onzième.
On donne l’affichage obtenu dans la console Python :
Que simule ce résultat ? Dans quel réservoir arrive la bille ?
La bille a fait 7 rebonds à droite et arrive dans le réservoir « 7 », c’est-à-dire le 8e réservoir en partant
de la gauche.
3. Un jeu consiste à miser 2 € puis à lancer une bille sur la
planche de Galton à 10 rangées de clous.
On donne ci-dessous les gains obtenus selon le réservoir où
arrive la bille.
[5 €, 4 €, 3 €, 2 €, 1 €, 0,00 €, 1 €, 2 €, 3 €, 4 €, 5 €].
Écrire ci-contre une fonction jeu sans argument qui retourne le
gain du joueur.
Cette fonction pourra utiliser la fonction droite précédente.
36 › Planche de Galton et simulation d’une variable aléatoire binomiale

ordinateur
2 1. On considère le jeu de la question 3 précédente et on souhaite effec-

tuer plusieurs fois ce jeu.
Recopier dans l’éditeur Python les fonctions droite et jeu précédentes.
Écrire ci-contre et dans l’éditeur Python une fonction plusieursjeu qui
prend pour argument N le nombre de partie jeu et qui retourne le gain
total obtenu.
Cette fonction pourra utiliser la fonction jeu précédente.
2. Donner ci-dessous trois résultats affichés lorsqu’on saisit dans la console Python plusieursjeu(1000).
On obtient par exemple −783, −830, −780.
3. On note X la variable aléatoire qui, à une bille, associe le numéro du réservoir dans lequel elle arrive après
les dix rangées de clous.
a. Quelle est la loi de probabilité suivie par X ? X suit la loi binomiale B(10 ; 0,5).
b. Compléter les tableaux ci-dessous en utilisant la calculatrice. Les résultats seront arrondis à 10−3 .
X 0 1 2 3 4 5 6 7 8 9 10
proba 0,001 0,01 0,044 0,117 0,205 0,246 0,205 0,117 0,044 0,01 0,001
c. On note Y la variable aléatoire qui donne le gain obtenu en fonction du réservoir dans lequel tombe la bille.
Quelles sont les valeurs prises par la variable aléatoire Y ?
Y prend les valeurs 3 €, 2 €, 1 €, 0 €, 1 € et 2 €.
Calculer l’espérance de la variable aléatoire Y.
E (Y ) ≈ 3 × 0,001+ 2 × 0,01+ 0,044 − 0,205 − 2 × 0,246 + …+ 2 × 0,01+ 3 × 0,001= −0,768
En déduire le gain moyen lorsqu’on effectue 1 000 fois le jeu. Le gain moyen est −0,768 ×1000 = −768.
3 Le but de cet exercice est de visualiser la répartition de N billes dans les réservoirs d’arrivés lorsqu’elles ont
été lancées successivement au sommet d’une planche de Galton à L rangées de clous.
1. Modifier la fonction droite précédente afin qu’elle 1 def galton(N,L):
prenne pour argument L et retourne le nombre de 2 réservoir=[ 0,]*(L+1)
rebonds à droite effectués par la bille au bout des L
3 for n in range(N):
rangées de clous.
4 D=droite(L)
5 réservoir[D]=réservoir[D]+1
6 plt.plot( D , réservoir[D] ,'r*')
7 plt.show()
8 return réservoir
a. Expliquer la ligne réservoir=[0,]*(L+1).

La variable réservoir est une liste qui contient L+1
zéro.
b. Recopier et compléter ci-dessus la fonction
2. On considère la fonction incomplète galton galton en utilisant la fonction droite précédente.
ci-contre. Cette fonction a pour arguments N le c. Écrire ci-dessous l’affichage obtenu lorqu’on sai-
nombre de billes lancées et L le nombre de rangées sit dans la console galton(1000,5).
de clous.
On obtient par exemple [32, 157, 319, 311, 148, 33].
Objectif
Travaux pratiques • Modéliser et simuler une marche

aléatoire
Probabilités Marche aléatoire

On considère un jeu de Pile ou Face où un joueur joue contre une banque. Le joueur lance une
pièce de monnaie parfaitement symétrique (la probabilité d’obtenir « Pile » est égale à la
probabilité d’obtenir « Face »). Pour chaque lancer, si le résultat est « Pile », le joueur gagne
1 € de la banque et si le résultat est « Face », le joueur perd 1 € qu’il donne à la banque.
Ceci est répété un nombre fini de fois. Il est clair que chaque lancer n’est pas influencé par
les lancers précédents.
PARTIE 1 Modélisation d’un jeu

1 On considère ci-contre la fonction lance de paramètre n.
a. Lorsqu’on saisit lance(5) dans la console, quel résultat
pourrait être affiché ?
['F' , 'F' , 'F' , 'F' , 'P']
b. Que simule cette fonction ? Quel sera le résultat affiché ?
Cette fonction simule n lancers de la pièce.
Elle affiche la liste de Pile et Face obtenus.
2 On appelle X n la variable aléatoire qui donne le gain du joueur après les n lancers de la
pièce de monnaie.
a. Quelles sont les valeurs prises par la variable aléatoire X 3 ?
La variable aléatoire X 3 prends les valeurs −3, −1, 1 et 3
b. Compléter la fonction gain ci-contre qui simule le 1 def gain(n):
gain du joueur après avoir effectué n lancers de la
2 L=lance( n )
pièce de monnaie.
Tester quatre fois cette fonction pour n = 3 et noter 3 G=0
ci-dessous les résultats obtenus. 4 for k in L :
Exemple de résultats obtenus 1,1, −1, 3 5 if k=='P' :
c. Écrire ci-dessous une fonction plusieursjeux de 6 G=G+1
paramètres n (nombre de lancers de la pièce de mon-
7 else:
naie) et N (nombre de jeux effectués) qui retourne le
gain moyen du joueur lors des N jeux. Cette fonction 8 G=G-1
pourra utiliser la fonction gain précédente. 9 return G
Quel est le résultat affiché lorsqu’on saisit dans la console Python plusieursjeux(3,100000) ?
Que peut-on conjecturer ?
Un résultat possible affiché est 0,00902. On peut conjecturer que le gain moyen est nul.
d. Compléter le tableau suivant.
X 3 prend
En déduire l’espérance de la variable aléatoire X 3 . −3 −1 1 3
la valeur
L’espérance est égale à 0 1 3 3 1
Probabilité
8 8 8 8
38 › Marche aléatoire
PARTIE 2 Une représentation graphique pour un jeu de 5 lancers
On veut représenter dans un repère du plan une séquence de cinq lancers par une ligne
brisée qui part de l’origine du repère. L’axe des abscisses représente le nombre de lancers
du jeu et l’axe des ordonnées les gains possibles du joueur.
1 Quels sont les gains possibles du joueur 1 import matplotlib.pyplot as plt
lors d’un jeu de cinq lancers d’une pièce
2 def graphejeu():
de monnaie ?
3 plt.axis([0,5,-5 ,5 ])
Les gains possibles sont −5, −3, −1, 1, 3 et 5.
4 plt.grid()
1 Compléter la fonction graphejeu ci-contre
5 x=[0]
qui affiche la ligne brisée correspondant à
un jeu de cinq lancers et qui retourne le 6 y=[0]
gain du joueur. 7 for k in range(5):
2 Combien y-a-t-il de lignes brisées possibles 8 x.append(x[k]+1 )
lors d’un jeu de 5 lancers d’une pièce de 9 if randint(0,1)==1:
monnaie ?
10 y.append( y[k]+1 )
Il y a 25 = 32 lignes brisées possibles 11 else:
12 y.append(y[k]-1)
13 plt.plot(x,y)
14 plt.show()
15 return y[-1]
PARTIE 3 Retour à l’origine
On s’intéresse au problème de la « ruine du joueur ». C’est-à-dire au moment où la fortune
du joueur est nulle.
1 On note n le nombre de lancers de la pièce de monnaie. Quelle doit être la parité de n afin
que le gain du joueur puisse être nul ?
n doit être pair.
2 a. Écrire une fonction gainnul de paramètres n (nombre
de lancers de la pièce de monnaie) et N (nombre de jeux
de n lancers) qui retourne la fréquence des jeux dont le
gain est 0,00 € parmi les N jeux effectués. Cette fonction
devra utiliser la fonction gain précédente.
b. Tester cette fonction dans la console Python pour n = 20 et N = 100 000. Quel est le résul-
tat affiché ?
Le résultat affiché peut être par exemple 0,17615.
3 a. On note Y20 la variable aléatoire qui donne le nombre de pile obtenu par le joueur lors de
20 lancés d’une pièce de monnaie. Donner la loi de probabilité suivie par Y20 .
Y20 suit la loi binomiale de paramètres n = 20 et de probabilité du succès p = 0,5.
b. Compléter la phrase ci-dessous.
« Le gain du joueur est de 0,00 € si et seulement si Y20 prend la valeur 10 »
c. Calculer alors la probabilité d’avoir un gain de 0 euro lors d’un jeu de 20 lancers. Arrondir
le résultat à 10−3 .
P (Y = 20) ≈ 0,176
rs l’ é p re u ve du Bac
Ve
1 Exercice type 1 • Limite de suites

Soit u1 un réel donné. • Boucle bornée
On considère la suite ( un ) définie, pour tout entier naturel n , par un+1 = ( n +1) un −1.
1. Vérifier par le calcul que, si u1 = 0 , alors u4 = −17.
On a u2 = 2u1 −1= 2 × 0 −1= −1 ; u3 = 3u2 −1= 3 × ( −1) −1= −4 ; u4 = 4u3 −1= 2 × ( −4 ) −1= −17
2. Recopier et compléter l’algorithme ci-dessous 4. Compléter la nouvelle fonction nommée suite2
écrit en langage naturel, pour que, en saisissant ci-dessous, afin qu’elle affiche la liste des termes de
préalablement dans U la valeur de u1, il calcule les la suite depuis u1 jusqu’à un .
termes de la suite ( un ) de u2 à u13 .
1 def suite2(u1,n):
Pour N allant de 1 à 12 2 U=u1
U ← N × U −1
3 S=[u1]
3. Compléter la fonction suivante écrite en Python 4 for N in range( 2 , n+1 ):
qui renvoie le résultat de l’algorithme précédent 5 U=N*U-1
pour une valeur de u1 et une valeur du rang n entrés
6 S.append( U )
en arguments.
7 return S
1 def suite(u1,n):
2 U=u1 5. En utilisant cette fonction, conjecturer la limite de
la suite ( un ) lorsque u1 = 0,7 puis lorsque u1 = 0,8.
3 for N in range( 2 , n+1 ):
On conjecture que pour u1 = 0,7 la suite tend vers −∞.
4 U=i*U-1
5 return U Pour u1 = 0,8 la suite tend vers +∞.

On considère la suite ( Tn ) définie par T0 = 80 et, pour tout entier naturel n , par : • Boucle bornée
Tn+1 − Tn = k ( Tn − M ) ,
où k et M sont deux constantes réelles.
1. Montrer que, pour tout entier naturel n , Tn+1 = ( k +1) Tn − kM .
Tn+1 − Tn = k ( Tn − M ) ⇔ Tn+1 = Tn + kTn − km
⇔ Tn+1 = ( k +1) Tn − kM
2. Compléter la fonction Python suivante, nommée 3. Écrire cette fonction dans un éditeur Python et
suiteT, d’arguments k, M et n, afin qu’elle renvoie le conjecturer la limite de la suite ( Tn ) lorsque n tend
terme de rang n de la suite ( Tn ) . vers +∞.
1 def suiteT(k ,M ,n ): On conjecture que la suite ( Tn ) tend vers 10.
2 T=80
3 for i in range( 1 , n+1 ):
4 T=(k+1)*T-k*M
5 return T
40 › Vers l’épreuve du Bac

3 Exercice type 3 • Logarithme
Dire si l’affirmation suivante est fausse et justifier la réponse. • Boucle non bornée
Soit A un réel strictement positif. • Langage naturel
On considère l’algorithme ci-dessous écrit en langage naturel.
I ←0
Tant que 2I ! A
I ← I +1
On suppose que la variable I contient la valeur 15 en fin d’exécution de cet algorithme.
Affirmation. 15ln(2) ! ln( A ) !16ln(2)
L’affirmation est FAUSSE
Si la variable I contient la valeur 15 à la fin de l’algorithme alors 214 ! A et 215 > A .
Donc 14ln(2) ! ln( A ) !15ln(2) .

Une commune dispose de 380 voitures et propose un système de locations de ces • Boucle bornée
voitures selon les modalités suivantes :
• chaque voiture est louée pour une durée d’un mois ;
• la location commence le premier jour du mois et se termine le dernier jour du même mois ;
• le nombre de voitures louées est comptabilisé à la fin de chaque mois.
À la fin du mois de janvier 2019, 280 voitures ont été louées avec ce système de location.
Le responsable de ce système souhaite étudier l’évolution du nombre de locations de voiture. Pour cela, il
modélise le nombre de voitures louées chaque mois par une suite ( un ) , où, pour tout entier naturel n , un
représente le nombre de voitures louées le n-ième mois après le mois de janvier 2019. Ainsi, u0 = 280.
On admet que cette modélisation conduit à l’égalité un+1 = 0,9un + 42.
1. Combien de voitures ont été louées avec ce 3. En utilisant cette fonction, conjecturer la date à
système de location au mois de février ? laquelle le nombre de voitures louées dépassera le
u1 = 0,9 × u0 + 42 = 0,9 × 280 + 42 = 294 stock de voitures dont dispose la commune.
On trouve que le nombre de voiture louées
294 voitures ont été louées en février.
dépassera 380 au mois de janvier 2020.
2. Compléter la fonction nommée location
ci-dessous, d’argument n, afin qu’elle renvoie la 4. Conjecturer le nombre limite de voitures que la
liste du nombre de voitures louées depuis le mois commune doit avoir en stock pour qu’elle puisse
de janvier jusqu’au n-ième mois. toujours en louer une.
1 def location(n): On conjecture que la limite de la suite ( un ) est 420.
2 u=280 Il faudrait donc que la commune possède au moins
3 L=[u] 420 voitures pour pouvoir toujours en louer une.
5 u=0.9*u+42
6 L.append(u )
7 return L
Vers l’épreuve du Bac ‹ 41

Ve
5 Exercice type 5 • Algorithme de dichotomie

On considère la fonction f définie sur l’intervalle [ −4 ;10] par : • Boucles non bornée et bornée
f ( x ) = 1+ ( −4x 2 −10x + 8)e −0,5x . • Variables et affectation
1. On admet que l’équation f ( x ) = 0 admet une unique solution dans

l’intervalle [ −4 ;2] .
On considère l’algorithme suivante écrit en langage naturel.
a ← −4
b ← −2
Tant que ( b − a ) > 0,1
a+b
m←
2
p ← f (a) × f (m)
Si p > 0 alors
a←m
Sinon
b←m
Compléter la troisième ligne du tableau ci-dessous correspondant au deuxième passage dans la boucle.
m Signe de p a b a−b b − a > 0,1
Initialisation −4 −2 2 VRAI
Après le 1er passage dans la boucle −3 Négatif −4 −3 1 VRAI
Après le 2e passage dans la boucle − 3,5 Positif − 3,5 −3 0,5 VRAI
2. Compléter les fonctions Python f et algo suivantes 3. En utilisant les fonctions précédentes, montrer
dans un éditeur Python, pour qu’elles renvoient les que les valeurs de a et de b obtenues sont
valeurs finales de a et b calculées par l’algorithme a = −3,1875 et b = −3,125 .
précédent.
1 from math import exp
2 def f(x):
4. Interpréter le résultat.
3 return 1+(-4*x**2-10*x+8)*exp(-0.5*x)
Cet algorithme est un algorithme de dichotomie. Il
4
5 def algo(): permet d’obtenir un encadrement de la solution α
6 a=-4 de l’équation f ( x ) = 0 dans l’intervalle [ −4 ; −2].
7 b=-2 On peut donc affirmer que −3,1875 < α < −3,125.
8 while b-a>0.1 :
9 m=(a+b)/2
10 p=f(a)*f(m)
11 if p>0 :
12 a=m
13 else:
14 b=m
15 return , a ,b

Un infographiste simule sur ordinateur la croissance d’un bambou. Il • Boucles bornée et non bornée
prend pour modèle un bambou d’une taille initiale de 1 m dont la taille
augmente d’un mois sur l’autre de 5 % auxquels s’ajoutent 20 cm. Pour
tout entier naturel n ,non nul, on note un la taille, exprimée en centimètre, qu’aurait le bambou à la fin du
n-ième mois, et u0 = 100.
1. Calculer u1 et u2 .
Le coefficient multiplicateur associé à une augmentation de 5 % est 1,05 .
On a donc u1 = 1,05 × u0 + 20 = 125 et u2 = 1,05 × u1 + 20 = 151,25.
2. On admet que, pour tout entier naturel n , un+1 = 1,05un + 20.
Écrire une fonction en Python, nommée taille, d’argument n, qui renvoie la taille du bambou au bout du
n-ième mois.
3. En utilisant la fonction précédente, calculer la taille du bambou à la fin du 7e mois.
Le bambou mesurera environ 3,03 mètres.

4. On considère la fonction taille2 ci-dessous, écrite en Python.
Quelle valeur renvoie cet algorithme lorsqu’on l’utilise ? Interpréter le résultat dans le contexte de l’exercice.
L’algorithme renvoie la valeur 4. La taille du bambou dépassera 2 mètres au bout de 4 mois.
5. Modifier la fonction précédente pour qu’elle détermine le nombre de mois qu’il faudrait à un bambou de
50 cm pour atteindre ou dépasser10 m. Combien trouve-t-on ?
On trouve 24 mois.

Ve
7 Exercice type 7 • Comparaison de suites

L’énergie houlomotrice est obtenue par exploitation de la force des • Boucle non bornée
vagues. Il existe différents dispositifs pour produire de l’électricité à partir
de cette énergie. Les installations houlomotrices doivent être capables de
résister à des conditions extrêmes, ce qui explique que le coût actuel de production d’électricité par énergie
houlomotrice est élevé. On estime qu’en 2019, le coût de production d’un kilowattheure (kWh) par énergie
houlomotrice était de 24 centimes d’euro. C’est nettement plus que le coût de production d’un kilowattheure
par énergie nucléaire, qui était de 6 centimes d’euro en 2018.
On admet qu’à partir de 2018 les progrès technologiques permettront une baisse de 5 % par an du coût de
production d’un kilowattheure par énergie houlomotrice.
Pour tout entier naturel n , on note cn le coût de production, en centime d’euro, d’un kilowattheure d’électricité
produite par énergie houlomotrice pour l’année 2019 + n. Ainsi, c0 = 24.
1. Calculer c1.
Baisser de 5 % revient à multiplier par 0,95. On a donc c1 = 0,95c0 = 22,8.
2. Dans cette question, on admet que le coût de 3. Dans cette question, on admet que le coût de
production d’un kilowattheure par énergie nucléaire production d’un kilowattheure par énergie nucléaire
reste constant et égal à 6 centimes d’euro. augmente chaque année d’un centime.
Compléter la fonction cout2 suivante pour qu’elle
a. Écrire une fonction Python, nommé cout, sans
renvoie l’année à partir de laquelle le coût d’un
argument, qui détermine l’année à partir de laquelle
kilowattheure produit par énergie houlomotrice
le coût d’un kilowattheure produit par énergie hou-
deviendra strictement inférieur au coût d’un
lomotrice deviendra strictement inférieur au coût
kilowattheure produit par énergie nucléaire.
d’un kilowattheure produit par énergie nucléaire.
1 def cout2():
2 c=24
3 D=6
4 n=0
5 while c>=D :
6 c=0.95*c
7 D=D+1
8 n=n+1
9 return 2019+n
b. Quelle année trouve-t-on ?
4. Quelle année trouve-t-on ?
On trouve l’année 2029.
On trouve, en utilisant la fonction, l’année 2047.

8 Exercice type 8 • Méthode des rectangles
On considère la fonction f définie sur [1; 3] par : • Intégration
f ( x ) = xln( x ) . • Boucle bornée
On a construit sa courbe représentative ci-dessous.
3,5
2,5
1,5
0,5
0
0 0,5 1 1,5 2 2,5 3
On construit la suite de nombre réels ( ai ) de la manière suivante.
On partage l’intervalle [1; 3] en n parties égales.
a0 = 1.
2
ai = a0 + × i pour tout entier naturel i compris entre 1 et n −1.
n
2
On construit n rectangles de largeur et de hauteur f ( ai ) pour i = 0;…, n −1.
n
On pose :
S n = a0 f ( a0 ) + a1 f ( a1) + …+ an−1 f ( an−1) .
1. Que représente S n ?
S n représente la somme des aires des n rectangles.
2. Écrire une fonction Python, nommée f qui renvoie la valeur de f ( x ) pour un réel x de l’intervalle [1; 3] .
3. Compléter la fonction nommée S suivante, d’argument n, qui renvoie la valeur de S n .

5 def S(n):
6 a=1
7 S=0
8 for i in range( 1 , n ):
9 a=1+i*2/n
10 S=S+2/n*f(a)
11 return S
3
4. En utilisant la fonction précédente, déterminer une valeur approchée de ∫ xln( x ) dx en utilisant 100 rectangles.
1
L’intégrale est environ égale à 2,91 au centième près.

Ve

On considère la suite ( un ) définie par u0 = 1 et, pour tout entier naturel n , • Boucle bornée
par : • Variables et affectation
1
un+1 = un + n − 2.
3
1. Compléter la fonction suivante pour qu’elle renvoie la valeur de un pour un entier naturel n entré en argument.
1 def suite(n):
2 u=1
4 u=u/3+i-3
5 return u
2. Conjecturer la limite de la suite ( un ) lorsque n tend vers +∞.

On conjecture que un tend vers +∞.
10 Exercice type 10 • Théorème des valeurs intermédiaires

Dans une usine, on se propose de tester un prototype de hotte • Équation
aspirante pour un local industriel. Avant de lancer la fabrication en • Langage naturel
série, on réalise l’expérience suivante : dans un local clos équipé du
prototype de hotte aspirante, on diffuse du dioxyde de carbone (CO2) à débit constant. Dans ce qui suit, t est le temps
exprimé en minute. À l’instant t = 0, la hotte est mise en marche et on la laisse fonctionner pendant 20 minutes.
Les mesures réalisées permettent de modéliser le taux (en pourcentage) de CO2 contenu dans le local au bout
de t minutes de fonctionnement de la hotte par l’expression f ( t ) , où f est la fonction définie pour tout réel t
de l’intervalle [0 ; 20] par :
f ( t ) = (0,8t + 0,2)e −0,5t + 0,03.
On admet que les variations de la fonction f sont les suivantes.
t 0 1,75 20
f ′ (t ) + 0 −
f
0,23
1. Calculer une valeur approchée de f (1,75) et de a. Quelle est la valeur de la variable t à la fin de cet
f (20) . algorithme ?
f (1,75) ≈ 0,697 et f (20) ≈ 0,031 Par approximations successives, on trouve
2. On admet qu’il existe un unique temps T dans f (15,65) ≈ 0,0351 et f (15,75) ≈ 0,0349 ;
l’intervalle [1,75;20] à partir duquel le taux de CO2
la valeur de t à la fin de l’algorithme est donc 15,75.
devient inférieur ou égal à 3,5 %.
On considère l’algorithme suivant : b. Interpréter cette variable t dans le contexte de
l’exercice.
t ←1,75
p ← 0,1
15,75 est une valeur approchée du temps
Tant que V > 0,035 en minutes à partir duquel le taux de CO2 sera
t ←t+ p
V ← (0,8t + 0,2)e −0,5t + 0,03
inférieur à 3,5 %. Ce temps est donc environ
de 15 minutes et 45 secondes.

11 Exercice type 11 • Intégration
On considère la fonction f définie pour tout réel x appartenant à l’intervalle [ −2,5;2,5] • Boucle bornée
par :
f ( x ) = ln( −2x 2 +13,5) .
2,5
On note I = ∫ f ( x ) dx .
0
1. On considère l’algorithme suivant :
S ←0
Pour k variant de 1 à n faire :
2,5 2,5
R← × f ⎛⎜ × k ⎞⎟
n ⎝ n ⎠
S←S+R
Utiliser cet algorithme pour compléter les lignes du tableau suivant. On arrondira les résultats à 10−6 près.
Initialisation S = 0, n = 50
Boucle Pour Étape k R S
1 0,130 116 0,130 116
2 0,130 060 0,260 176
3 0,129 968 0,390 144
4 0,129 837 0,519 981
2. Compléter les fonctions Python ci-dessous, nommées f d’argument x et Int d’argument n, pour qu’elles
renvoient le résultat de l’algorithme précédent.
1 from math import log
2 def f(x):
3 return log(-2*x**2+13.5)
4
5 def Int(n):
6 S=0
7 for k in range( 1 , n+1) :
8 R=2.5/n*f(2.5/n*k)
9 S=S+R
10 return S
3. En utilisant ces fonctions, calculer la valeur de la variable S lorsque n = 50. Interpréter le résultat.
On trouve
La variable S est une valeur approchée par défaut de la valeur de I .

Ve
12 Exercice type 12 • Factorielle

Un groupe d’amis constitué de trois filles et quatre garçons veut se faire photographier par • Permutation
un photographe professionnel. Le photographe propose plusieurs types de photographies. • Boucle bornée
Il dispose pour cela les membres du groupe assis côte à côte sur un banc.
1. Pour le premier type de photo, toutes les filles veulent rester ensemble côte à côte et tous les garçons aussi.
Combien de photos différentes peut prendre le photographe ?
Il y a 7 places sur le banc. Les filles veulent rester ensemble côte à côte et les garçons aussi.
Il n’y a que 2 façons de répartir le groupe des filles côte à côte sur le banc : FFFGGGG ou GGGGFFF.
Pour chacune de ces positions, il y a 3! permutations possibles pour les filles et 4 ! permutations possibles
pour les garçons.
Par le principe multiplicatif, il y a donc 2 × 3!× 4 ! = 288 photos différentes possibles.
2. Pour le deuxième type de photo, seules toutes les filles veulent rester ensemble côte à côte.
Les filles veulent rester ensemble mais le groupe des filles peut s’intercaler entre deux garçons.
Il y a donc 5 façons de répartir le groupe des filles côte à côte sur le banc : FFFGGGG ou GFFFGGG
ou GGFFFGG ou GGGFFFG ou GGGGFFF .
Pour chacune de ces positions, il y a 3! permutations possibles des filles. Et 4 ! permutations possibles
des garçons.
Par le principe multiplicatif, il y a donc 5 × 3!× 4! = 720 photos différentes possibles.
3. Pour le troisième type de photo, tout le monde peut se placer comme il souhaite sur le banc.
Tout le monde peut s’installer où il veut sur le banc. Il y a donc 7 choix possibles pour la première personne,
puis 6 choix possibles pour la deuxième personne, 5 choix pour la troisième personne,
4 choix pour la quatrième personne, 3 choix pour la cinquième personne, 2 choix pour la sixième personne
et plus qu’un choix pour la septième personne.
Il y a donc 7! = 5 040 photos différentes possibles.
4. Compléter la fonction nommée factorielle suivante, 5. Retrouver, en utilisant cette fonction, les résultats
d’argument n, afin qu’elle renvoie le nombre n ! des questions 1, 2 et 3.
2 f=1
3 for i in range( 1 , n+1):
4 f=f*i
5 return f

Cahier d’algorithmique
et de programmation
MÉMENTO
DE POCHE
COLLECTION BARBAZO
Le principe de l’algorithmique
porte mois if porte = ouverte

elif + for b = 14/5
a b
x else % a = 0.55555
// while
Variable(s) Instruction(s) Résultat(s)

Opération(s)
Sorte de boîte pouvant Condition(s) Valeurs des
contenir une valeur différentes variables
qui peut varier. mises en jeu dans
l’algorithme.
Edupython
Lancer un programme Arrêter une boucle infinie
Éditeur : lieu où
les programmes
sont écrits
Console : lieu où
les programmes
sont utilisés
‹1
Le langage naturel
On peut écrire de l’algorithmique sans passer par un langage informatique,
c’est ce qu’on appelle le langage naturel. Il sert à exprimer les programmes
en français, avec peu de syntaxe spécifique, afin de pouvoir les écrire en
langage informatique plus efficacement.
Affectation des variables

a ← 7 affecte le nombre 7 à la variable a
Instructions conditionnelles
Une seule condition Si condition alors
Instructions
Fin Si
Deux conditions Si condition alors

Instructions 1
Sinon
Instructions 2
Fin Si
Plusieurs conditions Si condition alors

Instructions 1
Sinon
Instructions 2
…
Sinon
Instructions finales
Fin Si
Boucle bornée Pour

Pour i allant de valeur_min à valeur_max faire
Instructions
Fin Pour
Boucle non bornée Tant que

Tant que condition faire
Instructions
Fin Tant que
‹2
Les bibliothèques de Python
Syntaxe générale
Depuis la bibliotheque
on appelle la fonction.
Les fonctions les plus courantes

Bibliothèque Fonction Explications
Importe toutes les fonctions de la
bibliothèque math qui contient toutes
*
les fonctions mathématiques utilisées
au lycée.
math sqrt Importe la fonction racine carrée.
pi Importe la valeur de pi.
sin, cos, Importe les trois fonctions

tan trigonométriques principales.
Importe toutes les fonctions de la

bibliothèque random qui contient toutes
*
les fonctions relatives aux statistiques et
aux probabilités.
random Importe la fonction qui renvoie

randint
aléatoirement un nombre entier.
Importe la fonction qui renvoie

random aléatoirement un nombre décimal
compris entre 0 et 1 exclus.
Définition générale d’une fonction
Une fonction peut avoir aucun, un ou plusieurs arguments.

Le résultat renvoyé par une fonction est réutilisable dans un
programme ou une autre fonction.
‹3
Les instructions sous Python
Instruction conditionnelle if…elif…else

if condition 1 : Le mot clé « alors » n’existe pas en
instruction(s) 1 Python. C’est l’indentation, c’est-
elif condition 2 : à-dire le décalage automatique du
retour à la ligne vers la droite, qui
instruction(s) 2
le remplace.
else :
instruction(s) 3
• elif est la contraction de else if
La boucle bornée for

for variable in range() : La fonction range() permet
instruction(s) d’énumérer le nombre de
passages dans la boucle bornée.
La boucle peut être appelée de plusieurs façons :

– range(n), où n est un entier, fait prendre à la variable les valeurs
entières de 0 à n–1, donc n valeurs ;
– range(n,m), où n et m sont des entiers, fait prendre à la variables
les valeurs entières de n à m–1 ;
– range(n,m,k), où n, m et k sont des entiers, fait prendre à la
variable les valeurs entières de n à m–1, avec un pas de k.
La boucle non bornée while

while condition : Dès que la condition n’est plus
instruction(s) vraie, la boucle s’arrête.
‹4
Affectations et manipulations de variables
Affectation des variables numériques

La variable compteur reçoit la valeur 0.
La variable a reçoit la valeur 22 ;
b reçoit la valeur 6.
Principales opérations en Python

Pour effectuer certaines opérations, comme sqrt() ou randint(),
on doit importer auparavant les fonctions des bibliothèques
correspondantes (voir page 3).
Addition des valeurs des variables a et b
Soustraction des valeurs des variables

a et b
Produit des valeurs des variables a et b
Quotient des valeurs des variables a et b
Puissance entière de a
Racine carrée de a
Reste de la division euclidienne de a par b
Quotient de la division euclidienne de a

par b
Renvoie aléatoirement un nombre entier

entre 3 et 12 inclus.
Renvoie aléatoirement un nombre décimal

entre 0 et 1 exclus.
Outils de comparaison
Si la variable a est strictement inférieure à 10
(respectivement > pour strictement supérieure)
Si la variable a est inférieure ou égale à 10
(respectivement >= pour supérieure ou égale)
Si la variable a est différente de 10
Si la variable a est strictement égale à 10
‹5
Les aﬃchages et les graphiques
La représentation graphique d’une fonction

avec numpy et matplotlib.pyplot
Le script suivant écrit dans l’éditeur utilise les fonctions usuelles.
Importe les
bibliothèques.
Donne l’intervalle de variation de x,

et le nombre de points calculés.
Détermine les dimensions des axes.

Trace la courbe.
Affiche la grille.
Ouvre la fenêtre et affiche la courbe.
La courbe représentative d’une fonction

La courbe suivante s’affiche lorsqu’on lance le programme.
Grille
Courbe
Dimensions
des axes
‹6
Les aﬃchages et les graphiques
La représentation graphique
d’une suite avec matplotlib.pyplot
Le script suivant, écrit dans l’éditeur, utilise les fonctions usuelles
et les listes.
On veut tracer la représentation graphique de la suite ( un ) définie
3n +1
pour tout entier naturel n par un = .
n+4
Importe la bibliothèque.
Définit les axes :

[ −1;22] sur l’axe des
abscisses ; [ −1; 4 ] sur
l’axe des ordonnées.
Définit les valeurs de l’entier n.
Définit les valeurs des termes de la suite.
Affiche le graphique. Affiche la grille. Trace le nuage de points ( x ; y ).
Le nuage de points d’une suite

Le nuage de points suivant s’affiche lorsqu’on lance le programme.
‹7
Les variables listes
Les caractéristiques des listes

Une liste est une collection d’objets de différents types (variables
numériques, chaînes de caractères, booléens, listes, etc.).
Liste vide
Liste contenant des objets

de types différents
Premier objet de la liste ou

objet de rang 0
k + 1-ième objet de la liste

ou objet de rang k
Dernier objet de la liste
Longueur ou nombre
d’objets d’une liste
Ajouter un objet en fin

de liste
Insérer un objet au rang k
Les opérations avec les listes

• Additionner deux listes
concatène (rassemble en une seule liste) les listes L1 et L2.
• Générer une liste avec une suite numérique

crée la liste des nombres
de la forme 2n – 4 pour n variant de 0 à 9.
• Parcourir les éléments d’une liste
La variable k parcourt les éléments de la liste pour des tests ou des

instructions.
‹8
Dictionnaire
abs : abréviation de absolute, len : abréviation de length,

absolu (renvoie la valeur longueur (d’une chaîne de
absolue d’un nombre) caractères ou d’une liste)
and : et or : ou
append : ajouter (un élément à pi : nombre π
une liste)
plot : point (d’un repère)
axis : axe (d’un repère)
print : afficher
boxplot : tracé de boîte (affiche
un diagramme en boîte) randint : contraction de random
integer (nombre aléatoire
def : définition (d’une fonction) entier naturel)
elif : contraction de else…if random : aléatoire
(sinon… si)
range : portée, intervalle (de …
else : sinon à …)
end : fin return : retourner (une valeur
pour une fonction)
false : faux, variable de type
booléen scatter : disperser, éparpiller
(place des points isolés dans
for … in … : pour … de … à un nuage de points)
from : depuis (une bibliothèque) show : montrer (un graphique)
grid : grille (dans un repère) sort, sorted : trier, trié (une
if : si liste dans l’ordre croissant ou
décroissant)
import : importer (d’une
bibliothèque) sqrt : abréviation de square root
(racine carrée)
insert : insérer (un élément dans
une liste à un certain rang) str : abréviation de string (chaîne
de caractères)
int : entier (valeur d’un entier
naturel) true : vrai, variable de type
booléen
in : dans (utile dans les boucles
for) while : tant que (boucle non
bornée)
‹9
Les interactions programme-utilisateur
L’entrée de valeurs par l’utilisateur

Les instructions suivantes peuvent se rencontrer dans les
programmes Python mais sont très peu utilisées dans ce cahier.
Leur but est de rendre les programmes plus conviviaux.
Affectation d’une valeur à une variable de type entier
La réponse doit être écrite dans la fenêtre qui s’ouvre :
Affectation d’une valeur à une variable de type flottant (décimal)
Affectation d’une valeur à une variable de type réel écrite sous la forme d’une
racine carrée ou d’un quotient
‹ 10
Les principales opérations en langage Python
La multiplication et la division sont prioritaires sur l’addition et la soustraction.
Syntaxe Opération
a+b Addition de a et b. (Si les variables a et b sont des chaînes de caractères, on parle de concaténation.)
a*b Multiplication de a et b. (Si la variable a ou b est une chaîne de caractères, on parle de répétition.)
a/b Division de a par b.
a ** b Élévation de a à la puissance b.
sqrt(a) Racine carrée de a. (Il faut importer sqrt() depuis la bibliothèque math.)
a // b Quotient de la division euclidienne de a par b.
a%b Reste de la division euclidienne de a par b.
Affecter des valeurs aux variables

Syntaxe Rôle
Affecte (stocke) simultanément la valeur 1.4 dans la variable x et la valeur 3.65 dans la
x,y = 1.4,3.65
variable y (équivaut aux instructions x = 1.4 et y = 3.65).
x,y = 3 *x+y, 4 *x-2 *y Affecte aux variables x et y les valeurs 3x+y et 4x-2y simultanément.
x=x+1 Incrémente la variable x de 1.
Tests, conditions et opérateurs de comparaison en langage Python

Syntaxe Rôle
if condition : Teste la condition. Si la condition est vérifiée, exécute la (ou les)
instruction(s) instruction(s) indentées.
if condition :
instruction(s) 1 Teste la condition. Si la condition est vérifiée, exécute la (ou les) instruction(s) 1,
else : sinon, exécute la (ou les) instruction(s) 2.
instruction(s) 2
if condition 1 :
instruction(s) 1
Teste la condition 1. Si la condition 1 est vérifiée, exécute la (ou les)
elif condition 2 :
instruction(s) 1, sinon, teste la condition 2. Si la condition 2 est vérifiée, exécute
instruction(s) 2
la (ou les) instruction(s) 2, sinon exécute la (ou les) instruction(s) 3.
else :
instruction(s) 3
a == b Teste si a est égal à b.
a != b Teste si a est différent de b.
a < b (ou a > b) Compare si a est strictement inférieur à b (ou si a est strictement supérieur à b).
a <= b (ou a >= b) Compare si a est inférieur ou égal à b (ou si a est supérieur ou égal à b).
condition 1 and condition 2 Teste si la condition 1 ET la condition 2 sont vérifiées.
condition 1 or condition 2 Teste si la condition 1 OU la condition 2 est vérifiée.
Les boucles en langage Python

Syntaxe Rôle
while condition :
Exécute en boucle la (ou les) instruction(s) tant que la condition est vérifiée.
instruction(s)
for variable in range(n) : Exécute en boucle la (ou les) instruction(s) pour une variable
instruction(s) allant de 0 à n–1.
for variable in range(n,m) : Exécute en boucle la (ou les) instruction(s) pour une variable
instruction(s) allant de n à m–1.
for variable in range(n,m,k) : Exécute en boucle la (ou les) instruction(s) pour une variable
instruction(s) allant de n à m–1 avec un pas de k.
for caractere in chaine : Exécute en boucle la (ou les) instruction(s) pour chaque caractere
instruction(s) de la chaîne de caractères chaine.
Créer une fonction en langage Python

Syntaxe Commentaires
Une fonction est un programme qui porte un nom et qui peut utiliser plusieurs
def nom(p1,p2) :
paramètres (p1,p2,...) ou aucun paramètre.
instruction(s)
Le mot-clé return est obligatoire à la fin d’une fonction. Le resultat renvoyé par
return resultat
une fonction peut être réutilisé dans un autre programme ou une autre fonction.
Les principales fonctions informatiques
Syntaxe Rôle Commentaires
Fonctions mathématiques
sqrt(a) Racine carrée de a.
exp(x) Exponentielle d’un nombre réel x.
log(x) Logarithme népérien d’un nombre réel x.
pi Équivaut à la constante mathématique π. Il faut importer sqrt(), exp(), log(), pi, e, sin()
Constante e, image de 1 par la fonction et cos() depuis la bibliothèque math.
e
exponentielle.
sin(a) Sinus d’un nombre a.
cos(a) Cosinus d’un nombre a.
Renvoie la valeur a avec une précision round(a) renvoie un entier puisque b=0, c’est-à-
round(a,b)
de b nombres après la virgule. dire aucun chiffre après la virgule.
min(a,b) Renvoie le paramètre le plus petit parmi a et b.
max(a,b) Renvoie le paramètre le plus grand parmi a et b.
Probabilités
Renvoie un nombre entier aléatoire compris
randint(a,b)
entre deux entiers a et b inclus.
Renvoie un nombre décimal aléatoire
random()
strictement compris entre 0 et 1. Il faut importer randint(), random(), uniform()
Renvoie un nombre décimal aléatoire compris et choice() de la bibliothèque random.
uniform(a,b)
entre deux nombres décimaux a et b.
choice Renvoie aléatoirement un des éléments de la
("chaine") chaîne de caractères "chaine".
Conversion
Reconnaît ou convertit le nombre ou la chaîne int(2.76) convertit la valeur 2.76 en donnant sa
int(x)
de caractères x en un entier. troncature : l’entier 2.
Reconnaît ou convertit le nombre ou la chaîne float("235.76") convertit la chaîne de caractères
float(x)
de caractères x en nombre flottant. "235.76" en nombre flottant : 235.76.
Reconnaît ou convertit le nombre x en chaîne str(176) convertit la valeur 176 en '176', une
str(x)
de caractères. chaîne constituée des caractères 1 ; 7 et 6.
Listes
Syntaxe Rôle
L = [] Liste vide.
L = [3,"oui",False]
Exemple de listes contenant des objets de types différents.
L = [3,4.2,[0,1,2]]
L[0] Premier objet de la liste ou objet de rang 0
L[k] k + 1-ième objet de la liste ou objet de rang k.
L[-1] Dernier objet de la liste.
len(L) Longueur ou nombre d’objets d’une liste.
L.append(objet) Ajoute un objet en fin de liste.
L.insert(rang,objet) Insère un objet au rang k.
L1+L2 Concatène (rassemble) deux listes.
Graphiques
Syntaxe Rôle Commentaires
grid() Affiche une grille dans un repère.
Affiche un repère gradué de a à b sur l’axe des
axis(a,b,c,d)
abscisses et de c à d sur l’axe des ordonnées.
Définit l’intervalle dans lequel varie x et le nombre Il faut importer les bibliothèques
linspace(a,b, nbrepoints) pylab et numpy ou matplotlib.
de points calculés pour tracer la courbe.
pyplot.
plt.plot(x,y) Trace le point de coordonnées (x ; y).
plt.scatter(x,y) Trace un nuage de points.
plt.show() Montre le graphique dans une nouvelle fenêtre.

Barbazo Cahier DAlgo Mathématiques Terminales Spécialité Corrigés

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Barbazo Cahier DAlgo Mathématiques Terminales Spécialité Corrigés

Transféré par

Droits d'auteur :

Formats disponibles

le

Introduction Découvrir l’algorithmique et la programmation ................... 4

2 Boucles bornées et non bornées...................................................................................... 10

© Hachette Livre 2020,

PARTIE 3 Vers l’épreuve du Bac

2 Exercice type 2 ....................................................................................................................... 40

3 Exercice type 3 ....................................................................................................................... 41

4 Exercice type 4 ....................................................................................................................... 41

5 Exercice type 5 ....................................................................................................................... 42

6 Exercice type 6 ....................................................................................................................... 43

7 Exercice type 7 ....................................................................................................................... 44

8 Exercice type 8 ....................................................................................................................... 45

9 Exercice type 9 ....................................................................................................................... 46

10 Exercice type 10..................................................................................................................... 46

11 Exercice type 11..................................................................................................................... 47

12 Exercice type 12..................................................................................................................... 48

Fabrication : Miren Zapirain

Découvrir l’algorithmique et la programmation

2 Les principales structures algorithmiques en langage naturel

Les instructions conditionnelles

▶ Pour aiguiller dans différentes La syntaxe d’une instruction

La boucle non bornée

4 › Découvrir l’algorithmique et la programmation

3 Le logiciel EduPython et le langage Python

L’interface du logiciel EduPython

La console peut aussi être utilisée comme une puissante calculatrice.

4 Les principales structures algorithmiques en Python

Le programme affecte à la variable y une valeur égale à

Le programme affecte à la variable y une valeur égale à

La boucle bornée for

La boucle non bornée while

6 › Découvrir l’algorithmique et la programmation

5 Les bibliothèques de Python

• On peut importer d’une bibliothèque seulement les fonctions dont on a besoin.

Type de bibliothèque Nom de la bibliothèque Syntaxe d’importation

pylab import pylab as pb

1. Variables, fonctions et instruction conditionnelle

1 Un magasin propose des réductions à ses clients. 2 On considère la

8 › Variables, fonctions et instruction conditionnelle

3 1. On considère la fonction ci-dessous. 2. Quel est le résultat renvoyé par l’instruction

Recopier le script et écrire le résultat ci-dessous. 3. Que réalise la fonction signe ?

a. Elle renvoie le signe de f ( x ) avec la fonction f

True donnée et le réel x donné.

c. Que teste cette fonction ?

4 On considère le programme ci-dessous écrit avec

6. On donne f définie pour tout réel x par :

1. Combien la fonction signe possède-t-elle

2. Boucles bornées et non bornées

Boucle dans une chaîne de Pour caractere dans chaine Faire

1 On veut calculer une valeur approchée de la somme 3 On considère la fonction ci-dessous.

10 › Boucles bornées et non bornées

4 On veut calculer, pour toute entier naturel n ! 0, la 6 On considère l’équation e x = x + 2.

a. Recopier cette fonction dans un éditeur et indi-

1. Écrire une fonction bacteries qui renvoie le

Liste contenant des objets de types différents

Premier objet de la liste ou objet de rang 0

k +1-ième objet de la liste ou objet de rang k

Dernier objet de la liste

Insérer un objet au rang k

Concaténer (rassembler) deux listes

1 On considère la liste suivante, écrite dans la console. 3 On considère la fonction ci-dessous.

1. Qu’affichent les instructions suivantes lorsqu’elles

2 On considère les deux listes suivantes.

Qu’affiche l’instruction ? Elle renvoie la liste des n tirages entre 1 et 6 et