Skip to content
Related Articles

Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Sum of non-diagonal parts of a square Matrix

  • Difficulty Level : Basic
  • Last Updated : 08 Apr, 2021

Given a square matrix of size N X N, the task is to find the sum of all elements at each portion when the matrix is divided into four parts along its diagonals. The elements at the diagonals should not be counted in the sum.
Examples: 
 

Input: arr[][] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}} 
Output: 68 
Explanation: 
 

Attention reader! All those who say programming isn't for kids, just haven't met the right mentors yet. Join the  Demo Class for First Step to Coding Course, specifically designed for students of class 8 to 12. 

The students will get to learn more about the world of programming in these free classes which will definitely help them in making a wise career choice in the future.



From the above image, (1, 6, 11, 16) and (4, 7, 10, 13) are the diagonals. 
The sum of the elements needs to be found are: 
Top: (2 + 3) = 5 
Left: (5 + 9) = 14 
Bottom: (14 + 15) = 29 
Right: (8 + 12) = 20 
Therefore, sum of all parts = 68.
Input: arr[][] = { {1, 3, 1, 5}, {2, 2, 4, 1}, {5, 0, 2, 3}, {1, 3, 1, 5}} 
Output: 19 
 

 

Approach: The idea is to use indexing to identify the elements at the diagonals. 
 

  1. In a 2-dimensional matrix, two diagonals are identified in the following way: 
    1. Principal Diagonal: The first diagonal has the index of the row is equal to the index of the column. 
       
Condition for Principal Diagonal:
The row-column condition is row = column.
  1.  
  2. Secondary Diagonal: The second diagonal has the sum of the index of row and column equal to N(size of the matrix). 
     
Condition for Secondary Diagonal:
The row-column condition is row = numberOfRows - column -1
  1.  
  2. After identifying both the diagonals, the matrix can further be divided into two parts using the diagonal passing through the first element of the last row and the last element of the first row: 
    1. The left part: 
      • If the column index is greater than row index, the element belongs to the top portion of the matrix.
      • If the row index is greater than column index, the element belongs to the left portion of the matrix.
    2. The right part: 
      • If the column index is greater than row index, the element belongs to the right portion of the matrix.
      • If the row index is greater than column index, the element belongs to the bottom portion of the matrix.

  1. So in order to get the sum of the non-diagonal parts of the matrix: 
    • Traverse the matrix rowwise
    • If the element is a part of diagonal, then skip this element
    • If the element is part of the left, right, bottom, or top part (i.e. non-diagonal parts), add the the element in the resultant sum

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to return a vector which
// consists the sum of
// four portions of the matrix
int sumOfParts(int* arr, int N)
{
    int sum_part1 = 0, sum_part2 = 0,
        sum_part3 = 0, sum_part4 = 0;
    int totalsum = 0;
 
    // Iterating through the matrix
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
 
            // Condition for selecting all values
            // before the second diagonal of metrics
            if (i + j < N - 1) {
 
                // Top portion of the matrix
                if (i < j and i != j and i + j)
                    sum_part1 += (arr + i * N)[j];
 
                // Left portion of the matrix
                else if (i != j)
                    sum_part2 += (arr + i * N)[j];
            }
            else {
 
                // Bottom portion of the matrix
                if (i > j and i + j != N - 1)
                    sum_part3 += (arr + i * N)[j];
 
                // Right portion of the matrix
                else {
                    if (i + j != N - 1 and i != j)
                        sum_part4 += (arr + i * N)[j];
                }
            }
        }
    }
 
    // Adding all the four portions into a vector
    totalsum = sum_part1 + sum_part2
               + sum_part3 + sum_part4;
    return totalsum;
}
 
// Driver code
int main()
{
    int N = 4;
    int arr[N][N] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
 
    cout << sumOfParts((int*)arr, N);
}
Java



