Итерация одного размера выстраивает как двумерная матрица

Question

Итерация одного размера выстраивает как двумерная матрица

Если у Вас есть F# (который будет в следующей версии.NET), можно использовать

Seq.iter doSomething myIEnumerable

11

java arrays

задан Community 23 May 2017 в 11:33

3 ответа

Я думаю, это то, что вы пытаетесь сделать ... преобразовать однотомный массив в двумерный.

//this is just pseudo code...not real syntax

int[10] oneDim = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int first_dim = 5;
int second_dim = 2;

int[first_dim][second_dim] new_array;

for (int fdi = 0; fdi < first_dim; fdi++){
   for (int sdi = 0; sdi < second_dim; sdi++) {

      //this is the crux...you're calculating the one dimensional index to access the value

      new_array[fdi][sdi] = oneDim[fdi*second_dim + sdi] 

   }
}

2

ответ дан 3 December 2019 в 01:20

Два числа, которые вы показываете, можно вычислить в том порядке, в котором вы их показываете, как index / 2 и index% 2 соответственно. Это то, что вы подразумеваете под «проблемой»?

8

ответ дан 3 December 2019 в 01:20

Другие вопросы по тегам:

java arrays

Похожие вопросы:

score 32 · Accepted Answer

Если вы хотите упорядочить основные строки, заданная строка rowIndex ,column columnIndex и имитируют (из-за отсутствия лучшего термина) двумерный массив с numberOfColumns столбцами, формула

rowIndex * numberOfColumns + columnIndex.

Если вы хотите, чтобы порядок строк для данной строки rowIndex , column columnIndex и имитируют (из-за отсутствия лучшего термина) двумерный массив с numberOfRow строками, формула

columnIndex * numberOfRows + rowIndex.

Итак, предполагая основной порядок строк:

int[10] oneDim = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int rows = 2;
int columns = 5;
for (int row = 0; row < rows; row++) {
    for (int column = 0; column < columns; column++) {
        System.out.println(row + ", " + column + ": " + oneDim[row * columns + column]);
    }
}

Вывод:

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

И если вы настаиваете на индексировании с использованием одного цикла для , предполагая порядок основных строк, формула, которая вам нужна, будет следующей:

int column = index % numberOfColumns;
int row = (index - column) / numberOfColumns;

Если вы используете порядок столбцов, вам нужна следующая формула:

int row = index % numberOfRows;
int column = (index - row) / numberOfRows;

Итак,

int[10] oneDim = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int rows = 2;
int columns = 5;
for(int index = 0; index < 10; index++) {
    int column = index % columns;
    int row = (index - column) / columns;
    System.out.println(row + ", " + column + ": " + oneDim[index]);
}

выведет

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

, как ожидалось.

формула

rowIndex * numberOfColumns + columnIndex.

Если вы хотите упорядочить по строкам, заданы row rowIndex , column columnIndex и вы имитируете (из-за отсутствия лучшего термина) двумерный массив с numberOfRow строк, формула будет

columnIndex * numberOfRows + rowIndex.

Итак, в предположении основного порядка строк:

int[10] oneDim = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int rows = 2;
int columns = 5;
for (int row = 0; row < rows; row++) {
    for (int column = 0; column < columns; column++) {
        System.out.println(row + ", " + column + ": " + oneDim[row * columns + column]);
    }
}

Выход:

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

И если вы настаиваете на индексировании с использованием одного цикла for , предполагая строку -мажорный порядок, формула, которую вы хотите, следующая:

int column = index % numberOfColumns;
int row = (index - column) / numberOfColumns;

Если вы используете порядок по столбцам, вам нужна следующая формула:

int row = index % numberOfRows;
int column = (index - row) / numberOfRows;

Итак,

int[10] oneDim = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int rows = 2;
int columns = 5;
for(int index = 0; index < 10; index++) {
    int column = index % columns;
    int row = (index - column) / columns;
    System.out.println(row + ", " + column + ": " + oneDim[index]);
}

выведет

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

, как ожидалось .

формула

rowIndex * numberOfColumns + columnIndex.

Если вы хотите упорядочить по строкам, заданы row rowIndex , column columnIndex и вы имитируете (из-за отсутствия лучшего термина) двумерный массив с помощью numberOfRow строк, формула имеет вид

columnIndex * numberOfRows + rowIndex.

Итак, в предположении основного порядка строк:

int[10] oneDim = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int rows = 2;
int columns = 5;
for (int row = 0; row < rows; row++) {
    for (int column = 0; column < columns; column++) {
        System.out.println(row + ", " + column + ": " + oneDim[row * columns + column]);
    }
}

Выход:

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

И если вы настаиваете на индексировании с использованием одного цикла for , предполагая, что строка -мажорный порядок, формула, которую вы хотите, следующая:

int column = index % numberOfColumns;
int row = (index - column) / numberOfColumns;

Если вы используете порядок по столбцам, вам нужна следующая формула:

int row = index % numberOfRows;
int column = (index - row) / numberOfRows;

Итак,

int[10] oneDim = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int rows = 2;
int columns = 5;
for(int index = 0; index < 10; index++) {
    int column = index % columns;
    int row = (index - column) / columns;
    System.out.println(row + ", " + column + ": " + oneDim[index]);
}

выведет

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

, как ожидалось .

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

И если вы настаиваете на индексировании с использованием одного цикла для , предполагая порядок по старшим строкам, вам нужна следующая формула:

int column = index % numberOfColumns;
int row = (index - column) / numberOfColumns;

Если вы используете порядок по столбцам, формула, которая вам нужна, выглядит следующим образом:

int row = index % numberOfRows;
int column = (index - row) / numberOfRows;

Итак,

int[10] oneDim = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int rows = 2;
int columns = 5;
for(int index = 0; index < 10; index++) {
    int column = index % columns;
    int row = (index - column) / columns;
    System.out.println(row + ", " + column + ": " + oneDim[index]);
}

выведет

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

, как ожидалось.

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

И если вы настаиваете на индексировании с использованием одного цикла для , предполагая порядок по старшим строкам, вам нужна следующая формула:

int column = index % numberOfColumns;
int row = (index - column) / numberOfColumns;

Если вы используете порядок по столбцам, формула, которая вам нужна, выглядит следующим образом:

int row = index % numberOfRows;
int column = (index - row) / numberOfRows;

Итак,

int[10] oneDim = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int rows = 2;
int columns = 5;
for(int index = 0; index < 10; index++) {
    int column = index % columns;
    int row = (index - column) / columns;
    System.out.println(row + ", " + column + ": " + oneDim[index]);
}

выведет

0, 0: 1
0, 1: 2
0, 2: 3
0, 3: 4
0, 4: 5
1, 0: 6
1, 1: 7
1, 2: 8
1, 3: 9
1, 4: 10

, как ожидалось.