def minutes(heures, minutes):
"""Renvoie le nombre de minutes total correspondant à un nombre d'heures et de minutes.
Entréés :
heures = le nombre d'heures (int)
minutes = le nombre de minutes (int)
Sorties :
le nombre de minutes total (int)
"""
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):
"""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 (int)
Sortie :
le nombre de boîte de 6 oeufs (int)
"""
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):
"""Fonction qui détermine si un nombre entier est premier ou pas.
Entrée :
n = le nombre à tester (int)
Sortie :
True si le nombre est premier, False sinon (bool)
"""
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 == 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))
def mot_double(ch):
"""Renvoie une nouvelle chaîne avec chaque caractère doublé.
Entrée :
ch = la chaîne à doubler (str)
Sortie :
une nouvelle chaîne avec les caractères doublés (str)
"""
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 )
On parcourt la chaîne, et on teste si le caractère courant est égal à un de ceux à remplacer; si c'est le cas, on fait la substitution.
On concatène ensuite le caractère, remplacé ou non, à une nouvelle chaîne :
def enrhuber_chaine(chaine):
"""Renvoie une chaîne dans laquelle certains caractères ont été remplacés par d'autres.
Entréé :
chaine = la chaîne à transformer (str)
Sortie :
une nouvelle chaîne dans laquelle certains caractères de la chaîne d'origine ont été remplacés (str)
"""
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"))
Bien entendu, on a pensé à regrouper les tests qui menaient à la substitution du même caractère !
Ça en fait, des if...et si on veut gérer aussi les majuscules, cela rajoute encore des conditions...
Pour optimiser le code, on peut se souvenir de l'existence de deux choses en Python :
in, qui permet de tester si un caractère donné se trouve dans une chaîne donnéechaîne.index(caratère), qui renvoie l'indice d'un caractère dans une chaîneD'où l'idée :
def enrhuber_chaine(chaine):
"""Renvoie une chaîne dans laquelle certains caractères ont été remplacés par d'autres.
Entréé :
chaine = la chaîne à transformer (str)
Sortie :
une nouvelle chaîne dans laquelle certains caractères de la chaîne d'origine ont été remplacés (str)
"""
original = "cCqQmMpPvVsStT" # chaîne contenant tous les caractères à remplacer
remplacement = "gGgGbBbBbBzZdD" # chaîne contenant tous les caractères de remplacement, DANS LE MÊME ORDRE
chaine2 = "" # initialisation de la nouvelle chaîne
for car in chaine: # pour chaque caractère de la chaîne d'origine,
if car in original: # on teste si le caractère courant est un de ceux qu'ils faut remplacer;
indice = original.index(car) # dans ce cas, on détermine son indice dans la chaîne 'original',
car = remplacement[indice] # et on le remplace par le caractère DE MÊME INDICE dans la chaîne 'remplacement'.
chaine2+= car # On concatène le caractère, remplacé ou non, à la nouvelle chaîne.
return chaine2
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):
""" 'Traduit' une chaîne de caractères en javanais, c'est à dire rajoute 'av' devant les voyelles.
Entréee :
chaine = la chaîne d'origine (str)
Sortie :
la chaîne en javanais (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):
""" 'Traduit' une chaîne de caractères en javanais, c'est à dire rajoute 'av' devant les voyelles.
Entréee :
chaine = la chaîne d'origine (str)
Sortie :
la chaîne en javanais (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 utilisant, comme à l'exercice précédent, les opérateurs in ( est dans ) et not in ( n'est pas dans ).
Ici, la chaîne en question sera formée de l'ensemble des voyelles ( 'aeiouy', avec éventuellement les majuscules ), et il suffira de tester l'appartenance d'un caractère
à cette chaîne pour déterminer si ce caractère est une voyelle ou pas.
D'où le script final :
def javanais(chaine):
"""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, les majuscules,...)
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 😭...