Return an array of anti-diagonals of given N*N square matrix
Given a square matrix of size N*N, return an array of its anti-diagonals. For better understanding let us look at the image given below:
Examples:
Input :
Output :
1
2 5
3 6 9
4 7 10 13
8 11 14
12 15
16
Approach 1:
To solve the problem mentioned above we have two major observations.
- The first one is, some diagonals start from the zeroth row for each column and ends when either start column >= 0 or start row < N.
- While the second observation is that the remaining diagonals start with end column for each row and ends when either start row < N or start column >= 0.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
void diagonal( int A[3][3])
{
int N = 3;
for ( int col = 0; col < N; col++) {
int startcol = col, startrow = 0;
while (startcol >= 0 && startrow < N) {
cout << A[startrow][startcol] << " " ;
startcol--;
startrow++;
}
cout << "\n" ;
}
for ( int row = 1; row < N; row++) {
int startrow = row, startcol = N - 1;
while (startrow < N && startcol >= 0) {
cout << A[startrow][startcol] << " " ;
startcol--;
startrow++;
}
cout << "\n" ;
}
}
int main()
{
int A[3][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
diagonal(A);
return 0;
}
|
Java
class Matrix {
void diagonal( int A[][])
{
int N = 3 ;
for ( int col = 0 ; col < N; col++) {
int startcol = col, startrow = 0 ;
while (startcol >= 0 && startrow < N) {
System.out.print(A[startrow][startcol]
+ " " );
startcol--;
startrow++;
}
System.out.println();
}
for ( int row = 1 ; row < N; row++) {
int startrow = row, startcol = N - 1 ;
while (startrow < N && startcol >= 0 ) {
System.out.print(A[startrow][startcol]
+ " " );
startcol--;
startrow++;
}
System.out.println();
}
}
public static void main(String args[])
{
int A[][]
= { { 1 , 2 , 3 }, { 4 , 5 , 6 }, { 7 , 8 , 9 } };
Matrix m = new Matrix();
m.diagonal(A);
}
}
|
Python3
def diagonal(A):
N = 3
for col in range (N):
startcol = col
startrow = 0
while (startcol > = 0 and
startrow < N):
print (A[startrow][startcol], end = " " )
startcol - = 1
startrow + = 1
print ()
for row in range ( 1 , N):
startrow = row
startcol = N - 1
while (startrow < N and
startcol > = 0 ):
print (A[startrow][startcol],
end = " " )
startcol - = 1
startrow + = 1
print ()
if __name__ = = "__main__" :
A = [[ 1 , 2 , 3 ],
[ 4 , 5 , 6 ],
[ 7 , 8 , 9 ]]
diagonal(A)
|
C#
using System;
class GFG {
static void diagonal( int [, ] A)
{
int N = 3;
for ( int col = 0; col < N; col++) {
int startcol = col, startrow = 0;
while (startcol >= 0 && startrow < N) {
Console.Write(A[startrow, startcol] + " " );
startcol--;
startrow++;
}
Console.WriteLine();
}
for ( int row = 1; row < N; row++) {
int startrow = row, startcol = N - 1;
while (startrow < N && startcol >= 0) {
Console.Write(A[startrow, startcol] + " " );
startcol--;
startrow++;
}
Console.WriteLine();
}
}
public static void Main( string [] args)
{
int [, ] A
= { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
diagonal(A);
}
}
|
Javascript
<script>
function diagonal(A)
{
let N = 3;
for (let col = 0; col < N; col++)
{
let startcol = col, startrow = 0;
while (startcol >= 0 && startrow < N)
{
document.write(A[startrow][startcol] + " " );
startcol--;
startrow++;
}
document.write( "</br>" );
}
for (let row = 1; row < N; row++)
{
let startrow = row, startcol = N - 1;
while (startrow < N && startcol >= 0)
{
document.write(A[startrow][startcol] + " " );
startcol--;
startrow++;
}
document.write( "</br>" );
}
}
let A = [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ];
diagonal(A);
</script>
|
Output:
1
2 4
3 5 7
6 8
9
Time Complexity: O(N*N), Where N is the number of rows or columns of given matrix.
Auxiliary Space: O(1)
Approach 2: Much simpler and concise (Same time Complexity)
In this approach, we will make the use of sum of indices of any element in a matrix. Let indices of any element be represented by i (row) an j (column).
If we find the sum of indices of any element in a N*N matrix, we will observe that the sum of indices for any element lies between 0 (when i = j = 0) and 2*N – 2 (when i = j = N-1).
So we will follow the following steps:
- Declare a vector of vectors of size 2*N – 1 for holding unique sums from sum = 0 to sum = 2*N – 2.
- Now we will loop through the vector and pushback the elements of similar sum to same row in that vector of vectors.
Below is the implementation of the above approach:
C++
#include <iostream>
#include <vector>
using namespace std;
void diagonal(vector<vector< int > >& A)
{
int n = A.size();
int N = 2 * n - 1;
vector<vector< int > > result(N);
for ( int i = 0; i < n; i++)
for ( int j = 0; j < n; j++)
result[i + j].push_back(A[i][j]);
for ( int i = 0; i < result.size(); i++)
{
cout << endl;
for ( int j = 0; j < result[i].size(); j++)
cout << result[i][j] << " " ;
}
}
int main()
{
vector<vector< int > > A = { { 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 },
{ 13, 14, 15, 16 } };
diagonal(A);
return 0;
}
|
Java
import java.util.*;
import java.lang.*;
class GFG{
static void diagonal( int [][] A)
{
int n = A.length;
int N = 2 * n - 1 ;
ArrayList<ArrayList<Integer>> result = new ArrayList<>();
for ( int i = 0 ; i < N; i++)
result.add( new ArrayList<>());
for ( int i = 0 ; i < n; i++)
for ( int j = 0 ; j < n; j++)
result.get(i + j).add(A[i][j]);
for ( int i = 0 ; i < result.size(); i++)
{
System.out.println();
for ( int j = 0 ; j < result.get(i).size(); j++)
System.out.print(result.get(i).get(j) + " " );
}
}
public static void main(String[] args)
{
int [][] A = { { 1 , 2 , 3 , 4 },
{ 5 , 6 , 7 , 8 },
{ 9 , 10 , 11 , 12 },
{ 13 , 14 , 15 , 16 } };
diagonal(A);
}
}
|
Python3
def diagonal(A) :
n = len (A)
N = 2 * n - 1
result = []
for i in range (N) :
result.append([])
for i in range (n) :
for j in range (n) :
result[i + j].append(A[i][j])
for i in range ( len (result)) :
for j in range ( len (result[i])) :
print (result[i][j] , end = " " )
print ()
A = [ [ 1 , 2 , 3 , 4 ],
[ 5 , 6 , 7 , 8 ],
[ 9 , 10 , 11 , 12 ],
[ 13 , 14 , 15 , 16 ] ]
diagonal(A)
|
C#
using System;
using System.Collections.Generic;
class GFG {
static void diagonal(List<List< int >> A)
{
int n = A.Count;
int N = 2 * n - 1;
List<List< int >> result = new List<List< int >>();
for ( int i = 0; i < N; i++)
{
result.Add( new List< int >());
}
for ( int i = 0; i < n; i++)
for ( int j = 0; j < n; j++)
result[i + j].Add(A[i][j]);
for ( int i = 0; i < result.Count; i++)
{
for ( int j = 0; j < result[i].Count; j++)
Console.Write(result[i][j] + " " );
Console.WriteLine();
}
}
static void Main() {
List<List< int >> A = new List<List< int >>();
A.Add( new List< int > {1, 2, 3, 4});
A.Add( new List< int > {5, 6, 7, 8});
A.Add( new List< int > {9, 10, 11, 12});
A.Add( new List< int > {13, 14, 15, 16});
diagonal(A);
}
}
|
Javascript
<script>
function diagonal(A)
{
let n = A.length;
let N = 2 * n - 1;
let result = [];
for (let i = 0; i < N; i++)
{
result.push([]);
}
for (let i = 0; i < n; i++)
for (let j = 0; j < n; j++)
result[i + j].push(A[i][j]);
for (let i = 0; i < result.length; i++)
{
for (let j = 0; j < result[i].length; j++)
document.write(result[i][j] + " " );
document.write( "</br>" );
}
}
let A = [[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]];
diagonal(A);
</script>
|
Output :
1
2 5
3 6 9
4 7 10 13
8 11 14
12 15
16
Time Complexity: O(N*N), Where N is the number of rows or columns of given matrix.
Auxiliary Space: O(N*N)
Last Updated :
11 Apr, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...