yeah. you should initialize the max value to the value of the first hourglass.

yeah you can init max value to one less than the least value possible, in this case its '-55'

Hello,

I hvae written a code in PHP and test case 5 got failed.

I am thinking that code should past all test cases. Didn't know why it failed test case 5.

PS: I didn't initialize max value to 0

You can actually set -9, which is given in problem statement. :)

Yeah I wonder what percentage of people (me included) wrote everything correct the first attempt, but initialized at 0 ;)

i have 1 idea for that. first find min value from max=0arr[j][i]

Why is that? I dont understand the logic in it.

i intiliza max value -999 iam getting error can u have a c code

Good catch!!

I used

int max = numeric_limits<int>::min();

In python 3 I have used, MIN = -sys.maxsize -1

yes, you should not intialize maximum to zero its better to intialize with a large negative number

thank you

initialise to a negative number

i initialised max value with -63. it worked

Just intialize max value to -63.

For Python 3, the minimum value an integer can have is:

min = -sys.maxsize -1

then what should be taken

They have stated that minimum value of the element is -9. Therefore minimum value of an hourglass is -9*7 = -63. Initialize max value to -63.

//Here MAX is already 0 after that it cant pass the two testcase;

int MAX=0; int total=0; int main(){ double arr[10][10]; for(int i=0;i<6;i++){ for(int j=0;j<6;j++){ cin>>arr[i][j]; } } for(int i=0;i<4;i++){ for(int j=0;j<4;j++){ total=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]; MAX=max(total,MAX); } } cout<

Initialize max_value = -63, as the minimun value of an hourglass can be only -63. No need to assign large negative value as -99999.

Tks buddy. I was expend a long time to try fix it. My solution to get the minor int allowed:

int maxHourGlass = -1 * (int) Math.pow(2,32);

You can actually set it to -63 as we sum up 7 values at a time, and the least these values can be is -9 as per the specs.

min = -63 = -9 * 7

lol I made this mistake the first time too.

The maximum value can be a negetaive number. So initialize the max values to -63 (-9 * 7) because there are 7 elements in the hour glass and all can take the value of -9 in some case whose sumn will be the least number.

cause the hourglass given by sum of 7 integer value from -9 to 9 . You should set max_value = -64 or lower . Sorry about my English is not good.

Instead we can initialize max value to -64 as the max negative we can obtain is 7*-9

I set the value to None (Python 3) and set the max_value the first time it is calculated. Others have suggested that setting the value to -63 (7 * -9) is sufficient, which it is, but what happens when the spec changes (real world) and now we need to reset the initial max_value to whatever the lowest possible value could be.

integer.MIN_VALUE works as well. Generally I am against 'magic numbers' so None or the absolute lowest known value make the solution more scalable IMHO.

pattern is everything (for pythoholics)

def hourglassSum(arr):

li=[]

for i in range(len(arr)-2):

    for j in range(len(arr)-2):

      li.append(sum(arr[i][j:j+3]+arr[i+2][j:j+3])+arr[i+1][j+1])

return max(li)

Yea, make sure to set max to whatever the first value is.

in C# you can initialize it like var maxValue = int.MinValue too.

thanks, you're awesome!

Or just use Integer.Min_Value

Since it's like initialized before starting to calculate hourglasses the best / simplest idea is to initialize it to the minimum integer value. In Java Integer.MIN_VALUE; in C++ climits::INT_MIN.

If your language doesn't have anything like this its an easy guess that the minimum value of a 32 bit signed integer can be used, since most languages use this as a default integer type.

Yes - remember your max value can very well turn out to be a negative number.

min value is -9 and we have 7 elements to sum. Therefore the sum cannot be less than -63. If you initialize to anything less than -63 you are good.

i have passed it even g=-1000

Brilliant!

//Similar to this Java :) List sum = new ArrayList(); for(int i=0; i<4; i++){ for(int j=0; j<4; j++){ sum.add(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]); } } System.out.println(Collections.max(sum)); }

Could you please explain!

One liner in Python 3:

print(max([sum(arr[i-1][j-1:j+2] + [arr[i][j]] + arr[i+1][j-1:j+2]) for j in range(1, 5) for i in range(1, 5)]))

My Attempt :)

A = []
S = []
[A.append(list(map(int, input().split()))) for i in range(6)]
[S.append(sum(A[i][j:j+3]+A[i+2][j:j+3])+A[i+1][j+1]) for i in range(4) for j in range(4)]
print(max(S))

awesome and cool:)

Python help me understand such questions easily

Even I thought of the same solution but it doesnt pass a lot of test cases

To save space, you can check for max sum with every calculation of the hourglass sum. So instead of having an array with all values and then comparing the max, we can get the result as we traverse :)

Nice simple solution! I feel stupid that I solved it with a 4D array now...

prefect pythonian solution

Why is range(len(arr)-2) ?

A similar NodeJS solution:

var sum = [];
    
    for (i = 0; i < arr.length - 2; i++) {
        for (j =0; j < arr.length - 2; j++) {
            sum.push(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]);
        }
    }
    
    console.log(Math.max(...sum));

amazing !

