1. Activité d’introduction

1.1. Mise en place

Cette activité introduit les tableaux. Même si elle doit être faite avant le cours, il est utile de lire le paragraphe qui décrit la forme générale d’un tableau.

Python n’a pas de type Array (tableau), mais on peut les simuler.

1. Télécharger le squelette tableaux (vous ne changerez pas son nom : tableaux.py).
2. Ouvrir ce fichier avec Idle.
3. Lire la documentation puis exécuter le programme pour vérifier que les doctests passent (comme d’habitude, pour en être sûre, vous pourrez faire exprès d’en casser un).
4. Créer un autre fichier suite_arith.py, dans le même répertoire que tableaux.py, en y tapant juste from tableaux import Tableau. Exécuter ce programme pour vérifier que tout va bien (rien ne se passe).

1.2. Termes de suites

1.2.1. Suite arithmétique

On rappelle la définition d’une suite arithmétique :

$$ \left \{ \begin{array}{cl} u_0 &= u_0 \\\\ u_{n+1} &= u_n + r \end{array} \right. $$

Écrire une fonction sa qui :

• possède deux paramètres entiers :
  • le premier terme u0,
  • la raison r,
• crée un tableau de longueur 5 pour y stocker les 5 premiers termes de la suite arithmétique de premier terme u0 et de raison r,
• retourne ce tableau.

N’ayez pas peur d’utiliser les doctests :

>>> sa(10, 2)
{0: 10, 1: 12, 2: 14, 3: 16, 4: 18}

1.2.2. Suite géométrique

Puis de même avec :

$$ \left \{ \begin{array}{cl} u_0 &= u_0 \\\\ u_{n+1} &= u_n × q \\\\ \end{array} \right. $$

2. Tableaux de dimension 1

2.1. Reconnaissance d’algorithme

Voici un algorithme :

VARIABLES
Tableau d'entiers: nombre[5]
Entier: compteur

DEBUT
nombre[0] <- 1
Pour compteur de 1 à 4 Faire
    nombre[compteur] <- nombre[compteur-1] + 2
Fin Pour
Pour compteur de 0 à 4 Faire
    Afficher nombre[compteur]
Fin Pour
FIN

Que fait cet algorithme ?

2.2. Gestion de notes

Soit un tableau de 12 nombres (entiers ou flottants) compris entre 0 et 20. Ce sont les notes des élèves d'une classe.

Toutes les questions de cette page sont d’abord à rédiger en pseudo-code avec un papier et un crayon. Une fois que le professeur à contrôlé votre travail, tester sur machine en Python (penser aux doctests).

1. Écrire une fonction maxi, dont le tableau est un paramètre, qui retourne le maximum du tableau. De même pour une fonction mini.
2. Écrire une procédure indice, qui recherche un nombre dans le tableau et affiche les indices où le nombre apparaît dans le tableau. Vous réfléchirez à la signature de cette procédure.
3. Écrire une fonction moyenne, qui retourne la moyenne des éléments du tableau.
4. Écrire une fonction moyplus, qui a pour paramètres le tableau et un nombre, et qui retourne le pourcentage de notes du tableau supérieures ou égales à ce nombre.
5. Écrire un programme principal utilisant les fonctions ci-dessus, qui fait saisir 12 notes dans un tableau, puis affiche la note maximale et le numéro des élèves qui ont la meilleure note, la note minimale et le numéro des élèves qui ont la moins bonne note, la moyenne de la classe, le pourcentage de notes supérieures ou égales à 10, puis à 16.

2.3. Recherche

Écrire une fonction qui reçoit en paramètres :

• un tableau de nombres entiers,
• un entier,

et retourne :

• -1 si l’entier n’est pas dans le tableau,
• la position de l’entier dans le tableau sinon.

Il y a plusieurs façons de faire :

• parcourir tout le tableau,
• arrêter le parcours avec un return,
• arrêter le parcours avec un break,
• utiliser un while et arrêter le parcours avec un flag (un booléen utilisé dans la condition du while).

2.4. Filtres

2.4.1. Nombres positifs

Écrire une fonction filtre_pos qui parcourt un tableau de nombres et qui remplace les nombres négatifs du tableau par 0. Par exemple, [1, -2, -3, 4, 6, 7, -5] donnera [1, 0, 0, 4, 6, 7, 0].

Dans le programme principal, on fera saisir les nombres du tableau principal, puis afficher les éléments du tableau obtenu.

2.4.2. Nombres pairs

Écrire une fonction filtre_pair qui parcourt un tableau de nombres et qui remplace les nombres impairs du tableau par 0. Par exemple, [1, -2, -3, 4, 6, 7, -5] donnera [0, -2, 0, 4, 6, 0, 0].

Dans le programme principal, on fera saisir les nombres du tableau principal, puis afficher les éléments du tableau obtenu.

2.5. Multi-compteur

Cet énoncé est donné dans une console interactive, mais vous pouvez réutiliser des instructions dans un script.

>>> # On considère un dé à 6 faces:
...
>>> from random import randint
>>> randint(1, 6)
2
>>> randint(1, 6)
3
>>> randint(1, 6)
6
>>> # Utiliser le concept de compteur...
... 
>>> i = 0
>>> compteur = 0
>>> for i in range(10):
...     compteur = compteur + 1
... 
>>> compteur
10
>>> # ...et de tableau, afin de compter, sur 10 lancers,
... combien de tirages ont donné 1; 2; ...6.
... 
>>> from tableaux import Tableau
>>> multicompteur = Tableau(6)
>>> # À vous de jouer !

3. Tableaux de dimension 2

3.1. Taille

Écrire une fonction qui prend en paramètre un tableau t de dimension 2 et retourne un tableau à deux cases contenant le nombre de lignes et le nombre de colonnes de t.

3.2. Parcours

Soit une procédure tableau2x3 qui construit et renvoie un tableau de longueur 2, contenant des tableaux de longueur 3 (comme dans l’exemple du cours).

def tableau2x3():
    tab = Tableau(2)
    tab[0] = Tableau(3)
    tab[1] = Tableau(3)
    return tab

Le but de cette partie est d’obtenir de plusieurs façons les tableaux suivants.

1) 1 4   2) 4 1   3) 3 6   4) 6 3
   2 5      5 2      2 5      5 2
   3 6      6 3      1 4      4 1

