Como mapear os índices de uma matriz para uma matriz unidimensional (C ++)?

Eu tenho uma matriz 8×8, como esta:

char matrix[8][8]; 

Além disso, eu tenho uma matriz de 64 elementos, como este:

 char array[64]; 

Depois desenhei a matriz como uma tabela e preenchai as células com números, sendo cada número incrementado da esquerda para a direita, de cima para baixo.

Se eu tiver, digamos, índices 3 (coluna) e 4 (linha) na matriz, sei que corresponde ao elemento na posição 35 da matriz, como pode ser visto na tabela que desenhei. Eu acredito que existe algum tipo de fórmula para traduzir os 2 índices da matriz em um único índice da matriz, mas não consigo descobrir o que é.

Alguma ideia?

A maneira como a maioria dos idiomas armazena matrizes multidimensionais é fazendo uma conversão como a seguinte:

Se a matrix tiver tamanho, n por m [i i vai de 0 a (n-1) ej de 0 a (m-1)], então:

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

Então é como um sistema numérico de base ‘n’. Note que o tamanho da última dimensão não importa.


Para uma compreensão conceitual, pense em uma matriz (3×5) com ‘i’ como o número da linha e ‘j’ como o número da coluna. Se você começar a numeração de i,j = (0,0) --> 0 . Para a ordenação ‘row-major’ (assim), o layout se parece com:

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

Conforme você se move ao longo da linha (isto é, aumenta o número da coluna), você começa a contar, então os índices da Matriz são 0,1,2... Quando você chega na segunda linha, você já tem 5 inputs, então você começa com índices 1*5 + 0,1,2... Na terceira linha, você já tem 2*5 inputs, assim os índices são 2*5 + 0,1,2...

Para uma dimensão mais alta, esta ideia generaliza, isto é, para uma matrix 3D L por N por M:

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

e assim por diante.


Para uma explicação realmente boa, veja: http://www.cplusplus.com/doc/tutorial/arrays/ ; ou para alguns aspectos mais técnicos: http://en.wikipedia.org/wiki/Row-major_order

Para a ordenação das linhas principais, acredito que a matrix[ i ][ j ] = array[ i*n + j ] declarações matrix[ i ][ j ] = array[ i*n + j ] esteja errada.

O deslocamento deve ser offset = (row * NUMCOLS) + column .

Sua declaração resulta em row * NUMROWS + column , o que está errado.

Os links fornecidos fornecem uma explicação correta.

Algo assim?

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

O exemplo abaixo converte um índice novamente em coordenadas x e y.

 //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 🙂

Eu encontrei solução sem 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