Multidimensional array - dimmension of input array

I am doing course in Hyperskill platform - Introduction to Java. I am facing with an error of compilation which is not described anywhere (Failed test #6 of 8. Wrong answer)

Would you be able to look into my code and help me?

Please see the task description.

You need to implement printCorners method. It should print all corner elements of the twoDimArray in the following order: left to right and top to bottom.

The elements must be separated by space and printed as an example below.

Input array:

1 0 2
0 0 0
3 0 4

Printed corners:

1 2
3 4

Notice, that you must always print 4 corners, for example:

Input array:

1
2
3

Printed corners:

1 1
3 3

code:

public class ArrayOperations {
    public static void printCorners(int[][] twoDimArray) {
        int n = 2;
        int[][] myTable = new int[n][n];
        int cols = twoDimArray[0].length;
        if (cols == 1) {
            for (int i = 0; i < twoDimArray.length; i++) {
                if (i == 0) {
                    myTable[0][0] = twoDimArray[i][0];
                    myTable[0][1] = twoDimArray[i][0];
                    myTable[1][0] = twoDimArray[i][0];
                    myTable[1][1] = twoDimArray[i][0];
                }
                else if (i < twoDimArray.length - 1) {
                    myTable[1][0] = twoDimArray[i][0];
                    myTable[1][1] = twoDimArray[i][0];
                }
            }
            System.out.println(myTable[0][0] + " " + myTable[0][0]);
            System.out.println(myTable[1][0] + " " + myTable[1][1]);
        }
        else if (cols > 1) {
            for (int i = 0; i < twoDimArray.length; i++) {
                for (int j = 0; j < twoDimArray[i].length; j++) {
                    if (i == 0 && j == 0) {
                        myTable[0][0] = twoDimArray[i][j];
                    }
                    else if (i == 0 && j == twoDimArray[i].length - 1) {
                        myTable[0][1] = twoDimArray[i][j];
                    }
                    else if (i == twoDimArray.length - 1 && j == 0) {
                        myTable[1][0] = twoDimArray[i][j];
                    }
                    else if (i == twoDimArray.length - 1 && j == twoDimArray[i].length - 1) {
                        myTable[1][1] = twoDimArray[i][j];
                    }
                }
            }
            for (int i = 0; i < myTable.length; i++) {
                for (int j = 0; j < myTable[i].length; j++) {
                    System.out.print(myTable[i][j] + " ");
                }
                System.out.println();
            }
        }
    }
}

Here is full java based solution:

import java.util.ArrayList;
import java.util.List;
class ArrayOperations {
public static void main(String[] args) {
int[][] multiDimensionalArray1 = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
int[][] multiDimensionalArray2 = {
{1, 2},
{4, 5}
};
int[][] multiDimensionalArray3 = {
{1}
};
int[][] transformedArray1 = transformToMultiDimensionalArray(multiDimensionalArray1, 2);
int[][] transformedArray2 = transformToMultiDimensionalArray(multiDimensionalArray2, 2);
int[][] transformedArray3 = transformToMultiDimensionalArray(multiDimensionalArray3, 2);
for (int[] subarray : transformedArray1) {
for (int element : subarray) {
System.out.print(element + " ");
}
System.out.println();
}
System.out.println("------------------------------------");
for (int[] subarray : transformedArray2) {
for (int element : subarray) {
System.out.print(element + " ");
}
System.out.println();
}
System.out.println("------------------------------------");
for (int[] subarray : transformedArray3) {
for (int element : subarray) {
System.out.print(element + " ");
}
System.out.println();
}
}
public static int[][] transformToMultiDimensionalArray(int[][] matrix, int elementsPerSubarray) {
int rows = matrix.length;
int cols = matrix[0].length;
if (rows == 1 && cols == 1) {
return new int[][]{{matrix[0][0]}};
}
List<Integer> corners = new ArrayList<>();
for (int row = 0; row < rows; row++) {
for (int col = 0; col < cols; col++) {
if (row == 0 && col == 0) {
corners.add(matrix[row][col]); // first element first row
} else if (row == 0 && col == cols - 1) {
corners.add(matrix[row][col]); // last element first row
} else if (row == rows - 1 && col == 0) {
corners.add(matrix[row][col]); // first element last row
} else if (row == rows - 1 && col == cols - 1) {
corners.add(matrix[row][col]); // last element last row
}
}
}
int[][] multiDimensionalArray = new int[corners.size() / elementsPerSubarray][elementsPerSubarray];
for (int i = 0; i < corners.size(); i++) {
int row = i / elementsPerSubarray;
int col = i % elementsPerSubarray;
multiDimensionalArray[row][col] = corners.get(i);
}
return multiDimensionalArray;
}
}

This is not from Java. I've used javascript. For presentational purposes, I've adopted javascript based answer for this. But logic remains the same as above java solution.

Refer the code below:

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

function printCornerElements(matrix, elementsPerSubarray) {
let rows = matrix.length;
let cols = matrix[0].length;
if (rows === 1 && cols === 1) { 
return [matrix[0][0]];
}
let corners = [];
for (let row = 0; row < rows; row++) {
for (let col = 0; col < cols; col++) {
if (row === 0 && col === 0) {
corners.push(matrix[row][col]); // first element first row
} else if (row === 0 && col === cols - 1) {
corners.push(matrix[row][col]); // last element first row
} else if (row === rows - 1 && col === 0) {
corners.push(matrix[row][col]); // first element last row
} else if (row === rows - 1 && col === cols - 1) {
corners.push(matrix[row][col]); // last element last row
}
}
}
let multiDimensionalArray = [];
for (let i = 0; i < corners.length; i += elementsPerSubarray) {
let subarray = corners.slice(i, i + elementsPerSubarray);
multiDimensionalArray.push(subarray);
}
return multiDimensionalArray;
}
const multiDimensionalArray1 = [
[1, 2,3],
[4, 5,6],
[7, 8,9],
];
const multiDimensionalArray2 = [
[1, 2],
[4, 5],
];
const multiDimensionalArray3 = [
[1]
];
console.log(JSON.stringify(printCornerElements(multiDimensionalArray1,2)));
console.log(JSON.stringify(printCornerElements(multiDimensionalArray2,2)));
console.log(JSON.stringify(printCornerElements(multiDimensionalArray3,2)));

<!-- end snippet -->

You seem to be making this more complicated than it needs to be. The indexes of the corner elements can easily be determined as follows:

• top left = 0, 0
• top right = 0, length of row minus one
• bottom left = number of rows minus one, 0
• bottom right = number of rows minus one, length of row minus one

public class ArrayOperations {
    public static void printCorners(int[][] twoDimArray) {
        int n = 2;
        int[][] myTable = new int[n][n];
        myTable[0][0] = twoDimArray[0][0];
        myTable[0][1] = twoDimArray[0][twoDimArray[0].length - 1];
        myTable[1][0] = twoDimArray[twoDimArray.length - 1][0];
        myTable[1][1] = twoDimArray[twoDimArray.length - 1][twoDimArray[0].length - 1];
        for (int row = 0; row < 2; row++) {
            for (int col = 0; col < 2; col++) {
                System.out.print(myTable[row][col] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        printCorners(new int[][]{{1}, {2}, {3}});
        System.out.println("====================================================================");
        printCorners(new int[][]{{1, 0, 2},
                                 {0, 0, 0},
                                 {3, 0, 4}});
    }
}

Running above code produces following output:

1 1 
3 3 
====================================================================
1 2 
3 4

>You need to implement printCorners method. It should print all corner elements of the twoDimArray in the following order: left to right and top to bottom.

Since all you are asked to do is print the arrays, there is no need to build a new array. Also evidenced by the method being declared void and does not permit the return of the created array.

Some test Data

int[][] a1 = {{1},{2},{3}};
int[][] a2 = {{1,2,3,4},{2,3,4,5},{4,5,6,7}};
int[][] jagged = {{1},{2,3},{3,4},{5,6,7,7}};

The Method

To make it easy, define some positions

• lri - last row index
• lifr - last index of first row
• lilr - last index of last row

public static void printCorners(int[][] arr) {
int lri = arr.length-1;
int lifr = arr[0].length-1;
int lilr = arr[lri].length-1;
System.out.printf("%d %d%n", arr[0][0],arr[0][lifr]);
System.out.printf("%d %d%n", arr[lri][0],arr[lri][lilr]);
}
printCorners(a1);  System.out.println();
printCorners(a2);  System.out.println();
printCorners(jagged);  System.out.println();

prints

1 1
3 3
1 4
4 7
1 1
5 7
</details>