def minutes(heures: int, minutes: int) -> int:
"""Renvoie le nombre de minutes total correspondant à un nombre d'heures et de minutes.
Entréés :
heures = le nombre d'heures
minutes = le nombre de minutes
Sorties :
le nombre de minutes total
"""
return heures * 60 + minutes # oui, on peut tout faire en une seule ligne !
print(minutes(5, 27))
print(minutes(13, 4))
print(minutes(0, 59))
Le nombre de boîtes de 6 œufs est le quotient du nombre d’œufs par 6.
Il faut une boîte "additionnelle" dans le cas où il reste ensuite moins de 6 œufs à ranger, ce qui se produit si le nombre d'œufs n'est pas un multiple de 6 : on le détermine en calculant le reste de la division du nombre d’œufs par 6, et en testant si il est nul ( multiple de 6 ) ou pas ( pas multiple ).
def nb_boites(oeufs: int) -> int:
"""Renvoie le nombre de boîte(s) de 6 oeufs nécessaire pour ranger un certain nombre d'oeufs
Entrée :
oeufs = le nombre d'oeufs
Sortie :
le nombre de boîte de 6 oeufs
"""
boites = oeufs // 6 # nmbre "brut" de boîtes nécessaire
if oeufs % 6 != 0: # si le nombre d'oeufs n'est pas un multiple de 6,
boites = boites + 1 # alors il faut une boîte en plus pour ranger les oeufs restants.
return boites
print(nb_boites(8))
print(nb_boites(3))
print(nb_boites(6))
print(nb_boites(38))
print(nb_boites(600))
print(nb_boites(601))
print(nb_boites(0))
def est_premier(n: int) -> bool:
"""Fonction qui détermine si un nombre entier est premier ou pas.
Entrée :
n = le nombre à tester
Sortie :
un booléen True si le nombre est premier, False sinon
"""
if n == 0 or n == 1 : # deux cas particuliers
return False
for i in (2, n) : # pour tous les nombres entre 2 et n - 1,
if n != i and n % i == 0 : # si n est divisible par i ( <=> le reste de la division de n par i est nul )
return False # alors on renvoie prématurément 'False'
return True # une fois la boucle terminée, n n'est jamais été divisible par i, il est donc premier, on renvoie 'True'
print(est_premier(0))
print(est_premier(1))
print(est_premier(4))
print(est_premier(6))
print(est_premier(48))
print(est_premier(57))
print(est_premier(77))
print(est_premier(2))
print(est_premier(3))
print(est_premier(5))
print(est_premier(7))
print(est_premier(11))
print(est_premier(13))
print(est_premier(89))
print(est_premier(241))
Ligne 13 : en plus du test de la divisibilité de n par i, il fallait aussi exclure le cas où n == i ( n est forcément multiple de lui-même...) !
def mot_double(ch: str) -> str:
"""Renvoie une nouvelle chaîne avec chaque caractère doublé.
Entrée :
ch = la chaîne à doubler
Sortie :
une nouvelle chaîne avec les caractères doublés
"""
ch2 = "" # initialisation de la nouvelle chaîne
for car in ch: # pour chaque caractère de la chaîne d'origine,
ch2 = ch2 + car*2 # on concatène deux fois le caractère à la nouvelle chaîne
return ch2
print(mot_double('MAC'))
print(mot_double('Z'))
print(mot_double('Lovelace'))
print(mot_double('Turing'))
Ligne 13 : car*2 ne fait bien entendu pas une multiplication, mais crée une chaîne de 2 fois le caractère car ( cf. chapitre sur les chaînes )
def enrhuber_chaine(chaine: str) -> str:
"""Renvoie une chaîne dans laquelle certains caractères ont été remplacés par d'autres.
Entréé :
chaine = la chaîne à transformer
Sortie :
une nouvelle chaîne dans laquelle certains caractères de la chaîne d'origine ont été remplacés
"""
chaine2 = "" # initialisation de la nouvelle chaîne
for car in chaine: # pour chaque caractère de la chaîne d'origine,
if car == "c" or car == "q": # on teste si le caractère courant
chaine2 = chaine2 + "g" # est un de ceux qu'ils faut remplacer;
elif car == "m" or car == "p" or car == "v":# on regroupe les tests pour que ceux-ci soient les plus simples.
chaine2 = chaine2 + "b" # Si un des test est positif,
elif car == "s": # alors on concatène à la nouvelle chaîne le
chaine2 = chaine2 + "z" # caractère de remplacement.
elif car == "t":
chaine2 = chaine2 + "d"
else: # sinon, on concatène
chaine2 = chaine2 + car # simplement le caractère courant.
return chaine2
print(enrhuber_chaine("place"))
print(enrhuber_chaine("chant"))
print(enrhuber_chaine("arret"))
print(enrhuber_chaine("ourse"))
print(enrhuber_chaine("stylo"))
L'idée qui vient tout de suite à l'esprit est de parcourir la chaîne à transformer caractère par caractère, et si le caractère courant est une voyelle, alors on concatène "av" + le caractère à une nouvelle chaîne :
def javanais(chaine: str) -> str:
chaine2 = "" # initialisation d'une nouvelle chaîne
for car in chaine: # pour chaque caractère de la chaîne d'origine,
if car == "a" or car == "e" or car == "i" or car == "o" or car == "u" or car == "y": # si le caractère courant est une voyelle,
chaine2 = chaine2 + "av" + car # alors on concatène "av" + le caractère courant à la nouvelle chaîne,
else:
chaine2 = chaine2 + car # sinon, on concatène simplement le caractère courant.
return chaine2
print(javanais('gros')) # 'gravos' => ça marche
print(javanais('bonjour')) # 'bavonjavoavur' => ça ne marche pas !
Problème : cela ne fonctionne pas dans le cas où le mot contient deux voyelles successives.
Pour résoudre ce problème, il faudrait pouvoir tester si le caractère précédent le caractère courant est aussi une voyelle, et dans ce cas, ne pas concaténer "av".
Mais il est impossible de faire ça avec le type de parcours de chaîne que l'on utilise ici, qui est un parcours par valeur; il va donc falloir utiliser l'autre façon de "s'adresser" à un
caractère dans une chaîne, qui est de le désigner par son index ( cf. cours sur les chaînes si ce n'est plus clair ), et adopter alors un parcours par index de la chaîne grâce à une boucle
for ... in range() :
def javanais(chaine: str) -> str:
chaine2 = "" # initialisation d'une nouvelle chaîne
for i in range(len(chaine)): # pour chaque caractère de la chaîne d'origine,
if (chaine[i] == "a" or chaine[i] == "e" or chaine[i] == "i" or chaine[i] == "o" or chaine[i] == "u" or chaine[i] == "y") and chaine[i-1] != "a" and chaine[i-1] != "e" and chaine[i-1] != "i" and chaine[i-1] != "o" and chaine[i-1] != "u" and chaine[i-1] != "y": # si le caractère courant est une voyelle, et que le caractère précédent N'EST PAS une voyelle,
chaine2 = chaine2 + "av" + chaine[i] # alors on concatène "av" + le caractère courant à la nouvelle chaîne,
else:
chaine2 = chaine2 + chaine[i] # sinon, on concatène simplement le caractère courant.
return chaine2
print(javanais('gros')) # ça marche,
print(javanais('bonjour')) # et là, ça marche aussi !
Le test à la ligne 6 du script précédent est un peu compliqué...
On peut l'écrire plus judicieusement en se rappelant de l'existence des opérateurs in ( est dans ) et not in ( n'est pas dans ), qui permettent, entre autres,
de tester si un caractère donné se trouve dans une chaîne de caractères.
Ici, la chaîne en question sera formée de l'ensemble des voyelles ( 'aeiouy' ), et il suffira de tester l'appartenance d'un caractère dans cette chaîne pour déterminer si ce caractère est une voyelle.
D'où le script final :
def javanais(chaine: str) -> str:
"""Traduit un texte en javanais
Entrée :
chaine = la chaine à traduire
Sortie :
une nouvelle chaine, traduction en javanais de celle d'origine
"""
chaine2 = "" # initialisation d'une nouvelle chaîne
voyelles = 'aeiouyé' # chaîne contenant les voyelles ( on peut aussi y rajouter les caractères accentués...)
for i in range(len(chaine)): # pour chaque caractère de la chaîne d'origine,
if (chaine[i] in voyelles and chaine[i-1] not in voyelles): # si le caractère courant est une voyelle, et que le caractère précédent N'EST PAS une voyelle,
chaine2 = chaine2 + "av" + chaine[i] # alors on concatène "av" + le caractère courant à la nouvelle chaîne,
else:
chaine2 = chaine2 + chaine[i] # sinon, on concatène simplement le caractère courant.
return chaine2
print(javanais('train'))
print(javanais('gros'))
print(javanais('bonjour'))
print(javanais('bon'))
print(javanais('champion'))
print(javanais('plans'))
print(javanais('supermarché'))
print(javanais('poirier'))
def reussir_examen(fra: float, ang: float, phi: float, mat: float, phy: float, inf: float) -> bool:
"""Détermine si un étudiant a réussi à un examens selon les notes qu'il a reçu.
Entrée :
l'ensemble des notes dans chaque matière
Sortie :
un booléen True ou False selon que l'étudaitn a réussi ou non l'examen
"""
m_litt = (4*fra + 3*ang + phi)/(4+3+1)
m_sci = (4*mat + 2*phy + 6*inf)/(4+2+6)
if (m_litt >= 11 and m_sci >= 11) or m_sci >= 16:
return True
else:
return False
print(reussir_examen(10, 13, 11, 15, 6, 12))
print(reussir_examen(8, 13, 11, 15, 6, 12))
print(reussir_examen(10, 13, 11, 11, 6, 12))
print(reussir_examen(6, 3, 11, 15, 16, 20))
print(reussir_examen(8, 11, 14, 13, 9, 11)) # cet étudiant n'a pas réussi l'examen...
Il est à signaler, comme cela a déjà été dit ( par exemple ici ), que, à la place des tests aux lignes 13 à 16, on peut très bien simplement renvoyer le résultat de la condition évaluée :
def reussir_examen(fra: float, ang: float, phi: float, mat: float, phy: float, inf: float) -> bool:
"""Détermine si un étudiant a réussi à un examens selon les notes qu'il a reçu.
Entrée :
l'ensemble des notes dans chaque matière
Sortie :
un booléen True ou False selon que l'étudaitn a réussi ou non l'examen
"""
m_litt = (4*fra + 3*ang + phi)/(4+3+1)
m_sci = (4*mat + 2*phy + 6*inf)/(4+2+6)
return (m_litt >= 11 and m_sci >= 11) or m_sci >= 16
L'évaluation d'une condition renvoie en effet un résultat ( True ou False ) comme n'importe quelle expression.
def gain_tirage(c: int, d: int, u: int)->int:
if c == 7 and d == 7 and u == 7 :
somme = 333
elif c == d and d == u :
somme = 33
elif c == u :
somme = 1
elif c < d and d < u :
somme = 15
else :
somme = 0
return somme
print(gain_tirage(1, 7, 4))
print(gain_tirage(4, 5, 6))
print(gain_tirage(5, 7, 5))
print(gain_tirage(4, 4, 4))
print(gain_tirage(7, 7, 7))
print(gain_tirage(5, 6, 5)) # gain de 1
Remarque : le test à la ligne 3 peut effectivement être écrit ainsi en Python :
if c == d == u == 7 :
...
Et de même, celui à la ligne 9 :
elif c < d < u :
...
Ce qui se rapproche plus de la notation mathématique des égalités/inégalités.
Mais cette écriture est uniquement "pythonesque" et n'existe pas dans les autres langages : on évitera donc de l'utiliser.
from random import randint
def gain_tirage(c: int, d: int, u: int)->int:
if c == 7 and d == 7 and u == 7 :
somme = 333
elif c == d and d == u :
somme = 33
elif c == u :
somme = 1
elif c < d and d < u :
somme = 15
else :
somme = 0
return somme
def machine_a_sous()->int:
c = randint(1, 9)
d = randint(1, 9)
u = randint(1, 9)
somme = gain_tirage(c, d, u)
return (c, d, u, somme)
print(machine_a_sous())
En lançant le script plusieurs fois de suite, on s'aperçoit qu'on ne gagne pas beaucoup, et pas très souvent 😭...