2. Les tableaux multidimensionnels

Tu sauras après cette quête comment utiliser des tableaux multidimensionnels

Objectifs

• Instancier un tableau multidimensionnel
• Modifier un tableau multidimensionnel

Une nouvelle dimension

Nous sommes en l'an 2317. Une avancée majeure a été réalisée : nous avons trouvé le moyen de rejoindre une nouvelle dimension.

Tu es l'élu, le premier choisi pour tenter l'expérience vers une dimension inconnue. Mais comme nous ne sommes pas sadiques, nous allons t'initier aux résultats de nos recherches.

Plusieurs dimensions

Jusqu'à présent, nous pensions que nos corps physiques évoluaient dans une seule et même dimension. Nous savons depuis longtemps qu'il existe plus de dimensions que ce que nos yeux nous laissent voir, mais nous n'avions aucun moyen d'y accéder. Maintenant que nous avons fait nos recherches, nous avons ennnfiiin trouvé un moyen d'y voyager !

Le tableau int[] intArray = new int[2]; est dit uni-dimensionnel. C'est-à-dire qu'il ne dispose que d'une seule dimension. Si je te dis ça, c'est que tes tableaux ne sont pas obligés de n'être que d'une seule dimension, ils peuvent très bien en avoir plusieurs.

Les tableaux multi-dimensionnels sont très, très utiles dans beaucoup de contextes. Une carte où se déplace un joueur dans un jeu vidéo 2D peut être représentée par un tableau bi-dimensionnel. La position est représentée comme sur un graphique en mathématique : avec des coordonnées x et y.

Comment je fais pour ajouter des dimensions à mes tableaux, alors ?

Un tableau uniforme

C# met à disposition une manière de déclarer des tableaux multidimensionnels uniformes ou rectangulaires, c'est-à-dire ayant toutes leurs dimensions à une taille fixe. Cependant, un tableau rectangulaire ne peut être que bi-dimensionnel ou tri-dimensionnel.

Voici une déclaration de tableaux multidimensionnels uniformes :

int[,] bidimensionalArray = new int[3,2];
bool[,,] tridimensionalArray = new bool[2,2,2];

Le premier tableau de l'exemple ci-dessus déclare un tableau bidimensionnel dont la première dimension est de taille 3 et la deuxième dimension de taille 2.

Le deuxième déclare un tableau tridimensionnel avec toutes ses dimensions de taille 2.

En pratique, voici comment on peut faire pour représenter un tableau pour le jeu du Morpion :

int[,] ticTacToeBoard = new int[3, 3]
{
    {0,1,2},
    {0,1,2},
    {2,2,1},
};

Les cases à 0 représentent les cases vides. Les cases à 1 représentent une croix, et les cases à 2 représentent un cercle. C'est aussi simple que ça : D.

On accède aux éléments d'un tableau multidimensionnel uniforme de cette façon :

int[,] ticTacToeBoard = new int[3, 3]
{
    {0,1,2},
    {0,1,2},
    {2,2,1},
};

int firstCross = ticTacToeBoard[0, 1];
int secondCross = ticTacToeBoard[1, 1];
int thirdCross = ticTacToeBoard[2, 2];
int firstCircle = ticTacToeBoard[0, 2];
int secondCircle = ticTacToeBoard[1, 2];
int thirdCircle = ticTacToeBoard[2, 0];
int fourthCircle = ticTacToeBoard[2, 1];

Un tableau irrégulier

Il existe un deuxième type de tableaux en C#. On les appelle tableaux irréguliers (jagged array). On les dit irréguliers car la taille des dimensions peut varier.

Un tableau irrégulier est simplement un tableau contenant des tableaux qui, à leur tour, peuvent contenir des tableaux ou des valeurs.

Un peu de code pour se représenter tout ça :

int[][] bidimensionalArray = new int[3][];
bidimensionalArray[0] = new int[2];
bidimensionalArray[1] = new int[] { 1, 2, 3 };
bidimensionalArray[2] = new int[3] { 3, 4, 5 };

Décortiquons un petit peu le code ci-dessus, ligne par ligne :

1. J'instancie un tableau bi-dimensionnel en lui affectant un tableau pouvant contenir d'autres tableaux
2. J'instancie un tableau uni-dimensionnel de taille 2 au premier indice du tableau bi-dimensionnel
3. J'instancie un tableau uni-dimensionnel de taille inconnue ayant déjà des valeurs au deuxième indice du tableau bi-dimensionnel
4. J'instancie un tableau uni-dimensionnel de taille 3 ayant déjà des valeurs au troisième indice du tableau bi-dimensionnel

Comme tu peux le constater, les tableaux affectés à la deuxième dimension peuvent avoir des tailles différentes. C'est ce qui change par rapport aux tableaux uniformes dont les dimensions sont fixes.

La syntaxe pour accéder aux valeurs d'un tableau irrégulier est la suivante : int jaggedArray[indice 1][indice 2]. Attention cependant à ce que indice 2 ne dépasse pas le nombre d'éléments de la deuxième dimension.

Ainsi:

int[][] bidimensionalArray = new int[3][];
bidimensionalArray[0] = new int[2];
bidimensionalArray[1] = new int[] { 1, 2, 3 };
bidimensionalArray[2] = new int[3] { 3, 4, 5 };

int secondElementOfSecondDimension = bidimensional[1][1];

Challenge

De tableaux en tableaux

Déclare un tableau uniforme de dimension 3x3.

Déclare ensuite un tableau irrégulier de dimension 3xn.

Tu vas devoir utiliser ton tableau uniforme pour remplir le tableau irrégulier de cette manière :

Tableau uniforme : [0 => [1, 2, 3], 
                   1 => [2, 3, 4], 
                   2 => [3, 4, 5]]
Tableau irrégulier : [0 => [1, 2, 3],
                     1 => [3, 4],
                     2 => [5]]

Il faut qu'à chaque indice du tableau uniforme, tu enlèves un élément en plus du tableau de la deuxième dimension, puis que tu places le tableau résultant au même indice dans le tableau irrégulier.

Compris ?

Critères de validation

• Un lien vers ta solution sur GitHub

• Les tableaux contiennent les données demandées

• Les valeurs du tableau irrégulier sont celles qui ont été affectées aux cases du tableau uniforme.