Sum of all parts of a square Matrix divided by its diagonals

Given a 2D matrix arr[][] of N*N dimensions, the task is to find the sum of elements of all four parts of the matrix divided by the diagonals without including the diagonal elements in any of the four parts.

Example:

Input: arr[][] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }
Output: 2 4 6 8
Explanation:
(1, 5, 9) and (3, 5, 7) are diagonals of arr[][] matrix. Therefore sum of parts are:
Top = 2
Left = 4
Right = 6
Bottom = 8

Input: arr[][] = { {1, 3, 1, 5}, {2, 2, 4, 1}, {5, 0, 2, 3}, { 1, 3, 3, 5} }
Output: 4 7 4 6
Explanation:
(1, 2, 2, 5) and (5, 4, 0, 1) are diagonals of arr[][] matrix. Therefore sum of parts are:
Top = 3 + 1 = 4
Left = 2 + 5 = 7
Right = 1 + 3 = 4
Bottom = 3 + 3 = 6

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

As shown in the above figure, After the matrix of size NxN is divided by diagonals. We observe the following properties:

1. If sum of index of row and column is less than N – 1 then, it belongs to either Top part or Left part.
• If column index is greater than row index it belongs to Top part.
• Else it belongs to Left part.
2. Else it belongs to either Right part or Down part.
• If column index is greater than row index it belongs to Right part.
• Else it belongs to Down part.

