Сортировать от низкого к высокому двухмерные массивы int по сумме arr [i]

Question

Я попал в тупик в домашней работе по сортировке целочисленного двумерного массива.

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

Пример - input - int [] [] array = {{2, 4, 1,9,9,9,9}, {6, 8}, {7, 3, 6, 5, 1}};

output - array = {{6, 8}, {7, 3, 6, 5, 1}, {2, 4, 1,9,9,9,9}};

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

public static int[] arraysCalculator(int[][] arr) { 
int[] sums = new int[arr.length];
int sum= 0;
for(int i = 0; i  < arr.length; i++)
{
    for(int j = 0; j < arr[i].length; j++)
    {
        sum += arr[i][j];
    }
    sums[i] = sum;
    sum = 0;
}

Answer 1

Вы можете легко суммировать int[], транслируя его и затем вызывая sum(). Оттуда, это просто вопрос вызова Arrays.sort с компаратором, который сравнивает эту сумму:

Arrays.sort(array, Comparator.comparingInt(a -> Arrays.stream(a).sum()));

Answer 2

Ты получил как треть. Что вам нужно сейчас:

• после создания этого первого массива sums, который содержит суммы"внутренних" массивов, вы просто создаете точную копию этого массива, например originalSums
• затем вы сортируете содержимое sums

Пример: скажем, sums и originalSums равны [ 12, 3, 7]. После сортировки вы получите:

originalSums: [ 12, 3, 7]

sums: [ 3, 7, 12]

Дело в том, что, взглянув на оба массива, вы можете решить, как поменять местами внутренние массивы в соответствии с порядком, который sums показывает вам сейчас.

В приведенном выше примере вы заметили, что 12 имеет исходный индекс 0. После сортировки его индекс равен 2. Таким образом, вы знаете, что вам нужно «поменять» внутренние массивы на 0 и 2. Вы также можете вывести что 3 должно перейти к индексу 0, а 7 к индексу 2.

Конечно, все еще нужно немного поработать, чтобы поменяться местами (как вам лучше не менять местами индексы дважды ).

Самый простой способ добиться цели - просто посмотреть только по одному индексу за раз (как вы делаете какую-то пузырьковую сортировку).

Короче говоря: есть много разных способов решить эту проблему. Я предлагаю вам начать с самого простого пути.

Answer 3

В дополнение к другим ответам, которые проделали большую работу, объясняя теорию и закладывая основы для решения вашего задания, вот полный рабочий пример (с подробной документацией о том, что каждая вещь делает и почему) мы надеемся, что это поможет:

/**
 * This method will sort the inner arrays of a given two dimensional array
 * from lowest to highest value according to the sum of it's elements.
 */
private static int[][] arrayCalc(int[][] arr)
{
    /*
     * We're working with a TreeMap here because this type
     * of map is allowed to have duplicate key entries
     */
    java.util.Map<Integer, Integer[]> map = new java.util.TreeMap<>();
    /*
     * This value represents the largest inner array
     * size found in 2d array passed as parameter
     */
    int largestSize = 0;
    for (int[] inner : arr) {
        /*
         * Convert the inner array to an array of Integer
         * objects so it can be placed inside a map
         */
        Integer[] integers = IntStream.of(inner).boxed().toArray(Integer[]::new);
        map.put(IntStream.of(inner).sum(), integers);
        /*
         * Check if this inner array has a larger value
         * then the largest array we processed so far
         */
        if (inner.length > largestSize) {
            largestSize = inner.length;
        }
    }

    int[][] result = new int[map.size()][largestSize];
    /*
     * Iterate over the map and copy it's values which are represented
     * as Integer arrays into inner arrays of our return value
     */
    java.util.Iterator<java.util.Map.Entry<Integer, Integer[]>> iter = map.entrySet().iterator();
    for (int i = 0; i < result.length && iter.hasNext(); i++)
    {
        java.util.Map.Entry<Integer, Integer[]> entry = iter.next();
        /*
         * We can just return our value as an array of Integer objects
         * but for the sake of this exercise we will convert it to a
         * primitive 2D int array so it's consistent with our method parameter
         */
        Integer[] integers = entry.getValue();
        result[i] = java.util.Arrays.stream(integers).mapToInt(Integer::intValue).toArray();
    }
    return result;
}

public static void main(String[] args)
{
    int[][] array = {{2, 4, 1,9,9,9,9}, {6, 8}, {7, 3, 6, 5, 1}};
    int[][] result = arrayCalc(array);

    for (int[] iResult : result) {
        System.out.println(Arrays.toString(iResult));
    }
}

Вывод

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