NSI Première
S'inspirer de l'exemple de la somme calculée dans le cours : on initialise ici une variable produit à 1, et on multiplie la valeur de chaque élément successif dans le tableau par la valeur précédente de produit :
def produit(t):
"""
Renvoie le produit des valeurs dans un tableau.
Entrée :
t = le tableau d'entiers ( list de int )
Sortie :
le produit des valeurs ( int )
"""
produit = 1
for nombre in t : # parcours par valeur des éléments du tableau
produit = produit * nombre
return produit
nombres = [2, 3, 2]
print(produit(nombres))
S'inspirer de l'inversion d'une chaîne de caractères faite dans le chapitre sur les chaînes.
L'idée : on parcourt le tableau élément par élément, et on concatène chacun de ses éléments au début du nouveau tableau ( préalablement initialisé, bien sûr ! ) :
def inverse_tableau(t ):
"""
Renvoie le "miroir" d'un tableau, c'est à dire un tableau avec les éléments du premier en ordre inverse.
Entrée :
t = le tableau à inverser ( list d'éléments de type(s) quelconque(s) )
Sortie :
un nouveau tableau, avec les éléments du premier en ordre inverse ( list )
"""
t_inverse = [] # tableau initialement vide
for elt in t :
t_inverse = [elt] + deuxieme # attention au type de 'elt' : ce doit être un élément de tableau, pas une valeur "seule"
return t_inverse
t1 = [12, 56, 6, 1, 78, 96]
print(inverse_tableau(t1))
Comme ici on concatène un tableau après un élément, on ne peut donc pas utiliser la fonction append(), qui concatène un élément à la fin d'un tableau...
On parcourt chaque élément du tableau, et on le compare à son précédent ou son suivant : on est donc obligé de faire un parcours par indice du tableau.
Deux possibilités pour la comparaison :
len(tab)-2 ), sinon on "dépasse" les limites du tableau arrivé à la fin de celui-ci.len(tab)-1 ), sinon on va comparer l'élément d'indice 0 ( le premier élément du tableau ) et celui d'indice -1 ( le dernier ! ).
def est_trie(tab):
"""
Détermine si un tableau est trié ou non dans l'ordre croissant.
Entrée :
tab = le tableau à tester ( list )
Sortie :
True ou False selon que le tableau est trié ou non ( bool )
"""
for i in range(0, len(tab)-1): # on choisit de comparer les éléments d'indice i et i + 1
if tab[i] > tab[i+1]: # si un élément a une valeur plus grande que son suivant,
return False # alors le tableau n'est pas ( complètement ) trié dans l'ordre croissant
return True # EN FIN DE PARCOURS, si on n'a jamais rencontré d'ordre incorrect, c'est que le tableau est complètement trié dans l'ordre croissant.
Il était plus simple ici d'arrêter le parcours quand on rencontre un problème, plutôt que de tester si l'ordre est correct, et dans ce cas...ne rien faire !
Et il ne faut surtout pas écrire quelque chose comme :
for i in range(0, len(tab)-1)
if tab[i] < tab[i+1]: # si les éléments sont dans le bon ordre,
return True
Avec ce code, on SORT DE LA FONCTION si on rencontre deux éléments dans le bon ordre : et la suite du tableau alors ? Il faut au contraire POURSUIVRE le parcours...
Autre possibilité :
def est_trie(tab):
"""
Détermine si un tableau est trié ou non dans l'ordre croissant.
Entrée :
tab = le tableau à tester ( list )
Sortie :
True ou False selon que le tableau est trié ou non ( bool )
"""
for i in range(1, len(tab)): # on choisit de comparer les éléments d'indice i et i - 1
if tab[i] < tab[i-1]: # si un élément a une valeur plus petite que son précédent,
return False # alors le tableau n'est pas ( complètement ) trié dans l'ordre croissant
return True # EN FIN DE PARCOURS, si on n'a jamais rencontré d'ordre incorrect, c'est que le tableau est complètement trié dans l'ordre croissant.
On s'inspire de l'algorithme de comptage des occurrences d'un caractère dans une chaîne.
Version 1 :
def analyse_ADN(tab):
"""
Compte et renvoie le nombre d'occurrences du gène 'A' dans un tableau de gènes.
Entrée :
tab = le tableau de gènes ( list de str )
Sortie :
le nombre d'occurrences du gène 'A' dans le tableau ( int )
"""
a = 0
for gene in tab:
if gene == 'A':
a = a + 1
return a
ADN = ['T', 'G', 'T', 'G', 'T', 'G', 'A', 'G', 'C', 'C', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'T', 'A', 'T', 'C', 'A', 'T', 'A', 'A', 'G', 'T', 'T', 'G', 'A', 'A', 'T', 'T', 'C', 'G', 'T', 'C', 'T', 'T', 'C', 'G', 'G', 'T', 'G', 'A', 'G', 'C', 'G', 'T', 'T']
print(analyse_ADN(ADN))
Version 2 :
def analyse_ADN(tab):
"""
Compte et renvoie le nombre d'occurrences des gènes 'A', 'C', 'G' et 'T' dans un tableau de gènes.
Entrée :
tab = le tableau de gènes ( list de str )
Sortie :
le nombre d'occurrences de chaque gène dans le tableau ( tuple de 4 int )
"""
a = 0 # une variable compteur pour chacun des 4 types de gène
t = 0
c = 0
g = 0
for gene in tab :
if gene == 'A':
a += 1
elif gene == 'T':
t += 1
elif gene == 'C':
c += 1
else : # ça ne peut être qu'un des 4 gènes !
g += 1
return a, t, c, g # renvoi des 4 résultats sous forme d'un tuple ( les parenthèses ne sont pas obligatoires )
ADN = ['T', 'G', 'T', 'G', 'T', 'G', 'A', 'G', 'C', 'C', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'T', 'A', 'T', 'C', 'A', 'T', 'A', 'A', 'G', 'T', 'T', 'G', 'A', 'A', 'T', 'T', 'C', 'G', 'T', 'C', 'T', 'T', 'C', 'G', 'G', 'T', 'G', 'A', 'G', 'C', 'G', 'T', 'T']
analyse = analyse_ADN(ADN) # on récupère les résultats dans un tuple 'analyse'
print("Nombre de gènes 'A' :", analyse[0]) # le résultat pour le gène 'A' correspond au premier élément du tuple
print("Nombre de gènes 'T' :", analyse[1]) # celui pour 'T' au deuxième
print("Nombre de gènes 'C' :", analyse[2]) # celui pour 'C' au troisième
print("Nombre de gènes 'G' :", analyse[3]) # et celui pour 'G' au quatrième
Version 3 :
def analyse_ADN(tab):
"""
Compte et renvoie le pourcentage d'apparition des gènes 'A', 'C', 'G' et 'T' dans un tableau de gènes.
Entrée :
tab = le tableau de gènes ( list de str )
Sortie :
les pourcentages d'apparition de chaque gène dans le tableau ( tuple de 4 float )
"""
a = 0 # une variable compteur pour chacun des 4 types de gène
t = 0
c = 0
g = 0
for gene in tab :
if gene == 'A':
a += 1
elif gene == 'T':
t += 1
elif gene == 'C':
c += 1
else : # ça ne peut être qu'un des 4 gènes !
g += 1
n = len(tab) # nombre total de gènes dans le tableau
a = (a / n)*100 # calcul des pourcentages
t = (t / n)*100
c = (c / n)*100
g = (g / n)*100
return a, t, c, g # renvoi des 4 résultats sous forme d'un tuple ( les parenthèses ne sont pas obligatoires )
ADN = ['T', 'G', 'T', 'G', 'T', 'G', 'A', 'G', 'C', 'C', 'A', 'C', 'A', 'G', 'A', 'G', 'G', 'T', 'A', 'T', 'C', 'A', 'T', 'A', 'A', 'G', 'T', 'T', 'G', 'A', 'A', 'T', 'T', 'C', 'G', 'T', 'C', 'T', 'T', 'C', 'G', 'G', 'T', 'G', 'A', 'G', 'C', 'G', 'T', 'T']
analyse = analyse_ADN(ADN) # on récupère les résultats dans un tuple 'analyse'
print("Pourcentage de gènes 'A' :", analyse[0]) # le résultat pour le gène 'A' correspond au premier élément du tuple
print("Pourcentage de gènes 'T' :", analyse[1]) # celui pour 'T' au deuxième
print("Pourcentage de gènes 'C' :", analyse[2]) # celui pour 'C' au troisième
print("Pourcentage de gènes 'G' :", analyse[3]) # et celui pour 'G' au quatrième
L'idée : "recopier" dans deux nouveaux tableaux, les éléments d'indice inférieurs ou égal à n dans l'un, et les autres dans l'autre.
Attention, n représente bien un indice "limite" pour le partage, pas la valeur d'un élément.
Un parcours par indice est indispensable ici, puisqu'il faut tester si la valeur de cet indice est inférieur ou égal à n, ou pas.
On peut faire cette recopie à l'aide d'une boucle sur les éléments du tableau d'origine :
def partage_tableau(tab, n):
"""
Renvoie les deux sous-tableaux obtenus après partage d'un tableau selon un certain indice de ce tableau.
Entrées :
tab = le tableau à partager ( list )
n = l'indice de partage du tableau ( int ). Remarque : l'élément d'indice 'n' est inclus dans le premier sous-tableau
Sorties :
les deux sous-tableaux issus du partage ( tuple de 2 list )
"""
t1 = [] # tableau pour les éléments d'indice <= n
t2 = [] # tableau pour les éléments d'indice > n
for i in range(len(tab)):
if i <= n:
t1.append(tab[i])
else:
t2.append(tab[i])
return t1, t2
print(partage_tableau([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 4))
On pouvait aussi écrire, en choisissant judicieusement les bornes de deux boucles successives, l'une pour parcourir la première moitié du tableau ( éléments d'indices 0 à n inclus), et l'autre
pour parcourir la deuxième moitié ( éléments d'indices n+1 à len(tab)-1 inclus ) :
def partage_tableau(tab, n):
t1 = [] # tableau pour les éléments d'indice <= n
t2 = [] # tableau pour les éléments d'indice > n
for i in range(0, n+1): # indices de 0 à n ( attention à comment "fonctionne" la fonction range() ! )
t1.append(tab[i])
for i in range(n+1, len(tab)): # indices de n+1 à len(tab)-1 ( même remarque... )
t2.append(tab[i])
return t1, t2
print(partage_tableau([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 4))
Ce qui est beaucoup plus simple à faire avec des compréhensions :
def partage_tableau(tab, n):
t1 = [tab[i] for i in range(0, n+1)]
t2 = [tab[i] for i in range(n+1, len(tab))]
return t1, t2
print(partage_tableau([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 4))
Ici, pour compter les différences, il faut parcourir les deux tableaux "parallèlement", c'est à dire en adressant chacun de leurs éléments de même indice en même temps : on ne peut donc pas faire ici de parcours par valeur, puisque celui ci ne permettrait le parcours que d'un seul tableau à la fois.
C'est donc un parcours par indice qu'il faut faire ici :
def compter_differences(t1, t2):
"""
Compte et renvoie le nombre de différences entre les valeurs des éléments au même indice dans deux tableaux.
Entrées :
t1, t2 = les deux tableaux de même nombre d'éléments ( list )
Sortie :
le nombre de différences ( int )
"""
differences = 0 # variable compteur du nombre de différence
for i in range(len(t1)): # ou len(t2), les deux tableaux ont le même nombre d'éléments
if t1[i] != t2[i]: # attention, on compare les valeurs des éléments, pas leur indice ( c'est le même ici ! ) !
differences = differences + 1
return differences
tab_1 = ['a', 'g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p']
tab_2 = ['a', 'g', 's', 'u', 'c', 'k', 'p', 'l', 't', 'v', 'p']
print(compter_differences(tab_1, tab_2))
Même problème que précédemment : un parcours par indice est indispensable.
def moyenne_coefficient(notes, coeffs):
"""
Calcule et renvoie la moyenne coefficientée d'un ensemble de notes.
Entrée :
notes = le tableau des notes ( list de float )
coeffs = le tableau des coefficient, dans le même ordre que les notes correspondants ( list de float )
Sortie :
la moyenne coefficientée ( float )
"""
somme_notes = 0
somme_coeff = 0
for i in range(len(notes)):
somme_notes = somme_notes + notes[i]*coeffs[i] # somme des notes pondérées par leur coefficient
somme_coeff = somme_coeff + coeffs[i] # somme total des coefficients
return somme_notes / somme_coeff # calcul de la moyenne
notes = [10, 10, 20]
coeffs = [1, 3, 1]
print(moyenne_coefficient(notes, coeffs))
On pouvait parcourir successivement les deux tableaux, pour calculer d'abord la somme des notes, puis la sommes des coefficients, mais, comme les deux tableaux ont le même nombre d'éléments, on peut faire ça dans la même boucle...
Attention, problème pas évident !
imax + 1 = n - 1, ce qui conduit à : imax = n - 2 : il faut donc parcourir le tableau de son éliment d'indice 0,
jusqu'à son élément d'indice n - 2.for ... i n range(), on devra donc écrire pour le parcours : for i in range(len(t)-1)t[i+1] - t[i]; si celle-ci est positive, alors on l'ajoute à un compteur de dénivelées positives,
si elle est négative, on l'ajoute à un compteur de dénivelée négatives, si elle est nulle, on ne fait rien !
def compter_deniveles(t):
"""
Compte et renvoie les dénivelées cumulées positive et négative dans un tableau d'altitudes.
Entrée :
t = le tableau des altitudes ( list de int )
Sortie :
les dénivelées cumulées positive et négative ( tuple de 2 int )
"""
d_plus = 0 # compteurs pour les dénivelées cumulées positive
d_moins = 0 # et négative
for i in range(len(t)-1): # pour i variant de 0 à n - 2
d = t[i+1] - t[i] # calcul de la dénivelée entre deux altitudes successives
if d > 0: # si elle est positive,
d_plus = d_plus + d # on l'ajoute à la dénivelée cumulée positive,
elif d < 0: # si elle est négative,
d_moins = d_moins + d # à la dénivelée cumulée négative.
return d_plus, d_moins # renvoi des deux résultats sous forme d'un tuple de deux éléments
altitudes = [3, 7, 8, 9, 1, 0, 7, 8, 9, 3, 7, 8, 9, 4, 6, 1, 0, 0, 9, 5, 7, 34, 4, 5, 6, 7, 8, 9]
print(compter_deniveles(altitudes))