// Java implementation of the above approach
class GFG
{
  
// Function to return a vector which
// consists the sum of
// four portions of the matrix
static int sumOfParts(int[][] arr, int N)
{
    int sum_part1 = 0, sum_part2 = 0,
        sum_part3 = 0, sum_part4 = 0;
    int totalsum = 0;
  
    // Iterating through the matrix
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
  
            // Condition for selecting all values
            // before the second diagonal of metrics
            if (i + j < N - 1) {
  
                // Top portion of the matrix
                if (i < j && i != j && i + j > 0)
                    sum_part1 += arr[i][j];
  
                // Left portion of the matrix
                else if (i != j)
                    sum_part2 += arr[i][j];
            }
            else {
  
                // Bottom portion of the matrix
                if (i > j && i + j != N - 1)
                    sum_part3 += arr[i][j];
  
                // Right portion of the matrix
                else {
                    if (i + j != N - 1 && i != j)
                        sum_part4 += arr[i][j];
                }
            }
        }
    }
  
    // Adding all the four portions into a vector
    totalsum = sum_part1 + sum_part2
               + sum_part3 + sum_part4;
    return totalsum;
}
  
// Driver code
public static void main(String[] args)
{
    int N = 4;
    int arr[][] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
  
    System.out.print(sumOfParts(arr, N));
}
}
 
// This code is contributed by PrinciRaj1992
Python3



# Python3 implementation of the above approach
 
# Function to return a vector which
# consists the sum of
# four portions of the matrix
def sumOfParts(arr,N):
    sum_part1, sum_part2, sum_part3, \
    sum_part4 = 0, 0, 0, 0
    totalsum = 0
 
    # Iterating through the matrix
    for i in range(N):
        for j in range(N):
             
            # Condition for selecting all values
            # before the second diagonal of metrics
            if i + j < N - 1:
                 
                # Top portion of the matrix
                if(i < j and i != j and i + j):
                    sum_part1 += arr[i][j]
                 
                # Left portion of the matrix
                elif i != j:
                    sum_part2 += arr[i][j]
            else:
                 
                # Bottom portion of the matrix
                if i > j and i + j != N - 1:
                    sum_part3 += arr[i][j]
                else:
                     
                # Right portion of the matrix
                    if i + j != N - 1 and i != j:
                        sum_part4 += arr[i][j]
        # Adding all the four portions into a vecto
    return sum_part1 + sum_part2 + sum_part3 + sum_part4
 
# Driver code
N = 4
arr = [[ 1, 2, 3, 4 ],
       [ 5, 6, 7, 8 ],
       [ 9, 10, 11, 12 ],
       [ 13, 14, 15, 16 ]]
 
print(sumOfParts(arr, N))
 
# This code is contributed by mohit kumar 29
C#



// C# implementation of the above approach
using System;
 
class GFG
{
  
    // Function to return a vector which
    // consists the sum of
    // four portions of the matrix
    static int sumOfParts(int[,] arr, int N)
    {
        int sum_part1 = 0, sum_part2 = 0,
            sum_part3 = 0, sum_part4 = 0;
        int totalsum = 0;
      
        // Iterating through the matrix
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
      
                // Condition for selecting all values
                // before the second diagonal of metrics
                if (i + j < N - 1) {
      
                    // Top portion of the matrix
                    if (i < j && i != j && i + j > 0)
                        sum_part1 += arr[i, j];
      
                    // Left portion of the matrix
                    else if (i != j)
                        sum_part2 += arr[i, j];
                }
                else {
      
                    // Bottom portion of the matrix
                    if (i > j && i + j != N - 1)
                        sum_part3 += arr[i, j];
      
                    // Right portion of the matrix
                    else {
                        if (i + j != N - 1 && i != j)
                            sum_part4 += arr[i, j];
                    }
                }
            }
        }
      
        // Adding all the four portions into a vector
        totalsum = sum_part1 + sum_part2
                   + sum_part3 + sum_part4;
        return totalsum;
    }
      
    // Driver code
    public static void Main()
    {
        int N = 4;
        int [,]arr = { { 1, 2, 3, 4 },
                          { 5, 6, 7, 8 },
                          { 9, 10, 11, 12 },
                          { 13, 14, 15, 16 } };
      
        Console.WriteLine(sumOfParts(arr, N));
    }
}
 
