Как найти максимальную сумму в двумерном массиве - Исправление недочетов и поиск решений вместе с Examum.ru

Volkoff_anton

0 / 0 / 0

Регистрация: 18.11.2020

Сообщений: 24

Найти наибольшую сумму элементов из строк двумерного массива

12.05.2021, 15:42. Показов 1873. Ответов 3

Метки массив (Все метки)

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

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
 
namespace Arrays2DConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            CultureInfo.CurrentCulture = (CultureInfo)CultureInfo.CurrentCulture.Clone();
            CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator = ".";
            Console.OutputEncoding = Encoding.Unicode;
 
            int n, m;
            double sum1 = 0;
            Console.WriteLine($"Введіть кількість рядків:");
            while (true)
            {
                try
                {
                    n = Convert.ToInt32(Console.ReadLine());
                    break;
                }
                catch { Console.WriteLine($"Спробуйте ще раз. nВведіть кількість рядків: "); }
            }
            Console.WriteLine($"Введіть кількість стовпів:");
            while (true)
            {
                try
                {
                    m = Convert.ToInt32(Console.ReadLine());
                    break;
                }
                catch { Console.WriteLine($"Спробуйте ще раз. nВведіть кількість стовпів: "); }
            }
 
 
            double[,] mass = new double[n, m];
            Random rnd = new Random();
 
 
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    mass[i, j] = rnd.NextDouble() * (3.53 + 8.541) - 8.541;
                    mass[i, j] = Math.Round(mass[i, j], 2);
                    Console.Write($"{mass[i, j],4:f2} ");
                }
                Console.WriteLine();
            }
 
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    sum1 += mass[i, j];
                }
                Console.WriteLine();
                Console.WriteLine("Сума " + (i + 1) + " рядка дорівнює " + Math.Round(sum1, 3));
            }
        }
    }
}

DesireToBelieve

37 / 33 / 18

Регистрация: 18.09.2020

Сообщений: 125

12.05.2021, 16:06

Вот код

using System;
 
namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
 
            var rand = new Random();
            var arr = new int[5,5];
 
            var sum = new int[5];
 
            for (int i = 0; i < 5; i++) //Заполянем масив
            {
                for (int j = 0; j < 5; j++)
                {
                    arr[i, j] = rand.Next(10);
                    Console.Write(arr[i,j] + " ");
                }
                Console.WriteLine();
            }
 
            for (int i = 0; i < 5; i++) //Считаем суммы каждой строки
            {
                for (int j = 0; j < 5; j++)
                {
                    sum[i] += arr[i, j];
                }
            }
 
            var max = int.MinValue;
            var maxIndex = 0;
 
            for (int i = 0; i < sum.Length; i++) //Находим в масиве Сумм максимальную 
            {
                if (sum[i] < max) continue;
                max = sum[i];
                maxIndex = i;
            }
 
            Console.WriteLine($"Максимальная строка {maxIndex + 1} с суммой {max}");
        }
    }
}

DesireToBelieve

37 / 33 / 18

Регистрация: 18.09.2020

Сообщений: 125

12.05.2021, 16:14

Сообщение было отмечено Volkoff_anton как решение

Решение

Сайт что-то тупит

Добавлено через 3 минуты
Надеюсь понятно почему совпадает индекс строки и индекс суммы

Добавлено через 1 минуту
На самом деле сумму каждой строки можно считать еще когда мы массив заполняем. Так будет оптимальнее

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

using System;
 
namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
 
            var rand = new Random();
            var arr = new int[5,5];
 
            var sum = new int[5];
 
            for (int i = 0; i < 5; i++) //Заполянем масив и попутно считаем сумму + выводим
            {
                for (int j = 0; j < 5; j++)
                {
                    arr[i, j] = rand.Next(10);
                    sum[i] += arr[i, j];
                    Console.Write(arr[i,j] + " ");
                }
                Console.WriteLine();
            }
 
            var max = int.MinValue;
            var maxIndex = 0;
 
            for (int i = 0; i < sum.Length; i++) //Находим в масиве Сумм максимальную 
            {
                if (sum[i] < max) continue;
                max = sum[i];
                maxIndex = i;
            }
 
            Console.WriteLine($"Максимальная строка {maxIndex + 1} с суммой {max}");
        }
    }
}