5) 1 2   6) 2 1   7) 5 6   8) 6 5
   3 4      4 3      3 4      4 3
   5 6      6 5      1 2      2 1

Pour chacun des exercices suivants, vous écrirez huit fonctions, de p1 à p8, qui retourneront chacune le bon tableau. Un bon réflexe pour ce genre d’exercice : les doctests ! Vous téléchargerez donc trois copies de ce squelette :

• tab_parcours_canonique.py,
• tab_parcours_avec_compteur.py,
• tab_parcours_indices.py.

3.2.1. Parcours canonique

On considère le parcours canonique suivant :

for i in range(2):
    for j in range(3):
        # affectation de l’élément i,j du tableau
        tab[i][j] = ...

Que mettre à la place de ... pour obtenir les différents tableaux ?

3.2.2. Autres parcours, avec un compteur

Cette fois-ci, à l’aide d’un compteur, on remplit les éléments du tableau de 1 à 6.

n = 1
for ... in range(...):
    for ... in range(...):
        tab[i][j] = n
        n = n + 1

Que mettre à la place des ... pour obtenir les différents tableaux ? Il faut choisir la place de i et de j, et choisir entre :

• range(2) ou [0, 1],
• range(3) ou [0, 1, 2],
• range(1, -1, -1) ou [1, 0], ou mieux :retrorange(2),
• range(2, -1, -1) ou [2, 1, 0], ou mieux :retrorange(3).

3.2.3. Encore une autre méthode

On peut aussi mettre en place :

• une double boucle comme dans un parcours canonique,
• un compteur,

mais au lieu de trouver une expression en i et j à affecter aux éléments, on cherche une expression en i et j pour les indices du tableau.

n = 1
for i in range(2):
    for j in range(3):
        tab[...][...] = n
        n = n + 1

3.3. Saisie d’informations

On cherche à stocker les informations de candidats :

• nom,
• prénom,
• profession.

Écrire un algorithme qui :

• demande combien de personnes on doit enregistrer,
• remplit un tableau de tableaux de chaînes de caractères avec les informations des candidats :
  • que l’utilisateur entrera dans l’ordre naturel :
    • nom, puis prénom, puis profession de la première personne,
    • nom, puis prénom, puis profession de la deuxième personne,
    • …
    • Vous ferez attention à bien guider l’utilisateur.
  • Libre à vous de créer les tableaux au moment où vous voulez :
    • avant toutes les saisies,
    • au fur et à mesure des saisies.
• affiche un résumé (assez étrange) des informations :
  • tous les prénoms,
  • toutes les professions, mais dans l’ordre inverse de la saisie,
  • toutes les personnes, mais présentées ainsi :
    • profession de la première,
    • prénom de la première,
    • nom de la première,
    • profession de la deuxième,
    • prénom de la deuxième,
    • nom de la deuxième,
    • …

