Нахождение минимального и максимального значения в каждом столбце в массиве

У меня проблема с моей программой. Я хочу напечатать min и max в каждом столбце, но он не работает должным образом. Я думаю, что все должно быть в порядке. Когда цикл заканчивается, я перезагружаю минимальное и максимальное значение.


public class tablice2 {
  public static void main(String[] args){
      int t [][] = new int [5][5];
      int n [] = new int [5];
      int x [] = new int [5];
      Random r = new Random();
      int min  = t[0][0];
      int max = t[0][0];


      for (int i = 0; i <t.length ;i++){
          min = 0;
          max = 0;
          for(int j = 0; j < t[i].length ;j++){
            t[i][j] = r.nextInt(6)-5;
              System.out.print(t[i][j] + " ");

              if (t[j][i] < min){
                  min = t[j][i];
              }

              if (t[j][i] > max){
                  max = t[j][i];
              }

          }
          n[i]=min;
          x[i]=max;


          System.out.println(" ");
      }

      for(int p=0;p<x.length;p++){
          System.out.println("Max Column "+p + ": " +x[p] );
      }

      for(int k=0;k<n.length;k++){
          System.out.println("Min Column "+k + ": " +n[k]);
      }



  }
}

Всего 4 ответа


Не вводите и не сортируйте одновременно, поскольку элементы могут все еще инициализироваться со значениями по умолчанию (то есть 0 ). Также во внешнем цикле сбросьте max и min на первый элемент столбца.

Сделайте это следующим образом:

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        int t[][] = new int[5][5];
        int n[] = new int[5];
        int x[] = new int[5];
        Random r = new Random();
        int min;
        int max;

        for (int i = 0; i < t.length; i++) {
            for (int j = 0; j < t[i].length; j++) {
                t[i][j] = r.nextInt(10) - 5;
                System.out.printf("%4d", t[i][j]);
            }
            System.out.println();
        }

        for (int i = 0; i < t.length; i++) {
            min = t[0][i];
            max = t[0][i];
            for (int j = 0; j < t[i].length; j++) {
                if (t[j][i] < min) {
                    min = t[j][i];
                }
                if (t[j][i] > max) {
                    max = t[j][i];
                }
            }
            n[i] = min;
            x[i] = max;
        }

        for (int p = 0; p < x.length; p++) {
            System.out.println("Max Column " + p + ": " + x[p]);
        }

        for (int k = 0; k < n.length; k++) {
            System.out.println("Min Column " + k + ": " + n[k]);
        }
    }
}

Пример прогона:

   3  -4   2   0   1
  -2  -2   4  -1  -2
  -3   1   4  -1   0
  -4   4  -2  -5   2
  -5  -3  -3  -4  -1
Max Column 0: 3
Max Column 1: 4
Max Column 2: 4
Max Column 3: 0
Max Column 4: 2
Min Column 0: -5
Min Column 1: -4
Min Column 2: -3
Min Column 3: -5
Min Column 4: -2

Примечания:

  1. Я изменил r.nextInt(6)-5 на r.nextInt(10) - 5 , чтобы получить сочетание отрицательных, 0 и положительных чисел, чтобы вы могли быстро проверить результат. Вы можете изменить его обратно на r.nextInt(6)-5 согласно вашему требованию.
  2. Я также использовал printf вместо print для печати каждого числа с пробелом в 4 единицы. Вы можете изменить его обратно на print если хотите.
  3. Использование Integer.MAX_VALUE и / или Integer.MIN_VALUE вообще не требуется для решения этой проблемы.

Не стесняйтесь комментировать в случае каких-либо сомнений.


Вы инициализировали min как ноль, я бы предложил Integer.MIN_VALUE . В противном случае положительные значения не могут быть «найдены».

Это также та проблема, которую кто-то уже решил для вас, например, с помощью потоков:

assertThat(
        IntStream.of(new int[] { 1, 2, 3, 4, 5 }).max().getAsInt(), 
        is(5));

Ваш первый цикл должен быть над столбцами (j).

t[0].length

Сначала в цикле установите для min значение min = Integer.MAX_VALUE и аналогично max = Integer.MIN_VALUE . Это обеспечит нам, что каждое случайное число будет (по крайней мере) меньше, чем инициализированный min (и аналогично для max)

В этом случае вы рисуете числа от -5 до 0, так что вы можете установить мин. Как, например, -6 и макс. 1, и тогда вы уверены, что вытянутое число будет больше -6 и меньше 1 и будет корректно обновляться

В вашем коде вы смешали i и j - это должно быть

if (t[i][j] < min){
    min = t[i][j];
}

и аналогично в остальной части кода

Также, когда вы создаете массив в Java, он автоматически инициализируется нулями. Так

int t [][] = new int [5][5];
int min  = t[0][0];

означает min = 0 потому что весь массив заполнен нулями, поэтому вам не нужно дублировать код


Есть идеи?

10000