0 / 0 / 0

Регистрация: 18.11.2020

Сообщений: 24

12.05.2021, 20:27

[ТС]

Cпасибо.

Источник

Дан целочисленный массив, найдите в нем непрерывный подмассив с наибольшей суммой.

Например,

Input: {-2, 1, -3, 4, -1, 2, 1, -5, 4}

Output: Subarray with the largest sum is {4, -1, 2, 1} with sum 6.

Потренируйтесь в этой проблеме

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

Мы можем легко решить эту задачу за линейное время, используя Алгоритм Кадане. Идея состоит в том, чтобы поддерживать максимальный (с положительной суммой) подмассив, “заканчивающийся” на каждом индексе данного массива. Этот подмассив либо пуст (в этом случае его сумма равна нулю), либо состоит на один элемент больше, чем максимальный подмассив, оканчивающийся на предыдущем индексе.

Алгоритм может быть реализован следующим образом на C++, Java и Python:

C++

#include <iostream>

#include <vector>

using namespace std;

// Функция для нахождения максимальной суммы непрерывного подмассива

// в заданном целочисленном массиве

int kadane(vector<int> const &arr)

{

// сохраняет максимальный суммарный подмассив, найденный на данный момент

int max_so_far = 0;

// сохраняет максимальную сумму подмассива, заканчивающегося на текущей позиции

int max_ending_here = 0;

// обход заданного массива

for (int i = 0; i < arr.size(); i++)

{

// обновить максимальную сумму подмассива, «заканчивающегося» на индексе «i» (путем добавления

// текущий элемент до максимальной суммы, заканчивающейся на предыдущем индексе ‘i-1’)

max_ending_here = max_ending_here + arr[i];

// если максимальная сумма отрицательна, устанавливаем ее в 0 (что представляет

// пустой подмассив)

max_ending_here = max(max_ending_here, 0);

// обновить результат, если текущая сумма подмассива окажется больше

max_so_far = max(max_so_far, max_ending_here);

}

return max_so_far;

}

int main()

{

vector<int> arr = { —2, 1, —3, 4, —1, 2, 1, —5, 4 };

cout << «The maximum sum of a contiguous subarray is « << kadane(arr);

return 0;

}

Скачать Выполнить код

результат:

The maximum sum of a contiguous subarray is 6

Java

class Main

