Create matrix whose sum of diagonals in each sub matrix is even

0 0 4 minutes read

Given a number N, the task is to create a square matrix of size N*N with values in range [1, N*N], such that the sum of each diagonal of an even sub-square matrix is even.

Examples:

Input: N = 3
Output:
1 2 3
4 5 6
7 8 9
Explanation:For each even sub-square matrix the sum of each diagonal is a even number.
1 2
4 5
sum of each diagonal is 6 and 6 i.e even number.

Input: N = 4
Output:
1 2 3 4
6 5 8 7
9 10 11 12
14 13 16 15
Explanation:
For each even sub-square matrix the sum of each diagonal is a even number.
1 2
6 5
sum of each diagonal is 6 and 8 i.e even number.

Approach: The idea is to arrange elements from 1 to N*N in the below-given ways:

Initialize odd and even by 1 and 2 elements respectively.
Iterate two nested loop in the range [0, N].
If the sum of indices in the two nested loops is even the print the value of odd and increment odd by 2 and if the sum is odd then print the value of even, and increment even by 2.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <iostream>
using namespace std;
 
// Function to print N*N order matrix
// with all sub-matrix of even order
// is sum of its diagonal also even
void evenSubMatrix(int N)
{
    // Even index
    int even = 1;
 
    // Odd index
    int odd = 2;
 
    // Iterate two nested loop
    for (int i = 0; i < N; i++) {
 
        for (int j = 0; j < N; j++) {
 
            // For even index the element
            // should be consecutive odd
            if ((i + j) % 2 == 0) {
                cout << even << " ";
                even += 2;
            }
 
            // for odd index the element
            // should be consecutive even
            else {
                cout << odd << " ";
                odd += 2;
            }
        }
        cout << "\n";
    }
}
 
// Driver Code
int main()
{
    // Given order of matrix
    int N = 4;
 
    // Function call
    evenSubMatrix(N);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to print N*N order matrix
// with all sub-matrix of even order
// is sum of its diagonal also even
static void evenSubMatrix(int N)
{
     
    // Even index
    int even = 1;
 
    // Odd index
    int odd = 2;
 
    // Iterate two nested loop
    for(int i = 0; i < N; i++) 
    {
        for(int j = 0; j < N; j++) 
        {
             
            // For even index the element
            // should be consecutive odd
            if ((i + j) % 2 == 0)
            {
                System.out.print(even + " ");
                even += 2;
            }
             
            // For odd index the element
            // should be consecutive even
            else
            {
                System.out.print(odd + " ");
                odd += 2;
            }
        }
        System.out.println();
    }
}
 
// Driver code
public static void main(String[] args)
{
     
    // Given order of matrix
    int N = 4;
     
    // Function call
    evenSubMatrix(N);
}
}
 
// This code is contributed by offbeat

Python3

# Python3 program for the above approach
 
# Function to print N*N order matrix
# with all sub-matrix of even order
# is sum of its diagonal also even
def evenSubMatrix(N):
     
    # Even index
    even = 1
 
    # Odd index
    odd = 2
 
    # Iterate two nested loop
    for i in range(N):
        for j in range(N):
 
            # For even index the element
            # should be consecutive odd
            if ((i + j) % 2 == 0):
                print(even, end = " ")
                even += 2
             
            # For odd index the element
            # should be consecutive even
            else:
                print(odd, end = " ")
                odd += 2
                 
        print() 
 
# Driver Code
 
# Given order of matrix
N = 4
 
# Function call
evenSubMatrix(N)
 
# This code is contributed by sanjoy_62

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to print N*N order matrix
// with all sub-matrix of even order
// is sum of its diagonal also even
static void evenSubMatrix(int N)
{
     
    // Even index
    int even = 1;
 
    // Odd index
    int odd = 2;
 
    // Iterate two nested loop
    for(int i = 0; i < N; i++) 
    {
        for(int j = 0; j < N; j++) 
        {
             
            // For even index the element
            // should be consecutive odd
            if ((i + j) % 2 == 0)
            {
                Console.Write(even + " ");
                even += 2;
            }
             
            // For odd index the element
            // should be consecutive even
            else
            {
                Console.Write(odd + " ");
                odd += 2;
            }
        }
        Console.WriteLine();
    }
}
 
// Driver code
public static void Main(String[] args)
{
     
    // Given order of matrix
    int N = 4;
     
    // Function call
    evenSubMatrix(N);
}
}
 
// This code is contributed by amal kumar choubey

Javascript

<script>
// Java script program for the above approach
 
// Function to print N*N order matrix
// with all sub-matrix of even order
// is sum of its diagonal also even
function evenSubMatrix( N)
{
     
    // Even index
    let even = 1;
 
    // Odd index
    let odd = 2;
 
    // Iterate two nested loop
    for(let i = 0; i < N; i++)
    {
        for(let j = 0; j < N; j++)
        {
             
            // For even index the element
            // should be consecutive odd
            if ((i + j) % 2 == 0)
            {
                document.write(even + " ");
                even += 2;
            }
             
            // For odd index the element
            // should be consecutive even
            else
            {
                document.write(odd + " ");
                odd += 2;
            }
        }
        document.write("<br>");
    }
}
 
// Driver code
 
     
    // Given order of matrix
    let N = 4;
     
    // Function call
    evenSubMatrix(N);
 
// This code is contributed by manoj
</script>

Output:

1 2 3 4 
6 5 8 7 
9 10 11 12 
14 13 16 15

Time Complexity: O(N*N)
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!