Cum se convertește o matrice 1d în matrice 2d? (Programare, Java, Array-Uri, Matrice Multidimensională)

kafter2 a intrebat.

Să zicem că am o matrice 1d cu 30 de elemente:

array1d[0] = 1  
array1d[1] = 2  
array1d[2] = 3  
.  
.  
.  
array1[29] = 30

Cum să convertesc matricea 1d în matrice 2d?
Să zicem 10×3?

array2d[0][0] = 1 array2d[0][1] =2 array2d[0][2] =3
.
.
.
array2d[9][0] = 28 array2d[9][1] =29 array2d[9][2] =30

Ar trebui să folosesc o buclă for?
Dar nu reușesc să o rezolv.

9 răspunsuri
epalm

Fără să scriu vreun cod pentru tine…

  • Gândește-te cât de mare trebuie să fie matricea ta 2d.
  • Recunoașteți că va trebui să faceți o buclă peste conținutul array-ului sursă pentru a introduce fiecare valoare în array-ul destinație.

Deci, va arăta ceva de genul…

  • Creați o matrice 2d de dimensiune corespunzătoare.
  • Folosiți o buclă for pentru a trece în buclă peste matricea 1d.
  • În interiorul buclei for, va trebui să vă dați seama unde ar trebui să ajungă fiecare valoare din matricea 1d în matricea 2d. Încercați să utilizați funcția mod în raport cu variabila contor pentru a „înfășura” indicii din matricea 2d.

Sunt intenționat vag, având în vedere că este o temă pentru acasă. Încearcă să postezi niște cod, ca să vedem unde te-ai blocat.

Bala R
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]; 

Comentarii

  • Mulțumesc! Cum se procedează dacă elementul array-ului meu nu este un număr continuu, ci un număr aleatoriu? Cum pot edita bucla for pentru a face asta? –  > Por kafter2.
  • codul său este independent de ceea ce conține array-ul, deci va funcționa pentru orice element de array –  > Por TimCodes.NET.
  • array2d[i][j] = array1d[(j*10) + i]; este greșit. Ar trebui să fie array2d[i][j] = array1d[j%3+i*3]; –  > Por compski.
  • Acest lucru nu funcționează corect pentru mine. Am încercat să o folosesc pentru a converti o matrice 1D int de coduri de culoare a imaginii într-o matrice 2D, dar imaginea rezultată este rotită cu 90 de grade –  > Por EștiAGitPentruNuUtilizareaGit.
  • arr2d[i][j] = (int) arr1d[(i*3)+j]; de asemenea, funcționează –  > Por Cuong Trinh.
Luca Sepe

Aici o funcție generică pentru a converti din 1D -> array 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;
}

Dacă doriți să faceți contrariul (2D -> 1D), iată funcția:

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;
}

Comentarii

  • Aceasta nu funcționează corect pentru mine. Am încercat să o folosesc pentru a converti un array 1D int de coduri de culoare a imaginii într-un array 2D, dar imaginea rezultată este rotită cu 90 de grade și, de asemenea, are linii verticale prin ea. –  > Por EștiAGitPentruNuUtilizareaGit.
arunn
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 */

Comentarii

  • vă rugăm să vă abțineți de la a adăuga doar răspunsuri cu cod fără explicații –  > Por dmportella.
Nolesh
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++;
          } 

Comentarii

  • Btw, OP a fost pentru direcția opusă. –  > Por Paul Rigor.
Dezvoltator Marius Žilėnas

Deseori veți găsi aceeași problemă: cum să manipulați array 2D ca array 1D. Am scris o clasă generică Grid, care permite accesarea obiectelor prin index sau prin (x,y).

Vedeți următoarea clasă și înțelegeți ideea din spatele ei. 🙂

Ați putea utiliza următoarea clasă pentru manipularea datelor sub formă de matrice 2D sau matrice 1D. Iată codul pe care l-am scris și pe care îl folosesc.

/**
 * 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;
    }
}

Iată cum se utilizează clasa (vedeți un exemplu 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;
    }
}

Vikrant Upadhyay
package com.vikrant;

import java.util.Arrays;

public class TwoD {
    public static void main(String args[])
    {
        int a[][]=new int[4][3];
        int d[]={10,20,30,40,50,60,70,80,90,100,110,120};
        int count=0;
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<3;j++)
            {
                if(count==d.length) break;
                a[i][j]=d[count];
                count++;
            }}
        int j=0;
        for (int i = 0; i<4;i++)
        {
            for(j=0;j<3;j++)
        System.out.println(a[i][j]);

        }
    }}

ACEST LUCRU FACE TREABA

Comentarii

  • Bine ați venit la SO. Vă mulțumim pentru răspunsul dvs. În timp ce răspunsurile numai cu cod ar putea oferi un cod de lucru, unii ar putea avea probleme în a înțelege, ce face codul. Vă rugăm să încercați să detaliați fragmentele de cod. –  > Por Korashen.
Anex Johnson

Acesta este doar un pseudocod. Rândurile reprezintă lungimea matricei 2d, iar Coloanele reprezintă lungimea primului element din matrice

for(i=0; i<ROWS; i++)
   for(j=0; j<COLUMNS; j++)
       array2d[i][j] = array1d[ (i*COLUMNS) + j];

krtek

Nu puteți „converti” o matrice 1D într-o matrice 2D, dar o matrice poate fi multidimensională atunci când o declarați.

int myArray2d[][] = new int[10][3]