{

// Функция для нахождения максимальной суммы непрерывного подмассива

// в заданном целочисленном массиве

public static int kadane(int[] arr)

{

// сохраняет максимальный суммарный подмассив, найденный на данный момент

int maxSoFar = 0;

// сохраняет максимальную сумму подмассива, заканчивающегося на текущей позиции

int maxEndingHere = 0;

// обход заданного массива

for (int i: arr)

{

// обновить максимальную сумму подмассива, «заканчивающегося» на индексе «i» (путем добавления

// текущий элемент до максимальной суммы, заканчивающейся на предыдущем индексе ‘i-1’)

maxEndingHere = maxEndingHere + i;

// если максимальная сумма отрицательна, устанавливаем ее в 0 (что представляет

// пустой подмассив)

maxEndingHere = Integer.max(maxEndingHere, 0);

// обновить результат, если текущая сумма подмассива окажется больше

maxSoFar = Integer.max(maxSoFar, maxEndingHere);

}

return maxSoFar;

}

public static void main(String[] args)

{

int[] arr = { —2, 1, —3, 4, —1, 2, 1, —5, 4 };

System.out.println(«The sum of contiguous subarray with the « +

«largest sum is « + kadane(arr));

}

Скачать Выполнить код

результат:

The maximum sum of a contiguous subarray is 6

Python

# Функция нахождения максимальной суммы непрерывного подмассива

# в заданном целочисленном массиве

def kadane(arr):

# хранит подсписок максимальной суммы, найденный на данный момент.

max_so_far = 0

# хранит максимальную сумму подсписков, заканчивающихся на текущей позиции

max_ending_here = 0

# пройти по заданному списку

for i in arr:

# обновляет максимальную сумму подсписка, «заканчивающегося» на индексе «i» (путем добавления

# текущий элемент до максимальной суммы, заканчивающейся на предыдущем индексе ‘i-1’)

max_ending_here = max_ending_here + i

#, если максимальная сумма отрицательна, установите ее на 0 (что означает

# пустой подсписок)

max_ending_here = max(max_ending_here, 0)

# обновляет результат, если сумма текущего подсписка оказывается больше

max_so_far = max(max_so_far, max_ending_here)

return max_so_far

if __name__ == ‘__main__’:

arr = [—2, 1, —3, 4, —1, 2, 1, —5, 4]

print(‘The sum of contiguous sublist with the largest sum is’,

kadane(arr))

Скачать Выполнить код

результат:

The maximum sum of a contiguous subarray is 6

Временная сложность приведенного выше решения равна O(n) и не требует дополнительного места, где n это размер ввода.

Приведенный выше код не обрабатывает случай, когда все элементы массива отрицательные. Если массив содержит все отрицательные значения, ответом является максимальный элемент. Мы можем легко разместить эту проверку перед тем, как продолжить алгоритм. Реализацию можно увидеть ниже на C++, Java и Python:

C++

#include <iostream>

#include <vector>

#include <algorithm>

using namespace std;

// Функция для нахождения максимальной суммы непрерывного подмассива

// в заданном целочисленном массиве

int kadane(vector<int> const &arr)

{

// находим максимальный элемент в заданном массиве

int max_num = *max_element(arr.begin(), arr.end());

// если массив содержит все отрицательные значения, вернуть максимальный элемент

if (max_num < 0) {

return max_num;

}

// сохраняет максимальный суммарный подмассив, найденный на данный момент

int max_so_far = 0;

// сохраняет максимальную сумму подмассива, заканчивающегося на текущей позиции

int max_ending_here = 0;

// обход заданного массива

for (int i = 0; i < arr.size(); i++)

{

// обновить максимальную сумму подмассива, «заканчивающегося» на индексе «i» (путем добавления

// текущий элемент до максимальной суммы, заканчивающейся на предыдущем индексе ‘i-1’)

max_ending_here = max_ending_here + arr[i];

// если максимальная сумма отрицательна, устанавливаем ее в 0 (что представляет

// пустой подмассив)

max_ending_here = max(max_ending_here, 0);

// обновить результат, если текущая сумма подмассива окажется больше

max_so_far = max(max_so_far, max_ending_here);

}

return max_so_far;

}

int main()

{

vector<int> arr = { —8, —3, —6, —2, —5, —4 };

cout << «The maximum sum of a contiguous subarray is « << kadane(arr);

return 0;

}

Скачать Выполнить код

результат:

The maximum sum of a contiguous subarray is -2

Java

import java.util.Arrays;

class Main

{

// Функция для нахождения максимальной суммы непрерывного подмассива

// в заданном целочисленном массиве

public static int kadane(int[] arr)

{

// находим максимальный элемент в заданном массиве

int max = Arrays.stream(arr).max().getAsInt();

// если массив содержит все отрицательные значения, вернуть максимальный элемент

if (max < 0) {

return max;

}

// сохраняет максимальный суммарный подмассив, найденный на данный момент

int maxSoFar = 0;

// сохраняет максимальную сумму подмассива, заканчивающегося на текущей позиции

int maxEndingHere = 0;

// делаем для каждого элемента заданного массива

for (int i: arr)

{

// обновить максимальную сумму подмассива, «заканчивающегося» на индексе «i» (путем добавления

// текущий элемент до максимальной суммы, заканчивающейся на предыдущем индексе ‘i-1’)

maxEndingHere = maxEndingHere + i;

// если максимальная сумма отрицательна, устанавливаем ее в 0 (что представляет

// пустой подмассив)

maxEndingHere = Integer.max(maxEndingHere, 0);

// обновить результат, если текущая сумма подмассива окажется больше

maxSoFar = Integer.max(maxSoFar, maxEndingHere);

}

return maxSoFar;

}

public static void main(String[] args)

{

int[] arr = { —8, —3, —6, —2, —5, —4 };

System.out.println(«The sum of contiguous subarray with the « +

«largest sum is « + kadane(arr));

}

Скачать Выполнить код

результат:

The maximum sum of a contiguous subarray is -2

Python

# Функция нахождения максимальной суммы непрерывного подмассива

# в заданном целочисленном массиве

def kadane(arr):

# найти максимальный элемент, присутствующий в данном списке

maximum = max(arr)

#, если список содержит все отрицательные значения, вернуть максимальный элемент

if maximum < 0:

return maximum

# хранит подсписок максимальной суммы, найденный на данный момент.

max_so_far = 0

# хранит максимальную сумму подсписков, заканчивающихся на текущей позиции

max_ending_here = 0

# сделать для каждого элемента заданного списка

for i in arr:

# обновляет максимальную сумму подсписка, «заканчивающегося» на индексе «i» (путем добавления

# текущий элемент до максимальной суммы, заканчивающейся на предыдущем индексе ‘i-1’)

max_ending_here = max_ending_here + i

#, если максимальная сумма отрицательна, установите ее на 0 (что означает

# пустой подсписок)

max_ending_here = max(max_ending_here, 0)

# обновляет результат, если сумма текущего подсписка оказывается больше

max_so_far = max(max_so_far, max_ending_here)

return max_so_far

if __name__ == ‘__main__’:

arr = [—8, —3, —6, —2, —5, —4]

print(‘The sum of contiguous sublist with the largest sum is’, kadane(arr))

Скачать Выполнить код

результат:

The maximum sum of a contiguous subarray is -2

Этот подход требует двух обходов входного массива. Мы можем легко модифицировать основной алгоритм, чтобы он обрабатывал и отрицательные целые числа. Алгоритм может быть реализован следующим образом на C++, Java и Python:

C++

#include <iostream>

#include <vector>

#include <climits>

using namespace std;

// Функция для нахождения максимальной суммы непрерывного подмассива

// в заданном целочисленном массиве (также обрабатывает отрицательные числа)

int kadaneNeg(vector<int> const &arr)

{

// сохраняет максимальный суммарный подмассив, найденный на данный момент

int max_so_far = INT_MIN;

// сохраняет максимальную сумму подмассива, заканчивающегося на текущей позиции

int max_ending_here = 0;

// обход заданного массива

for (int i = 1; i < arr.size(); i++)

{

// обновить максимальную сумму подмассива, «заканчивающегося» на индексе «i» (путем добавления

// текущий элемент до максимальной суммы, заканчивающейся на предыдущем индексе ‘i-1’)

max_ending_here = max_ending_here + arr[i];

// максимальная сумма должна быть больше текущего элемента

max_ending_here = max(max_ending_here, arr[i]);

// обновить результат, если текущая сумма подмассива окажется больше

max_so_far = max(max_so_far, max_ending_here);

}

return max_so_far;

}

int main()

{

vector<int> arr = { —8, —3, —6, —2, —5, —4 };

cout << «The maximum sum of a contiguous subarray is « << kadaneNeg(arr);

return 0;

}

Скачать Выполнить код

результат:

The maximum sum of a contiguous subarray is -2

Java

class Main

{

// Функция для нахождения максимальной суммы непрерывного подмассива

// в заданном целочисленном массиве (также обрабатывает отрицательные числа)

public static int kadaneNeg(int[] arr)

{

// сохраняет максимальный суммарный подмассив, найденный на данный момент

int maxSoFar = Integer.MIN_VALUE;

// сохраняет максимальную сумму подмассива, заканчивающегося на текущей позиции

int maxEndingHere = 0;

// обход заданного массива

for (int i: arr)

{

// обновить максимальную сумму подмассива, «заканчивающегося» на индексе «i» (путем добавления

// текущий элемент до максимальной суммы, заканчивающейся на предыдущем индексе)

maxEndingHere = maxEndingHere + i;

// максимальная сумма должна быть больше текущего элемента

maxEndingHere = Integer.max(maxEndingHere, i);

// обновить результат, если текущая сумма подмассива окажется больше

maxSoFar = Integer.max(maxSoFar, maxEndingHere);

}

return maxSoFar;

}

public static void main(String[] args)

{

int[] arr = { —8, —3, —6, —2, —5, —4 };

System.out.println(«The maximum sum of a contiguous subarray is « +

kadaneNeg(arr));

}

Скачать Выполнить код

результат:

The maximum sum of a contiguous subarray is -2

Python

import sys

# Функция нахождения максимальной суммы непрерывного подмассива

# в заданном целочисленном массиве (также обрабатывает отрицательные числа)

def kadaneNeg(arr):

# хранит подсписок максимальной суммы, найденный на данный момент.

max_so_far = —sys.maxsize

# хранит максимальную сумму подсписков, заканчивающихся на текущей позиции

max_ending_here = 0

# пройти по заданному списку

for i in range(len(arr)):

# обновляет максимальную сумму подсписка, «заканчивающегося» на индексе «i» (путем добавления

# текущий элемент до максимальной суммы, заканчивающейся на предыдущем индексе ‘i-1’)

max_ending_here = max_ending_here + arr[i]

# Максимальная сумма # должна быть больше, чем текущий элемент

max_ending_here = max(max_ending_here, arr[i])

# обновляет результат, если сумма текущего подсписка оказывается больше

max_so_far = max(max_so_far, max_ending_here)

return max_so_far

if __name__ == ‘__main__’:

arr = [—8, —3, —6, —2, —5, —4]

print(‘The sum of contiguous sublist with the largest sum is’, kadaneNeg(arr))

Скачать Выполнить код

результат:

The maximum sum of a contiguous subarray is -2

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

Связанный пост:

Вывести непрерывный подмассив с максимальной суммой

Использованная литература: https://en.wikipedia.org/wiki/Maximum_subarray_problem

Источник

пока есть такой код из 12 строк и 8 столбцов с сгенерированными случайными значениями, мне необходимо посчитать сумму каждой строки, сравнить эти суммы, и индекс самой максимальной по сумме строчки вывести на экран

public class Task3 {
    public static void main(String[] args) {
        Random rand = new Random();
        int m = 12;
        int n = 8;
        int[][] numbers = new int [m][n];
        int sum = 0;
        for(int i=0; i< numbers.length; i++) {
            for (int j = 0; j < numbers[i].length; j++) {
                numbers[i][j] = rand.nextInt(51);
                System.out.print(numbers[i][j] + " ");
            }
            System.out.println(`введите сюда код`);
        }
    }
}

Nowhere Man

11.5k18 золотых знаков16 серебряных знаков27 бронзовых знаков

задан 25 окт 2022 в 6:07

В цикле проходите по всем строкам и считаете сумму чисел в каждой строке. Как только посчитали сумму — сравниваете с переменной для максимума. Всё.
Собственно вложенные циклы у вас уже есть, добавьте только подсчет суммы и поиск максимума.
Ну и поскольку сгенерированный массив вы никуда не возвращаете, его можно и не выделять.

ответ дан 25 окт 2022 в 6:12

DmitryKDmitryK

4,4961 золотой знак5 серебряных знаков19 бронзовых знаков

Если программа большая, то имеет смысл уменьшить количество работы для неё и почитать сумму поэлементно:

Random rand = new Random();
    int m = 12;
    int n = 8;
    int[][] numbers = new int [m][n];
    int sum = 0;
    int max = 0;
    for(int i=0; i< numbers.length; i++) {
        for (int j = 0; j < numbers[i].length; j++) {
             numbers[i][j] = rand.nextInt(51);
             System.out.print(numbers[i][j] + " ");
             sum += numbers[i][j];
        }
        System.out.println();
        if (sum > max) {
            max = sum;
            m = i;
        }
    sum = 0;
    }
    System.out.print(String.format("Индекс строки с максимальной суммой элементов [%s]", m));

ответ дан 25 окт 2022 в 9:51

Источник

max1 is unintialized, hence the test if (sum > max1) is meaningless and max1 may not be updated correctly. In your case, max1 happened to have the value 4201200, but the behavior is undefined and this could have been any value or even a trap value on some systems.

Since all matrix elements are positive, you can initialize max1 to 0, otherwise you would use INT_MIN defined in <limits.h> or add a test for the first column.

Furthermore, the index values i and j are swapped in the second loop and the loop test is incorrect too.

Here is a modified version:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {

    int rows = 3, cols = 5;
    int *a = (int *)malloc(rows * cols * sizeof(int));

    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            a[i * cols + j] = (rand() % (10 - 1 + 1)) + 1;   
        }
    }

