tite fractale

Tableaux, exercices

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 :

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 :

et retourne :

Il y a plusieurs façons de faire :

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 :

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 :

Noter les coordonnées de la case 1, puis de la 2, jusqu’à la case 6 puis repérer :
  • quelle coordonnée tourne plus vite,
  • dans quel sens vont les coordonnées (croissant ou non).

3.2.3. Encore une autre méthode

On peut aussi mettre en place :

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 :

Écrire un algorithme qui :

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 :

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 :

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 ?

Les lignes.

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 :

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 :

Vous indiquerez dans des commentaires les signatures de ces fonctions.

3.5.4. Produit

Les plus courageux essaieront sans les indications qui suivent.

Un découpage soigneux et une répartition des calculs dans des fonctions bien choisies peut faciliter grandement les choses.
On pourra commencer par implémenter les fonctions :
  • ligne(i, mat), qui retourne un tableau contenant les termes de la ligne numéro i de la matrice mat,
  • colonne(j, mat), qui retourne un tableau contenant les termes de la colonne numéro j de la matrice mat,
  • somme_des_produits(tab1, tab2), qui retourne la somme des produits des termes de même indice dans les tableaux fournis en paramètre (tableaux de même longueur).

4. Approfondissement

4.1. Suites

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

4.2. Matrices

Prolongement possible pour les manipulations de matrices :




J.D. pour la dim 1, Christophe Gragnic pour la dim 2, le 26/09/2014, 15h05'58".






Page générée le 04/12/2016, 10h08'07" (source).
historique de la page
historique global

 TogetherJS