2D Array - DS Discussions | Data Structures

Sort 3329 Discussions, By:

9 minutes ago+ 0 comments

It's not the dryest one but it works for all cases. Python. I'm not sure if it's an easy level. If you code it dynamically - no, it's not. If hardcoded - maybe.

def top_bottom(arr, i=None):
    #retrieving tops and bottoms 
    if i is None:
        i = 0
    j = 0
    summ = []
    for j in range(0, len(arr[0]) - 2):
        summ.append(arr[i][j] + arr[i][j + 1] + arr[i][j + 2])
        j += 1
    return summ

def middle(arr, i=None):
    #retrieving middles 
	if i is None:
		i = 0
    summ = []
    for n in range(1, len(arr[0]) - 1):
            summ.append(arr[i][n])
            n += 1
    return summ

def hourglassSum(arr):
    #merging, counting
    x = lambda arr: [top_bottom(arr, y) for y in range(len(arr))]
    y = lambda arr: [middle(arr, y) for y in range(1, len(arr) - 1)]
    arr1, arr2, total = x(arr), y(arr), []
    for i in range(0, len(arr2)):
        for j in range(0, len(arr2)):
            total.append(arr1[i][j] + arr2[i][j] + arr1[i+2][j])
            j += 1
    return max(total)

10 hours ago+ 0 comments

maxx=-99 for i in range(len(arr)-2):

    for j in range(len(arr)-2):
        a=arr[i][j]
        b=arr[i][j+1]
        c=arr[i][j+2]
        d=arr[i+1][j+1]
        e=arr[i+2][j]
        f=arr[i+2][j+1]
        g=arr[i+2][j+2]
        sum=a+b+c+d+e+f+g
        maxx=max(sum,maxx)
return maxx

2 days ago+ 1 comment

Java

 public static int hourglassSum(List<List<Integer>> arr) {
        int maxSumHourGlass = Integer.MIN_VALUE;
          for (int p = 0; p <= 3; p++) {     
                for (int q = 0; q <= 3; q++) {
                    int sumOfOneHourglass = 0;                  
                    sumOfOneHourglass = arr.get(p).get(q) + 
                                        arr.get(p).get(q + 1) + 
                                        arr.get(p).get(q + 2)  + 
                                        arr.get(p + 1).get(q + 1) + 
                                        arr.get(p + 2).get(q) + 
                                        arr.get(p + 2).get(q + 1) +
                                        arr.get(p + 2).get(q + 2);
                    if (maxSumHourGlass < sumOfOneHourglass) {
                        maxSumHourGlass = sumOfOneHourglass;
                    }               
                }
            } 
            return maxSumHourGlass;           
    }

2 days ago+ 0 comments

function hourglassSum(arr: number[][]): number {
    // flatten array 
    const result: number[] = arr.reduce((accumulator, value) => accumulator.concat(value), []);
    const extractHourGlass = (arr: number[], startIndex: number) => {
        return arr.slice(startIndex, startIndex+3)
            .concat(arr.slice(startIndex+7, startIndex+8))
            .concat(arr.slice(startIndex+12, startIndex+15));
    }
    const startIndces: number[] = [0,1,2,3,
                                   6,7,8,9,
                                   12,13,14,15,
                                   18,19,20,21];
    const hourglassSums: number[] = startIndces.map<number>((x) => {
        return extractHourGlass(result, x).reduce<number>((j, v) => {
            return j + v;
        }, 0)
    }, 0)
    console.log(hourglassSums);
    return Math.max(...hourglassSums);
}

2 days ago+ 0 comments

my JavaScript solution (h= horizontal and v=vertical direction).

function hourglassSum(arr) {
    let h= 0;
    let v= 0;
    let sum =0;
    let max=Number.MIN_SAFE_INTEGER;
    while ((h+2) < arr.length) {
        v=0;
        while ((v+2) < arr.length) {
            sum=0;
            for (let i=0+h ; i < (3+h); i++) {
                sum = sum + arr[v][i];
                sum = sum + arr[v+2][i];
            }
            sum = sum + arr[v+1][h+1];
            
            if (sum > max) {
                max= sum;
            }
            v++;
        }
       h++; 
    }
    
   return max;
}

Load more conversations