    printf("The array elements are:n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf(" %2d", a[i * cols + j]);
        }
        printf("n");
    }
    
    int max_col = 0;
    int max_sum = 0;
    for (int j = 0; j < cols; j++) {
        int sum = 0;
        for (int i = 0; i < rows; i++) {
            sum += a[i * cols + j];
        }
        printf("sum of column %i is -> %dn", j, sum);
        if (j == 0 || sum > max_sum) {
            printf("max is detectedn");
            max_sum = sum;
            max_col = j;
        }
    }
    printf("max is %d column %dn", max_col, max_sum);
    free(a);
    return 0;
}

Источник

Давайте посмотрим на этот вопрос сегодня: найти наибольшую двумерную матрицу в большой матрице. Фактически, это найти X, Y в двумерном массиве так, чтобы (X, Y), (X, Y + 1), (X + 1, Y), (X + 1, Y + 1) было больше, чем другие Любые подобные подмассивы большие. Вот пример:

О чем свидетельствует:
1 2 0 3 4
2 3 4 5 1
1 1 5 3 0
Самый большой это:
4 5

5 3

Ну, все понимают, что большая матрица на самом деле является двумерным массивом, а двумерная матрица на самом деле является подмассивом из четырех точек, состоящих из точек (X, Y) вправо и вниз. Нет проблем, верно? Посмотрите на эту картинку, вы будете более интуитивным.

