Блог

Мне нужно решить этот вопрос

Напишите метод, который принимает двумерный массив типа integer в качестве параметра и возвращает значение, обратное массиву (строки становятся столбцами и наоборот).

это то, что я сделал с помощью поиска, но он показывает кучу ошибок

 public static class inverse{

    public static int[][] arrayInverse(int[][] A){
        int[][] B = new int[3][3];
        for(int i=0; i<B.length/2;i  ){
            for (int j=0; j<B[i].length/2;j  ) {
                int swap = B[i][j];
                B[B.length - i - 1] = swap;
            }
        }
        return swap;
    }
}
 

}

Во-первых, как упоминалось в комментариях, задача состоит в том, чтобы перенести входной массив, чтобы строки стали столбцами, и наоборот

Если входной 2D-массив квадратный (количество строк совпадает с количеством столбцов), наиболее эффективным способом было бы поменять местами элементы ниже и по главной диагонали: a[i][j] ⇄ a[j][i] без использования дополнительного массива:

 public static int[][] transposeSquare(int[][] arr) {
    for (int i = 0, n = arr.length; i < n; i  ) {
        // select the elements only above the main diagonal
        for (int j = i   1, m = arr[i].length; j < m; j  ) {
            int tmp = arr[i][j];
            arr[i][j] = arr[j][i];
            arr[j][i] = tmp;
        }
    }
    return arr;
}
 

Однако в общем случае прямоугольной матрицы может потребоваться создать новый массив/матрицу размера M x N вместо N x M , и скопировать значения из входных данных в соответствующем порядке (тогда обмен не требуется):

 public static int[][] transpose(int[][] arr) {
    int[][] result = new int[arr[0].length][arr.length];
    for (int i = 0, n = arr.length; i < n; i  ) {
        for (int j = 0, m = arr[i].length; j < m; j  ) {
            result[j][i] = arr[i][j];
        }
    }
    return resu<
}
 

Вам нужно заменить между столбцами и строками

 public class inverse {
    /**
     * The entry point of application.
     *
     * @param args the input arguments
     */
    public static void main(String[] args) {
        int ints[][] = {{1, 2, 3},
                {5, 6, 7},
                {9, 10, 11},
                {12, 13, 14}
        };
        print2D(ints);
        System.out.println("n");
        print2D(arrayInverse(ints));
    }

    /**
     * Array inverse int [ ] [ ].
     *
     * @param A the a
     * @return the int [ ] [ ]
     */
    public static int[][] arrayInverse(int[][] A) {
        if (A.length == 0 || A[0].length == 0) {
            System.out.println("A.length==0 || A[0].length==0");
            return A;
        }
        int[][] B = new int[A[0].length][A.length];
        for (int i = 0; i < B.length; i  ) {
            for (int j = 0; j < B[i].length; j  ) {
                B[i][j] = A[j][i];
            }
        }
        return B;
    }

    /**
     * Print 2 d.
     *
     * @param mat the mat
     */
    public static void print2D(int mat[][]) {
        // Loop through all rows
        for (int i = 0; i < mat.length; i  ) {

            for (int j = 0; j < mat[i].length; j  ) {
                System.out.print(mat[i][j]   " ");
            }
            System.out.println(" ");
        }
    }
}
 

Выход:

1 2 3
5 6 7
9 10 11
12 13 14

1 5 9 12
2 6 10 13
3 7 11 14

Вот общее решение. Он транспонирует любую матрицу, в том числе и неровную.

 List<int[][]> demo = List.of(
        new int[][] { { 1 }, { 2, 3, 4 }, { 5, 6 } },
        new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } },
        new int[][] { { 1, 2, 3, 4, 5 },
                { 6, 7, 8, 9, 10 } });

for (int[][] arr : demo) {
    System.out.println("Original");
    for (int[] b : arr) {
        System.out.println(Arrays.toString(b));
    }
    System.out.println("Transposed");
    for (int[] b : transpose(arr)) {
        System.out.println(Arrays.toString(b));
    }
    System.out.println();
}
 

С принтами

 Original
[1]
[2, 3, 4]
[5, 6]
Transposed
[1, 2, 5]
[3, 6]
[4]

Original
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
Transposed
[1, 4, 7]
[2, 5, 8]
[3, 6, 9]

Original
[1, 2, 3, 4, 5]
[6, 7, 8, 9, 10]
Transposed
[1, 6]
[2, 7]
[3, 8]
[4, 9]
[5, 10]
 

• сначала найдите полученное количество строк, которое является максимальным количеством столбцов в исходной матрице.
• Затем просто выполните итерацию по матрице, создавая новые строки и копируя соответствующие значения каждого столбца в их новую строку. Поскольку строки могут быть разной длины, проверяется, существует ли значение в текущей строке.
• затем скопируйте эту строку нужной длины в транспонированную строку.

 public static int[][] transpose(int[][] nums) {
    int maxRows = nums[0].length;
    for (int[] ar : nums) {
        maxRows = Math.max(maxRows, ar.length);
    }
    int[][] trans = new int[maxRows][];
    for (int r = 0; r < maxRows; r  ) {
        int[] row = new int[nums.length];
        int cc = 0;
        for (int c = 0; c < row.length; c  ) {
            if (r < nums[c].length) {
                row[cc  ] = nums[c][r];
            }
        }
        trans[r] = Arrays.copyOf(row, cc);
    }
    return trans;
}
 

С принтами