Как добавить соседние ячейки в 2d массив?

1

Мне нужно, чтобы каждая ячейка в первом массиве стала суммой всех смежных ячеек, а затем сбрасывала этот ответ во второй массив. Пример:

Начальный массив со случайными числами:

3   5   11  
5   9   14   
1   2   8

Вычисленный массив:

19  42  41  
20  49  48  
33  62  44

3 пятна ([0] [0]) составляет 5 + 9 + 5 = 19 и т.д. Вот что у меня есть:

public class ProcessArray {

    private int rows;
    private int columns;
    private int [][] firstArray;
    private int [][] secondArray;


public ProcessArray(int rows, int columns) {

    this.rows=rows;
    this.columns=columns;
    firstArray = new int[rows][columns];
    secondArray = new int[rows][columns];

    initializeArray(firstArray, secondArray);

    randomlyFillArray(firstArray);
    System.out.println("Initial array with random numbers: ");
    printArray(firstArray, secondArray, rows, columns);
    getFirstArray(firstArray);
    System.out.println("Computed array:");
    computeArrayValues(firstArray);



}

private void initializeArray(int firstArray[][], int secondArray[][]){
    for(int i = 0; i <firstArray.length; i++){
        for (int j =0; j<firstArray[i].length; j++){
            firstArray[i][j] = (0);
        }

    }
    for(int i = 0; i <secondArray.length; i++){
        for (int j =0; j<secondArray[i].length; j++){
            secondArray[i][j] = (0);
        }

    }
}

public void randomlyFillArray(int firstArray[][]){
    for(int i = 0; i <firstArray.length; i++){
        for (int j =0; j<firstArray[i].length; j++){
            firstArray[i][j] = (int)(Math.random()*15);
        }

    }

}

//here where I try to have it add, I don't know what loop to have it run to go to each spot in the 'firstArray':

public void computeArrayValues(int firstArray[][]){
    int x=1;
    int y=1;
    int sum;

    int topLeft = firstArray[x-1][y-1];
    int top = firstArray[x][y-1];
    int topRight = firstArray[x+1][y-1];
    int midLeft = firstArray[x-1][y];
    int midRight = firstArray[x+1][y];
    int botLeft = firstArray[x-1][y+1];
    int bot = firstArray[x][y+1];
    int botRight = firstArray[x+1][y+1];

    secondArray[0][0]= (bot+botRight+midRight);

    for (x=0; x<firstArray.length; x++){
        for(y=0; y<firstArray.length; y++){
    secondArray[x][y] = (topLeft+top+topRight+midLeft+midRight+botLeft+bot+botRight);
        }
    }
    System.out.println(secondArray[x][y]);
}

public void printArray(int firstArray[][], int secondArray[][], int rows, int columns){

    for (int i = 0; i < rows; i++){
        for (int j = 0; j < columns; j++){
            System.out.printf(String.format("%4s", firstArray[i][j]));
        }
        System.out.println();
    }

}

public int[][] getFirstArray(int array[][]){
    array = firstArray;
    return array;

}

public int[][] getSecondArray(int array[][]){
    array = secondArray;
    return array;

}

}

  • 0
    Какой у Вас вопрос? Вы просите комментировать ваш код или альтернативные подходы?
  • 1
    Ваш пример исходного массива и вычисленного массива верны? Из вашего объяснения, нижняя левая ячейка вычисляемого массива должна быть 5 + 9 + 2 = 16. Но вы сказали, что это 33. Я правильно понял ваш вопрос?
Теги:
arrays
multidimensional-array
for-loop

2 ответа

0

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

19 42 28 
20 49 35 
16 37 25

Это будет правильным результатом для суммы всех смежных ячеек (сообщите мне, если я неправильно понял вопрос).

public class ArraySum {
    static int[][] sum(int array[][]) {
        // Asuming square arrays
        int size = array.length;

        int result[][] = new int[size][size];

        // For every cell in the table
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {

                // Iterate the neighbors
                for (int n = -1; n <= 1; n++) {
                    for (int m = -1; m <= 1; m++) {
                        // Discard the cell     
                        if (n == 0 && m == 0) {
                            continue; 
                        }
                        int ii = i - n;
                        int jj = j - m;
                        // Check if the neighbor coordinates are 
                        // inside of the array bounds 
                        if (ii >= 0 && ii < size && jj >= 0 && jj < size) {
                            result[i][j] += array[ii][jj];
                        }
                    }
                }
            }
        }   
        return result;
    }   


    public static void main(String... args) {
        int a[][] = { {3, 5, 11}, 
                      {5, 9, 14}, 
                      {1, 2,  8} };
        int r[][] = sum(a);

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) { 
                System.out.printf("%d ", r[i][j]);
            }
            System.out.println();
        }
    }
}
Поделиться
0

Предполагая, что вы ищете предложения по альтернативным подходам, я бы предложил инкапсулировать координаты ячеек и использовать потоки ячеек вместо итерации. Это предполагает java 8 (естественно):

class Cell {
    private final int row;
    private final int col;

    private Cell(int row, int col) {
        this.row = row;
        this.col = col;
    }

    public static Stream<Cell> streamCells(int rows, int cols) {
        return IntStream.range(0, rows)
            .flatMap(row -> IntStream.range(0, cols)
                .flatMap(col -> new Cell(row, col)));
    }

    public Stream<Cell> streamAdjacentCells(int rows, int cols) {
        return IntStream.range(row - 1, row + 1)
            .flatMap(row -> IntStream.range(col - 1, col + 1)
                .flatMap(col -> new Cell(row, col)))
            .filter(cell -> cell.row >= 0 && cell.col >= 0)
            .filter(cell -> cell.row < rows && cell.col < cols)
            .filter(cell -> cell.row != this.row && cell.col != this.col);
    }

    public int getValue(int[][] array) {
        return array[row][col];
    }

    public void setValue(int[][] array, int value) {
        array[row][col] = value;
    }
}

Тогда код для установки смежных значений довольно прост:

int[][] destination = new int[rows][cols];
Cell.streamCells(rows, cols)
    .forEach(cell -> setValue(
        destination,
        cell.streamAdjacentCells(rows, cols)
            .mapToInt(adj -> getValue(source, adj))
            .sum()));
Поделиться

Ещё вопросы

Сообщество Overcoder
Наверх
Меню