# Find a Symmetric matrix of order N that contain integers from 0 to N-1 and main diagonal should contain only 0’s

Given an integer N. The task is to generate a symmetric matrix of order N*N having the following properties.

1. Main diagonal should contain only 0’s
2. The matrix should contain elements from 0 to N-1 only.

Examples:

Input: N = 4
Output:
0 2 3 1
2 0 1 3
3 1 0 2
1 3 2 0

Input: N = 5
Output:
0 2 3 4 1
2 0 4 1 3
3 4 0 2 1
4 1 2 0 3
1 3 1 3 0

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

Approach: Since the required matrix has to be a square matrix, we can generate a symmetric matrix containing an element from 1 to n-1, excluding 0. We will deal with the case of 0 later.
Take for example when N = 4:
We first generate a symmetric matrix, and it can be easily done by filling every row from 1 to n-1 in cyclic order, i.e. fill the first row by 1 2 3, and do this for all subsequent rows in cyclic order.

So, the final matrix will be,
1 2 3
2 3 1
3 1 2

Now, we have generated a symmetric matrix containing elements from 1 to n. Let’s discuss case 0. We will take the benefit of the above matrix being symmetrical, we will add a column of 0 and rows of 0 like this,

1 2 3 0
2 3 1 0
3 1 2 0
0 0 0 0

Now, we have to put all 0 in diagonal. For this, we will start with the first row till last-1 row and swap all the 0 with the number that is there in each row and will also make a change in the last row like this:

For row 1, we swap 0 and 1 and also put last row’s 1st element with the number we swapped i.e. 1.
0 2 3 1
2 3 1 0
3 1 2 0
1 0 0 0

