2D Array - DS

Given the fixed small size of the problem, brute force is fine.

Points to note:-

1. Negative values possible.
2. Maximum sum can be less than zero.
3. Range of element value is -9 to 9.
4. Numbers to be summed for each hourglass = 7.
5. Minimum possible value for sum = .

So we'll initialize our maxSum to -63. From there, we just calculate the sums of all hourglasses and return the maxSum. Here is an implementation of the function in Python:

def array2D(arr):

    # want to find the maximum hourglass sum

    # minimum hourglass sum = -9 * 7 = -63

    maxSum = -63

    

    for i in range(4):

        for j in range(4):

        

            # sum of top 3 elements

            top = sum(arr[i][j:j+3])

            

            # sum of the mid element

            mid = arr[i+1][j+1]

            

            # sum of bottom 3 elements

            bottom = sum(arr[i+2][j:j+3])

            

            hourglass = top + mid + bottom

            

            if hourglass > maxSum:

                maxSum = hourglass

                

    return maxSum

  Java Method-1

import java.io.*;

import java.math.*;

import java.security.*;

import java.text.*;

import java.util.*;

import java.util.concurrent.*;

import java.util.regex.*;

public class Solution {

    // Complete the hourglassSum function below.

    static int hourglassSum(int[][] a) {

        int rows=a.length;// row length

        int colums=a[0].length; //column length

        int max_value=-63;  //given in the question max value is 63

        for(int i=0;i<rows-2;i++)

        {

            for(int j=0;j<colums-2;j++)

            {

                 int current_sum=0;

                 current_sum=a[i][j]+a[i][j+1]+a[i][j+2]+a[i+1][j+1]+

                                        a[i+2][j]+a[i+2][j+1]+a[i+2][j+2];

                 max_value=Math.max(max_value,current_sum);

            }

        }

        return max_value;

    }

    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) throws IOException {

        BufferedWriter bufferedWriter = new 

                BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        int[][] arr = new int[6][6];

        for (int i = 0; i < 6; i++) {

            String[] arrRowItems = scanner.nextLine().split(" ");

            scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

            for (int j = 0; j < 6; j++) {

                int arrItem = Integer.parseInt(arrRowItems[j]);

                arr[i][j] = arrItem;

            }

        }

        int result = hourglassSum(arr);

        bufferedWriter.write(String.valueOf(result));

        bufferedWriter.newLine();

        bufferedWriter.close();

        scanner.close();

    }

}

    Java Method-2

public class Solution {

    private static final int _MAX = 6; // size of matrix

    private static final int _OFFSET = 2; // hourglass width

    private static int matrix[][] = new int[_MAX][_MAX];

    private static int maxHourglass = -63; // initialize to lowest possible sum (-9 x 7)

    

    /** Given a starting index for an hourglass, sets maxHourglass

    *   @param i row 

    *   @param j column 

    **/

    private static void hourglass(int i, int j){

        int tmp = 0; // current hourglass sum

        

        // sum top 3 and bottom 3 elements

        for(int k = j; k <= j + _OFFSET; k++){

            tmp += matrix[i][k]; 

            tmp += matrix[i + _OFFSET][k]; 

        }

        

        // sum middle element

        tmp += matrix[i + 1][j + 1]; 

        

        if(maxHourglass < tmp){

            maxHourglass = tmp;

        }

    }

    public static void main(String[] args) {

        // read inputs

        Scanner scan = new Scanner(System.in); 

        for(int i=0; i < _MAX; i++){

            for(int j=0; j < _MAX; j++){

                matrix[i][j] = scan.nextInt();

            }

        }

        scan.close();

        

        // find maximum hourglass

        for(int i=0; i < _MAX - _OFFSET; i++){

            for(int j=0; j < _MAX - _OFFSET; j++){

                hourglass(i, j);

            }

        }

        

        // print maximum hourglass

        System.out.println(maxHourglass);

    }

}