找到一个 N x N 网格，其每行和每列的 xor 都相等

给定一个整数N是4的倍数，任务是找到一个N x N网格，其中每行和每列的按位异或都相同。
例子：

Input: N = 4 
Output: 
0 1 2 3 
4 5 6 7 
8 9 10 11 
12 13 14 15 
Input: N = 8 
Output: 
0 1 2 3 16 17 18 19 
4 5 6 7 20 21 22 23 
8 9 10 11 24 25 26 27 
12 13 14 15 28 29 30 31 
32 33 34 35 48 49 50 51 
36 37 38 39 52 53 54 55 
40 41 42 43 56 57 58 59 
44 45 46 47 60 61 62 63 
 

方法：为了解决这个问题，让我们将每一行和每列的异或固定为 0，因为从 0 开始的 4 个连续数字的异或是 0。这是一个 4 x 4 矩阵的例子：

0 ^ 1 ^ 2 ^ 3 = 0 
4 ^ 5 ^ 6 ^ 7 = 0 
8 ^ 9 ^ 10 ^ 11 = 0 
12 ^ 13 ^ 14 ^ 15 = 0 
and so on. 
 

如果你注意到在上面的例子中，每行和每列的异或都是 0。现在我们需要以每行和每列的异或为 0 的方式放置数字。所以我们可以将我们的N x N矩阵划分为具有N / 4行和列的较小的 4 x 4 矩阵，并以每行和每列的异或为 0 的方式填充单元格。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to find the n x n matrix
// that satisfies the given condition
void findGrid(int n)
{
    int arr[n][n];
 
    // Initialize x to 0
    int x = 0;
 
    // Divide the n x n matrix into n / 4 matrices
    // for each of the n / 4 rows where
    // each matrix is of size 4 x 4
    for (int i = 0; i < n / 4; i++) {
        for (int j = 0; j < n / 4; j++) {
            for (int k = 0; k < 4; k++) {
                for (int l = 0; l < 4; l++) {
                    arr[i * 4 + k][j * 4 + l] = x;
                    x++;
                }
            }
        }
    }
 
    // Print the generated matrix
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << arr[i][j] << " ";
        }
        cout << "\n";
    }
}
 
// Driver code
int main()
{
    int n = 4;
 
    findGrid(n);
 
    return 0;
}

Java

// Java implementation of the approach
import java.io.*;
 
class GFG
{
     
// Function to find the n x n matrix
// that satisfies the given condition
static void findGrid(int n)
{
    int [][]arr = new int[n][n];
 
    // Initialize x to 0
    int x = 0;
 
    // Divide the n x n matrix into n / 4 matrices
    // for each of the n / 4 rows where
    // each matrix is of size 4 x 4
    for (int i = 0; i < n / 4; i++)
    {
        for (int j = 0; j < n / 4; j++)
        {
            for (int k = 0; k < 4; k++)
            {
                for (int l = 0; l < 4; l++)
                {
                    arr[i * 4 + k][j * 4 + l] = x;
                    x++;
                }
            }
        }
    }
 
    // Print the generated matrix
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            System.out.print(arr[i][j] + " ");
        }
        System.out.println(" ");
    }
}
 
// Driver code
public static void main (String[] args)
{
    int n = 4;
     
    findGrid(n);
}
}
 
// This code is contributed by ajit.

Python3

# Python3 implementation of the approach
 
# Function to find the n x n matrix
# that satisfies the given condition
def findGrid(n):
 
    arr = [[0 for k in range(n)]
              for l in range(n)]
 
    # Initialize x to 0
    x = 0
 
    # Divide the n x n matrix into n / 4 matrices
    # for each of the n / 4 rows where
    # each matrix is of size 4 x 4
    for i in range(n // 4):
        for j in range(n // 4):
            for k in range(4):
                for l in range(4):
                    arr[i * 4 + k][j * 4 + l] = x
                    x += 1
 
    # Print the generated matrix
    for i in range(n):
        for j in range(n):
            print(arr[i][j], end = " ")
        print()
 
# Driver code
n = 4
findGrid(n)
 
# This code is contributed by divyamohan123

C#

// C# implementation of the approach
using System;
     
class GFG
{
     
// Function to find the n x n matrix
// that satisfies the given condition
static void findGrid(int n)
{
    int [,]arr = new int[n, n];
 
    // Initialize x to 0
    int x = 0;
 
    // Divide the n x n matrix into n / 4 matrices
    // for each of the n / 4 rows where
    // each matrix is of size 4 x 4
    for (int i = 0; i < n / 4; i++)
    {
        for (int j = 0; j < n / 4; j++)
        {
            for (int k = 0; k < 4; k++)
            {
                for (int l = 0; l < 4; l++)
                {
                    arr[i * 4 + k, j * 4 + l] = x;
                    x++;
                }
            }
        }
    }
 
    // Print the generated matrix
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            Console.Write(arr[i, j] + " ");
        }
        Console.WriteLine(" ");
    }
}
 
// Driver code
public static void Main (String[] args)
{
    int n = 4;
     
    findGrid(n);
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
// Javascript implementation of the approach
 
// Function to find the n x n matrix
// that satisfies the given condition
function findGrid(n)
{
    let arr = new Array(n);
    for (let i = 0; i < n; i++)
        arr[i] = new Array(n);
 
    // Initialize x to 0
    let x = 0;
 
    // Divide the n x n matrix into n / 4 matrices
    // for each of the n / 4 rows where
    // each matrix is of size 4 x 4
    for (let i = 0; i < parseInt(n / 4); i++) {
        for (let j = 0; j < parseInt(n / 4); j++) {
            for (let k = 0; k < 4; k++) {
                for (let l = 0; l < 4; l++) {
                    arr[i * 4 + k][j * 4 + l] = x;
                    x++;
                }
            }
        }
    }
 
    // Print the generated matrix
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            document.write(arr[i][j] + " ");
        }
        document.write("<br>");
    }
}
 
// Driver code
    let n = 4;
 
    findGrid(n);
 

输出：

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

时间复杂度： O(N ² )

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。