my approch has -1 calculation on each glass and no additional array sum. Look on it. . '''

def hourglassSum(arr):
len_arr = len(arr)
n=(len_arr-2)**2
s_max = None
for k in range(n):
i = k//(len_arr-2)
j = k%(len_arr-2)
if j==0: # new row glass sum
_ = sum((arr[i][0],arr[i][1],arr[i][2],
arr[i+1][1],
arr[i+2][0],arr[i+2][1],arr[i+2][2])
if(s_max is None):
s_max = _
else: # next glass in the same row sum calc
_ += (-arr[i][j-1]-arr[i+1][j]-arr[i+2][j-1] + \
arr[i][j+2]+arr[i+1][j+1]+arr[i+2][j+2])
s_max = max(s_max,_)
return s_max
'''

Here's a python3 one-liner.

max([sum(arr[j][i:i+3]) + arr[j+1][i+1] + sum(arr[j+2][i:i+3])
        for j in range(len(arr)-2) for i in range(len(arr[0])-1)])

This code uses list comprehension to build a list of hour glass sums. For the rows where 3 values are added, I used sum(arr[row][col:col+3]) then summed all values. The code starts at i, j = 0, 0 and I used the size of the array to limit the i and j terms. Think nested loop

thanks man, didn't realize this without your hint

This is true. I tried outputting the matrix to the screen in standard x,y format, it does not look like the input. This caused a lot of confusion and time wasted while debugging. IMO, Hackerrank should fix this.

It doesn't help that the initial test case passes when the indexing is switched.

That was the thing. Misleading pre provided scanning code. It scans by columns - not by rows - which I assume most would not expect. I was so sure mine was right but had no idea why certain test cases were failing. Only thing I had to change was to switch the for statements (outer to inner and inner to outer) and all test cases passed.

Yours is the most observant and helpful comment. Thanks much

thanks bro, you saved my day!!

2d matrix usually has array[row][column] format, not x,y

they are easy compared to the hard level problems. :)

I agree with milad. This one was harder than https://www.hackerrank.com/challenges/sparse-arrays?utm_campaign=challenge-recommendation&utm_medium=email&utm_source=3-day-campaign.

To make matter more complicated, I solved it by calculating the new hourglass value by subtracting out the old cells and adding the new cells, and made the hourglass size (3x3) configurable, and the array size configurable too. But even without this, it is harder than the one mentioned above.

True the question isn't easy.

I am guessing because you just have to brute force the solution. There is no smart/advanced way to get the answer.

It is easy! If not to you then this good practice for you so that later you will see that it is easy.

Hey awesome solution, just a quick question why use -Infinity

take a bow ..salute to ur code

Similar JavaScript solution:

function hourglassSum(arr) {
    let max = -63;

    for (let i = 0; i < 4; i++) {
        for (let j = 0; j < 4; j++) {
            let sum = arr[i + 1][j + 1];
            for (let k = 0; k < 3; k++) {
                sum += arr[i][j + k];
                sum += arr[i + 2][j + k]
            }
            if (sum > max) max = sum;
        }
    }

    return max;
}

WOW.. Genius!

This is the solution I found, i had the loop stop at +2 away from the current index instead of a maxX/maxY, and saved the sums of all the hourglasses in an array which was a unnesscary decision after looking at your code, my variable names are also very long which i think i should change, everyone else seems to use very short variables.

function hourglassSum(arr) {
        let top, mid, bottom = 0
        //looking back idk why i thought these were pyramids!!!
        let pyramid = [] 
        let innerPyramid= []

        function inOrder(a,b) {
                return a - b
        }

        // outer loop moves up and down
        for (const [index, value] of arr.entries()) {
                if(index+2 < arr.length){
                        //inner loop goes left to right
                        for(const [innerIndex, innerValue] of value.entries()){
                                if(innerIndex + 2 < value.length){
                                        //get the sum of the top 
                                        top = innerValue + value[innerIndex+1] + value[innerIndex+2]
                                        //get the sum of the mid
                                        mid = arr[index+1][innerIndex+1]
                                        //get the sum of the bottom
                                        bottom = arr[index+2][innerIndex]+arr[index+2][innerIndex+1]+arr[index+2][innerIndex+2]
                                        //get the sum of the entire hourglass
                                        innerPyramid[innerIndex] = top+mid+bottom
                                }else{
                                        break
                                }
                        }
                        //combine the two arrays
                        Array.prototype.push.apply(pyramid, innerPyramid)
                }else{
                        break
                }
        }
        return pyramid.sort(inOrder)[pyramid.length - 1]
}

the hourglass you bolded out is 1 + 1 + 9 + 2 = 13 you do not add the two outer 1's in the middle line with the three 1's above the line with 9

yeah same here.

Did the same thing essentially. Just shortened it.

arr = [[int(x) for x in input().split()] for _ in range(6)]
hoursum = lambda arr,r,c: sum(arr[r-1][c-1:c+2]) + arr[r][c] + sum(arr[r+1][c-1:c+2])
ans = max(hoursum(arr,r,c) for r in range(1,5) for c in range(1,5))
print(ans)

Wow this is amazing, I had like 50 lines of code. Thank you for this example, it is really helpful. I couldn't figure out how to make the range function work for me here but this makes SO much sense