Красный блок самая большая сумма,
Желтый блок также представляет собой сумму четырех чисел, а не наибольшее,
Такие X, Y на самом деле ограничены фиолетовой областью

Как решить такую проблему? Мы анализируем следующие две идеи, а затем раскопаем суть следующей темы:

1. Мы берем сумму каждой точки (X, Y) и четырех точек, сформированных из этой точки, а затем сканируем структуру, чтобы найти наибольшее число. Можем ли мы просто попросить об этом? Мы можем построить одномерный массив, который содержит сумму четырех чисел, начиная с (X, Y) точек. И мы можем найти (X, Y) из следующей таблицы, мы используем i для представления нижнего индекса, тогда x = i / длина второго измерения массива, Y = i-X * длина второй цифры массива. Следует отметить, что в это время максимальное значение X равно уникальной длине массива-2, а максимальное значение Y равно двумерной длине массива -2;

2. После того, как вы поняли первую идею, можете ли вы провести некоторую оптимизацию? Нам действительно нужно найти каждую длину?

Суть проблемы на самом деле в пузырчатой сортировке, чтобы найти максимальное значение. право? Это просто суть идеи 1. Мы использовали эту идею и в идее 2. Но только для более глубокого ее понимания. Нам нужно только сравнивать друг друга и сохранять максимальное значение каждый раз в качестве часового. Надо учитьсяСортировку друзей можно посмотреть здесьУзнайте это систематически.

