Comment convertir un tableau 1d en tableau 2d?
Dis, j'ai un tableau 1d avec 30 éléments:
array1d[0] = 1
array1d[1] = 2
array1d[2] = 3
.
.
.
array1[29] = 30
Comment convertir le tableau 1d en tableau 2d?
Dis 10x3?
array2d[0][0] = 1 array2d[0][1] =2 array2d[0][2] =3
.
.
.
array2d[9][0] = 28 array2d[9][1] =29 array2d[9][2] =30
Devrais-je utiliser une boucle for?
Mais je ne peux pas y arriver.
Sans écrire de code pour vous ...
- Pensez à la taille de votre tableau 2D.
- Sachez que vous devez parcourir le contenu de votre tableau source pour obtenir chaque valeur dans votre tableau de destination.
Donc, ça va ressembler à quelque chose comme ...
- Créez un tableau 2D de taille appropriée.
- Utilisez une boucle for pour parcourir votre tableau 1d.
- À l'intérieur de cette boucle for, vous devrez déterminer où chaque valeur du tableau 1d doit aller dans le tableau 2d. Essayez d’utiliser la fonction mod en regard de votre variable counter pour "envelopper" les indices du tableau 2D.
Je suis intentionnellement vague, vu que c'est un devoir. Essayez de poster du code afin que nous puissions voir où vous êtes bloqué.
int array2d[][] = new int[10][3];
for(int i=0; i<10;i++)
for(int j=0;j<3;j++)
array2d[i][j] = array1d[(j*10) + i];
public class Test{
public static void main(String[] argv)
{
int x,y;
for(int num =0; num<81;num++)
{
if((num % 9)>0)
{
x = num/9;
y = num%9;
}else
{
x = num/9;
y = 0;
}
System.out.println("num ["+num+"]---["+x+","+y+"]");
}
}
}
/* Replace 9 by the size of single row of your 2D array */
Voici une fonction générique pour convertir un tableau 1D -> 2D:
public int[][] monoToBidi( final int[] array, final int rows, final int cols ) {
if (array.length != (rows*cols))
throw new IllegalArgumentException("Invalid array length");
int[][] bidi = new int[rows][cols];
for ( int i = 0; i < rows; i++ )
System.arraycopy(array, (i*cols), bidi[i], 0, cols);
return bidi;
}
Si vous voulez faire le contraire (2D -> 1D), voici la fonction:
public int[] bidiToMono( final int[][] array ) {
int rows = array.length, cols = array[0].length;
int[] mono = new int[(rows*cols)];
for ( int i = 0; i < rows; i++ )
System.arraycopy(array[i], 0, mono, (i*cols), cols);
return mono;
}
int[] oneDArray = new int[arr.length*arr.length];
//Flatten 2D array to 1D array...
int s = 0;
for(int i = 0; i < arr.length; i ++)
for(int j = 0; j < arr.length; j ++){
oneDArray[s] = arr[i][j];
s++;
}
Vous trouverez souvent le même problème: comment manipuler un tableau 2D en tant que tableau 1D. J'ai écrit une classe générique Grid, qui permet d'accéder aux objets par index ou par (x, y) .
Voir le cours suivant et comprendre l’idée qui le sous-tend. :)
Vous pouvez utiliser la classe suivante pour la manipulation de données en tant que tableau 2D ou tableau 1D. Voici le code que j'ai écrit et utilisé.
/**
* Grid represents a 2 dimensional grid.
*
* @param <E> the type of elements in this grid
*/
import Java.util.List;
import Java.util.ArrayList;
import Java.util.Collections;
import Java.util.Iterator;
public class Grid<E>
{
private int size ;
private int width ;
private int height ;
private List<E> elements;
public int getCapacity()
{
return getWidth() * getHeight();
}
/**
* @return number of elements in grid. Null is also an element.
*/
public int getSize()
{
return getElements().size();
}
/**
* @param sideSize size of the grid side
*/
public Grid(int sideSize)
{
this(sideSize,sideSize);
}
/**
* @param width of the grid
* @param height of the grid
*/
public Grid(int width, int height)
{
this.width = width ;
this.height = height;
this.elements = new ArrayList<E>(
Collections.nCopies(width*height, (E)null));
}
public int getHeight()
{
return height;
}
public int getWidth()
{
return width;
}
/**
* @return all elements of the grid
*/
public List<E> getElements()
{
return elements;
}
/**
* @return iterator for a grid
*/
public Iterator<E> iterator()
{
return getElements().iterator();
}
/**
* Returns the element at position (x,y).
*
* @return the element at position (x,y)
*/
public E get(int x, int y)
{
return getElements().get(
idx(x,y));
}
/**
* Returns the element at index idx.
*
* @return the element at given index
*/
public E get(int idx)
{
return getElements().get(idx);
}
/**
* Puts an element to the position idx
*
* @param element to be added
*
* @param x position x to add element to
*
* @param y position y to add element to
*/
public void put(int x, int y, E element)
{
put(idx(x,y), element);
}
/**
* Puts an element to the position idx
*
* @param element to be added
*
* @param idx to add element at
*/
public void put(int idx, E element)
{
getElements().add(idx, element);
}
/**
* Returns the x coordinate from the index.
*
* @return x coordinate of the index
*/
public int x(int idx)
{
return idx % getHeight();
}
/**
* Returns the y coordinate from the index.
*
* @return y coordinate of the index
*/
public int y(int idx)
{
return (idx - idx % getHeight()) / getHeight();
}
/**
* Returns index of element at (x,y).
*
* @return index of the coordinates
*/
public int idx(int x, int y)
{
return y*getHeight() + x;
}
}
Voici comment utiliser la classe (voir un exemple de test):
public class TestGrid
{
public static final int SIZE = 10;
public static final Integer el1 = new Integer(2);
public static final Integer el2 = new Integer(3);
public static final Integer el3 = new Integer(3);
public static void main(String[] args)
{
Grid<Integer> grid = new Grid<>(SIZE);
assert grid.getCapacity() == SIZE*SIZE ;
assert grid.idx(0,0) == 0 ;
assert grid.idx(1,0) == 1 ;
assert grid.idx(0,1) == 10;
assert grid.idx(6,1) == 16;
assert grid.idx(9,9) == 99;
grid.put(1, el1);
assert grid.get(1) == el1 : grid.get(1);
grid.put(0, 1, el2);
assert grid.get(0,1) != el1 && el1 != el2 && grid.get(0,1) == el2;
grid.put(15, el3);
assert grid.get(5,1) == el3;
}
}
Ceci est juste un pseudo code. ROWS représente la longueur du tableau 2d et COLUMNS représente la longueur du 1er élément du tableau
for(i=0; i<ROWS; i++)
for(j=0; j<COLUMNS; j++)
array2d[i][j] = array1d[ (i*COLUMNS) + j];