def autre_fonction(s : str, n : int) -> str :
"""
Entrées : s un chaîne de caractère et n un entier naturel
Sortie : s répétée n fois, chaque répétition est délimitée par " - "
"""
s_repetee = ""
if n > 0 :
s_repetee = (s + " - ") * (n-1)
s_repetee = s_repetee + s
return s_repetee
autre_fonction("Cuisine", 6)
'Cuisine - Cuisine - Cuisine - Cuisine - Cuisine - Cuisine'
Il faut arriver à calculer le code du $i^\text{ème}$ caractère après c.
Il s'agit de $c+i$ tant que $c+i$ ne dépasse pas le caractère 'z'
'f', ord('f'), ord('f')+7, chr(ord('f') + 7)
('f', 102, 109, 'm')
Lorsque $c+i$ dépasse 'z'
il faut revenir au code de 'a'
.
Il existe plusieurs méthode pour résoudre ce problème :
'a'
'z'
ord('f') + 22, chr(ord('f') + 22)
(124, '|')
En enlevant ord('a')
on obtient le numéro de la lettre cherchée entre 0 et 25 dans l'alphabet.
ord('f')-ord('a') + 22
27
En prenant ce nombre modulo 26, on revient à 0 lorsqu'on dépasse 25.
(ord('f')-ord('a') + 22) % 26
1
En additionnant ord(a)
, on retrouve le codage du caractère correspondant à la lettre 5
code = ord('a') + (ord('f') - ord('a') + 22) % 26
code, chr(code)
(98, 'b')
def alphabet(c : str) -> str :
"""
Entrées : un caractère c
Sortie : l'alphabet commençant par c et revenant à 'a' après avoir dépassé 'z'
"""
code = ord(c)
alpha = ""
compteur = 0
while compteur < 26 :
code_suivant = ord('a') + ( code - ord('a') + compteur ) % 26
alpha = alpha + chr(code_suivant)
compteur = compteur + 1
return alpha
alphabet('f'), alphabet('a'), alphabet('z')
('fghijklmnopqrstuvwxyzabcde', 'abcdefghijklmnopqrstuvwxyz', 'zabcdefghijklmnopqrstuvwxy')
On remarque que les lettre minuscules et majuscules sont séparées dans le codage ASCII par la même valeur, quelque soit la lettre :
ord('a') - ord('A'), ord('b') - ord('B'), ord('j') - ord('J')
(32, 32, 32)
c = 'g'
chr(ord(c)-32)
'G'
D'autre part une lettre majuscule possède un code entre 65 et 90 et une lettre minuscule entre 97 et 122.
ord('A'), ord('Z'), ord('a'), ord('z')
(65, 90, 97, 122)
def inverser_casse(s : str) -> str :
"""
Entrées : s une chaîne de caractère
Sortie : une chaîne de caractère avec la casse inversée.
"""
s_inversee = ""
decalage = ord('a') - ord('A') # 32
i = 0
n = len(s)
while i < n :
if ord('A') <= ord(s[i]) <= ord('Z') : # 65 <= s[i] <= 90
s_inversee = s_inversee + chr(ord(s[i]) + decalage)
elif ord('a') <= ord(s[i]) <= ord('z') : # 97 <= s[i] <= 122
s_inversee = s_inversee + chr(ord(s[i]) - decalage)
else :
s_inversee = s_inversee + s[i]
i = i + 1
return s_inversee
inverser_casse("NadinE EsT DiVinE")
'nADINe eSt dIvINe'
def produit_vectoriel(u : tuple[int,int,int], v : tuple[int,int,int]) -> tuple[int,int,int] :
"""
Entrées : u, v deux vecteurs de R^3
Sortie : le produit vectoriel de u et v dans R^3
"""
return (u[1] * v[2] - u[2] * v[1],
u[2] * v[0] - u[0] * v[2],
u[0] * v[1] - u[1] * v[0])
produit_vectoriel((1,0,0), (0,1,0))
(0, 0, 1)
def triangles(p1 : tuple[float,float],
p2 : tuple[float,float],
p3 : tuple[float,float]) -> tuple[bool,bool,bool] :
R = False
I = False
E = False
C_carre = ((p2[0]-p1[0]) ** 2 + (p2[1]-p1[1])**2,
(p3[0]-p2[0]) ** 2 + (p3[1]-p2[1])**2,
(p1[0]-p3[0]) ** 2 + (p1[1]-p3[1])**2 )
if (C_carre[0] == C_carre[1] + C_carre[2] or
C_carre[1] == C_carre[0] + C_carre[2] or
C_carre[2] == C_carre[1] + C_carre[0] ) :
R = True
if (C_carre[0] == C_carre[1] or
C_carre[0] == C_carre[2] or
C_carre[1] == C_carre[2] ) :
I = True
if (C_carre[0] == C_carre[1] and C_carre[1] == C_carre[2]) :
E = True
return (R,I,E)
triangles( (0.0,1.0), (1.0,0.0), (0.0,0.0) ), triangles((1.0,2.0),(1.0,0.0),(0.0,0.0)), triangles((0.0,0.0),(1.0,0.0),(0.5,0.8660254037844386))
((True, True, False), (True, False, False), (False, True, False))
On notera le problème du à la précision des flottants :
p1 = (0.0,0.0)
p2 = (1.0,0.0)
p3 = (0.5,0.8660254037844386)
C_carre = ((p2[0]-p1[0]) ** 2 + (p2[1]-p1[1])**2,
(p3[0]-p2[0]) ** 2 + (p3[1]-p2[1])**2,
(p1[0]-p3[0]) ** 2 + (p1[1]-p3[1])**2 )
C_carre
(1.0, 0.9999999999999999, 0.9999999999999999)
def somme_liste(l) :
"""
Entrées : une liste d'entiers relatifs
Sortie : la somme des entiers de la liste
"""
i = 0
n = len(l)
somme = 0
while(i < n) :
somme = somme + l[i]
i = i + 1
return somme
somme_liste([12,21,24,144])
201
def somme_liste(l) :
"""
Entrées : une liste d'entiers relatifs
Sortie : la somme des entiers de la liste
"""
i = 0 # Indice de l'élément courant
n = len(l) # Longueur de la liste
somme = 0 # Somme intermédiaire des i premiers éléments
# Tant que tous les éléments n'ont pas été ajouté...
while(i < n) :
somme = somme + l[i] # Ajouter l'élément à l'indice i
i = i + 1 # Passer à l'indice suivant
return somme
somme_liste([12,21,24,144])
def produit_liste(l) :
"""
Entrées : une liste d'entiers relatifs
Sortie : la somme des entiers de la liste
"""
i = 0
n = len(l)
produit = 1
while(i < n) :
produit = produit * l[i]
i = i + 1
return produit
def somme_liste_pairs(l) :
"""
Entrées : une liste d'entiers relatifs
Sortie : la somme des entiers de la liste
"""
i = 0
n = len(l)
somme = 0
while(i < n) :
if l[i] % 2 == 0 :
somme = somme + l[i]
i = i + 1
return somme
$m$ est initialement nul.
$i$ parcours les indices de la liste.
À chaque tour de boucle, si l'élément de $L$ à l'indice $i$ est plus grand que $m$, $m$ devient cet élément.
$m$ est donc associé au maximum des éléments de $L$ plus petits que $i$.
À la fin de la boucle, $m$ est le maximum de la liste.
def imax(l : list[int]) -> int :
"""
Entrées : une liste d'entiers L
Sortie : l'indice du maximum de la liste
"""
i_max = -1
if l != [] :
i_max = 0
i = 1
n = len(l)
while i < n :
if l[i] > l[i_max] :
i_max = i
i = i + 1
return i_max
def imin(l : list[int]) -> int :
"""
Entrées : Une liste d'entiers L
Sortie : l'indice du minimum de la liste
"""
i_min = -1
if l != [] :
i_min = 0
i = 1
n = len(l)
while i < n :
if l[i] < l[i_min] :
i_min = i
i = i + 1
return i_min
def moyenne(l : list[int]) -> float :
"""
Entrées : une liste d'entiers L
Sortie : la moyenne des valeurs de la liste l
"""
i = 0
somme = 0
n = len(l)
while i < n :
somme = somme + l[i]
i = i + 1
return somme / n
def variance(l : list[int]) -> float :
"""
Entrées : une liste d'entiers l
Sortie : la variance des valeurs de la liste l
"""
i = 0
moy = moyenne(l)
somme = 0.0
n = len(l)
while i < n :
somme = somme + (l[i] - moy) ** 2
i = i + 1
return somme / n
On regarde chaque élément de la liste un par un.
Si on trouve l'élément on arrête le parcours et on renvoie l'indice courant.
def recherche(l : list[int], x : int) -> int :
"""
Entrées : une liste d'entiers l et un entier x
Sortie : l'indice de la première occurence de x dans l, ou -1 si x n'est pas dans l
"""
i_x = -1
i = 0
n = len(l)
while i < n and i_x == -1 :
if l[i] == x :
i_x = i
i = i + 1
return i_x
def somme(l1 : list[int], l2 : list[int]) -> list[int] :
"""
Entrées : deux listes d'entiers l1 et l2 de même longueur
Sortie : une liste dont les éléments sont la sommes des éléments de l1 et l2 deux à deux.
"""
i = 0
n = len(l1)
l = [0] * n
while i < n :
l[i] = l1[i] + l2[i]
i = i + 1
return l