Thread: (Comparing and) Printing 2D Array value on each direction (Down and Right)

Hello. I have a 2D Array/Matrix and I want to write a code where I can compare each value in both directions. Let me explain myself I wrote a method that prints each value of the Array with the right direction and another one with the down direction. But my problem is how to compare each value? I have a hard time implementing a code about it and I need help.

Here are the two methods

//Driver 
public static void main(String[] args) {
        int[][] grid = new int[][] { { 7, 4, 2 },
                { 0, 5, 6 },
                { 3, 1, 2 } };
 
int arraySize = grid.length;
 
  for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid.length; j++) {
// I can't solve my second issue to two the first issue with dead code
            }
        }
 
}
 
// goes to right direction - increment j first
    public static int nextRightElementMatrix(int[][] array, int arraySize) {
        System.out.println("Printing via right direction : ");
        for (int i = 0; i < arraySize; i++) {
            for (int j = 0; j < arraySize; j++) {
                return array[i][j];
            }
        }
    }
 
//  goes to down direction - increment i first
public static int nextDownElementMatrix(int[][] array, int arraySize) {
        System.out.println("Printing via down direction : ");
        for (int j = 0; j < arraySize; j++) {
            for (int i = 0; i < arraySize; i++) {
                return array[i][j];
            }
        }
    }

The first issue is that I get a dead code on j++ if I try to return the value of the element to the method. The second issue will be how to compare each value of those two methods. (I was thinking to include both of them in another a compare?)
This is where I need help, thank you.

OK. I will give you the instructions for this exercise to better understand me.
Here it is: Write a Java program to find a path from top left to bottom in the right direction which minimizes the sum of all numbers along its path - Note: Move either down or right at any point in time.

So in that case, my approach is to to start from the top left of the grid so 7, and compare his adjacent value so 4 and 0 in that case. 0<4 so the sum will be 7 + 0. Then, we move to the adjacent value of 0 and compare them, and so on.
So in my approach - I made two functions to give the next Right element of the grid and the next Down element of the grid. Here you will have a visual understanding of my explanation : https://www.w3resource.com/java-exer...ercise-133.php

Dead code is any code that's never executed, or if executed, the execution has no effect on the application's behaviour.

New program? Are you talking about the solutions of the link I provided. I haven't look at it. I'm working on my own solution first before checking. Just for the image representation I shared that link : https://www.w3resource.com/java-exer...ercise-133.php
From my understanding, the rules is to go only right or down. The goal is to get to the "from top left to bottom in the right direction which minimizes the sum of all numbers along its path" - so in others words, from 7 (top left) to 2 (right bottom). So the sum starts at 7. You check the right number and down number to 7 and choose the smallest one and add it to the sum, then you move to the smallest number between both and check the right and down number from it and choose the smallest to add to sum and so on

The case of no next element should come when we reach the right bottom. But True, I haven't take care of that case yet

--- Update ---

Maybe my approach is not the best? And I should reconsider?