// This code is contributed by Yash_R
Javascript



<script>
 
// javascript implementation of the above approach
 
  
// Function to return a vector which
// consists the sum of
// four portions of the matrix
function sumOfParts(arr , N)
{
    var sum_part1 = 0, sum_part2 = 0,
        sum_part3 = 0, sum_part4 = 0;
    var totalsum = 0;
  
    // Iterating through the matrix
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
  
            // Condition for selecting all values
            // before the second diagonal of metrics
            if (i + j < N - 1) {
  
                // Top portion of the matrix
                if (i < j && i != j && i + j > 0)
                    sum_part1 += arr[i][j];
  
                // Left portion of the matrix
                else if (i != j)
                    sum_part2 += arr[i][j];
            }
            else {
  
                // Bottom portion of the matrix
                if (i > j && i + j != N - 1)
                    sum_part3 += arr[i][j];
  
                // Right portion of the matrix
                else {
                    if (i + j != N - 1 && i != j)
                        sum_part4 += arr[i][j];
                }
            }
        }
    }
  
    // Adding all the four portions into a vector
    totalsum = sum_part1 + sum_part2
               + sum_part3 + sum_part4;
    return totalsum;
}
  
// Driver code
var N = 4;
var arr = [ [ 1, 2, 3, 4 ],
                  [ 5, 6, 7, 8 ],
                  [ 9, 10, 11, 12 ],
                  [ 13, 14, 15, 16 ] ];
 
document.write(sumOfParts(arr, N));
 
// This code is contributed by 29AjayKumar
 
</script>
Output: 
68
 
Time Complexity: O(N2) as we are traversing the complete matrix rowwise.
 



My Personal Notes
arrow_drop_up
Next

Efficiently compute sums of diagonals of a matrix
Recommended Articles
Page :
Sum of all parts of a square Matrix divided by its diagonals
10, May 20
Split a number into 3 parts such that none of the parts is divisible by 3
16, Dec 18
Divide N into K unique parts such that gcd of those parts is maximum
13, Jan 20
Minimum length of a rod that can be split into N equal parts that can further be split into given number of equal parts
16, May 21
Count of numbers in range [L, R] having sum of digits of its square equal to square of sum of digits
24, Aug 21
Construct a square Matrix whose parity of diagonal sum is same as size of matrix
09, Aug 20
Smallest N digit number whose sum of square of digits is a Perfect Square
22, Apr 20
Check if matrix can be converted to another matrix by transposing square sub-matrices
12, Mar 19
Count the number of ways to divide an array into three contiguous parts having equal sum
18, May 17
Break a number such that sum of maximum divisors of all parts is minimum
10, Dec 17
Divide a number into two parts such that sum of digits is maximum
09, Oct 18
Check if an array of 1s and 2s can be divided into 2 parts with equal sum
14, Feb 19
Sum of all second largest divisors after splitting a number into one or more parts
11, Jul 19
Divide a sorted array in K parts with sum of difference of max and min minimized in each part
12, May 20
Split the array into equal sum parts according to given conditions
28, Jan 19
Count square and non-square numbers before n
14, Jan 18
Program to print Square inside a Square
20, Feb 18
Solid square inside a hollow square | Pattern
23, Jan 18
Check if a number is perfect square without finding square root
01, Jan 19
Find smallest perfect square number A such that N + A is also a perfect square number
02, May 20
Check if a number is a perfect square having all its digits as a perfect square
15, Sep 20
Area of a triangle with two vertices at midpoints of opposite sides of a square and the other vertex lying on vertex of a square
26, May 21
Count of pair of integers (x , y) such that difference between square of x and y is a perfect square
27, Sep 21
Given an n x n square matrix, find sum of all sub-squares of size k x k
22, Sep 14
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
manthanpandey039
@manthanpandey039
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox