¿Cómo mapear los índices de una matriz a una matriz de 1 dimensión (C ++)?

Tengo una matriz de 8×8, como esta:

char matrix[8][8]; 

Además, tengo una matriz de 64 elementos, como este:

 char array[64]; 

Luego dibujé la matriz como una tabla y llené las celdas con números, cada número se incrementó de izquierda a derecha, de arriba a abajo.

Si tengo, digamos, índices 3 (columna) y 4 (fila) en la matriz, sé que corresponde al elemento en la posición 35 en la matriz, como se puede ver en la tabla que he dibujado. Creo que hay algún tipo de fórmula para traducir los 2 índices de la matriz en un solo índice de la matriz, pero no puedo entender cuál es.

¿Algunas ideas?

La forma en que la mayoría de los lenguajes almacenan matrices multidimensionales es haciendo una conversión como la siguiente:

Si la matrix tiene tamaño, n por m [es decir, i va de 0 a (n-1) y j de 0 a (m-1)], entonces:

matrix[ i ][ j ] = array[ i*m + j ] .

Entonces es como un sistema numérico de base ‘n’. Tenga en cuenta que el tamaño de la última dimensión no importa.


Para una comprensión conceptual, piense en una matriz (3×5) con ‘i’ como número de fila y ‘j’ como número de columna. Si comienza a numerar desde i,j = (0,0) --> 0 . Para el orden ‘row-major’ (como este), el diseño se ve así:

  |-------- 5 ---------| Row ______________________ _ _ 0 |0 1 2 3 4 | | 1 |5 6 7 8 9 | 3 2 |10 11 12 13 14| _|_ |______________________| Column 0 1 2 3 4 

A medida que se mueve a lo largo de la fila (es decir, aumenta el número de columna), simplemente comienza a contar, por lo que los índices de matriz son 0,1,2... Cuando llegas a la segunda fila, ya tienes 5 entradas, así que comienzas con los índices 1*5 + 0,1,2... En la tercera fila, ya tienes 2*5 entradas, por lo tanto, los índices son 2*5 + 0,1,2...

Para una dimensión más alta, esta idea se generaliza, es decir, para una matrix 3D L por N por M:

matrix[ i ][ j ][ k ] = array[ i*(N*M) + j*M + k ]

y así.


Para una explicación realmente buena, ver: http://www.cplusplus.com/doc/tutorial/arrays/ ; o para algunos aspectos más técnicos: http://en.wikipedia.org/wiki/Row-major_order

Para ordenamiento de fila mayor, creo que la matrix[ i ][ j ] = array[ i*n + j ] sentencia matrix[ i ][ j ] = array[ i*n + j ] es incorrecta.

El desplazamiento debe ser offset = (row * NUMCOLS) + column .

Su statement resulta ser row * NUMROWS + column , lo cual es incorrecto.

Los enlaces que proporcionó dan una explicación correcta.

¿Algo como esto?

 //columns = amount of columns, x = column, y = row var calculateIndex = function(columns, x, y){ return y * columns + x; }; 

El siguiente ejemplo convierte un índice a las coordenadas xey.

 //i = index, x = amount of columns, y = amount of rows var calculateCoordinates = function(index, columns, rows){ //for each row for(var i=0; i= columns * i){ //return x, y return [index - columns * i, i]; } } return null; }; 

Heh 🙂

Encontré una solución sin matriz

 var mas = [ // 0 1 2 "1","2","3", "4","5","6", "7","8","9", "0","d","s" ] var m = mas.index(of: "d")! let sections = 4 let items = 3 for i in (0...sections) { if (m < (items * i) + items && m >= items * i){ "section: \(i)" "item: \(m - items * i)" } } let section = (m + m % sections) / sections let item = m - items * section let index = item + section * items