Below is the implementation of the above approach:

 `// C++ program for the above approach ` `#include "bits/stdc++.h" ` `using` `namespace` `std; ` ` `  `// Function to calculate the ` `// sum of all parts of matrix ` `void` `SumOfPartsOfMetrics(``int``* arr, ` `                         ``int` `N) ` `{ ` ` `  `    ``// To store the sum of all four ` `    ``// parts of the diagonals ` `    ``int` `top, bottom, left, right; ` ` `  `    ``// Intialise respective sum ` `    ``// as zero ` `    ``top = bottom = right = left = 0; ` ` `  `    ``// Traversing the matrix ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``for` `(``int` `j = 0; j < N; j++) { ` ` `  `            ``// If i + j < N -1 ` `            ``// then it belongs to ` `            ``// top or left ` `            ``if` `(i + j < N - 1 && i != j) { ` ` `  `                ``// Belongs to top ` `                ``if` `(i < j) { ` `                    ``top += (arr + i * N)[j]; ` `                ``} ` ` `  `                ``// Belongs to left ` `                ``else` `{ ` `                    ``left += (arr + i * N)[j]; ` `                ``} ` `            ``} ` ` `  `            ``// If i+j > N - 1 then ` `            ``// it belongs to right ` `            ``// or bottom ` `            ``else` `if` `(i + j > N - 1 && i != j) { ` ` `  `                ``// Belongs to right ` `                ``if` `(i > j) { ` `                    ``bottom += (arr + i * N)[j]; ` `                ``} ` ` `  `                ``// Belongs to bottom ` `                ``else` `{ ` `                    ``right += (arr + i * N)[j]; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `    ``cout << top << ``' '` `<< left ` `         ``<< ``' '` `<< right << ``' '` `         ``<< bottom << endl; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N = 4; ` `    ``int` `arr[N][N] = { { 1, 3, 1, 5 }, ` `                      ``{ 2, 2, 4, 1 }, ` `                      ``{ 5, 0, 2, 3 }, ` `                      ``{ 1, 3, 3, 5 } }; ` `    ``// Function call to find print ` `    ``// sum of al parts ` `    ``SumOfPartsOfMetrics((``int``*)arr, N); ` `    ``return` `0; ` `} `

 `// Java program for the above approach  ` `class` `GFG { ` ` `  `// Function to calculate the  ` `// sum of all parts of matrix  ` `static` `void` `SumOfPartsOfMetrics(``int` `[][]arr,  ` `                                ``int` `N)  ` `{  ` `     `  `    ``// To store the sum of all four  ` `    ``// parts of the diagonals  ` `    ``// Intialise respective sum  ` `    ``// as zero  ` `    ``int` `top = ``0``, bottom = ``0``; ` `    ``int` `left = ``0``, right = ``0``;  ` ` `  `    ``// Traversing the matrix  ` `    ``for``(``int` `i = ``0``; i < N; i++) ` `    ``{  ` `       ``for``(``int` `j = ``0``; j < N; j++) ` `       ``{  ` `           `  `          ``// If i + j < N -1  ` `          ``// then it belongs to  ` `          ``// top or left  ` `          ``if` `(i + j < N - ``1` `&& i != j) ` `          ``{  ` `               `  `              ``// Belongs to top  ` `              ``if` `(i < j) ` `              ``{  ` `                  ``top += arr[i][j];  ` `              ``}  ` `               `  `              ``// Belongs to left  ` `              ``else` `              ``{  ` `                  ``left += arr[i][j];  ` `              ``}  ` `          ``}  ` `           `  `          ``// If i+j > N - 1 then  ` `          ``// it belongs to right  ` `          ``// or bottom  ` `          ``else` `if` `(i + j > N - ``1` `&& i != j) ` `          ``{  ` `               `  `              ``// Belongs to right  ` `              ``if` `(i > j) ` `              ``{  ` `                  ``bottom += arr[i][j];  ` `              ``}  ` `               `  `              ``// Belongs to bottom  ` `              ``else`  `              ``{  ` `                  ``right += arr[i][j];  ` `              ``}  ` `          ``}  ` `       ``}  ` `    ``}  ` `    ``System.out.println(top + ``" "` `+ left + ``" "` `+ ` `                     ``right + ``" "` `+ bottom);  ` `}  ` `     `  `// Driver Code  ` `public` `static` `void` `main (String[] args)  ` `{  ` `    ``int` `N = ``4``;  ` `    ``int` `arr[][] = { { ``1``, ``3``, ``1``, ``5` `},  ` `                    ``{ ``2``, ``2``, ``4``, ``1` `},  ` `                    ``{ ``5``, ``0``, ``2``, ``3` `},  ` `                    ``{ ``1``, ``3``, ``3``, ``5` `} };  ` `                         `  `    ``// Function call to find print  ` `    ``// sum of al parts  ` `    ``SumOfPartsOfMetrics(arr, N);  ` `}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

 `# Python3 program for the above approach  ` ` `  `# Function to calculate the  ` `# sum of all parts of matrix  ` `def` `SumOfPartsOfMetrics(arr, N):  ` ` `  `    ``# To store the sum of all four  ` `    ``# parts of the diagonals  ` `    ``# Intialise respective sum  ` `    ``# as zero  ` `    ``top ``=` `bottom ``=` `right ``=` `left ``=` `0``;  ` ` `  `    ``# Traversing the matrix  ` `    ``for` `i ``in` `range``(N): ` `        ``for` `j ``in` `range``(N): ` ` `  `            ``# If i + j < N -1  ` `            ``# then it belongs to  ` `            ``# top or left  ` `            ``if` `(i ``+` `j < N ``-` `1` `and` `i !``=` `j): ` ` `  `                ``# Belongs to top  ` `                ``if` `(i < j): ` `                    ``top ``+``=` `arr[i][j];  ` `             `  `                ``# Belongs to left  ` `                ``else``: ` `                    ``left ``+``=` `arr[i][j];  ` ` `  `            ``# If i+j > N - 1 then  ` `            ``# it belongs to right  ` `            ``# or bottom  ` `            ``elif` `(i ``+` `j > N ``-` `1` `and` `i !``=` `j): ` ` `  `                ``# Belongs to right  ` `                ``if` `(i > j): ` `                    ``bottom ``+``=` `arr[i][j];  ` ` `  `                ``# Belongs to bottom  ` `                ``else``: ` `                    ``right ``+``=` `arr[i][j];  ` `             `  `    ``print``(top, left, right, bottom);  ` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``N ``=` `4``;  ` `    ``arr ``=` `[ [ ``1``, ``3``, ``1``, ``5` `],  ` `            ``[ ``2``, ``2``, ``4``, ``1` `],  ` `            ``[ ``5``, ``0``, ``2``, ``3` `],  ` `            ``[ ``1``, ``3``, ``3``, ``5` `] ]; ` `             `  `    ``# Function call to find print  ` `    ``# sum of al parts  ` `    ``SumOfPartsOfMetrics(arr, N);  ` `     `  `# This code is contributed by AnkitRai01 `

 `// C# program for the above approach  ` `using` `System; ` ` `  `class` `GFG { ` ` `  `// Function to calculate the  ` `// sum of all parts of matrix  ` `static` `void` `SumOfPartsOfMetrics(``int` `[,]arr,  ` `                                ``int` `N)  ` `{  ` `         `  `    ``// To store the sum of all four  ` `    ``// parts of the diagonals  ` `    ``// Intialise respective sum  ` `    ``// as zero  ` `    ``int` `top = 0, bottom = 0; ` `    ``int` `left = 0, right = 0;  ` `     `  `    ``// Traversing the matrix  ` `    ``for``(``int` `i = 0; i < N; i++) ` `    ``{  ` `       ``for``(``int` `j = 0; j < N; j++) ` `       ``{  ` ` `  `          ``// If i + j < N -1  ` `          ``// then it belongs to  ` `          ``// top or left  ` `          ``if` `(i + j < N - 1 && i != j) ` `          ``{  ` `               `  `              ``// Belongs to top  ` `              ``if` `(i < j) ` `              ``{ ` `                  ``top += arr[i, j];  ` `              ``}  ` `               `  `              ``// Belongs to left  ` `              ``else` `              ``{  ` `                  ``left += arr[i, j];  ` `              ``}  ` `          ``}  ` `           `  `          ``// If i+j > N - 1 then  ` `          ``// it belongs to right  ` `          ``// or bottom  ` `          ``else` `if` `(i + j > N - 1 && i != j) ` `          ``{  ` `                 `  `            ``// Belongs to right  ` `            ``if` `(i > j) ` `            ``{  ` `                ``bottom += arr[i, j];  ` `            ``}  ` `             `  `            ``// Belongs to bottom  ` `            ``else` `            ``{  ` `                ``right += arr[i, j];  ` `            ``}  ` `          ``}  ` `       ``}  ` `    ``}  ` `    ``Console.WriteLine(top + ``" "` `+ left + ``" "` `+ ` `                    ``right + ``" "` `+ bottom);  ` `}  ` `         `  `// Driver Code  ` `public` `static` `void` `Main (``string``[] args)  ` `{  ` `    ``int` `N = 4;  ` `    ``int` `[,]arr = { { 1, 3, 1, 5 },  ` `                   ``{ 2, 2, 4, 1 },  ` `                   ``{ 5, 0, 2, 3 },  ` `                   ``{ 1, 3, 3, 5 } };  ` `                             `  `    ``// Function call to find print  ` `    ``// sum of al parts  ` `    ``SumOfPartsOfMetrics(arr, N);  ` `}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

Output:
```4 7 4 6
```

Time Complexity: O(N2)

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : AnkitRai01

Article Tags :
Practice Tags :