Давайте посмотрим на код вместе:

 public static int[][] FindMaxSum(int[][] input)
        {
            if (input != null && input.Length < 2 && input[0].Length < 2)
            {
                throw new ArgumentException («Введенный вами массив не соответствует требованиям.»);
            }
            int maxx = input.Length;
            int maxy = input[0].Length;

            int xMark = 0;
            int yMark = 0;
            int maxSum = int.MinValue;

            for (int x = 0; x < maxx - 1; x++)
            {
                for (int y = 0; y < maxy - 1; y++)
                {
                    int sum = input[x][y] + input[x + 1][y] + input[x][y + 1] + input[x + 1][y + 1];

                    if (sum > maxSum)
                    {
                        maxSum = sum;
                        xMark = x;
                        yMark = y;
                    }
                }
            }

            int[][] result = new int[][] {new int[] {input[xMark][yMark], input[xMark][yMark+1]},
                new int[] {input[xMark+1][yMark], input[xMark+1][yMark+1]}};

            return result;
        }

Давайте посмотрим на метод испытаний:

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

Классические вопросы интервью，

Алгоритмы и структуры данных，

Связанный список、Сортировка темУзнайте больше ресурсов.

Следите за нашим общедоступным аккаунтом и присоединяйтесь к нашей группе QQ: 709211597. Получайте регулярные толчки. Обратите внимание на курсы, там будут регулярные скидки.

Источник