Exercice 1 : programme avec le langage Python
a) La variable \( x \) est de type entier (int).
b) Pour les valeurs fournies de \( x \) :
– Si \( x = 3 \) :
\[
y = 4 \times x = 4 \times 3 = 12
\]
\[
y = y + 1 = 12 + 1 = 13
\]
\[
y = y \times 2 = 13 \times 2 = 26
\]
Donc, pour \( x = 3 \), \( y = 26 \).
– Si \( x = -1 \) :
\[
y = 4 \times x = 4 \times (-1) = -4
\]
\[
y = y + 1 = -4 + 1 = -3
\]
\[
y = y \times 2 = -3 \times 2 = -6
\]
Donc, pour \( x = -1 \), \( y = -6 \).
– Si \( x = 11 \) :
\[
y = 4 \times x = 4 \times 11 = 44
\]
\[
y = y + 1 = 44 + 1 = 45
\]
\[
y = y \times 2 = 45 \times 2 = 90
\]
Donc, pour \( x = 11 \), \( y = 90 \).
c) Le programme définit une fonction \( f : x \mapsto y \). On a :
\[
y = 4x + 1
\]
\[
y = (4x + 1) \times 2 = 8x + 2
\]
Ainsi, la fonction \( f \) est définie par :
\[
f(x) = 8x + 2
\]
Exercice 2 : décrire le rôle et fonctionnement de l’algorithme
Corrigé de l’exercice :
1. \[\]Lgr\[\] \( \text{(C)} \) donne pour résultat le nombre de caractères de la chaîne C.
\[ \text{Lgr}(\text{« algorithme »}) = 10 \]
2. \[\]Sch\[\] \((C, a, b)\) donne pour résultat la sous-chaîne extraite de C à partir du caractère \(a\) ayant \(b\) caractères.
\[ \text{Sch}(\text{« informatique »}, 3, 6) = \text{« format »} \]
Maintenant, décrivons l’algorithme :
1. Saisir une chaîne de caractères non vide \( C \).
2. Affecter à \( \ell \) la valeur de la longueur de \( C \), c’est-à-dire \( \ell = \text{Lgr}(C) \).
3. Affecter à \( C’ \) la sous-chaîne de \( C \) commençant au premier caractère et ayant \( \ell – 1 \) caractères :
\[ C’ = \text{Sch}(C, 1, \ell – 1) \]
4. Afficher \( C’ \).
Le rôle de cet algorithme est donc de supprimer le dernier caractère de la chaîne \( C \) 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.
\[\]Exemple 1 : 30 photocopies\[\]
« `python
Entrer N :
30
Prix = 4.5
« `
Explication :
\( 30 \times 0.15 = 4.5 \)
\[\]Exemple 2 : 50 photocopies\[\]
« `python
Entrer N :
50
Prix = 7.5
« `
Explication :
\( 50 \times 0.15 = 7.5 \)
\[\]Exemple 3 : 75 photocopies\[\]
« `python
Entrer N :
75
Prix = 10.0
« `
Explication :
\( 50 \times 0.15 + (75 – 50) \times 0.10 = 7.5 + 2.5 = 10.0 \)
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
\[\]Partie a)\[\]
Le temps total \( T \) mis par Louise pour parcourir les 7 km est décomposé en deux parties :
– \( t_1 \) est le temps pour parcourir les 5 premiers kilomètres à une vitesse de 15 km/h.
– \( t_2 \) est le temps pour parcourir les 2 kilomètres restants à une vitesse de 12 km/h.
Calculons \( t_1 \) :
\[
t_1 = \frac{5}{15} = \frac{1}{3} \text{ heures} = 20 \text{ minutes}
\]
Calculons \( t_2 \) :
\[
t_2 = \frac{2}{12} = \frac{1}{6} \text{ heures} = 10 \text{ minutes}
\]
Le temps total \( T \) est donc :
\[
T = t_1 + t_2 = 20 \text{ minutes} + 10 \text{ minutes} = 30 \text{ minutes}
\]
Donc, Louise met 30 minutes pour parcourir les 7 km.
\[\]Partie b)\[\]
Lorsqu’on introduit \( t \) en minutes, nous devons noter que :
– Pour \( 0 \leq\, t \leq\, 20 \), la vitesse est de 15 km/h.
– Pour \( 20 < t \leq\, 30 \), la vitesse est de 12 km/h.
Pour les 5 premiers kilomètres, en vitesse de 15 km/h, la distance \( d(t) \) est donnée par :
\[
d(t) = ( \frac{t}{60} ) \times 15 \quad \text{pour } 0 \leq\, t \leq\, 20
\]
ce qui se simplifie en :
\[
d(t) = \frac{15t}{60} = \frac{t}{4} \quad \text{pour } 0 \leq\, t \leq\, 20
\]
Pour les 2 derniers kilomètres avec une vitesse de 12 km/h, la distance totale parcourue jusqu’à \( t \) est :
\[
d(t) = 5 + ( \frac{t – 20}{60} ) \times 12 \quad \text{pour } 20 < t \leq\, 30
\]
ce qui se simplifie en :
\[
d(t) = 5 + \frac{12(t – 20)}{60} = 5 + \frac{t – 20}{5} = 5 + \frac{t}{5} – 4 = 1 + \frac{t}{5} \quad \text{pour } 20 < t \leq\, 30
\]
L’algorithme pour calculer et afficher \( d(t) \) 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
\[\]Correction de l’exercice :\[\]
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 \( M \) fois la simulation. Comment doit-elle modifier son programme ?
Pour effectuer \( M \) fois la simulation, Suzy peut encapsuler le code original dans une nouvelle boucle qui s’exécute \( M \) 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 \( M \).
– `results = []`: Une liste pour stocker les résultats des \( M \) simulations.
– `for _ in range(M)`: Une boucle pour exécuter la simulation \( M \) 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 \( n = 5 \) en entrée.
Initialement, \( S = 0 \).
Pour \( i = 1 \) :
\[ S = S + i^2 = 0 + 1^2 = 0 + 1 = 1 \]
Pour \( i = 2 \) :
\[ S = S + i^2 = 1 + 2^2 = 1 + 4 = 5 \]
Pour \( i = 3 \) :
\[ S = S + i^2 = 5 + 3^2 = 5 + 9 = 14 \]
Pour \( i = 4 \) :
\[ S = S + i^2 = 14 + 4^2 = 14 + 16 = 30 \]
Pour \( i = 5 \) :
\[ S = S + i^2 = 30 + 5^2 = 30 + 25 = 55 \]
Le résultat affiché en sortie est donc \( S = 55 \).
b) De façon plus générale, cet algorithme calcule la somme des carrés des \( n \) premiers nombres entiers naturels. Plus précisément, il réalise la somme des valeurs \( i^2 \) pour \( i \) allant de 1 à \( n \).
On peut également exprimer cette somme sous forme de série mathématique :
\[ S = \sum_{i=1}^{n} i^2 \]
Ceci correspond à la somme des carrés des premiers \( n \) entiers naturels.
Exercice 7 : un algorithme qui donne l’image par une fonction
Pour écrire l’algorithme de la fonction \( f \) en fonction de \( x \), 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
{Algorithme de la fonction \( f \) en fonction de \( x \) :}
\begin{verbatim}
Entrée : \( x \) (un nombre réel)
Sortie : \( f(x) \)
\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}
« `
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 \( AB \) entre les points \( A \) et \( B \) sur une droite graduée est donnée par la valeur absolue de la différence de leurs abscisses. Ainsi,
\[ AB = |a – b| \]
b) Voici l’algorithme d’une fonction \(\text{distance}(a, b)\) qui retourne la distance \( AB \) :
\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 \( b^2 = a^2 + c^2 \).
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
\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 :
\[
b^2 = a^2 + c^2
\]
Ainsi, la vérification dans une fonction LaTeX pourrait se présenter comme suit :
\[
\text{Si } b^2 = a^2 + c^2 \text{ alors }\quad H(a, b, c) = \text{Vrai}
\]
\[
\text{Sinon } \quad H(a, b, c) = \text{Faux}
\]
« `
Exercice 10 : volume d’un cylindre et écrire un algorithme
a) Recopier et compléter cet algorithme.
Variables : \(R, h, S, V\) sont des nombres réels
Entrées : Saisir \(R, h\)
Traitement : Affecter à \(S\) la valeur \(\pi R^2\)
Traitement : Affecter à \(V\) la valeur \(S \cdot h\)
Sortie : Afficher \(V\)
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 \[\] 2
# Calcul du volume
V = S * h
# Affichage du volume
print(« Le volume du cylindre est de », V, « cm^3 »)
« `
c) Contrôler le programme avec des exemples.
Exemple 1 :
– R = 3 cm
– h = 5 cm
Calculs :
\[
S = \pi \cdot R^2 = \pi \cdot 3^2 = 9\pi \approx 28.27 \, \text{cm}^2
\]
\[
V = S \cdot h = 28.27 \cdot 5 = 141.35 \, \text{cm}^3
\]
Exemple 2 :
– R = 2 cm
– h = 10 cm
Calculs :
\[
S = \pi \cdot R^2 = \pi \cdot 2^2 = 4\pi \approx 12.57 \, \text{cm}^2
\]
\[
V = S \cdot h = 12.57 \cdot 10 = 125.7 \, \text{cm}^3
\]
Le programme devrait afficher les volumes \(141.35 \, \text{cm}^3\) pour le premier exemple et \(125.7 \, \text{cm}^3\) pour le deuxième exemple.
Exercice 11 : un programme écrit en Python
a) Le type de la variable \( x \) est un entier (int).
b) Pour chaque valeur de \( x \) :
– Si \( x = 1 \) :
\[
y = x^2 \implies y = 1^2 = 1
\]
\[
y = -y + 3 \times x \implies y = -1 + 3 \times 1 = 2
\]
\[
y = y + 4 \implies y = 2 + 4 = 6
\]
Donc, lorsque \( x = 1 \), \( y = 6 \).
– Si \( x = -2 \) :
\[
y = x^2 \implies y = (-2)^2 = 4
\]
\[
y = -y + 3 \times x \implies y = -4 + 3 \times (-2) = -4 – 6 = -10
\]
\[
y = y + 4 \implies y = -10 + 4 = -6
\]
Donc, lorsque \( x = -2 \), \( y = -6 \).
– Si \( x = 12 \) :
\[
y = x^2 \implies y = 12^2 = 144
\]
\[
y = -y + 3 \times x \implies y = -144 + 3 \times 12 = -144 + 36 = -108
\]
\[
y = y + 4 \implies y = -108 + 4 = -104
\]
Donc, lorsque \( x = 12 \), \( y = -104 \).
c) Le programme définit une fonction \( f : x \mapsto y \).
Exprimons \( y \) en fonction de \( x \) :
\[
y = x^2
\]
\[
y arrow -y + 3x \implies y = -x^2 + 3x
\]
\[
y arrow y + 4 \implies y = -x^2 + 3x + 4
\]
Donc, la fonction définie par le programme est
\[
f(x) = -x^2 + 3x + 4.
\]
Exercice 12 : location d’une voiture et programmer un algorithme
### Correction de l’exercice de mathématiques:
### a) Recopier et compléter cet algorithme.
L’algorithme complété est le suivant :
« `
Variables : x est un nombre entier naturel
m est un nombre réel
Entrée : Saisir x
Traitement :
Si x ≤ 100 alors
Affecter à m la valeur 50 + 0.25 * x
sinon
Affecter à m la valeur 50 + 0.25 * 100 + 0.35 * (x – 100)
Fin Si
Sortie : Afficher m
« `
Explication :
– Lorsque le nombre de kilomètres parcourus \( x \) est inférieur ou égal à 100, le coût total \( m \) est donné par \( 50 + 0.25 \times x \).
– Lorsque \( x \) est supérieur à 100, le coût total \( m \) est donné par \( 50 + 0.25 \times 100 + 0.35 \times (x – 100) \).
### b) Coder cet algorithme dans un langage de programmation.
Voici une implémentation possible en Python :
« `python
# Entrée : Saisir x
x = int(input(« Saisir le nombre de kilomètres 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 différentes valeurs de x.
#### Test 1 :
x = 50
Calcul à effectuer:
\[
m = 50 + 0.25 \times 50 = 50 + 12.5 = 62.5
\]
#### Test 2 :
x = 100
Calcul à effectuer:
\[
m = 50 + 0.25 \times 100 = 50 + 25 = 75
\]
#### Test 3 :
x = 150
Calcul à effectuer:
\[
m = 50 + 0.25 \times 100 + 0.35 \times (150 – 100) = 50 + 25 + 17.5 = 92.5
\]
### 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 résultats 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 différentes valeurs de \( x \).
Exercice 13 : simuler un lancer de dé et écrire un programme
a) La valeur de la variable \( S \) affichée à la fin du programme représente la somme des résultats de 10 lancers d’un dé équilibré dont les faces sont numérotées de 1 à 6. À chaque itération de la boucle pour, un nouveau lancer de dé est généré aléatoirement (avec \( \text{ALGOBOX\_ALEA\_ENT}(1, 6) \)) et cette valeur est ajoutée à \( S \).
b) La valeur maximale de \( S \) se produit lorsque chaque lancer de dé donne le résultat le plus élevé possible, soit 6. Ainsi, pour 10 lancers, la valeur maximale de \( S \) est :
\[
S_{\text{max}} = 10 \times 6 = 60
\]
Donc, la plus grande valeur de \( S \) que le programme peut afficher est 60.
Exercice 14 : un programme écrit avec le langage Python
a) On saisit \( n = 4 \), quelle valeur le programme affiche-t-il en sortie ?
Pour \( n = 4 \), le programme exécute les opérations suivantes :
1. Initialisation de \( S \) à 0.
2. Boucle de \( j \) de 1 à \( n+1 \) (donc de 1 à 5).
– Pour \( j = 1 \) : \( S = S + 2 \times j = 0 + 2 \times 1 = 2 \).
– Pour \( j = 2 \) : \( S = S + 2 \times j = 2 + 2 \times 2 = 6 \).
– Pour \( j = 3 \) : \( S = S + 2 \times j = 6 + 2 \times 3 = 12 \).
– Pour \( j = 4 \) : \( S = S + 2 \times j = 12 + 2 \times 4 = 20 \).
Finalement, \( S = 20 \).
b) De façon plus générale, expliquer le calcul effectué par ce programme.
Le programme calcule la somme des \( n \) premiers entiers pairs à partir du premier entier (2) jusqu’à \( 2n \). Cela se décrit par la formule :
\[ S = \sum_{j=1}^{n} 2j \]
On observe que cette somme peut être simplifiée en :
\[ S = 2 \sum_{j=1}^{n} j \]
Et la somme des entiers de 1 à \( n \) est donnée par :
\[ \sum_{j=1}^{n} j = \frac{n (n + 1)}{2} \]
En substitution,
\[ S = 2 \times \frac{n (n + 1)}{2} = n (n + 1) \]
Ainsi, pour une valeur donnée de \( n \), la valeur finale de \( S \) que le programme affiche est :
\[ S = n (n + 1) \]
Exercice 15 : donner un programme qui fournit les 100 premiers entiers
\[\]Correction de l’exercice :\[\]
\[\]a) Le résultat donné par la fonction `diviseurs(N)`\[\]
La fonction `diviseurs(N)` décrite dans l’énoncé compte le nombre de diviseurs de \(N\). Voici le déroulé de l’algorithme :
1. Initialisation de la variable \(x\) à 0.
2. Pour chaque \(k\) de 1 à \(N\) inclus:
– Si \(k\) divise \(N\) (\(N \% k = 0\)), on incrémente \(x\) de 1.
3. À la fin de la boucle, \(x\) contient le nombre de diviseurs de \(N\).
Le résultat de l’algorithme est donc le nombre de diviseurs de \(N\).
\[\]b) Programme déterminant les nombres entiers de 1 à 100 possédant au moins dix diviseurs\[\]
Nous pouvons écrire un programme en Python pour accomplir cette tâche :
« `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)
« `
Ce programme fonctionne comme suit :
1. La fonction `diviseurs(n)` calcule le nombre de diviseurs de \(n\).
2. Une boucle de 1 à 100 appelle cette fonction pour chaque nombre et vérifie si le nombre de diviseurs est supérieur ou égal à 10.
3. Les nombres qui satisfont cette condition sont ajoutés à la liste `numeros`.
4. La liste `numeros` contenant les nombres de 1 à 100 avec au moins 10 diviseurs est affichée.
En LaTeX pour formuler le programme, nous pouvons utiliser l’environnement `lstlisting` pour le code :
« `latex
\usepackage{listings}
Voici le programme pour déterminer les nombres entiers de 1 à 100 possédant 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 présentation claire du programme Python en LaTeX.
Exercice 16 : préciser le plus petit ensemble du nombre a
Voici la correction de l’exercice :
Pour \(a = 2\) :
\[
\begin{align*}
b = a^2 = 2^2 = 4, \\
c = a – b = 2 – 4 = -2, \\
d = 2c = 2 \times (-2) = -4, \\
e = d – c + b = -4 – (-2) + 4 = -4 + 2 + 4 = 2.
\end{align*}
\]
On obtient donc \( e = 2 \).
Pour \(a = -4\) :
\[
\begin{align*}
b = a^2 = (-4)^2 = 16, \\
c = a – b = -4 – 16 = -20, \\
d = 2c = 2 \times (-20) = -40, \\
e = d – c + b = -40 – (-20) + 16 = -40 + 20 + 16 = -4.
\end{align*}
\]
On obtient donc \( e = -4 \).
Pour \(a = \sqrt{2}\) :
\[
\begin{align*}
b = a^2 = (\sqrt{2})^2 = 2, \\
c = a – b = \sqrt{2} – 2, \\
d = 2c = 2 (\sqrt{2} – 2) = 2\sqrt{2} – 4, \\
e = d – c + b = (2\sqrt{2} – 4) – (\sqrt{2} – 2) + 2 \\
= 2\sqrt{2} – 4 – \sqrt{2} + 2 + 2 \\
= \sqrt{2}.
\end{align*}
\]
On obtient donc \( e = \sqrt{2} \).
Ainsi, les valeurs de \(e\) pour les différents arguments sont \(2\), \(-4\), et \(\sqrt{2}\) respectivement. Le plus petit ensemble auquel appartient \(e\) pour tous ces arguments est \(\mathbb{R}\).
Exercice 17 : on exécute le script ci-dessous
[a.] \[\text{nombre}(3)\] est-il un entier ?
\[
a = 3 \\
b = \frac{a}{2} = \frac{3}{2} = 1.5 \\
c = 3 + b = 3 + 1.5 = 4.5 \\
d = \sqrt{c} = \sqrt{4.5} \approx 2.1213
\]
Non, le résultat de \[\text{nombre}(3)\] n’est pas un entier.
[b.] \[\text{nombre}(12)\] est-il un entier ?
\[
a = 12 \\
b = \frac{a}{2} = \frac{12}{2} = 6 \\
c = 3 + b = 3 + 6 = 9 \\
d = \sqrt{c} = \sqrt{9} = 3
\]
Oui, le résultat de \[\text{nombre}(12)\] est un entier.
[c.] \[\text{nombre}(-4)\] est-il un entier ?
\[
a = -4 \\
b = \frac{a}{2} = \frac{-4}{2} = -2 \\
c = 3 + b = 3 + (-2) = 1 \\
d = \sqrt{c} = \sqrt{1} = 1
\]
Oui, le résultat de \[\text{nombre}(-4)\] est un entier.
[d.] Quel sera l’affichage de \[\text{nombre}(-12)\] ?
\[
a = -12 \\
b = \frac{a}{2} = \frac{-12}{2} = -6 \\
c = 3 + b = 3 + (-6) = -3 \\
d = \sqrt{c} = \sqrt{-3}
\]
Comme \[\sqrt{-3}\] n’est pas un nombre réel, la fonction retournera une erreur de type « math domain error ».
Exercice 18 : l’algorithme de la fonction opération
Soit \( a \) l’argument de la fonction \texttt{operation}, alors :
\[
b = -a
\]
\[
c = b^2 = (-a)^2 = a^2
\]
\[
d = -2c = -2a^2
\]
\[
e = d + \lvert a \rvert = -2a^2 + \lvert a \rvert
\]
Nous devons ensuite vérifier si \( e \) est un entier pour les trois valeurs données de \( a \).
1. \[\]Pour \( a = -2 \)\[\]:
\[
b = -(-2) = 2
\]
\[
c = 2^2 = 4
\]
\[
d = -2 \cdot 4 = -8
\]
\[
e = -8 + \lvert -2 \rvert = -8 + 2 = -6
\]
\[
\text{Conclusion: } e = -6 \in \mathbb{Z} \Rightarrow \text{la fonction renvoie « entier ».}
\]
2. \[\]Pour \( a = 3 \)\[\]:
\[
b = -(3) = -3
\]
\[
c = (-3)^2 = 9
\]
\[
d = -2 \cdot 9 = -18
\]
\[
e = -18 + \lvert 3 \rvert = -18 + 3 = -15
\]
\[
\text{Conclusion: } e = -15 \in \mathbb{Z} \Rightarrow \text{la fonction renvoie « entier ».}
\]
3. \[\]Pour \( a = \sqrt{2} \)\[\]:
\[
b = -\sqrt{2}
\]
\[
c = (-\sqrt{2})^2 = (\sqrt{2})^2 = 2
\]
\[
d = -2 \cdot 2 = -4
\]
\[
e = -4 + \lvert \sqrt{2} \rvert = -4 + \sqrt{2}
\]
\[
\text{Conclusion: } e = -4 + \sqrt{2} \notin \mathbb{Z} \Rightarrow \text{la fonction renvoie « pas entier ».}
\]
– Pour \( a = -2 \) : la fonction renvoie « entier ».
– Pour \( a = 3 \) : la fonction renvoie « entier ».
– Pour \( a = \sqrt{2} \) : la fonction renvoie « pas entier ».
Exercice 19 : script de la fonction compteur
a. Pour \texttt{compteur(0.9)}:
\[
\begin{align*}
\text{Initialement } a = 0.9, \; N = 0 \\
\text{Itération 1: } a = 0.9^2 = 0.81, \; N = 1 \\
\text{Itération 2: } a = 0.81^2 = 0.6561, \; N = 2 \\
\text{Itération 3: } a = 0.6561^2 = 0.43046721, \; N = 3 \\
\text{Itération 4: } a = 0.43046721^2 = 0.1853020188851841, \; N = 4 \\
\text{Itération 5: } a = 0.1853020188851841^2 = 0.03433683820292518, \; N = 5 \\
\text{à partir de l’itération 5, } a \leq\, 0.1 \\
\end{align*}
\]
Donc, \texttt{compteur(0.9)} retourne \(\boxed{5}\).
Pour \texttt{compteur(0.1)}:
\[
a = 0.1
\]
Comme \(a \leq\, 0.1\) dès le départ, aucune itération n’est effectuée, donc \(\text{compteur(0.1)}\) retourne \(\boxed{0}\).
b. L’affichage de ce programme représente le nombre de fois qu’un nombre \(a\) (strictement compris entre 0 et 1) doit être multiplié par lui-même jusqu’à ce que sa valeur devienne inférieure à 0.1.
Exercice 20 : algorithme qui détermine la racine carrée
\[
\begin{array}{|c|c|c|c|}
\hline
u 2 1,5 \ldots \\
\hline
u – \sqrt{2} 0,586 \ldots \ldots \\
\hline
\end{array}
\]
1. Complétons le tableau :
Calculons \( u \) en utilisant l’algorithme fourni, avec \( n = 2 \) et \( p = 0,01 \).
\[
u_0 = 2
\]
\[
u_1 = \frac{1}{2}(u_0 + \frac{2}{u_0}) = \frac{1}{2}(2 + \frac{2}{2}) = \frac{1}{2}(2 + 1) = 1,5
\]
\[
u_2 = \frac{1}{2}(u_1 + \frac{2}{u_1}) = \frac{1}{2}(1,5 + \frac{2}{1,5}) = \frac{1}{2}(1,5 + 1,333) = \frac{1}{2}(2,833) \approx 1,417
\]
\[
u_3 = \frac{1}{2}(u_2 + \frac{2}{u_2}) = \frac{1}{2}(1,417 + \frac{2}{1,417}) = \frac{1}{2}(1,417 + 1,411) = \frac{1}{2}(2,828) \approx 1,414
\]
Arrêtons-nous ici, car :
\[
|1,414 – \sqrt{2}| \approx |1,414 – 1,414| < 0,01
\]
Le tableau complété est :
\[
\begin{array}{|c|c|c|c|c|}
\hline
u 2 1,5 1,417 1,414 \\
\hline
u – \sqrt{2} 0,586 0,086 0,003 < 0,01 \\
\hline
\end{array}
\]
L’affichage de l’algorithme avec \( n = 2 \) et \( p = 0,01 \) est \( 1,414 \).
2. Quel est l’affichage de \texttt{val\_app(3, 0.0001)} ?
\[
n = 3, \quad p = 0.0001
\]
Utilisons l’algorithme :
\[
u_0 = 3
\]
\[
u_1 = \frac{1}{2}(3 + \frac{3}{3}) = \frac{1}{2}(3 + 1) = 2
\]
\[
u_2 = \frac{1}{2}(2 + \frac{3}{2}) = \frac{1}{2}(2 + 1,5) = 1,75
\]
\[
u_3 = \frac{1}{2}(1,75 + \frac{3}{1,75}) = \frac{1}{2}(1,75 + 1,714) = 1,732
\]
\[
u_4 = \frac{1}{2}(1,732 + \frac{3}{1,732}) = \frac{1}{2}(1,732 + 1,731) = 1,732
\]
Arrêtons-nous ici, car :
\[
|1,732 – \sqrt{3}| \approx |1,732 – 1,732| < 0,0001
\]
L’affichage de \texttt{val\_app(3, 0.0001)} est \( 1,732 \).
3. Quel est l’affichage de \texttt{val\_app(7, 0.00001)} ?
\[
n = 7, \quad p = 0.00001
\]
Utilisons l’algorithme :
\[
u_0 = 7
\]
\[
u_1 = \frac{1}{2}(7 + \frac{7}{7}) = \frac{1}{2}(7 + 1) = 4
\]
\[
u_2 = \frac{1}{2}(4 + \frac{7}{4}) = \frac{1}{2}(4 + 1,75) = 2,875
\]
\[
u_3 = \frac{1}{2}(2,875 + \frac{7}{2,875}) = \frac{1}{2}(2,875 + 2,435) = 2,655
\]
\[
u_4 = \frac{1}{2}(2,655 + \frac{7}{2,655}) = \frac{1}{2}(2,655 + 2,638) = 2,646
\]
\[
u_5 = \frac{1}{2}(2,646 + \frac{7}{2,646}) = \frac{1}{2}(2,646 + 2,645) = 2,646
\]
Arrêtons-nous ici, car :
\[
|2,646 – \sqrt{7}| \approx |2,646 – 2,646| < 0,00001
\]
L’affichage de \texttt{val\_app(7, 0.00001)} est \( 2,646 \).
Exercice 21 : ordinateur et mot de passe
\[\]Question a.\[\]
L’ordinateur propose \(2020\) à M. Galois, quel est le nombre généré ?
Prenons \(a = 2\), \(b = 0\), \(c = 2\) et \(d = 0\).
Calculons \(p\):
\[ p = 1000 \cdot a + 100 \cdot b + 10 \cdot c + d \]
\[ p = 1000 \cdot 2 + 100 \cdot 0 + 10 \cdot 2 + 0 \]
\[ p = 2000 + 0 + 20 + 0 \]
\[ p = 2020 \]
Initialisons \(s\):
\[ s = p \]
\[ s = 2020 \]
Tant que \(s \geq\, 10\), répétons:
\[ k = \frac{p}{(a + b + c + d)} \]
\[ a + b + c + d = 2 + 0 + 2 + 0 = 4 \]
\[ k = \frac{2020}{4} = 505 \]
Ensuite on vérifie \(k < 10\):
\[ k = 505 \]
Puis:
\[ k \mod 10 = 505 \mod 10 = 5 \]
\[ s = 5 \]
Finalement, \(s\) vaut:
\[ \boxed{5} \]
\[\]Question b.\[\]
Même question si l’ordinateur propose \(1789\) ?
Prenons \(a = 1\), \(b = 7\), \(c = 8\) et \(d = 9\).
Calculons \(p\):
\[ p = 1000 \cdot a + 100 \cdot b + 10 \cdot c + d \]
\[ p = 1000 \cdot 1 + 100 \cdot 7 + 10 \cdot 8 + 9 \]
\[ p = 1000 + 700 + 80 + 9 \]
\[ p = 1789 \]
Initialisons \(s\):
\[ s = p \]
\[ s = 1789 \]
Tant que \(s \geq\, 10\), répétons:
\[ k = \frac{p}{(a + b + c + d)} \]
\[ a + b + c + d = 1 + 7 + 8 + 9 = 25 \]
\[ k = \frac{1789}{25} = 71.56 \]
Ensuite on vérifie \(k < 10\):
\[ k = 71 \]
Puis:
\[ k \mod 10 = 71 \mod 10 = 1 \]
\[ s = 1 \]
Finalement, \(s\) vaut:
\[ \boxed{1} \]
\[\]Question c.\[\]
L’ordinateur peut-il lui proposer le code \(0000\) ?
Prenons \(a = 0\), \(b = 0\), \(c = 0\) et \(d = 0\).
Calculons \(p\):
\[ p = 1000 \cdot a + 100 \cdot b + 10 \cdot c + d \]
\[ p = 1000 \cdot 0 + 100 \cdot 0 + 10 \cdot 0 + 0 \]
\[ p = 0 \]
Initialisons \(s\):
\[ s = p \]
\[ s = 0 \]
Donc, sans boucle:
\[ s = 0 \]
Finalement, \(s\) vaut:
\[ \boxed{0} \]
L’ordinateur peut donc proposer le code \(0000\) et générer le nombre \(0\).
Exercice 22 : algorithme de la fonction nombre
Pour \( a = 2 \) :
\[
\begin{align*}
b = a^2 = 2^2 = 4, \\
c = a – b = 2 – 4 = -2, \\
d = 2c = 2 \times (-2) = -4, \\
e = d – c + b = -4 – (-2) + 4 = -4 + 2 + 4 = 2.
\end{align*}
\]
Donc, \( nombre(2) = 2 \).
Pour \( a = -4 \) :
\[
\begin{align*}
b = a^2 = (-4)^2 = 16, \\
c = a – b = -4 – 16 = -20, \\
d = 2c = 2 \times (-20) = -40, \\
e = d – c + b = -40 – (-20) + 16 = -40 + 20 + 16 = -4.
\end{align*}
\]
Donc, \( nombre(-4) = -4 \).
Pour \( a = \sqrt{2} \) :
\[
\begin{align*}
b = a^2 = (\sqrt{2})^2 = 2, \\
c = a – b = \sqrt{2} – 2, \\
d = 2c = 2 (\sqrt{2} – 2) = 2\sqrt{2} – 4, \\
e = d – c + b = (2\sqrt{2} – 4) – (\sqrt{2} – 2) + 2 = 2 \sqrt{2} – 4 – \sqrt{2} + 2 + 2 = \sqrt{2}.
\end{align*}
\]
Donc, \( nombre(\sqrt{2}) = \sqrt{2} \).
Le plus petit ensemble auquel appartiennent les valeurs de \( nombre(a) \) pour \( a = 2 \), \( a = -4 \), et \( a = \sqrt{2} \) est \( \mathbb{R} \).
Exercice 23 : script et nombre entier
a.
Soit \( a = 3 \).
On calcule:
\[ b = \frac{a}{2} = \frac{3}{2} = 1.5 \]
Ensuite:
\[ c = 3 + b = 3 + 1.5 = 4.5 \]
Finalement:
\[ d = \sqrt{c} = \sqrt{4.5} \]
Or, \(\sqrt{4.5}\) n’est pas un entier.
Donc, le résultat de `nombre(3)` n’est pas un entier.
—
b.
Soit \( a = 12 \).
On calcule:
\[ b = \frac{a}{2} = \frac{12}{2} = 6 \]
Ensuite:
\[ c = 3 + b = 3 + 6 = 9 \]
Finalement:
\[ d = \sqrt{c} = \sqrt{9} = 3 \]
Or, \(3\) est un entier.
Donc, le résultat de `nombre(12)` est un entier.
—
c.
Soit \( a = -4 \).
On calcule:
\[ b = \frac{a}{2} = \frac{-4}{2} = -2 \]
Ensuite:
\[ c = 3 + b = 3 + (-2) = 1 \]
Finalement:
\[ d = \sqrt{c} = \sqrt{1} = 1 \]
Or, \(1\) est un entier.
Donc, le résultat de `nombre(-4)` est un entier.
—
d.
Soit \( a = -12 \).
On calcule:
\[ b = \frac{a}{2} = \frac{-12}{2} = -6 \]
Ensuite:
\[ c = 3 + b = 3 + (-6) = -3 \]
Finalement:
\[ d = \sqrt{c} \]
Cependant, \(\sqrt{-3}\) n’est pas défini dans les réels (où il résulterait en un nombre complexe).
Donc, la fonction `nombre(-12)` affichera une valeur d’erreur en indiquant que la racine carrée d’un nombre négatif n’est pas définie dans l’ensemble des réels.
Exercice 24 : qu’affiche la fonction opération ?
Pour \( a = -2 \)
\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*}
\[
-6 \text{ est un entier, donc la fonction renvoie } « entier ».
\]
Pour \( a = 3 \)
\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*}
\[
-15 \text{ est un entier, donc la fonction renvoie } « entier ».
\]
Pour \( a = \sqrt{2} \)
\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*}
\[
-4 + \sqrt{2} \text{ n’est pas un entier, donc la fonction renvoie } « pas entier ».
\]
Exercice 25 : que représente l’affichage de ce programme ?
a. Calculons la valeur pour compteur(0.9) et compteur(0.1) en suivant le script donné :
1. \[\]Pour \( \text{compteur}(0.9) \)\[\] :
\[
\begin{align*}
a = 0.9, \, N = 0 \\
a = a^2 = 0.9^2 = 0.81, \, N = 1 \\
a = a^2 = 0.81^2 = 0.6561, \, N = 2 \\
a = a^2 = 0.6561^2 = 0.43046721, \, N = 3 \\
a = a^2 = 0.43046721^2 = 0.1853020188851841, \, N = 4 \\
a = a^2 = 0.1853020188851841^2 = 0.03433683820292518, \, N = 5 \\
\end{align*}
L’itération s’arrête ici car \( a < 0.1 \).
Donc, \( \text{compteur}(0.9) = 5 \).
2. \[\]Pour \( \text{compteur}(0.1) \)\[\] :
\[
\begin{align*}
a = 0.1, \, N = 0 \\
a = a^2 = 0.1^2 = 0.01, \, N = 1 \\
\end{align*}
L’itération s’arrête ici car \( a < 0.1 \).
Donc, \( \text{compteur}(0.1) = 1 \).
b. Ce programme réalise un compte du nombre d’itérations nécessaires pour que \( a \), en étant exposantiation successivement par lui-même (c’est-à-dire \( a = a \times a \)), devienne inférieur à 0.1. Pour un nombre donné \( a \) strictement compris entre 0 et 1, la fonction retourne le nombre d’itérations nécessaires pour que la valeur de \( a \) devienne inférieure à 0.1.
Exercice 26 : quel est le plus petit ensemble fourni par ce script ?
Pour résoudre cet exercice, évaluons le script `quisuisje(x)` pour chaque valeur d’entrée.
1. Pour \( x = -2 \) :
\( x \leq\, -1 \), donc \( a = 2x – 1 \).
\[
a = 2(-2) – 1 = -4 – 1 = -5
\]
\( a \in \mathbb{Z} \).
2. Pour \( x = \sqrt{2} \) :
\( x < 4 \), donc \( a = \frac{x}{3} \).
\[
a = \frac{\sqrt{2}}{3}
\]
\( a \in \mathbb{R} \setminus \mathbb{Q} \).
3. Pour \( x = 3\sqrt{2} \) :
\( x < 4 \), donc \( a = \frac{x}{3} \).
\[
a = \frac{3\sqrt{2}}{3} = \sqrt{2}
\]
\( a \in \mathbb{R} \setminus \mathbb{Q} \).
4. Pour \( x = \frac{1}{2} \) :
\( x < 4 \), donc \( a = \frac{x}{3} \).
\[
a = \frac{1}{2} : 3 = \frac{1}{6}
\]
\( a \in \mathbb{Q} \).
5. Pour \( x = \frac{3}{2} \) :
\( x < 4 \), donc \( a = \frac{x}{3} \).
\[
a = \frac{3}{2} : 3 = \frac{3}{2} \times \frac{1}{3} = \frac{1}{2}
\]
\( a \in \mathbb{Q} \).
Le plus petit ensemble auquel appartiennent toutes les valeurs de `quisuisje(x)` pour chaque argument donné est \(\mathbb{R}\).
En conclusion, le plus petit ensemble auquel appartient `quisuisje(x)` pour \( x \in \{-2, \sqrt{2}, 3\sqrt{2}, \frac{1}{2}, \frac{3}{2}\} \) est :
\[
\boxed{\mathbb{R}}
\]
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 \(\sqrt{2}\).
\begin{tabular}{|c|c|c|}
\hline
\( b-a \) \( a \) \( b \) \\
\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 \(\sqrt{2}\). En particulier, il affine les valeurs de \(a\) et \(b\) jusqu’à ce que la différence \((b – a)\) devienne plus petite que \(n\) (ici, 0.1 dans le cas initial).
[c.] Que doit-on modifier si l’on souhaite un encadrement à \(10^{-3}\) près de \(\sqrt{7}\) ?
Pour un encadrement à \(10^{-3}\) près de \(\sqrt{7}\), il faut :
Changer la condition de la boucle \texttt{while} pour vérifier si \((b-a) > 10^{-3}\).
Modifier la constante \(\sqrt{2}\) en \(\sqrt{7}\).
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 \(\ a = 2\ \) :
\[
\begin{align*}
b = a^2 = 2^2 = 4, \\
c = a – b = 2 – 4 = -2, \\
d = 2c = 2 \times (-2) = -4, \\
e = d – c + b = -4 – (-2) + 4 = -4 + 2 + 4 = 2.
\end{align*}
\]
Donc, \(\ \text{nombre}(2) = 2\ \).
Pour \(\ a = -4\ \) :
\[
\begin{align*}
b = a^2 = (-4)^2 = 16, \\
c = a – b = -4 – 16 = -20, \\
d = 2c = 2 \times (-20) = -40, \\
e = d – c + b = -40 – (-20) + 16 = -40 + 20 + 16 = -4.
\end{align*}
\]
Donc, \(\ \text{nombre}(-4) = -4\ \).
Pour \(\ a = \sqrt{2}\ \) :
\[
\begin{align*}
b = a^2 = (\sqrt{2})^2 = 2, \\
c = a – b = \sqrt{2} – 2, \\
d = 2c = 2 \times (\sqrt{2} – 2) = 2\sqrt{2} – 4, \\
e = d – c + b = (2\sqrt{2} – 4) – (\sqrt{2} – 2) + 2 = 2\sqrt{2} – 4 – \sqrt{2} + 2 + 2 = \sqrt{2}.
\end{align*}
\]
Donc, \(\ \text{nombre}(\sqrt{2}) = \sqrt{2}\ \).
Les résultats des arguments \(\ a = 2\ \), \(\ a = -4\ \) et \(\ a = \sqrt{2}\ \) sont respectivement dans \(\ \mathbb{Z}\ \), \(\ \mathbb{Z}\ \) et \(\ \mathbb{R}\setminus\mathbb{Q}\ \).
Ainsi, le plus petit ensemble auquel appartient \(\ \text{nombre}(a)\ \) pour les valeurs données de \(\ a\ \) est \(\ \mathbb{R}\setminus\mathbb{Q}\ \).
Exercice 29 : quel est l’affichage fourni par ce script ?
\( \begin{array}{ll}
\text{On analyse la fonction } \texttt{nombre} \text{ définie ci-contre.} \\
\text{Prenons } a \text{ comme paramètre.} \\
\text{1. Calcul de } b: b = \frac{a}{2} \\
\text{2. Calcul de } c: c = 3 + b \\
\text{3. Calcul de } d: d = \sqrt{c} \\
\text{Question (a) : nombre(3) est-il un entier ?} \\
\text{Calcul: } \\
b = \frac{3}{2} = 1.5 \\
c = 3 + 1.5 = 4.5 \\
d = \sqrt{4.5} \approx 2.12 \text{(ce n’est pas un entier)} \\
\text{Question (b) : nombre(12) est-il un entier ?} \\
\text{Calcul: } \\
b = \frac{12}{2} = 6 \\
c = 3 + 6 = 9 \\
d = \sqrt{9} = 3 \text{(c’est un entier)} \\
\text{Question (c) : nombre(-4) est-il un entier ?} \\
\text{Calcul: } \\
b = \frac{-4}{2} = -2 \\
c = 3 – 2 = 1 \\
d = \sqrt{1} = 1 \text{(c’est un entier)} \\
\text{Question (d) : Quel sera l’affichage de nombre(-12) ?} \\
\text{Calcul: } \\
b = \frac{-12}{2} = -6 \\
c = 3 – 6 = -3 \\
d = \sqrt{-3} \\
\text{(non défini dans les réels, résultat est une valeur complexe.)}\\
\end{array}\)
Exercice 30 : algorithme de la fonction opération
Pour \( a = -2 \) :
– \( b \) prend la valeur de \( -(-2) = 2 \)
– \( c \) prend la valeur de \( 2^2 = 4 \)
– \( d \) prend la valeur de \( -2 \cdot 4 = -8 \)
– \( e \) prend la valeur de \( -8 + |-2| = -8 + 2 = -6 \)
\(e \) est un entier, donc la fonction renvoie « entier ».
Pour \( a = 3 \) :
– \( b \) prend la valeur de \( -3 \)
– \( c \) prend la valeur de \( (-3)^2 = 9 \)
– \( d \) prend la valeur de \( -2 \cdot 9 = -18 \)
– \( e \) prend la valeur de \( -18 + |3| = -18 + 3 = -15 \)
\(e \) est un entier, donc la fonction renvoie « entier ».
Pour \( a = \sqrt{2} \) :
– \( b \) prend la valeur de \( -\sqrt{2} \)
– \( c \) prend la valeur de \( (-\sqrt{2})^2 = 2 \)
– \( d \) prend la valeur de \( -2 \cdot 2 = -4 \)
– \( e \) prend la valeur de \( -4 + |\sqrt{2}| = -4 + \sqrt{2} \)
\(e \) n’est pas un entier, donc la fonction renvoie « pas entier ».
Résumons les résultats :
– Pour \( a = -2 \) : la fonction renvoie « entier ».
– Pour \( a = 3 \) : la fonction renvoie « entier ».
– Pour \( a = \sqrt{2} \) : la fonction renvoie « pas entier ».
Exercice 31 : argument et fonction compteur
Soit la fonction \( \text{compteur}(a) \) 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 \(\text{compteur}(0.9)\) ? \(\text{compteur}(0.1)\) ?
Pour \( \text{compteur}(0.9) \) :
1. Initialement, \( a = 0.9 \) et \( N = 0 \).
2. Comme \( 0.9 \geq\, 0.1 \), on entre dans la boucle :
– \( a arrow a \times a = 0.9 \times 0.9 = 0.81 \)
– \( N arrow N + 1 = 1 \)
3. Comme \( 0.81 \geq\, 0.1 \), on entre dans la boucle :
– \( a arrow a \times a = 0.81 \times 0.81 = 0.6561 \)
– \( N arrow N + 1 = 2 \)
4. Comme \( 0.6561 \geq\, 0.1 \), on entre dans la boucle :
– \( a arrow a \times a = 0.6561 \times 0.6561 = 0.43046721 \)
– \( N arrow N + 1 = 3 \)
5. Comme \( 0.43046721 \geq\, 0.1 \), on entre dans la boucle :
– \( a arrow a \times a = 0.43046721 \times 0.43046721 = 0.1853020188851841 \)
– \( N arrow N + 1 = 4 \)
6. Comme \( 0.1853020188851841 \geq\, 0.1 \), on entre dans la boucle :
– \( a arrow a \times a = 0.1853020188851841 \times 0.1853020188851841 = 0.03433683820292518 \)
– \( N arrow N + 1 = 5 \)
7. Désormais, \( a = 0.03433683820292518 < 0.1 \), la boucle s’arrête.
8. La fonction retourne \( N = 5 \).
Donc, \(\text{compteur}(0.9) = 5\).
Pour \( \text{compteur}(0.1) \) :
1. Initialement, \( a = 0.1 \) et \( N = 0 \).
2. Comme \( 0.1 = 0.1 \), on entre dans la boucle :
– \( a arrow a \times a = 0.1 \times 0.1 = 0.01 \)
– \( N arrow N + 1 = 1 \)
3. Désormais, \( a = 0.01 < 0.1 \), la boucle s’arrête.
4. La fonction retourne \( N = 1 \).
Donc, \(\text{compteur}(0.1) = 1\).
### b. Que représente l’affichage de ce programme ?
Le programme itère en multipliant le nombre \( a \) 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 \( a \) devienne inférieur à 0.1. ainsi, le résultat de cette fonction (\(N\)) représente le nombre d’itérations nécessaires pour que \( a^N \) 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 :
