Maximum Sum of an Hourglass

Maximum Sum of an Hourglass - Problem

You are given an m x n integer matrix grid.

We define an hourglass as a part of the matrix with the following form:

a b c
  d
e f g

Return the maximum sum of the elements of an hourglass.

Note: An hourglass cannot be rotated and must be entirely contained within the matrix.

Input & Output

Example 1 — Basic 3x4 Matrix

$ Input: grid = [[7,4,0,1],[1,9,6,2],[0,3,3,1]]

› Output: 26

💡 Note: The hourglass with maximum sum is at position (0,0): 7+4+0 (top) + 9 (middle) + 0+3+3 (bottom) = 26

Example 2 — Minimum 3x3 Matrix

$ Input: grid = [[1,1,1],[1,1,1],[1,1,1]]

› Output: 7

💡 Note: Only one possible hourglass: 1+1+1 (top) + 1 (middle) + 1+1+1 (bottom) = 7

Example 3 — Negative Numbers

$ Input: grid = [[-1,-2,-3],[-4,5,-6],[-7,-8,-9]]

› Output: -25

💡 Note: Only one hourglass possible: (-1)+(-2)+(-3)+5+(-7)+(-8)+(-9) = -25

Constraints

m == grid.length
n == grid[i].length
3 ≤ m, n ≤ 150
0 ≤ grid[i][j] ≤ 10⁶

Visualization

Tap to expand

Asked in

H HackerRank 25 M Microsoft 15

The key insight is recognizing the hourglass pattern: 3 top elements + center middle + 3 bottom elements, excluding middle row sides. Best approach is direct calculation checking all valid 3×3 positions. Time: O(m×n), Space: O(1)

Common Approaches

✓ Brute Force Pattern Matching

⏱️ Time: O(m×n) Space: O(1)

Iterate through every possible top-left position of a 3x3 subgrid, then for each position calculate the sum of the hourglass pattern: top 3 elements + middle center + bottom 3 elements.

Single Pass Optimized

⏱️ Time: O(m×n) Space: O(1)

Same approach as brute force but with optimizations like early termination when grid is too small, and more efficient index calculations. The core algorithm remains O(m×n) but with better constants.

Brute Force Pattern Matching — Algorithm Steps

Step 1: Iterate through all valid starting positions (i,j) where a 3x3 grid fits
Step 2: For each position, calculate hourglass sum: grid[i][j] + grid[i][j+1] + grid[i][j+2] + grid[i+1][j+1] + grid[i+2][j] + grid[i+2][j+1] + grid[i+2][j+2]
Step 3: Keep track of maximum sum encountered

Visualization

Tap to expand

Step-by-Step Walkthrough

Position (0,0)

Calculate first hourglass sum

Position (0,1)

Move right and calculate next hourglass

Continue

Check all valid positions and find maximum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

int solution(int** grid, int rows, int cols) {
    if (rows < 3 || cols < 3) {
        return 0;
    }
    
    int maxSum = INT_MIN;
    
    // Check all possible hourglass positions
    for (int i = 0; i <= rows - 3; i++) {
        for (int j = 0; j <= cols - 3; j++) {
            // Calculate hourglass sum
            int hourglassSum = 
                grid[i][j] + grid[i][j+1] + grid[i][j+2] +  // top row
                grid[i+1][j+1] +                            // middle
                grid[i+2][j] + grid[i+2][j+1] + grid[i+2][j+2];  // bottom row
            if (hourglassSum > maxSum) {
                maxSum = hourglassSum;
            }
        }
    }
    
    return maxSum;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for 2D array - assumes well-formed input
    int** grid = (int**)malloc(100 * sizeof(int*));
    int rows = 0, cols = 0;
    
    char* ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            grid[rows] = (int*)malloc(100 * sizeof(int));
            int col = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' || *ptr == '-') {
                    grid[rows][col++] = atoi(ptr);
                    while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
                    if (rows == 0) cols++;
                }
                if (*ptr == ',') ptr++;
            }
            if (*ptr == ']') ptr++;
            rows++;
        }
        if (*ptr == ',') ptr++;
    }
    
    int result = solution(grid, rows, cols);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Single pass through all valid positions, each hourglass calculation is O(1)

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track maximum sum

✓ Linear Space

25.8K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Pattern Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler