Skip to content
Related Articles

Related Articles

Given an n x n square matrix, find sum of all sub-squares of size k x k

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 23 Jun, 2022
View Discussion
Improve Article
Save Article

Given an n x n square matrix, find sum of all sub-squares of size k x k where k is smaller than or equal to n. 

Examples : 

Input:
n = 5, k = 3
arr[][] = { {1, 1, 1, 1, 1},
            {2, 2, 2, 2, 2},
            {3, 3, 3, 3, 3},
            {4, 4, 4, 4, 4},
            {5, 5, 5, 5, 5},
         };
Output:
       18  18  18
       27  27  27
       36  36  36


Input:
n = 3, k = 2
arr[][] = { {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9},
         };
Output:
       12  16
       24  28

A Simple Solution is to one by one pick starting point (leftmost-topmost corner) of all possible sub-squares. Once the starting point is picked, calculate sum of sub-square starting with the picked starting point. 

Following is the implementation of this idea. 

C++




// A simple C++ program to find sum of all subsquares of
// size k x k
#include <iostream>
using namespace std;
 
// Size of given matrix
#define n 5
 
// A simple function to find sum of all sub-squares of size
// k x k in a given square matrix of size n x n
void printSumSimple(int mat[][n], int k)
{
    // k must be smaller than or equal to n
    if (k > n)
        return;
 
    // row number of first cell in current sub-square of
    // size k x k
    for (int i = 0; i < n - k + 1; i++) {
        // column of first cell in current sub-square of
        // size k x k
        for (int j = 0; j < n - k + 1; j++) {
            // Calculate and print sum of current sub-square
            int sum = 0;
            for (int p = i; p < k + i; p++)
                for (int q = j; q < k + j; q++)
                    sum += mat[p][q];
            cout << sum << "  ";
        }
 
        // Line separator for sub-squares starting with next
        // row
        cout << endl;
    }
}
 
