def conversion_secondes(jours : int, heures : int, minutes : int, secondes : int) -> int :
"""
Entrées : 4 nombres entiers.
nombre de jours, d'heures, de minutes et de secondes
Sortie : un entier.
Le nombre de secondes équivalents à la durée donnée en paramètre
"""
total = 0
total = total + secondes
total = total + minutes * 60
total = total + heures * ( 60 * 60 )
total = total + jours * ( 60 * 60 * 24 )
return total
conversion_secondes(12,12,12,12)
1080732
def conversion_secondes(jours : int, heures : int, minutes : int, secondes : int) -> int :
"""
Entrées : 4 nombres entiers.
nombre de jours, d'heures, de minutes et de secondes
Sortie : un entier.
Le nombre de secondes équivalents à la durée donnée en paramètre
"""
# Initialisation à 0 d'une variable représentant le total cumulé des durée en secondes.
total = 0
# Calcul de l'addition de la valeur de total et de la valeur de seconde.
# Mise à jour de la valeur de total avec le résultat de l'addition
total = total + secondes #
# Ajout du nombre de minute convertit en seconde au total
total = total + minutes * 60
# Ajout du nombre d'heures convertit en seconde au total
total = total + heures * ( 60 * 60 )
# Ajout du nombre de jours convertit en seconde au total
total = total + jours * ( 60 * 60 * 24 )
# Renvoie de la valeur de total, c'est à dire la somme de chaque durée convertit en seconde
return total
def conversion_secondes_2(annee : int, jours : int, heures : int, minutes : int, secondes : int) -> int :
"""
Entrées : 5 nombres entiers.
nombre d'années, de jours, d'heures, de minutes et de secondes
Sortie : un entier.
Le nombre de secondes équivalents à la durée donnée en paramètre
"""
total = 0
total = total + secondes
total = total + minutes * 60
total = total + heures * ( 60 * 60 )
total = total + jours * ( 60 * 60 * 24 )
total = total + annee * ( 60 * 60 * 24 * 365 )
return total
conversion_secondes_2(12,12,12,12,12)
379512732
def calculatrice(a : int, b : int, operation : str) -> int :
"""
Entrées :
- ( a : entier ), (b : entier) ; deux entiers
- ( operation : chaîne de caractère ) ;
le symbole de l'opération arithmétique à exécuter
Sortie : un entier.
Le résultat de l'opération ayant comme opérandes a et b
"""
resultat = 0
if operation == "+" :
resultat = a + b
elif operation == "-" :
resultat = a - b
elif operation == "*" or operation == "x" :
resultat = a * b
elif operation == "/" and b != 0:
resultat = a // b
elif operation == "%" :
resultat = a % b
elif operation == "**" :
resultat = a ** b
else :
resultat = None
return resultat
calculatrice(12,21,"+")
33
calculatrice(12,21,"-")
-9
calculatrice(12,21,"*")
252
calculatrice(21,12,"/")
1
calculatrice(144,21,"%")
18
calculatrice(12,4,"**")
20736
def calculatrice(a : int, b : int, operation : str) -> bool :
"""
Entrées :
- ( a : entier ), (b : entier) ; deux entiers
- ( operation : chaîne de caractère ) ;
le symbole de l'opération arithmétique à exécuter
Sortie : un entier.
Le résultat de l'opération ayant comme opérandes a et b
"""
# Initialisation à 0 d'une variable resultat qui contiendra le résultat de l'opération
resultat = 0
if operation == "+" : # Si opération est égal au caractère "+"
resultat = a + b # Mettre dans le resultat la somme des entrées
elif operation == "-" : # Si opération est égal au caractère "-"
resultat = a - b # Mettre dans le resultat la différence des entrées
elif operation == "*" or operation == "x" : # Si opération est égal au caractère "*" ou "x"
resultat = a * b # Mettre dans le resultat le produit des entrées
elif operation == "/" and b != 0: # Si opération est égal au caractère "/" et b n'est pas nul
resultat = a // b # Mettre dans le resultat le quotient de la division euclidienne de a par b
elif operation == "%" : # Si opération est égal au caractère "%"
resultat = a % b # Mettre dans le resultat le reste de la division euclidienne de a par b
elif operation == "**" : # Si opération est égal au caractère "**"
resultat = a ** b # Mettre dans le resultat a à la puissance b
else :
resultat = None
return resultat
calculatrice(12,0,"%")
--------------------------------------------------------------------------- ZeroDivisionError Traceback (most recent call last) Input In [15], in <cell line: 1>() ----> 1 calculatrice(12,0,"%") Input In [8], in calculatrice(a, b, operation) 18 resultat = a // b 19 elif operation == "%" : ---> 20 resultat = a % b 21 elif operation == "**" : 22 resultat = a ** b ZeroDivisionError: integer division or modulo by zero
def somme(n : int) -> int :
"""
Entrées : n un nombre entier positif
Sortie : s un entier. la somme des entiers de 0 à n
"""
somme_temporaire = 0
entier = 0
while entier <= n :
somme_temporaire = somme_temporaire + entier
entier = entier + 1
return somme_temporaire
somme(6)
21
def somme(n : int) -> int :
"""
Entrées : n un nombre entier positif
Sortie : s un entier. la somme des entiers de 0 à n
"""
somme_temporaire = 0 # Somme intermédiaire des i premiers entiers à l'étape i de la boucle
entier = 0 # entier à ajouter au total, au départ 0
# Pour chaque entier i de 0 à n inclus, on ajoute i à la somme intermédiaire des entiers de 0 à i-1
# Chaque fois que l'on arrive à la ligne ci dessous,
# somme_intermédiaire contient la somme des entiers de 0 à "entier-1"
while entier <= n : # Tant que entier est plus petit ou égal à n on répète le block d'instruction
somme_temporaire = somme_temporaire + entier # On ajoute à la somme temporaire l'entier
entier = entier + 1 # entier prend la valeur de l'entier souvent
# Quand la boucle est terminée, la condition de la boucle est fausse donc entier est plus grand que n
# Comme entier commence à 0 et augmente de 1 en 1, entier vaut exactement n + 1
# La somme temporaire vaut la somme des entiers de 0 à n, on renvoit alors la somme.
return somme_temporaire
def factorielle(n : int) -> int :
"""
Entrées : n un nombre entier positif
Sortie : s un entier. la factorielle de n
"""
multiplication_temporaire = 1
entier = 1
while entier <= n :
multiplication_temporaire = multiplication_temporaire * entier
entier = entier + 1
return multiplication_temporaire
factorielle(12)
479001600
def exp(a : int, b : int) -> int :
"""
Entrées : a et b deux nombre entiers
Sortie : un entier. a porté à la puissance b
"""
resultat = 1.0
compteur_operations = 0
if b >= 0 :
while compteur_operations < b :
resultat = resultat * a
compteur_operations = compteur_operations + 1
else :
while compteur_operations < b :
resultat = resultat / a
compteur_operations = compteur_operations + 1
return resultat
exp(12,3)
1728.0
exp(12,-3)
1.0
On remarque (et on s'en convaint avec le test ci-dessous) que le résultat n'est pas égal à $12^{-3}$
12 ** (-3)
0.0005787037037037037
La simulation montre qu'alors que l'on s'attend à ce que resultat
soit divisé trois fois par a = 12
, aucune opération n'est effectuée.
En effet, la seconde boucle while
(l.13) est sautée directement.
C'est cohérent puisque compteur_operations == 0
et b == -3
, donc compteur_operations < -3
est évalué à False
.
L'erreur est à ce niveau.
def exp(a : int, b : int) -> int :
"""
Entrées : a et b deux nombre entiers
Sortie : un entier. a porté à la puissance b
"""
resultat = 1.0
compteur_operations = 0
if b >= 0 :
while compteur_operations < b :
resultat = resultat * a
compteur_operations = compteur_operations + 1
else :
while compteur_operations > b :
resultat = resultat / a
compteur_operations = compteur_operations - 1
return resultat
exp(12,3)
1728.0
exp(12,-3)
0.0005787037037037037
L'algorithme $\cal E$ soustrait le plus petit entier au plus grand et ceux tant que les deux entiers ne sont pas égaux.
Il s'agit de l'algorithme d'Euclide qui calcule le PGCD de ses deux entrées.
def euclide(a : int, b : int) -> int :
while a != b :
if a >= b :
a = a - b
else :
b = b - a
return a
L'algorithme $\cal P$ verifie pour chaque entier $d$ de $2$ à $\lceil \sqrt n \rceil$ si $d$ divise $n$.
L'algorithme renvoie False
si $n$ possède un diviseur, True
sinon.
Il vérifie donc si $n$ est premier.
def premier(n : int) -> int :
p = True
d = 2
while d * d <= n :
if n % d == 0 :
p = False
d = d + 1
return p