tite fractale

Tableaux

1. Tableaux à une dimension

1.1. Comment

1.1.1. Forme

Un tableau est un type de données. Une variable de ce type « contiendra » en quelque sorte :

Les n variables sont rangées de façon linéaire (en ligne) et repérées par un nombre entier compris entre :

Lua, Blockly, Pascal (choix du nombre de départ !),… Sinon, voir cette section d’un article Wikipedia pour une liste plus complète.

Ce nombre est appelé l’index ou l’indice et est mis la plupart du temps entre crochets après le nom de la variable de type tableau.

Ici, on a représenté une variable tab de type tableau. Les tab[i] sont tous de type T.

ditaa diagram

Les autres noms des tableaux sont : vecteur, vector, array…

1.1.2. Contraintes

On rappelle que les éléments d’un même tableau sont d’un même type.

De plus, la longueur du tableau est fixe. Une fois créé, un tableau ne peut pas changer pas de taille.

1.2. Pourquoi

Un tableau sert à stocker une série de valeurs. Parmi les types de valeurs les plus fréquemment rencontrés, on trouve :

1.3. Syntaxes

1.3.1. Pseudo-code

Variables
 |  tableau d’entiers de longueur 3: mon_tab
 |  // ou Entiers[]: mon_tab
 |  // ou Entiers[3]: mon_tab
Début
 |  // pas besoin de construction
 |  // initialisation ou affectation
 |  mon_tab[0] = 666
 |  // lecture (ici pour affichage)
 |  Afficher mon_tab[0]
 |  // saisie utilisateur
 |  Demander mon_tab[1]
Fin

1.3.2. Python

Python n’a pas de tableaux, mais il est possible de les simuler. Voir le module tableaux, et surtout ses doctests.

1.3.3. C sharp

// déclaration
T[] mon_tab;
// construction
mon_tab = new T[n];
// les deux en même temps
T[] mon_tab = new T[n];

L’accès en lecture et écriture se fait pour chaque case comme s’il s’agissait d’une simple variable, mais avec les crochets.

1.4. Parcours d’un tableau

Le principe est de « boucler sur les indices ». Puisqu’on connaît la longueur du tableau, on utilise le plus souvent une boucle POUR.

1.4.0.1. Pseudo-code

Un exemple avec une fonction somme :

Fonction somme(Entiers[]: tab): Entier
 |  Entier s
 |  s <- 0
 |  Pour i de 0 à longueur(tab) - 1
 |   |  s <- s + tab[i]
 |  Fin Pour
 |  Retourne s
Fin Fonction

1.4.0.2. Python

Il n’y a pas de boucle POUR en Python (for dans les autres langages), mais plutôt une boucle POUR CHAQUE (souvent notée foreach dans les autres langages). Il faut taper :

for element in une_liste:
    # traitement

À noter :

 

>>> range(10)
range(0, 10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0, 10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0, 10, 2))
[0, 2, 4, 6, 8]
>>> list(range(10, step=2))
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    list(range(10, step=2))
TypeError: range() does not take keyword arguments
>>> list(range(10, 2))
[]

Voir la documentation de range.

 

>>> for i in range(3):
...     print("itération numéro:", i)
... 
itération numéro: 0
itération numéro: 1
itération numéro: 2

 

>>> liste = [42, "manger", 3.14]
>>> for i in range(len(liste)):
...     print(liste[i])
... 
42
manger
3.14

 

>>> for elt in liste:
...     print(elt)
... 
42
manger
3.14

 

>>> for i in range(len(liste)):
...     print("Élement n°", i, "=", liste[i])
... 
Élement n° 0 = 42
Élement n° 1 = manger
Élement n° 2 = 3.14

 

>>> for i, elt in enumerate(liste):
...     print("Élement n°", i, "=", elt)
... 
Élement n° 0 = 42
Élement n° 1 = manger
Élement n° 2 = 3.14

 

>>> list(range(3, 0, -1))
[3, 2, 1]
>>> list(range(3, -1, -1))
[3, 2, 1, 0]
>>> list(range(2, -1, -1))
[2, 1, 0]
>>> def retrorange(n):
...     return range(n-1, -1, -1)
...
>>> list(antirange(3))
[2, 1, 0]

2. Tableaux de dimension 2

2.1. Pourquoi et comment

2.1.1. Principe

On considère un tableau tab de longueur m, dans lequel chaque élément est à nouveau un tableau, mais de longueur n.

ditaa diagram

2.1.2. Remarques

2.2. Syntaxe

2.2.1. Pseudo-code

// déclarations
Tableau d’Entiers (m×n): tab
Entiers[m][n]: tab
Entiers[][]: tab
// accès aux tableaux en lecture ou écriture
tab[i][j]  // voir le diagramme ci-dessus

2.2.2. Python

# «initialisation» (que des None)
tab = Tableau(m)
tab[0] = Tableau(n)
tab[1] = Tableau(n)
...
tab[m-1] = Tableau(n)
# accès aux tableaux en lecture ou écriture
tab[i][j]  // voir le diagramme ci-dessus

2.2.3. C Sharp

On n’utilise pas tab[i][j], mais tab[i,j].

2.3. Parcours

Le principe est de « boucler sur les indices ». Puisqu’on connaît les longueurs des tableaux, on utilise des boucles POUR. Mais leur agencement doit être très spécial : elles doivent être imbriquées.

La première boucle, dite « externe » va parcourir le tableau qui contient les autres tableaux, afin de « choisir » un des sous-tableaux. La deuxième boucle, dite « interne » va parcourir le tableau ainsi « choisi » pour y choisir un élément.

Le fichier est disponible ici.

Remarques :

+-----+-----+
|     |     |
+-----+-----+
 +---+ +---+
 | 1 | | 4 |
 +---+ +---+
 | 2 | | 5 |
 +---+ +---+
 | 3 | | 6 |
 +---+ +---+

Aller aux exercices




Christophe Gragnic, 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