// Driver program to test above function
int main()
{
    int mat[n][n] = {
        { 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2 },
        { 3, 3, 3, 3, 3 }, { 4, 4, 4, 4, 4 },
        { 5, 5, 5, 5, 5 },
    };
    int k = 3;
    printSumSimple(mat, k);
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


C




// A simple C program to find sum of all subsquares of
// size k x k
#include <stdio.h>
 
// Size of given matrix
#define n 5
 
// A simple function to find sum of all sub-squares of size
// k x k in a given square matrix of size n x n
void printSumSimple(int mat[][n], int k)
{
    // k must be smaller than or equal to n
    if (k > n)
        return;
 
    // row number of first cell in current sub-square of
    // size k x k
    for (int i = 0; i < n - k + 1; i++) {
        // column of first cell in current sub-square of
        // size k x k
        for (int j = 0; j < n - k + 1; j++) {
            // Calculate and print sum of current sub-square
            int sum = 0;
            for (int p = i; p < k + i; p++)
                for (int q = j; q < k + j; q++)
                    sum += mat[p][q];
            printf("%d ", sum);
        }
 
        // Line separator for sub-squares starting with next
        // row
        printf("\n");
    }
}
 
// Driver program to test above function
int main()
{
    int mat[n][n] = {
        { 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2 },
        { 3, 3, 3, 3, 3 }, { 4, 4, 4, 4, 4 },
        { 5, 5, 5, 5, 5 },
    };
    int k = 3;
    printSumSimple(mat, k);
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


Java




// A simple Java program to find sum of all
// subsquares of size k x k
class GFG {
 
    // Size of given matrix
    static final int n = 5;
 
    // A simple function to find sum of all
    // sub-squares of size k x k in a given
    // square matrix of size n x n
    static void printSumSimple(int mat[][], int k)
    {
 
        // k must be smaller than or equal to n
        if (k > n)
            return;
 
        // row number of first cell in current sub-square of
        // size k x k
        for (int i = 0; i < n - k + 1; i++) {
 
            // column of first cell in current sub-square of
            // size k x k
            for (int j = 0; j < n - k + 1; j++) {
 
                // Calculate and print sum of current
                // sub-square
                int sum = 0;
                for (int p = i; p < k + i; p++)
                    for (int q = j; q < k + j; q++)
                        sum += mat[p][q];
 
                System.out.print(sum + " ");
            }
 
            // Line separator for sub-squares starting with
            // next row
            System.out.println();
        }
    }
 
    // Driver Program to test above function
    public static void main(String arg[])
    {
        int mat[][] = { { 1, 1, 1, 1, 1 },
                        { 2, 2, 2, 2, 2 },
                        { 3, 3, 3, 3, 3 },
                        { 4, 4, 4, 4, 4 },
                        { 5, 5, 5, 5, 5 } };
        int k = 3;
        printSumSimple(mat, k);
    }
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


Python3




# A simple Python 3 program to find sum
# of all subsquares of size k x k
 
# Size of given matrix
n = 5
 
# A simple function to find sum of all
# sub-squares of size k x k in a given
# square matrix of size n x n
def printSumSimple(mat, k):
 
    # k must be smaller than or equal to n
    if (k > n):
        return
 
    # row number of first cell in current
    # sub-square of size k x k
    for i in range(n - k + 1):
     
        # column of first cell in current
        # sub-square of size k x k
        for j in range(n - k + 1):
             
            # Calculate and print sum of
            # current sub-square
            sum = 0
            for p in range(i, k + i):
                for q in range(j, k + j):
                    sum += mat[p][q]
            print(sum, end = " ")
     
        # Line separator for sub-squares
        # starting with next row
        print()
 
# Driver Code
if __name__ == "__main__":
 
    mat = [[1, 1, 1, 1, 1],
           [2, 2, 2, 2, 2],
           [3, 3, 3, 3, 3],
           [4, 4, 4, 4, 4],
           [5, 5, 5, 5, 5]]
    k = 3
    printSumSimple(mat, k)
 
# This code is contributed by ita_c


C#




// A simple C# program to find sum of all
// subsquares of size k x k
using System;
 
class GFG
{
    // Size of given matrix
    static int n = 5;
     
    // A simple function to find sum of all
    //sub-squares of size k x k in a given
    // square matrix of size n x n
    static void printSumSimple(int [,]mat, int k)
    {
        // k must be smaller than or
        // equal to n
        if (k > n) return;
         
        // row number of first cell in
        // current sub-square of size k x k
        for (int i = 0; i < n-k+1; i++)
        {
            // column of first cell in current
            // sub-square of size k x k
            for (int j = 0; j < n-k+1; j++)
            {
                // Calculate and print sum of
                // current sub-square
                int sum = 0;
                for (int p = i; p < k+i; p++)
                    for (int q = j; q < k+j; q++)
                        sum += mat[p,q];
 
                Console.Write(sum+ " ");
            }
         
            // Line separator for sub-squares
            // starting with next row
            Console.WriteLine();
        }
    }
     
    // Driver Program to test above function
    public static void Main()
    {
        int [,]mat = {{1, 1, 1, 1, 1},
                      {2, 2, 2, 2, 2},
                      {3, 3, 3, 3, 3},
                      {4, 4, 4, 4, 4},
                      {5, 5, 5, 5, 5}};
        int k = 3;
        printSumSimple(mat, k);
    }
}
 
// This code is contributed by Sam007


PHP




<?php
// A simple PHP program to find
// sum of all subsquares of size
// k x k
 
// Size of given matrix
$n = 5;
 
// function to find sum of all sub -
// squares of size k x k in a given
// square matrix of size n x n
function printSumSimple( $mat, $k)
{
    global $n;
     
    // k must be smaller than
    // or equal to n
    if ($k > $n) return;
     
    // row number of first cell in
    // current sub-square of size
    // k x k
    for($i = 0; $i < $n - $k + 1; $i++)
    {
         
        // column of first cell in
        // current sub-square of size
        // k x k
        for($j = 0; $j < $n - $k + 1; $j++)
        {
             
            // Calculate and print sum of
            // current sub-square
            $sum = 0;
            for ($p = $i; $p < $k + $i; $p++)
                for ($q = $j; $q < $k + $j; $q++)
                    $sum += $mat[$p][$q];
            echo $sum , " ";
        }
     
        // Line separator for sub-squares
        // starting with next row
        echo "\n";
    }
}
 
    // Driver Code
    $mat = array(array(1, 1, 1, 1, 1),
                 array(2, 2, 2, 2, 2,),
                  array(3, 3, 3, 3, 3,),
                 array(4, 4, 4, 4, 4,),
                 array(5, 5, 5, 5, 5));
                     
    $k = 3;
    printSumSimple($mat, $k);
 
// This code is contributed by anuj_67.
?>


Javascript




<script>
 
// A simple Javascript program to find sum of all
// subsquares of size k x k
     
    // Size of given matrix
    let n = 5;
     
    // A simple function to find sum of all
    //sub-squares of size k x k in a given
    // square matrix of size n x n
    function printSumSimple(mat,k)
    {
        // k must be smaller than or
        // equal to n
        if (k > n) return;
           
        // row number of first cell in
        // current sub-square of size k x k
        for (let i = 0; i < n-k+1; i++)
        {
               
            // column of first cell in current
            // sub-square of size k x k
            for (let j = 0; j < n-k+1; j++)
            {
                   
                // Calculate and print sum of
                // current sub-square
                let sum = 0;
                for (let p = i; p < k+i; p++)
                    for (let q = j; q < k+j; q++)
                        sum += mat[p][q];
   
                document.write(sum+ " ");
            }
           
            // Line separator for sub-squares
            // starting with next row
            document.write("<br>");
        }
    }
     
    // Driver Program to test above function
    let mat=[[1, 1, 1, 1, 1],
             [2, 2, 2, 2, 2],
             [3, 3, 3, 3, 3],
             [4, 4, 4, 4, 4],
             [5, 5, 5, 5, 5]]
    let k = 3;
    printSumSimple(mat, k);
     
    // This code is contributed by avanitrachhadiya2155
     
</script>


Output

18  18  18  
27  27  27  
36  36  36  

Time complexity of above solution is O(k2n2). We can solve this problem in O(n2) time using a Tricky Solution

The idea is to preprocess the given square matrix. In the preprocessing step, calculate sum of all vertical strips of size k x 1 in a temporary square matrix stripSum[][]. Once we have sum of all vertical strips, we can calculate sum of first sub-square in a row as sum of first k strips in that row, and for remaining sub-squares, we can calculate sum in O(1) time by removing the leftmost strip of previous subsquare and adding the rightmost strip of new square. 

Following is the implementation of this idea.  

C++




// An efficient C++ program to find sum of all subsquares of
// size k x k
#include <iostream>
using namespace std;
 
// Size of given matrix
#define n 5
 
// A O(n^2) function to find sum of all sub-squares of size
// k x k in a given square matrix of size n x n
void printSumTricky(int mat[][n], int k)
{
    // k must be smaller than or equal to n
    if (k > n)
        return;
 
    // 1: PREPROCESSING
    // To store sums of all strips of size k x 1
    int stripSum[n][n];
 
    // Go column by column
    for (int j = 0; j < n; j++) {
        // Calculate sum of first k x 1 rectangle in this
        // column
        int sum = 0;
        for (int i = 0; i < k; i++)
            sum += mat[i][j];
        stripSum[0][j] = sum;
 
        // Calculate sum of remaining rectangles
        for (int i = 1; i < n - k + 1; i++) {
            sum += (mat[i + k - 1][j] - mat[i - 1][j]);
            stripSum[i][j] = sum;
        }
    }
 
    // 2: CALCULATE SUM of Sub-Squares using stripSum[][]
    for (int i = 0; i < n - k + 1; i++) {
        // Calculate and print sum of first subsquare in
        // this row
        int sum = 0;
        for (int j = 0; j < k; j++)
            sum += stripSum[i][j];
        cout << sum << "  ";
 
        // Calculate sum of remaining squares in current row
        // by removing the leftmost strip of previous
        // sub-square and adding a new strip
        for (int j = 1; j < n - k + 1; j++) {
            sum += (stripSum[i][j + k - 1]
                    - stripSum[i][j - 1]);
            cout << sum << "  ";
        }
 
        cout << endl;
    }
}
 
// Driver program to test above function
int main()
{
    int mat[n][n] = {
        { 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2 },
        { 3, 3, 3, 3, 3 }, { 4, 4, 4, 4, 4 },
        { 5, 5, 5, 5, 5 },
    };
    int k = 3;
    printSumTricky(mat, k);
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


C




// An efficient C program to find sum of all subsquares of
// size k x k
#include <stdio.h>
 
// Size of given matrix
#define n 5
 
// A O(n^2) function to find sum of all sub-squares of size
// k x k in a given square matrix of size n x n
void printSumTricky(int mat[][n], int k)
{
    // k must be smaller than or equal to n
    if (k > n)
        return;
 
    // 1: PREPROCESSING
    // To store sums of all strips of size k x 1
    int stripSum[n][n];
 
    // Go column by column
    for (int j = 0; j < n; j++) {
        // Calculate sum of first k x 1 rectangle in this
        // column
        int sum = 0;
        for (int i = 0; i < k; i++)
            sum += mat[i][j];
        stripSum[0][j] = sum;
 
        // Calculate sum of remaining rectangles
        for (int i = 1; i < n - k + 1; i++) {
            sum += (mat[i + k - 1][j] - mat[i - 1][j]);
            stripSum[i][j] = sum;
        }
    }
 
    // 2: CALCULATE SUM of Sub-Squares using stripSum[][]
    for (int i = 0; i < n - k + 1; i++) {
        // Calculate and print sum of first subsquare in
        // this row
        int sum = 0;
        for (int j = 0; j < k; j++)
            sum += stripSum[i][j];
        printf("%d ", sum);
 
        // Calculate sum of remaining squares in current row
        // by removing the leftmost strip of previous
        // sub-square and adding a new strip
        for (int j = 1; j < n - k + 1; j++) {
            sum += (stripSum[i][j + k - 1]
                    - stripSum[i][j - 1]);
            printf("%d ", sum);
        }
 
        printf("\n");
    }
}
 
// Driver program to test above function
int main()
{
    int mat[n][n] = {
        { 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2 },
        { 3, 3, 3, 3, 3 }, { 4, 4, 4, 4, 4 },
        { 5, 5, 5, 5, 5 },
    };
    int k = 3;
    printSumTricky(mat, k);
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


Java




// An efficient Java program to find sum of all subsquares
// of size k x k
import java.io.*;
 
class GFG {
 
    // Size of given matrix
    static int n = 5;
 
    // A O(n^2) function to find sum of all sub-squares of
    // size k x k in a given square matrix of size n x n
    static void printSumTricky(int mat[][], int k)
    {
 
        // k must be smaller than or equal to n
        if (k > n)
            return;
 
        // 1: PREPROCESSING
        // To store sums of all strips of size k x 1
        int stripSum[][] = new int[n][n];
 
        // Go column by column
        for (int j = 0; j < n; j++) {
 
            // Calculate sum of first k x 1 rectangle in
            // this column
            int sum = 0;
            for (int i = 0; i < k; i++)
                sum += mat[i][j];
            stripSum[0][j] = sum;
 
            // Calculate sum of remaining rectangles
            for (int i = 1; i < n - k + 1; i++) {
                sum += (mat[i + k - 1][j] - mat[i - 1][j]);
                stripSum[i][j] = sum;
            }
        }
 
        // 2: CALCULATE SUM of Sub-Squares
        // using stripSum[][]
        for (int i = 0; i < n - k + 1; i++) {
 
            // Calculate and print sum of first
            // subsquare in this row
            int sum = 0;
            for (int j = 0; j < k; j++)
                sum += stripSum[i][j];
            System.out.print(sum + " ");
 
            // Calculate sum of remaining squares in current
            // row by removing the leftmost strip of
            // previous sub-square and adding a new strip
            for (int j = 1; j < n - k + 1; j++) {
                sum += (stripSum[i][j + k - 1]
                        - stripSum[i][j - 1]);
                System.out.print(sum + " ");
            }
            System.out.println();
        }
    }
 
    // Driver program to test above function
    public static void main(String[] args)
    {
        int mat[][] = {
            { 1, 1, 1, 1, 1 }, { 2, 2, 2, 2, 2 },
            { 3, 3, 3, 3, 3 }, { 4, 4, 4, 4, 4 },
            { 5, 5, 5, 5, 5 },
        };
        int k = 3;
        printSumTricky(mat, k);
    }
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


Python3




# An efficient Python3 program to find sum
# of all subsquares of size k x k
 
# A O(n^2) function to find sum of all 
# sub-squares of size k x k in a given
# square matrix of size n x n
def printSumTricky(mat, k):
    global n
     
    # k must be smaller than or
    # equal to n
    if k > n:
        return
 
    # 1: PREPROCESSING
    # To store sums of all strips of size k x 1
    stripSum = [[None] * n for i in range(n)]
 
    # Go column by column
    for j in range(n):
         
        # Calculate sum of first k x 1
        # rectangle in this column
        Sum = 0
        for i in range(k):
            Sum += mat[i][j]
        stripSum[0][j] = Sum
 
        # Calculate sum of remaining rectangles
        for i in range(1, n - k + 1):
            Sum += (mat[i + k - 1][j] -
                    mat[i - 1][j])
            stripSum[i][j] = Sum
 
    # 2: CALCULATE SUM of Sub-Squares
    # using stripSum[][]
    for i in range(n - k + 1):
         
        # Calculate and print sum of first
        # subsquare in this row
        Sum = 0
        for j in range(k):
            Sum += stripSum[i][j]
        print(Sum, end = " ")
 
        # Calculate sum of remaining squares
        # in current row by removing the leftmost 
        # strip of previous sub-square and adding
        # a new strip
        for j in range(1, n - k + 1):
            Sum += (stripSum[i][j + k - 1] -
                    stripSum[i][j - 1])
            print(Sum, end = " ")
 
        print()
 
# Driver Code
n = 5
mat = [[1, 1, 1, 1, 1],
       [2, 2, 2, 2, 2],
       [3, 3, 3, 3, 3],
       [4, 4, 4, 4, 4],
       [5, 5, 5, 5, 5]]
k = 3
printSumTricky(mat, k)
 
# This code is contributed by PranchalK


C#




// An efficient C# program to find
// sum of all subsquares of size k x k
using System;
class GFG {
     
    // Size of given matrix
    static int n = 5;
     
    // A O(n^2) function to find sum of all
    // sub-squares of size k x k in a given
    // square matrix of size n x n
    static void printSumTricky(int [,]mat, int k)
    {
         
        // k must be smaller than or equal to n
        if (k > n)
        return;
     
        // 1: PREPROCESSING
        // To store sums of all strips of
        // size k x 1
        int [,]stripSum = new int[n,n];
     
        // Go column by column
        for (int j = 0; j < n; j++)
        {
             
            // Calculate sum of first k x 1
            // rectangle in this column
            int sum = 0;
            for (int i = 0; i < k; i++)
                sum += mat[i,j];
                 
            stripSum[0,j] = sum;
         
            // Calculate sum of remaining
            // rectangles
            for (int i = 1; i < n - k + 1; i++)
            {
                sum += (mat[i + k - 1,j]
                               - mat[i - 1,j]);
                stripSum[i,j] = sum;
            }
        }
     
        // 2: CALCULATE SUM of Sub-Squares
        // using stripSum[][]
        for (int i = 0; i < n - k + 1; i++)
        {
             
            // Calculate and print sum of first
            // subsquare in this row
            int sum = 0;
            for (int j = 0; j < k; j++)
                sum += stripSum[i,j];
                 
            Console.Write(sum + " ");
         
            // Calculate sum of remaining
            // squares in current row by
            // removing the leftmost strip
            // of previous sub-square
            // and adding a new strip
            for (int j = 1; j < n - k + 1; j++)
            {
                sum += (stripSum[i,j + k - 1]
                           - stripSum[i,j - 1]);
                Console.Write(sum + " ");
            }
            Console.WriteLine();
        }
    }
     
    // Driver program to test above function
    public static void Main()
    {
        int [,]mat = {{1, 1, 1, 1, 1},
                    {2, 2, 2, 2, 2},
                    {3, 3, 3, 3, 3},
                    {4, 4, 4, 4, 4},
                    {5, 5, 5, 5, 5},
                    };
        int k = 3;
        printSumTricky(mat, k);
    }
}
 
// This code is contributed by nitin mittal.


PHP




<?php
// An efficient PHP program to
// find sum of all subsquares
// of size k x k
 
// Size of given matrix
$n = 5;
 
// A O(n^2) function to find
// sum of all sub-squares of
// size k x k in a given
// square matrix of size n x n
function printSumTricky($mat, $k)
{
global $n;
 
// k must be smaller
// than or equal to n
if ($k > $n) return;
 
// 1: PREPROCESSING
// To store sums of all
// strips of size k x 1
$stripSum = array(array());
 
// Go column by column
for ($j = 0; $j < $n; $j++)
{
    // Calculate sum of first
    // k x 1 rectangle in this column
    $sum = 0;
    for ($i = 0; $i < $k; $i++)
        $sum += $mat[$i][$j];
    $stripSum[0][$j] = $sum;
 
    // Calculate sum of
    // remaining rectangles
    for ($i = 1; $i < $n - $k + 1; $i++)
    {
            $sum += ($mat[$i + $k - 1][$j] -
                          $mat[$i - 1][$j]);
            $stripSum[$i][$j] = $sum;
    }
}
 
// 2: CALCULATE SUM of
// Sub-Squares using stripSum[][]
for ($i = 0; $i < $n - $k + 1; $i++)
{
    // Calculate and print sum of
    // first subsquare in this row
    $sum = 0;
    for ($j = 0; $j < $k; $j++)
        $sum += $stripSum[$i][$j];
    echo $sum , " ";
 
    // Calculate sum of remaining
    // squares in current row by
    // removing the leftmost strip
    // of previous sub-square and
    // adding a new strip
    for ($j = 1; $j < $n - $k + 1; $j++)
    {
        $sum += ($stripSum[$i][$j + $k - 1] -
                 $stripSum[$i][$j - 1]);
        echo $sum , " ";
    }
 
    echo "\n";
}
}
 
// Driver Code
$mat = array(array(1, 1, 1, 1, 1),
             array(2, 2, 2, 2, 2),
             array(3, 3, 3, 3, 3),
             array(4, 4, 4, 4, 4),
             array(5, 5, 5, 5, 5));
$k = 3;
printSumTricky($mat, $k);
 
// This code is contributed by anuj_67.
?>


Javascript




<script>
 
// An efficient Javascript program to find
// sum of all subsquares of size k x k   
 
// Size of given matrix
let n = 5;
 
// A O(n^2) function to find sum of all
// sub-squares of size k x k in a given
// square matrix of size n x n
function printSumTricky(mat, k)
{
     
    // k must be smaller than or equal to n
    if (k > n)
        return;
     
    // 1: PREPROCESSING
    // To store sums of all strips of size k x 1
    let stripSum = new Array(n);
    for(let i = 0; i < n; i++)
    {
        stripSum[i] = new Array(n);
    }
     
    for(let i = 0; i < n; i++)
    {
        for(let j = 0; j < n; j++)
        {
            stripSum[i][j] = 0;
        }
    }
     
    // Go column by column
    for(let j = 0; j < n; j++)
    {
          
        // Calculate sum of first k x 1
        // rectangle in this column
        let sum = 0;
        for(let i = 0; i < k; i++)
            sum += mat[i][j];
             
        stripSum[0][j] = sum;
      
        // Calculate sum of remaining rectangles
        for(let i = 1; i < n - k + 1; i++)
        {
            sum += (mat[i + k - 1][j] - mat[i - 1][j]);
            stripSum[i][j] = sum;
        }
    }
  
    // 2: CALCULATE SUM of Sub-Squares
    // using stripSum[][]
    for(let i = 0; i < n - k + 1; i++)
    {
          
        // Calculate and print sum of first
        // subsquare in this row
        let sum = 0;
        for (let j = 0; j < k; j++)
            sum += stripSum[i][j];
             
        document.write(sum + " ");
      
        // Calculate sum of remaining squares
        // in current row by removing the
        // leftmost strip of previous sub-square
        // and adding a new strip
        for(let j = 1; j < n - k + 1; j++)
        {
            sum += (stripSum[i][j + k - 1] -
                    stripSum[i][j - 1]);
            document.write(sum + " ");
        }
        document.write("<br>");
    }
}
 
// Driver code
let mat = [ [ 1, 1, 1, 1, 1 ],
            [ 2, 2, 2, 2, 2 ],
            [ 3, 3, 3, 3, 3 ],
            [ 4, 4, 4, 4, 4 ],
            [ 5, 5, 5, 5, 5 ] ];
let k = 3;
printSumTricky(mat, k);
 
// This code is contributed by rag2127
 
</script>


Output

18  18  18  
27  27  27  
36  36  36  

Time complexity: O(n2).
Auxiliary Space: O(n2).


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!