This is helpful, thank you. I used Integer.MIN_VALUE;

It's worth noting that the description clearly states that the input will be -9 <= R <= 9. This means that the smallest possible value will be -9*7 (as there are 7 elements in an hourglass). So one can just initialize the max value to -63 :)

I just did this:

int max = Integer.MIN_VALUE;

Simply set it to null and use type specific comparison to assign first sum.

why should we initialize max value to large negative value?

Because of the -9<= A[i][j] <=9, so the extrame situation is that all the 7 elem are -9, the sum is -63, and any value that smaller than -63 could be set to the initial value.

The least no. possible is -9 * 7 = -63. We can also initialize it to that. :)

actually -63 is enough.Since 7 slots having a minimum value of -9 in each would turn out to a maximum negative of -7*9=-63

I used Number.NEGATIVE_INFINITY with Javascript

you can set it to integer.MIN_VALUE

You can use -63 as max value because it is stated in condition that a[i][j] is between -9 and + 9

you know max_value = -63 would do just fine. because the lowest maximum number that can be achieved with given constraints is -63. The given constraints for element in array is [-9,9] so the max an hour glass with all -9s would give (-9)*(7(no_of elements in hour glass)) = -63

may i know what is the reason behind this? why we have to initiliza ma_value = -9999 or -63

-63 would be enough

bro you can just set max value to -9 * 7 = -63 cause it can be the most small value of hourglass acording to question

even -63 can work fine

No need to set max value that low. It will not possibly be any lower than 7*9 so you can simply initialize it to 63.

perhaps -9*7 is enough, though

you could just use one less than the minimum possible value of an hourglass, which is -64.

Or initialize it to any value less than -63, because the input values of the array ranges from -9 to +9. So a hour glass can contain a maximum of 7 times -9, which sums up to -63. Any value greater than -64 can be accepted to swap the max variable, right!

HotIce!

since the least sum is -63 (when all elements are -9), you can initialize it to be -63

Or you can use

float('-inf')

which gives you the largest negative value.

I set max = nil and then checked if max was nil before setting max to the total with an or conditional

e.g., max = total if max == nil || total > max

short mayor=-63;

If you are writing in Java, you can actually use max_value= Integer.MIN_VALUE; to get the lowest signed interger value in case -99999 isn't enough.

The problem specifies that arr[i][j] values are only between -9 and 9, so the minSum for any hourglass can be -63, specifing the initial max_value = -64 will ensure that any sum will be greater

Actually, since the constraint is -9, and you are adding 7 values, the minimum would be -9 x 7 which is -63. That could save a fraction of memory instead of working with a large negative number.

This was helpful, thanks a ton.

Great solution if you don't care about scalability or the assumption that the dataset changes over time. Terrible solution if you do.

or you could initially allow to set first hour glass value as max value like if row & column is 0 & 0 respectively.....

Since the hour glass can only be a max of 7 digits and the smallest digit is -9, as long as your max value is initialized to less than -63 the results should be correct.

since each value is between -9 to 9 so -9*7 = -63 should suffice

Min value according to the instructions is actually -9 so -10 would be fine :)

how to do this task in C???

thanks for the correction mandar012 and my apologies for posting such wrong ans

Why not just use max = -63? If the whole array is -9 then max will never change and output correct answer of -63

Java Code :

private static int sumRow(int rowIndex, int startColIndex, int endcolIndex, int[][] array) {

    int sum = 0;
    for(int col = startColIndex; col <= endcolIndex; col ++ ) {
        sum = sum + array[rowIndex][col];
    }
    return sum;
}

private static int hourglassSum(int[][] arr) {
    int maxRow = 6, maxCol = 6, rowIndex = 0, columnIndex = 0, maxValue = 0;
    while(true) {
        //Hour Glass Sum
        int rowOne = sumRow(rowIndex, columnIndex, columnIndex + 2, arr);
        int rowTwo = arr[rowIndex + 1] [columnIndex + 1];
        int rowThree = sumRow(rowIndex + 2, columnIndex, columnIndex + 2, arr);

        int total = rowOne + rowTwo + rowThree;

        if((rowIndex == 0 && columnIndex == 0 ) || maxValue < total) {
            maxValue = total;
        }

        columnIndex++;
        if(columnIndex >= maxCol - 2) {
            rowIndex++;
            columnIndex = 0;
        }
        if(rowIndex >= maxRow - 2 )
            break;
    }
    return maxValue;
}