Parcours de tableaux/de tuples

Vous connaissez la manière d'adresser un élément de tableau avec la syntaxe : nom_du_tableau[indice].

Indiquer numériquement la valeur de l'indice suffit quand on ne manipule que quelques éléments d'un tableau ou d'un tuple, mais qu'en est-il si on voulait adresser tous les éléments d'un tableau/tuple contenant un très grand nombre d'éléments ?


notes = [10, 12, 9, 3, 14, 11, 8, 6, 7, 15, 19, 12, 13, 13]	

somme = notes[0] + notes[1] + notes[2] + notes[3] + notes[4] + notes[5] + notes[6] + notes[7] + notes[8] + notes[9] + notes[10] + notes[11] + notes[12] + notes[13]

Pas très pratique de faire la somme de tous les éléments !!

Il existe heureusement une manière d'adresser "automatiquement" les éléments d'un tableau/tuple les uns après les autres, et cela correspond à un parcours de tableau/tuple.

Parcours d'un tuple ou d'un tableau

Un tuple ou un tableau est, comme une chaîne de caractères, un objet itérable, que l'on peut donc parcourir avec une boucle pour adresser chacun de ses éléments les uns après les autres.

Comme pour les chaînes, deux types de parcours existent :

Parcours par valeur


for element in notes : # pour chaque élément du tableau
	print(element)     # la variable 'element' contient la valeur de l'élément


10
12
9
3
....

A chaque tour de boucle, la variable element prend comme valeur celles des éléments successifs du tuple/tableau.

L'inconvénient est que l'on n'adresse à chaque fois que la valeur de l'élément, et pas son indice; pour adresser ces deux données en même temps, utiliser la fonction enumerate() :


for indice, element in enumerate(notes) :
	print(indice, element)

Parcours par indice

L'idée est d'utiliser une boucle bornée for .... in range(), dont le compteur ira de 0 ( indice du premier élément du tableau ) à len(tableau) - 1 ( = indice du dernier élément ).
On se sert alors du compteur pour adresser successivement chaque élément du tableau :


for indice in range(len(notes)) :    # pour i variant de 0 à len()-1
	print(indice, notes[indice])	        # la variable indice contient l'indice de l'élément, notes[indice] représente sa valeur

Exemple : faire la somme des éléments

Si on revient à notre exemple du début, pour faire la somme de tous les éléments du tableau, il faut suivre l'algorithme suivant :


somme ← 0
pour chaque élément du tableau :
	somme ← somme + valeur de l'élément

Soit en Python, avec un parcours par valeur :


somme = 0
for element in notes :
	somme = somme + element

Et avec un parcours par indice :


somme = 0
for i in range(len(notes)) : 
	somme = somme + notes[i]

Parcours par indice ou par valeur ?

Pour simplement adresser les éléments d'un tableau/tuple, on peut pratiquement toujours utiliser l'un ou l'autre indifféremment !

La grosse différence est la suivante :

Le parcours par valeur ne permet pas, dans le cas d'un tableau, de modifier ses éléments; on utilisera plutôt pour cela le parcours par indice ( voir chapitre suivant ).

Exercices

On utilisera dans ces exercices les méthodes de parcours pour adresser successivement tous les éléments des tuples et des tableaux suivants.
A vous de choisir entre le mieux adapté, un parcours par indice ou un parcours par valeur.

Produit des valeurs

Il s'agit ici de faire le produit ( la multiplication ) de tous les nombres présents dans un tableau.

Compléter la fonction produit ci-dessous qui prend en paramètre un tableau tab d'entiers, et renvoie le produit de tous les entiers présents dans le tableau.
Par convention, si le tableau est vide on considérera que le produit est égal à 1.
Tester votre fonction grâce au jeu de tests ci-dessous :
- produit([2, 3, 2]) == 12
- produit([1, 2, 3, 4, 5, 6]) == 720
- produit([1, 1, 1, 1, 1, 1]) == 1
- produit([1, 14, 32, 0, 15, 6]) == 0
- produit([]) == 1
- produit([7]) == 7
- produit([12, 11, 3, 21, 5, 41, 4, 6, 4, 7]) == 1145612160

def produit(tab: list[int])->int: pass

Lien vers les RÉPONSES

Inversion d'un tableau

Inverser un tableau, c'est mettre tous ses éléments dans "l'autre sens" par rapport au "sens" initial :


t = [12, 56, 6, 1, 78, 96]

t_inverse = [96, 78, 1, 6, 56, 12]