3.4. Maxima par lignes et par colonnes

Générer un tableau de tableaux à neuf éléments contenant des entiers tirés au sort.

Recopier ce tableau tel quel dans un tableau à seize éléments, de façon à obtenir :

        ?                ?                ?        (max de la ligne)
        ?                ?                ?        (max de la ligne)
        ?                ?                ?        (max de la ligne)
(max de la col.) (max de la col.) (max de la col.) (max global)

Les maxima seront mis à jour lors de la recopie.

3.5. Matrices

Écrire une collection d’algorithmes avec lesquels on pourra :

• saisir une matrice,
• l’afficher,
• ajouter une matrice à une autre matrice,
• multiplier une matrice par un nombre,
• multiplier deux matrices.

Vous testerez au fur et à mesure les procédures et fonctions que vous créerez.

3.5.1. Représentation

Une matrice sera représentée par un tableau à deux dimensions. Deux problèmes se présentent :

• les tableaux sont indexés à partir de 0, et les matrices à partir de 1,
• choisir si le contenu du tableau principal (contenant les autres tableaux) représentera les lignes (contenant un élément par colonne) ou les colonnes (contenant un élément par ligne).

Le premier est assez simple à résoudre. Pour le second, à vous de décider après avoir compris les avantages et inconvénients des deux méthodes, détaillés ci-après.

Première méthode :

La manière la plus naturelle est de respecter l’ordre des « coordonnées » : tab[l][c] représente $a_{l'c'}$ (avec un « prime » à cause du problème du décalage, qui reste à résoudre).

Le tableau principal contiendra-t-il les lignes ou les colonnes ?

Sauf que l’affichage d’un tel tableau, si vous utilisez le module tableaux fourni en tapant print(tab) ne correspondra pas. Il faudra implémenter une procédure affiche_matrice qui vous permettra d’obtenir un affichage des termes dans le bon ordre (faisable en quelques ligne, même si les termes ne seront pas forcément alignés, car c’est difficile).

Deuxième méthode :

Pour rester cohérent avec l’affichage du module tableaux et avec la représentation du cours, on peut décider que le tableau principal contient les colonnes.

Le parcours de la matrice va être moins naturel que pour la première méthode, mais vous n’aurez pas à implémenter de méthode d’affichage.

3.5.2. Saisie

Écrire une procédure saisie_matrice qui demande :

• le nombre de lignes,
• le nombre de colonnes,
• tous les termes,

puis retourne un tableau de tableaux. Vous expliquerez dans des commentaires comment est représentée une matrice.

Un exemple d’utilisation, la saisie de la matrice nulle 2×3 :

>>> print(saisie_matrice())
Nombre de lignes? 2
Nombre de colonnes? 3
Terme ligne 1 colonne 1? 0
Terme ligne 1 colonne 2? 0
Terme ligne 1 colonne 3? 0
Terme ligne 2 colonne 1? 0
Terme ligne 2 colonne 2? 0
Terme ligne 2 colonne 3? 0
0 0 0
0 0 0

Notez que l’affichage peut être légèrement différent si vous avez choisi la première méthode de représentation.

3.5.3. Opérations simples

Écrire les fonctions suivantes :

• somme_matrice(mat1, mat2),
• matrice_opposee(mat),
• difference_matrice(mat1, mat2),
• produit_par_reel(x, mat),
• combinaison_lineaire(x, mat1, y, mat2)
  (cette dernière retournera $x×M_1 + y×M_2$).

Vous indiquerez dans des commentaires les signatures de ces fonctions.

3.5.4. Produit

Les plus courageux essaieront sans les indications qui suivent.

4. Approfondissement

4.1. Suites

Prolongements possibles pour les suites arithmétiques et géométriques :

• Demander le type de la suite à l’utilisateur.
• Demander le nombre de termes voulus.
• Écrire une fonction qui prend en paramètre un tableau et retourne la somme des éléments de ce tableau. Comment vérifier les formules de sommes de termes du cours (suites arithmétiques et géométriques).

4.2. Matrices

Prolongement possible pour les manipulations de matrices :

• contrôle de la saisie,
• vérifier les calculs de l’exercice 5 :
  • calculer $B$ avec $B = -\frac{1}{16} A + \frac{1}{2} I$,
  • calculer $AB$ et vérifier qu’on trouve bien la matrice unité.