Exercice 1 : programme avec le langage Python
a) La variable est de type entier (int).
b) Pour les valeurs fournies de :
– Si :
Donc, pour ,
.
– Si :
Donc, pour ,
.
– Si :
Donc, pour ,
.
c) Le programme définit une fonction . On a :
Ainsi, la fonction est définie par :
Exercice 2 : décrire le rôle et fonctionnement de l’algorithme
Corrigé de l’exercice :
1.
donne pour résultat le nombre de caractères de la chaîne C.
2.
donne pour résultat la sous-chaîne extraite de C à partir du caractère
ayant
caractères.
Maintenant, décrivons l’algorithme :
1. Saisir une chaîne de caractères non vide .
2. Affecter à la valeur de la longueur de
, c’est-à-dire
.
3. Affecter à la sous-chaîne de
commençant au premier caractère et ayant
caractères :
4. Afficher .
Le rôle de cet algorithme est donc de supprimer le dernier caractère de la chaîne saisie par l’utilisateur et d’afficher la chaîne résultante.
Exercice 3 : programme et magasin de reprographie
1. Compléter les lignes 1 et 2 de ce programme.
« `python
print(« Entrer N : »)
N = int(input())
if N <= 50:
Prix = N * 0.15
else:
Prix = 50 * 0.15 + (N – 50) * 0.10
print(« Prix = », Prix)
« `
2. Saisir le programme à l’ordinateur.
Pour saisir ce programme, vous pouvez utiliser un éditeur de texte comme Notepad++ ou un environnement de développement intégré (IDE) comme PyCharm, puis l’exécuter en utilisant l’interpréteur Python.
3. Contrôler son fonctionnement à l’aide d’exemples.
Nous allons vérifier le programme avec quelques exemples.
« `python
Entrer N :
30
Prix = 4.5
« `
Explication :
« `python
Entrer N :
50
Prix = 7.5
« `
Explication :
« `python
Entrer N :
75
Prix = 10.0
« `
Explication :
Ces exemples montrent que le programme calcule correctement le prix total en fonction du nombre de photocopies demandées.
Exercice 4 : algorithme qui affiche la distance
### Correction de l’Exercice
Le temps total mis par Louise pour parcourir les 7 km est décomposé en deux parties :
– est le temps pour parcourir les 5 premiers kilomètres à une vitesse de 15 km/h.
– est le temps pour parcourir les 2 kilomètres restants à une vitesse de 12 km/h.
Calculons :
Calculons :
Le temps total est donc :
Donc, Louise met 30 minutes pour parcourir les 7 km.
Lorsqu’on introduit en minutes, nous devons noter que :
– Pour , la vitesse est de 15 km/h.
– Pour , la vitesse est de 12 km/h.
Pour les 5 premiers kilomètres, en vitesse de 15 km/h, la distance est donnée par :
ce qui se simplifie en :
Pour les 2 derniers kilomètres avec une vitesse de 12 km/h, la distance totale parcourue jusqu’à est :
ce qui se simplifie en :
L’algorithme pour calculer et afficher est donné ci-dessous :
« `python
def distance_parcourue(t):
# Vérification pour les conditions données
if 0 <= t <= 20:
return t / 4
elif 20 < t <= 30:
return 1 + t / 5
else:
return None # Si t est en dehors de l’intervalle permis
# Exemple d’utilisation de la fonction
t = int(input(« Entrez le temps en minutes: « ))
d = distance_parcourue(t)
if d is not None:
print(f »La distance parcourue par Louise est de {d:.2f} km. »)
else:
print(« Le temps fourni n’est pas valide. »)
« `
### Fin de la correction
Exercice 5 : simuler 100 lancers avec Python
a) Expliquer le rôle de chacune des variables du programme.
– `n = 0`: Cette ligne initialise le compteur `n` qui va servir à compter le nombre de fois qu’un « Pile » est obtenu (c’est-à-dire quand `x` est inférieur ou égal à 0.5).
– `for i in range(1, 101)`: Cette boucle `for` permet d’exécuter le corps de la boucle 100 fois (de 1 à 100 inclus). Chaque itération de la boucle correspond à un lancer de pièce.
– `x = random()`: Cette ligne génère un nombre aléatoire `x` entre 0 et 1 grâce à la fonction `random()` du module `random`. Ce nombre aléatoire représente le résultat d’un lancer de pièce, où une valeur inférieure ou égale à 0.5 pourrait représenter « Pile » et une valeur supérieure à 0.5 représenterait « Face ».
– `if x <= 0.5`: Cette condition vérifie si le résultat du lancer de pièce est « Pile » (x ≤ 0.5).
– `n = n + 1`: Si la condition précédente est vraie (x ≤ 0.5), alors le compteur `n` est incrémenté de 1, indiquant qu’un « Pile » a été obtenu.
– `print(« n = », n)`: À la fin de la boucle, cette ligne affiche le nombre total de « Pile » obtenus après 100 lancers.
b) Suzy souhaite effectuer fois la simulation. Comment doit-elle modifier son programme ?
Pour effectuer fois la simulation, Suzy peut encapsuler le code original dans une nouvelle boucle qui s’exécute
fois. Voici le nouveau programme :
« ` python
from random import random
def simulation():
n = 0
for i in range(1, 101):
# pour i allant de 1 à 100
x = random()
if x <= 0.5:
n = n + 1
return n
M = 10 # Exemple: pour effectuer la simulation 10 fois
results = []
for _ in range(M):
result = simulation()
results.append(result)
print(« Résultats des simulations: », results)
« `
Dans ce programme :
– `simulation()`: Une fonction qui encapsule le code original et retourne le nombre de « Pile » après 100 lancers.
– `M = 10`: Cette ligne définit le nombre de simulations à effectuer. Vous pouvez remplacer 10 par n’importe quelle autre valeur numérique pour définir .
– `results = []`: Une liste pour stocker les résultats des simulations.
– `for _ in range(M)`: Une boucle pour exécuter la simulation fois.
– La liste `results` contiendra le nombre de « Pile » obtenus pour chaque simulation.
Exercice 6 : un algorithme à étudier
a) Exécutons cet algorithme avec la valeur en entrée.
Initialement, .
Pour :
Pour :
Pour :
Pour :
Pour :
Le résultat affiché en sortie est donc .
b) De façon plus générale, cet algorithme calcule la somme des carrés des premiers nombres entiers naturels. Plus précisément, il réalise la somme des valeurs
pour
allant de 1 à
.
On peut également exprimer cette somme sous forme de série mathématique :
Ceci correspond à la somme des carrés des premiers entiers naturels.
Exercice 7 : un algorithme qui donne l’image par une fonction
Pour écrire l’algorithme de la fonction en fonction de
, nous pouvons utiliser une structure conditionnelle. L’algorithme en pseudo-code est le suivant :
\begin{verbatim}
Entrée: x (un nombre réel)
Sortie: f(x)
Si x ≤ 0 alors
f(x) = x^2
Sinon si 0 < x ≤ 1 alors
f(x) = x
Sinon si 1 < x alors
f(x) = -2x + 3
\end{verbatim}
En LaTeX, l’algorithme peut également être écrit de la manière suivante :
« `latex
\documentclass{article}
\usepackage{amsmath}
\begin{document}
Algorithme de la fonction en fonction de
:
\begin{verbatim}
Entrée : (un nombre réel)
Sortie :
\begin{cases}
\text{Si } x \leq\, 0 \implies f(x) = x^2 \\
\text{Sinon si } 0 < x \leq\, 1 \implies f(x) = x \\
\text{Sinon si } 1 < x \implies f(x) = -2x + 3 \\
\end{cases}
\end{verbatim}
\end{document}
« `
Ce code LaTeX permet de générer un document affichant l’algorithme demandé.
Exercice 8 : algorithme qui fournit la distance entre 2 points
a) La distance entre les points
et
sur une droite graduée est donnée par la valeur absolue de la différence de leurs abscisses. Ainsi,
b) Voici l’algorithme d’une fonction qui retourne la distance
:
\begin{verbatim}
Début
Entrée : a, b (abscisses des points A et B)
Sortie : distance (distance entre A et B)
distance <- |a – b|
Retourner distance
Fin
\end{verbatim}
Exercice 9 : algorithme qui précise si un triangle est rectangle
Pour déterminer si le triangle ABC est rectangle en A, nous devons vérifier si le théorème de Pythagore est respecté, c’est-à-dire si .
En utilisant LaTeX pour l’algorithme et la vérification, on peut fournir une fonction H(a, b, c) de la manière suivante :
« `latex
\documentclass{article}
\usepackage{amsmath}
\begin{document}
\newcommand{\fonctionH}[3]{
\ifnum\pdfstrcmp{\outcome}{Vrai}=\numexpr#1^2+#3^2-#2^2=0 \relax
$H(#1, #2, #3) = \text{Vrai}$
\else
$H(#1, #2, #3) = \text{Faux}$
\fi
}
La fonction $H(a, b, c)$ qui détermine si le triangle ABC est rectangle en A peut s’écrire comme suit :
\begin{verbatim}
fonction H(a, b, c)
si b^2 = a^2 + c^2 alors
retourner ‘Vrai’
sinon
retourner ‘Faux’
\end{verbatim}
En LaTeX, l’équation utilisée pour la vérification est :
Ainsi, la vérification dans une fonction LaTeX pourrait se présenter comme suit :
\end{document}
« `
Exercice 10 : volume d’un cylindre et écrire un algorithme
a) Recopier et compléter cet algorithme.
Variables : sont des nombres réels
Entrées : Saisir
Traitement : Affecter à la valeur
Traitement : Affecter à la valeur
Sortie : Afficher
b) Coder cet algorithme dans un langage de programmation.
Voici un exemple de code en Python :
« `python
import math
# Entrée des valeurs
R = float(input(« Saisir le rayon R en cm : « ))
h = float(input(« Saisir la hauteur h en cm : « ))
# Calcul de l’aire de la base
S = math.pi * R
Exemple 2 :
– R = 2 cm
– h = 10 cm
Calculs :
Le programme devrait afficher les volumes pour le premier exemple et
pour le deuxieme exemple.
Exercice 11 : un programme ecrit en Python
a) Le type de la variable est un entier (int).
b) Pour chaque valeur de :
– Si :
Donc, lorsque ,
.
– Si :
Donc, lorsque ,
.
– Si :
Donc, lorsque ,
.
c) Le programme definit une fonction .
Exprimons en fonction de
:
Donc, la fonction definie par le programme est
Exercice 12 : location d’une voiture et programmer un algorithme
### Correction de l’exercice de mathematiques:
### a) Recopier et completer cet algorithme.
L’algorithme complete est le suivant :
« `
Variables : x est un nombre entier naturel
m est un nombre reel
Entree : Saisir x
Traitement :
Si x ≤ 100 alors
Affecter a m la valeur 50 + 0.25 * x
sinon
Affecter a m la valeur 50 + 0.25 * 100 + 0.35 * (x – 100)
Fin Si
Sortie : Afficher m
« `
Explication :
– Lorsque le nombre de kilometres parcourus est inferieur ou egal a 100, le cout total
est donne par
.
– Lorsque est superieur a 100, le cout total
est donne par
.
### b) Coder cet algorithme dans un langage de programmation.
Voici une implementation possible en Python :
« `python
# Entree : Saisir x
x = int(input(« Saisir le nombre de kilometres parcourus : « ))
# Traitement
if x <= 100:
m = 50 + 0.25 * x
else:
m = 50 + 0.25 * 100 + 0.35 * (x - 100)
# Sortie : Afficher m
print("Le montant de la location est de :", m, "€")
```
### c) Tester le programme obtenu avec differentes valeurs de x.
#### Test 1 :
x = 50
Calcul a effectuer:
#### Test 2 :
x = 100
Calcul a effectuer:
#### Test 3 :
x = 150
Calcul a effectuer:
### Code pour les tests en Python :
« `python
# Test 1
x = 50
if x <= 100:
m = 50 + 0.25 * x
else:
m = 50 + 0.25 * 100 + 0.35 * (x - 100)
print("Test 1 : Pour x = 50, m =", m)
# Test 2
x = 100
if x <= 100:
m = 50 + 0.25 * x
else:
m = 50 + 0.25 * 100 + 0.35 * (x - 100)
print("Test 2 : Pour x = 100, m =", m)
# Test 3
x = 150
if x <= 100:
m = 50 + 0.25 * x
else:
m = 50 + 0.25 * 100 + 0.35 * (x - 100)
print("Test 3 : Pour x = 150, m =", m)
```
Les resultats attendus sont :
- Test 1 : Pour x = 50, m = 62.5 €
- Test 2 : Pour x = 100, m = 75 €
- Test 3 : Pour x = 150, m = 92.5 €
Ainsi, le programme se comporte correctement pour les differentes valeurs de .
Exercice 13 : simuler un lancer de de et ecrire un programme
a) La valeur de la variable affichee a la fin du programme represente la somme des resultats de 10 lancers d’un de equilibre dont les faces sont numerotees de 1 a 6. A chaque iteration de la boucle pour, un nouveau lancer de de est genere aleatoirement (avec
) et cette valeur est ajoutee a
.
b) La valeur maximale de se produit lorsque chaque lancer de de donne le resultat le plus eleve possible, soit 6. Ainsi, pour 10 lancers, la valeur maximale de
est :
Donc, la plus grande valeur de que le programme peut afficher est 60.
Exercice 14 : un programme ecrit avec le langage Python
a) On saisit , quelle valeur le programme affiche-t-il en sortie ?
Pour , le programme execute les operations suivantes :
1. Initialisation de a 0.
2. Boucle de de 1 a
(donc de 1 a 5).
– Pour :
.
– Pour :
.
– Pour :
.
– Pour :
.
Finalement, .
b) De facon plus generale, expliquer le calcul effectue par ce programme.
Le programme calcule la somme des premiers entiers pairs a partir du premier entier (2) jusqu’a
. Cela se decrit par la formule :
On observe que cette somme peut etre simplifiee en :
Et la somme des entiers de 1 a est donnee par :
En substitution,
Ainsi, pour une valeur donnee de , la valeur finale de
que le programme affiche est :
Exercice 15 : donner un programme qui fournit les 100 premiers entiers » align= »absmiddle » />Correction de l’exercice :a) Le résultat donné par la fonction `diviseurs(N)`
. Voici le deroule de l’algorithme :
1. Initialisation de la variable a 0.
2. Pour chaque de 1 a
inclus:
– Si divise
(
), on incremente
de 1.
3. A la fin de la boucle, contient le nombre de diviseurs de
.
Le resultat de l’algorithme est donc le nombre de diviseurs de . » align= »absmiddle » />b) Programme déterminant les nombres entiers de 1 à 100 possédant au moins dix diviseurs
.
2. Une boucle de 1 a 100 appelle cette fonction pour chaque nombre et verifie si le nombre de diviseurs est superieur ou egal a 10.
3. Les nombres qui satisfont cette condition sont ajoutes a la liste `numeros`.
4. La liste `numeros` contenant les nombres de 1 a 100 avec au moins 10 diviseurs est affichee.
En LaTeX pour formuler le programme, nous pouvons utiliser l’environnement `lstlisting` pour le code :
« `latex
Voici le programme pour determiner les nombres entiers de 1 a 100 possedant au moins dix diviseurs :
\begin{lstlisting}[language=Python]
def diviseurs(n):
count = 0
for k in range(1, n + 1):
if n % k == 0:
count += 1
return count
numeros = []
for num in range(1, 101):
if diviseurs(num) >= 10:
numeros.append(num)
print(numeros)
\end{lstlisting}
« `
Ceci fournira une presentation claire du programme Python en LaTeX.
Exercice 16 : preciser le plus petit ensemble du nombre a
Voici la correction de l’exercice :
Pour :
On obtient donc .
Pour :
On obtient donc .
Pour :
On obtient donc .
Ainsi, les valeurs de pour les differents arguments sont
,
, et
respectivement. Le plus petit ensemble auquel appartient
pour tous ces arguments est
.
Exercice 17 : on execute le script ci-dessous
[a.] $nombre(3)$ est-il un entier ?
Non, le resultat de $nombre(3)$ n’est pas un entier.
[b.] $nombre(12)$ est-il un entier ?
Oui, le resultat de $nombre(12)$ est un entier.
[c.] $nombre(-4)$ est-il un entier ?
Oui, le resultat de $nombre(-4)$ est un entier.
[d.] Quel sera l’affichage de $nombre(-12)$ ?
Comme $\sqrt{-3}$ n’est pas un nombre reel, la fonction retournera une erreur de type « math domain error ».
Exercice 18 : l’algorithme de la fonction operation
Soit l’argument de la fonction \texttt{operation}, alors :
Nous devons ensuite verifier si est un entier pour les trois valeurs donnees de
.
1. » align= »absmiddle » />Pour
2. » align= »absmiddle » />Pour
3. » align= »absmiddle » />Pour
– Pour : la fonction renvoie « entier ».
– Pour : la fonction renvoie « entier ».
– Pour : la fonction renvoie « pas entier ».
Exercice 19 : script de la fonction compteur
a. Pour \texttt{compteur(0.9)}:
Donc, \texttt{compteur(0.9)} retourne .
Pour \texttt{compteur(0.1)}:
Comme des le depart, aucune iteration n’est effectuee, donc
retourne
.
b. L’affichage de ce programme represente le nombre de fois qu’un nombre (strictement compris entre 0 et 1) doit etre multiplie par lui-meme jusqu’a ce que sa valeur devienne inferieure a 0.1.
Exercice 20 : algorithme qui determine la racine carree
1. Completons le tableau :
Calculons en utilisant l’algorithme fourni, avec
et
.
Arretons-nous ici, car :
Le tableau complete est :
L’affichage de l’algorithme avec et
est
.
2. Quel est l’affichage de \texttt{val\_app(3, 0.0001)} ?
Utilisons l’algorithme :
Arretons-nous ici, car :
L’affichage de \texttt{val\_app(3, 0.0001)} est .
3. Quel est l’affichage de \texttt{val\_app(7, 0.00001)} ?
Utilisons l’algorithme :
Arretons-nous ici, car :
L’affichage de \texttt{val\_app(7, 0.00001)} est .
[/expander_maker]
Exercice 21 : ordinateur et mot de passe » align= »absmiddle » />Question a. a M. Galois, quel est le nombre genere ?
Prenons ,
,
et
.
Calculons :
Initialisons :
Tant que , repetons:
Ensuite on verifie :
Puis:
Finalement, vaut:
» align= »absmiddle » />Question b.
?
Prenons ,
,
et
.
Calculons :
Initialisons :
Tant que , repetons:
Ensuite on verifie :
Puis:
Finalement, vaut:
» align= »absmiddle » />Question c.
?
Prenons ,
,
et
.
Calculons :
Initialisons :
Donc, sans boucle:
Finalement, vaut:
L’ordinateur peut donc proposer le code et generer le nombre
.
Exercice 22 : algorithme de la fonction nombre
Pour :
Donc, .
Pour :
Donc, .
Pour :
Donc, .
Le plus petit ensemble auquel appartiennent les valeurs de pour
,
, et
est
.
Exercice 23 : script et nombre entier
a.
Soit .
On calcule:
Ensuite:
Finalement:
Or, n’est pas un entier.
Donc, le resultat de `nombre(3)` n’est pas un entier.
—
b.
Soit .
On calcule:
Ensuite:
Finalement:
Or, est un entier.
Donc, le resultat de `nombre(12)` est un entier.
—
c.
Soit .
On calcule:
Ensuite:
Finalement:
Or, est un entier.
Donc, le resultat de `nombre(-4)` est un entier.
—
d.
Soit .
On calcule:
Ensuite:
Finalement:
Cependant, n’est pas defini dans les reels (ou il resulterait en un nombre complexe).
Donc, la fonction `nombre(-12)` affichera une valeur d’erreur en indiquant que la racine carree d’un nombre negatif n’est pas definie dans l’ensemble des reels.
Exercice 24 : qu’affiche la fonction operation ?
Pour
\begin{align*}
b &= -(-2) = 2 \\
c &= b^2 = 2^2 = 4 \\
d &= -2c = -2 \cdot 4 = -8 \\
e &= d + |a| = -8 + |-2| = -8 + 2 = -6 \\
\end{align*}
Pour
\begin{align*}
b &= -(3) = -3 \\
c &= b^2 = (-3)^2 = 9 \\
d &= -2c = -2 \cdot 9 = -18 \\
e &= d + |a| = -18 + |3| = -18 + 3 = -15 \\
\end{align*}
Pour
\begin{align*}
b &= -(\sqrt{2}) = -\sqrt{2} \\
c &= b^2 = (-\sqrt{2})^2 = 2 \\
d &= -2c = -2 \cdot 2 = -4 \\
e &= d + |a| = -4 + |\sqrt{2}| = -4 + \sqrt{2} \\
\end{align*}
Exercice 25 : que represente l’affichage de ce programme ?
a. Calculons la valeur pour compteur(0.9) et compteur(0.1) en suivant le script donne :
1. » align= »absmiddle » />Pour
Donc, .
2. » align= »absmiddle » />Pour $$ :
\[
\begin{align*}
a & = 0.1, \, N = 0 \\
a & = a^2 = 0.1^2 = 0.01, \, N = 1 \\
\end{align*}
L’iteration s’arrete ici car .
Donc, .
b. Ce programme realise un compte du nombre d’iterations necessaires pour que , en etant exposantiation successivement par lui-meme (c’est-a-dire
), devienne inferieur a 0.1. Pour un nombre donne
strictement compris entre 0 et 1, la fonction retourne le nombre d’iterations necessaires pour que la valeur de
devienne inferieure a 0.1.
Exercice 26 : quel est le plus petit ensemble fourni par ce script ?
Pour resoudre cet exercice, evaluons le script `quisuisje(x)` pour chaque valeur d’entree.
1. Pour :
, donc
.
\[
a = 2(-2) – 1 = -4 – 1 = -5″ align= »absmiddle » />
.
2. Pour :
, donc
.
.
3. Pour :
, donc
.
.
4. Pour :
, donc
.
.
5. Pour :
, donc
.
.
Le plus petit ensemble auquel appartiennent toutes les valeurs de `quisuisje(x)` pour chaque argument donné est .
En conclusion, le plus petit ensemble auquel appartient `quisuisje(x)` pour est :
Exercice 27 : le script dichotomie
Correction de l’exercice :
[a.] En recopiant et complétant le tableau suivant, quel est l’affichage de ce script si les arguments sont (1, 2, 0.1) ?
Le script effectue un processus de dichotomie pour approcher la valeur de .
\begin{tabular}{|c|c|c|}
\hline
\\
\hline
1 1 2 \\
\hline
0.5 1 1.5 \\
\hline
0.25 1.25 1.5 \\
\hline
0.125 1.375 1.5 \\
\hline
0.0625 1.375 1.4375 \\
\hline
0.03125 1.40625 1.4375 \\
\hline
0.015625 1.421875 1.4375 \\
\hline
0.0078125 1.4296875 1.4375 \\
\hline
0.00390625 1.43359375 1.4375 \\
\hline
0.001953125 1.43359375 1.435546875 \\
\hline
\end{tabular}
[b.] Que représente l’affichage de ce script ?
Le script exécute une méthode de dichotomie afin de trouver une valeur approchant . En particulier, il affine les valeurs de
et
jusqu’à ce que la différence
devienne plus petite que
(ici, 0.1 dans le cas initial).
[c.] Que doit-on modifier si l’on souhaite un encadrement à près de
?
Pour un encadrement à près de
, il faut :
Changer la condition de la boucle \texttt{while} pour vérifier si en
.
Ainsi, le script modifié ressemblerait à ceci :
\begin{lstlisting}
def dichotomie(a, b, n):
while b – a > n:
if (a + b) / 2 – sqrt(7) > 0:
b = (a + b) / 2
else:
a = (a + b) / 2
return (a, b)
\end{lstlisting}
Exercice 28 : fonction nombre et algorithme
Correction :
Pour :
Donc, .
Pour :
Donc, .
Pour :
Donc, .
Les résultats des arguments ,
et
sont respectivement dans
,
et
.
Ainsi, le plus petit ensemble auquel appartient pour les valeurs données de
est
.
Exercice 29 : quel est l’affichage fourni par ce script ?
Exercice 30 : algorithme de la fonction opération
Pour :
– prend la valeur de
– prend la valeur de
– prend la valeur de
– prend la valeur de
est un entier, donc la fonction renvoie « entier ».
Pour :
– prend la valeur de
– prend la valeur de
– prend la valeur de
– prend la valeur de
est un entier, donc la fonction renvoie « entier ».
Pour :
– prend la valeur de
– prend la valeur de
– prend la valeur de
– prend la valeur de
n’est pas un entier, donc la fonction renvoie « pas entier ».
Résumons les résultats :
– Pour : la fonction renvoie « entier ».
– Pour : la fonction renvoie « entier ».
– Pour : la fonction renvoie « pas entier ».
Exercice 31 : argument et fonction compteur
Soit la fonction définie par le script suivant :
« `python
from math import *
def compteur(a):
N=0
while a>=0.1:
a=a*a
N=N+1
return N
« `
### a. Quelle est la valeur de ?
?
Pour :
1. Initialement, et
.
2. Comme , on entre dans la boucle :
–
–
3. Comme , on entre dans la boucle :
–
–
4. Comme , on entre dans la boucle :
–
–
5. Comme , on entre dans la boucle :
–
–
6. Comme , on entre dans la boucle :
–
–
7. Désormais, , la boucle s’arrête.
8. La fonction retourne .
Donc, .
Pour :
1. Initialement, et
.
2. Comme , on entre dans la boucle :
–
–
3. Désormais, , la boucle s’arrête.
4. La fonction retourne .
Donc, .
### b. Que représente l’affichage de ce programme ?
Le programme itère en multipliant le nombre par lui-même jusqu’à ce que sa valeur soit inférieure à 0.1. L’instruction `N = N + 1` compte le nombre d’itérations nécessaires pour que
devienne inférieur à 0.1. ainsi, le résultat de cette fonction (
) représente le nombre d’itérations nécessaires pour que
devienne inférieur à 0.1.
Réviser les cours et exercices de maths avec nos Q.C.M :
D'autres outils pour progresser en autonomie :