For row 2 we swap 0 and 3, and make the second element of the last row also 3.
0 2 3 1
2 0 1 3
3 1 2 0
1 3 0 0
and so on…
The final matrix generated will be the required matrix.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to generate the required matrix ` `void` `solve(``long` `long` `n) ` `{ ` `    ``long` `long` `initial_array[n - 1][n - 1], final_array[n][n]; ` ` `  `    ``for` `(``long` `long` `i = 0; i < n - 1; ++i) ` `        ``initial_array[i] = i + 1; ` ` `  `    ``// Form cyclic array of elements 1 to n-1 ` `    ``for` `(``long` `long` `i = 1; i < n - 1; ++i) ` `        ``for` `(``long` `long` `j = 0; j < n - 1; ++j) ` `            ``initial_array[i][j] ` `                ``= initial_array[i - 1][(j + 1) % (n - 1)]; ` ` `  `    ``// Store initial array into final array ` `    ``for` `(``long` `long` `i = 0; i < n - 1; ++i) ` `        ``for` `(``long` `long` `j = 0; j < n - 1; ++j) ` `            ``final_array[i][j] = initial_array[i][j]; ` ` `  `    ``// Fill the last row and column with 0's ` `    ``for` `(``long` `long` `i = 0; i < n; ++i) ` `        ``final_array[i][n - 1] = final_array[n - 1][i] = 0; ` ` `  `    ``for` `(``long` `long` `i = 0; i < n; ++i) { ` `        ``long` `long` `t0 = final_array[i][i]; ` `        ``long` `long` `t1 = final_array[i][n - 1]; ` ` `  `        ``// Swap 0 and the number present ` `        ``// at the current indexed row ` `        ``swap(final_array[i][i], final_array[i][n - 1]); ` ` `  `        ``// Also make changes in the last row ` `        ``// with the number we swapped ` `        ``final_array[n - 1][i] = t0; ` `    ``} ` ` `  `    ``// Print the final array ` `    ``for` `(``long` `long` `i = 0; i < n; ++i) { ` `        ``for` `(``long` `long` `j = 0; j < n; ++j) ` `            ``cout << final_array[i][j] << ``" "``; ` `        ``cout << endl; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``long` `long` `n = 5; ` `    ``solve(n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `class` `GFG ` `{ ` ` `  `// Function to generate the required matrix  ` `static` `void` `solve(``long` `n)  ` `{  ` `    ``long` `initial_array[][]= ``new` `long``[(``int``)n - ``1``][(``int``)n - ``1``],  ` `                    ``final_array[][]= ``new` `long``[(``int``)n][(``int``)n];  ` ` `  `    ``for` `(``long` `i = ``0``; i < n - ``1``; ++i)  ` `        ``initial_array[``0``][(``int``)i] = i + ``1``;  ` ` `  `    ``// Form cyclic array of elements 1 to n-1  ` `    ``for` `(``long` `i = ``1``; i < n - ``1``; ++i)  ` `        ``for` `(``long` `j = ``0``; j < n - ``1``; ++j)  ` `            ``initial_array[(``int``)i][(``int``)j]  ` `                ``= initial_array[(``int``)i - ``1``][(``int``)((``int``)j + ``1``) % ((``int``)n - ``1``)];  ` ` `  `    ``// Store initial array into final array  ` `    ``for` `(``long` `i = ``0``; i < n - ``1``; ++i)  ` `        ``for` `(``long` `j = ``0``; j < n - ``1``; ++j)  ` `            ``final_array[(``int``)i][(``int``)j] = initial_array[(``int``)i][(``int``)j];  ` ` `  `    ``// Fill the last row and column with 0's  ` `    ``for` `(``long` `i = ``0``; i < n; ++i)  ` `        ``final_array[(``int``)i][(``int``)n - ``1``] = final_array[(``int``)n - ``1``][(``int``)i] = ``0``;  ` ` `  `    ``for` `(``long` `i = ``0``; i < n; ++i)  ` `    ``{  ` `        ``long` `t0 = final_array[(``int``)i][(``int``)i];  ` `        ``long` `t1 = final_array[(``int``)i][(``int``)n - ``1``];  ` ` `  `        ``// Swap 0 and the number present  ` `        ``// at the current indexed row  ` `        ``long` `s = final_array[(``int``)i][(``int``)i]; ` `        ``final_array[(``int``)i][(``int``)i]=final_array[(``int``)i][(``int``)n - ``1``]; ` `        ``final_array[(``int``)i][(``int``)n - ``1``]=s; ` ` `  `        ``// Also make changes in the last row  ` `        ``// with the number we swapped  ` `        ``final_array[(``int``)n - ``1``][(``int``)i] = t0;  ` `    ``}  ` ` `  `    ``// Print the final array  ` `    ``for` `(``long` `i = ``0``; i < n; ++i)  ` `    ``{  ` `        ``for` `(``long` `j = ``0``; j < n; ++j)  ` `            ``System.out.print( final_array[(``int``)i][(``int``)j] + ``" "``);  ` `        ``System.out.println(); ` `    ``}  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String args[]) ` `{  ` `    ``long` `n = ``5``;  ` `    ``solve(n);  ` `} ` `} ` ` `  `// This code is contributed by Arnab Kundu  ` `   `

## Python3

 `# Python 3 implementation of the approach ` ` `  `# Function to generate the required matrix ` `def` `solve(n): ` `    ``initial_array ``=` `[[``0` `for` `i ``in` `range``(n``-``1``)] ``for` `j ``in` `range``(n``-``1``)] ` `    ``final_array ``=` `[[``0` `for` `i ``in` `range``(n)]``for` `j ``in` `range``(n)] ` ` `  `    ``for` `i ``in` `range``(n ``-` `1``): ` `        ``initial_array[``0``][i] ``=` `i ``+` `1` ` `  `    ``# Form cyclic array of elements 1 to n-1 ` `    ``for` `i ``in` `range``(``1``, n ``-` `1``): ` `        ``for` `j ``in` `range``(n ``-` `1``): ` `            ``initial_array[i][j] ``=` `initial_array[i ``-` `1``][(j ``+` `1``) ``%` `(n ``-` `1``)] ` ` `  `    ``# Store initial array into final array ` `    ``for` `i ``in` `range``(n``-``1``): ` `        ``for` `j ``in` `range``(n``-``1``): ` `            ``final_array[i][j] ``=` `initial_array[i][j] ` ` `  `    ``# Fill the last row and column with 0's ` `    ``for` `i ``in` `range``(n): ` `        ``final_array[i][n ``-` `1``] ``=` `final_array[n ``-` `1``][i] ``=` `0` ` `  `    ``for` `i ``in` `range``(n): ` `        ``t0 ``=` `final_array[i][i] ` `        ``t1 ``=` `final_array[i][n ``-` `1``] ` ` `  `        ``# Swap 0 and the number present ` `        ``# at the current indexed row ` `        ``temp ``=` `final_array[i][i] ` `        ``final_array[i][i] ``=` `final_array[i][n ``-` `1``] ` `        ``final_array[i][n ``-` `1``] ``=` `temp ` ` `  `        ``# Also make changes in the last row ` `        ``# with the number we swapped ` `        ``final_array[n ``-` `1``][i] ``=` `t0 ` ` `  `    ``# Print the final array ` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(n): ` `            ``print``(final_array[i][j],end ``=` `" "``) ` `        ``print``(``"\n"``,end ``=` `"") ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``n ``=` `5` `    ``solve(n) ` `     `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# implementation of the approach  ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to generate the required matrix  ` `static` `void` `solve(``long` `n)  ` `{  ` `    ``long` `[,]initial_array = ``new` `long``[(``int``)n - 1,(``int``)n - 1];  ` `    ``long` `[,]final_array = ``new` `long``[(``int``)n,(``int``)n];  ` ` `  `    ``for` `(``long` `i = 0; i < n - 1; ++i)  ` `        ``initial_array[0,(``int``)i] = i + 1;  ` ` `  `    ``// Form cyclic array of elements 1 to n-1  ` `    ``for` `(``long` `i = 1; i < n - 1; ++i)  ` `        ``for` `(``long` `j = 0; j < n - 1; ++j)  ` `            ``initial_array[(``int``)i,(``int``)j]  ` `                ``= initial_array[(``int``)i - 1,(``int``)((``int``)j + 1) % ((``int``)n - 1)];  ` ` `  `    ``// Store initial array into final array  ` `    ``for` `(``long` `i = 0; i < n - 1; ++i)  ` `        ``for` `(``long` `j = 0; j < n - 1; ++j)  ` `            ``final_array[(``int``)i,(``int``)j] = initial_array[(``int``)i,(``int``)j];  ` ` `  `    ``// Fill the last row and column with 0's  ` `    ``for` `(``long` `i = 0; i < n; ++i)  ` `        ``final_array[(``int``)i,(``int``)n - 1] = final_array[(``int``)n - 1,(``int``)i] = 0;  ` ` `  `    ``for` `(``long` `i = 0; i < n; ++i)  ` `    ``{  ` `        ``long` `t0 = final_array[(``int``)i, (``int``)i];  ` `        ``long` `t1 = final_array[(``int``)i, (``int``)n - 1];  ` ` `  `        ``// Swap 0 and the number present  ` `        ``// at the current indexed row  ` `        ``long` `s = final_array[(``int``)i,(``int``)i]; ` `        ``final_array[(``int``)i,(``int``)i] = final_array[(``int``)i, (``int``)n - 1]; ` `        ``final_array[(``int``)i,(``int``)n - 1] = s; ` ` `  `        ``// Also make changes in the last row  ` `        ``// with the number we swapped  ` `        ``final_array[(``int``)n - 1,(``int``)i] = t0;  ` `    ``}  ` ` `  `    ``// Print the final array  ` `    ``for` `(``long` `i = 0; i < n; ++i)  ` `    ``{  ` `        ``for` `(``long` `j = 0; j < n; ++j)  ` `            ``Console.Write( final_array[(``int``)i,(``int``)j] + ``" "``);  ` `        ``Console.WriteLine(); ` `    ``}  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String []args) ` `{  ` `    ``long` `n = 5;  ` `    ``solve(n);  ` `} ` `} ` ` `  `// This code contributed by Rajput-Ji `

## PHP

 ` `

Output:

```0 2 3 4 1
2 0 4 1 3
3 4 0 2 1
4 1 2 0 3
1 3 1 3 0
```

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up 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.