Удалить из двумерного массива строки и столбцы, содержащие максимальные и минимальные элементы среди всех элементов переданного массива

Question

Есть входной массив:

int[][] array = { {6, 15, 3, 4, 5, 6, 7, 8, 37},
                  {6, 2, 16, 2, 9, 30, 8, 11, 5},
                  {62, 6, 32, 7, 8, 4, 2, 5, 5},
                  {9, 8, 7, 51, 9, 7, 4, 9, 7},
                  {5, 3, 6, 12, 2, 7, 3, 2, 5} };

На выходе должно получиться:

{ {3, 6, 37}
  {7, 7, 7}

То есть в исходном массиве максимальное 62 и минимальное 2, мы удалили все строки и столбцы с этими значениями. Я написал метод, который удаляет строки, и я не знаю, что мне делать дальше.

public static int[][] removeRow(int[][] array, int min, int max) {
        int row = array.length;
        int column = array[0].length;

        int[][] newArray = new int[row][column];

        int count = 0;
        boolean flag = false;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                newArray[i - count][j] = array[i][j];
                if (array[i][j] == max || array[i][j] == min) {
                    count += 1;
                    if (i == row - 1){
                        flag = true;
                    }
                    break;
                }
            }
        }
        if(flag){
            for(int i = row - count; i < row - count + 1; i++) {
                for (int j = 0; j < column; j++) {
                    newArray[i][j] = 0;
                }
            }
        }
        return newArray;
    }

Сейчас мой код возвращает:

[[6, 15, 3, 4, 5, 6, 7, 8, 37], [9, 8, 7, 51, 9, 7, 4, 9, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]

Помогите, пожалуйста. И ещё, списки использовать нельзя, только массивы

Answer 1

Имеет смысл завести несколько булевых массивов, чтобы отследить индексы колонок и строк, содержащих минимальные и максимальные значения, затем вычислить размерность результирующего массива, создать его и скопировать оставшиеся значения.

Примерная реализация:

public static int[][] removeMinMax(int[][] array) {
    int rows = array.length;
    int cols = array[0].length;
    boolean[] minRows = null, maxRows = null;
    boolean[] minCols = null, maxCols = null;
    
    Integer min = null;
    Integer max = null;
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (null == min || array[i][j] < min) {
                minRows = new boolean[rows];
                minRows[i] = true;
                minCols = new boolean[cols];
                minCols[j] = true;
                min = array[i][j];
            } else if (array[i][j] == min) {
                minRows[i] = true;
                minCols[j] = true;
            }

            if (null == max || array[i][j] > max) {
                maxRows = new boolean[rows];
                maxRows[i] = true;
                maxCols = new boolean[cols];
                maxCols[j] = true;
                max = array[i][j];
            } else if (array[i][j] == max) {
                maxRows[i] = true;
                maxCols[j] = true;
            }
        }
    }
//  uncomment to debug
//    System.out.println("min=" + min + "; max=" + max);
//    System.out.println("minRows=" + Arrays.toString(minRows));
//    System.out.println("maxRows=" + Arrays.toString(maxRows));
//    System.out.println("minCols=" + Arrays.toString(minCols));
//    System.out.println("maxCols=" + Arrays.toString(maxCols));
    int rowsToDelete = 0, colsToDelete = 0;
    for (int i = 0; i < rows; i++) {
        if (minRows[i] || maxRows[i]) {
            rowsToDelete++;
        }
    }
    for (int i = 0; i < cols; i++) {
        if (minCols[i] || maxCols[i]) {
            colsToDelete++;
        }
    }
    
    if (rows == rowsToDelete || cols == colsToDelete) {
        return new int[1][0];
    }
    
    int[][] result = new int[rows - rowsToDelete][cols - colsToDelete];
    
    for (int i = 0, r = 0; i < rows; i++) {
        if (minRows[i] || maxRows[i])
            continue; // пропустить строку, содержащую минимум или максимум
        for (int j = 0, c = 0; j < cols; j++) {
            if (minCols[j] || maxCols[j])
                continue; // пропустить столбец, содержащий минимум или максимум
            result[r][c++] = array[i][j];
        }
        r++;
    }
    
    return result;
}

Тест:

int[][] array = { 
    { 6, 15,  3,  4, 5,  6, 7,  8, 37},
    { 6,  2, 16,  2, 9, 30, 8, 11,  5},
    {62,  6, 32,  7, 8,  4, 2,  5,  5},
    { 9,  8,  7, 51, 9,  7, 4,  9,  7},
    { 5,  3,  6, 12, 2,  7, 3,  2,  5} 
};
                
System.out.println(Arrays.deepToString(removeMinMax(array)));

Результат:

[[3, 6, 37], [7, 7, 7]]

БЛОГ НА HUSL

Удалить из двумерного массива строки и столбцы, содержащие максимальные и минимальные элементы среди всех элементов переданного массива

Ответы (1 шт):