public static int hourglassSum(List> arr) { int row = arr.size(); int col = arr.get(0).size();

    int maxSum = Integer.MIN_VALUE;
for(int i=0;i<=row - 3;i++){
    for(int j=0;j<=col-3;j++){
        int sum = arr.get(i).get(j)+arr.get(i).get(j+1)+arr.get(i).get(j+2)+arr.get(i+1).get(j+1)+arr.get(i+2).get(j)+arr.get(i+2).get(j+1)+arr.get(i+2).get(j+2);

        if(sum>maxSum){
            maxSum = sum;
        }
    }
}
return maxSum;

}

javaScript

function hourglassSum(arr) {
    // Write your code here
    let sum = [];
   for(let i = 0; i<= arr.length-3; i++){
    for(let j = 0; j<= arr.length-3; j++){
         let currentsum =
                arr[i][j] +
                arr[i][j+1] +
                arr[i][j+2] +
                arr[i+1][j+1] +
                arr[i+2][j] +
                arr[i+2][j+1] +
                arr[i+2][j+2];
                sum.push(currentsum)
    }
   }
   return Math.max(...sum)
}

I’m new to Python and couldn’t find a more intuitive solution for this problem, so I thought I’d share mine. Feedback or improvements are very welcome!

My Pyhton solution:

def hourglassSum(arr): # Write your code here

evey_sum_hourglass_1 = []
evey_sum_hourglass_2 = []
evey_sum_hourglass_3 = []
evey_sum_hourglass_4 = []

for i in range(0,4, +1):

    line_sum_1 = arr[i +1][1]
    for j in range(0, 3, +1):
        line_sum_1 += arr[i][j] + arr[i+2][j]
    evey_sum_hourglass_1.append(line_sum_1)    

for i in range(0,4, +1):

    line_sum_2 = arr[i +1][2]
    for j in range(1, 4, +1):
        line_sum_2 += arr[i][j] + arr[i+2][j]
    evey_sum_hourglass_2.append(line_sum_2)

for i in range(0,4, +1):

    line_sum_3 = arr[i +1][3]
    for j in range(2, 5, +1):
        line_sum_3 += arr[i][j] + arr[i+2][j]
    evey_sum_hourglass_3.append(line_sum_3) 

for i in range(0,4, +1):

    line_sum_4 = arr[i +1][4]
    for j in range(3, 6, +1):
        line_sum_4 += arr[i][j] + arr[i+2][j]
    evey_sum_hourglass_4.append(line_sum_4)   

all_sum = evey_sum_hourglass_1 + evey_sum_hourglass_2 + evey_sum_hourglass_3 + evey_sum_hourglass_4

max_sum = max(all_sum)


return max_sum

My Java solution with o(n * m) time complexity and o(1) space complexity:

public static int hourglassSum(List<List<Integer>> arr) {
        if(arr.size() < 3) return 0; //no possible hourglass
        
        int max = Integer.MIN_VALUE;
        
        //iterate over each row except the last two
        int i = 0;
        while(i < arr.size() - 2){
            //iterate over each col except the first & last
            int j = 1;
            while(j < arr.get(i).size() - 1){
                int currMax = calcHourglassSum(arr, i, j); //get the curr max
                max = Math.max(currMax, max); //update the max
                j++;
            }
            i++;
        }
        return max;
    }
    
    public static int calcHourglassSum(List<List<Integer>> arr, int i, int j){
        return 
            arr.get(i).get(j) + arr.get(i).get(j-1) + arr.get(i).get(j+1)
            + arr.get(i+1).get(j) + arr.get(i+2).get(j) + arr.get(i+2).get(j-1) 
            + arr.get(i+2).get(j+1);
    }

Here is my c++ solution you can watch video explanation here : https://www.youtube.com/watch?v=aJv6KLHL3Qk

int hourglassSum(vector<vector<int>> arr) {
    int result = -63;
    for(int r = 1; r <= 4; r++){
        for(int c = 1; c <= 4; c++){
          int s = arr[r][c] + arr[r-1][c] + arr[r-1][c-1] + arr[r-1][c+1];
          s += arr[r+1][c] + arr[r+1][c-1] + arr[r+1][c+1];
          result = max(result,s);
        }
    }
    
    return result;
}