écrire une fonction inverse_tableau, qui prend en paramètre un tableau t, et qui renvoie un nouveau tableau dont les éléments sont inversés par rapport au premier.
tester votre fonction avec le jeu de tests suivant :
- inverse_tableau([12, 56, 6, 1, 78, 96]) == [96, 78, 1, 6, 56, 12]
- inverse_tableau([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) == [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
- inverse_tableau([12]) == [12]
- inverse_tableau([]) == []

def inverse_tableau(t: list[int])->list[int]: pass

Lien vers les RÉPONSES

Statistiques sur l'ADN

Dans cet exercice, il faut parcourir les éléments d'un tableau pour y tester la présence de certaines valeurs.

Écrire une fonction analyse_ADN, qui prend un paramètre un tableau ( comme le tableau ADN ci-dessous ), et qui renvoie le nombre de fois où le "gène" 'A' apparaît dans le tableau.
Modifier la fonction pour qu'elle renvoie également le nombre de fois où les "gènes" 'C', 'G' et 'T' apparaissent.
Compléter la fonction pour qu'elle renvoie le pourcentage que représente chaque "gène" sur le nombre total de "gènes".

def analyse_ADN(tab: list[str])->int: pass 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']

Lien vers les RÉPONSES

Compter les différences

On dispose ici de deux tableaux de même longueur. Il s'agit de calculer le nombre de différences entre les deux tableaux.
Par exemple avec :


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']

→ il y a trois différences entre les deux tableaux : aux indices 2, 5 et 8.

Compléter la fonction compter_differences ci-dessous qui prend en paramètres deux tableaux t1 et t2 de même longueur, et renvoie le nombre de différences entre les deux tableaux.
Tester la fonction avec les paires de tableaux proposées.

def compter_differences(t1: list[str], t2: list[str])->int: pass # 3 différences 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'] # 0 différence tab_1 = ['a', 'g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p'] tab_2 = ['a', 'g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p'] # 10 différences tab_1 = ['a', 'g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p'] tab_2 = ['g', 'u', 'u', 'c', 'o', 'p', 'l', 'm', 'v', 'p', 'a'] # 1 différence tab_1 = ['a'] tab_2 = ['b']

Lien vers les RÉPONSES

Moyenne coefficientée

On dispose ici de deux tableaux de même longueur : un tableau de notes (sur 20) et un tableau de coefficients.
Il s'agit de calculer la moyenne coefficientée correspondante.

Par exemple avec :


notes  = [12, 15, 14, 18]
coeffs = [1,  2,  1,  4 ]

→→la moyenne sera calculée ainsi : (12*1 + 15*2 + 14*1 + 18*4)/(1 + 2 + 1 + 4) = 16.

Compléter la fonction moyenne_coefficient ci-dessous qui prend en paramètre deux tableaux non vides notes et coeffs et renvoie la moyenne coefficientée correspondante.
Tester votre fonction avec les tableaux proposés.

def moyenne_coefficient(notes: list[int], coeffs: list[int])->float: pass # moyenne = 12.0 notes = [10, 10, 20] coeffs = [1, 3, 1] # moyenne = 14.384615384615385 notes = [15, 17, 13, 19, 15, 11] coeffs = [2, 3, 5, 5, 3, 8] # moyenne = 10.0 notes = [8, 8, 8, 8, 12] coeffs = [1, 1, 1, 1, 4]

Lien vers les RÉPONSES

Dénivelées

La dénivelée entre deux points d'un parcours correspond à la différence entre les altitudes de ces deux points.

En randonnée cycliste, pédestre ou à skis, on définit les dénivelés positif et négatif cumulés :

le dénivelé positif cumulé correspond au «nombre total de mètres en hauteur» qui ont été montés du début à la fin du parcours,
le dénivelé négatif cumulé correspond au «nombre total de mètres en hauteur» qui ont été descendus du début à la fin du parcours.

Par exemple, soit un tableau dont chaque élément représente l'altitude d'un point d'un parcours de randonnée : [7, 4, 3, 6, 7, 4, 3, 1, 8].

→ on rencontre trois dénivelés positifs lors de son parcours :

+3 pour passer de la valeur 3 à la valeur 6,
+1 pour passer de la valeur 6 à la valeur 7,
+7 pour passer de la valeur 1 à la valeur 8;

soit un dénivelé positif cumulé de +11.

Et le dénivelé négatif cumulé vaut quant à lui : -3-1-3-1-2 = -10.

Plus généralement, dans un tableau tab de taille n éléments, le dénivelé à l'indice i est égal à tab[i+1] - tab[i] (à condition que l'indice i+1 existe).

Remarque : on considérera que dans un tableau vide ou de taille 1, le dénivelé cumulé est égal à zéro.

Voici le schéma d'un tableau tab de taille n :

---------------------------------------------
| indices | 0 | 1 | 2 | 3 | ... | n-2 | n-1 |
---------------------------------------------
| valeurs | . | . | . | . | ... |  .  |  .  |
---------------------------------------------

Le plus grand indice possible est donc n-1.

Pour avoir le droit d'écrire tab[i+1] - tab[i] avec un tableau tab de taille n, quelle est alors la plus grande valeur de i possible : n-2, n-1, n ou n+1 ?

Compléter la fonction compter_deniveles ci-dessous qui prend en paramètre un tableau alt de valeurs représentant des altitudes, et renvoie un tuple de deux éléments correspondant aux dénivelés positif cumulé et négatif cumulé.
Le parcours de tab sera fait par indice.
Tester votre fonction grâce au jeu de tests ci-dessous :
- compter_deniveles([1, 2, 3, 4, 5]) == (4, 0)
- compter_deniveles([5, 4, 3, 2, 1]) == (0, -4)
- compter_deniveles([0, 10, 0, 10]) == (20, -10)
- compter_deniveles([0, 10, 0, 10, 10, 10, 10, 0]) == (20, -20)
- compter_deniveles([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]) == (66, -60)
- compter_deniveles([]) == (0, 0)
- compter_deniveles([5]) == (0, 0)

def compter_deniveles(alt: list[int])->tuple[int, int]: pass

Lien vers les RÉPONSES