Dado un número entero N , la tarea es construir una array M[][] de tamaño N x N con números en el rango [1, N^2] con las siguientes condiciones:
- Los elementos de la array M deben ser un número entero entre 1 y N^2.
- Todos los elementos de la array M son distintos por pares.
- Para cada subarray cuadrada que contiene celdas en la fila r a r+a y en las columnas c a c+a (inclusive) para algunos enteros válidos r,c y a>=0: M(r,c)+M(r+a, c+a) es par y M(r,c+a)+M(r+a,c) es par.
Ejemplos:
Entrada: N = 2
Salida:
1 2
4 3
Explicación:
Esta array tiene 5 subarray cuadrada y 4 de ellas ([1], [2], [3], [4]) tienen a=0 por lo que cumplen las condiciones.
La última subarray cuadrada es toda la array M donde r=c=a=1. Podemos ver que M (1, 1) +M (2, 2) =1+3=4 y M (1, 2) +M (2, 1) =2+4=6 son pares.
Entrada: N = 4
Salida:
1 2 3 4
8 7 6 5
9 10 11 12
16 15 14 13
Planteamiento: Sabemos que la suma de dos números es par cuando su paridad es la misma. Digamos que la paridad de M (i, j) es impar, lo que significa que la paridad de M (i+1, j+1) , M (i+1, j-1) , M (i-1, j+1) ) , M (i-1, j-1) tiene que ser impar.
A continuación se muestra la ilustración de N = 4 para generar una array de tamaño 4×4:
Entonces, a partir de la ilustración anterior, tenemos que completar la array en el patrón de tablero de ajedrez . Podemos rellenarlo de dos formas:
- Todas las celdas negras tienen un número entero impar y las celdas blancas tienen un número par.
- Todas las celdas negras tienen un número entero par y las celdas blancas tienen un número entero impar.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program for the above approach
#include<bits/stdc++.h>
using namespace std;
// Function to print the desired matrix
void UniqueMatrix(int N)
{
int element_value = 1;
int i = 0;
// element_value will start from 1
// and go up to N ^ 2
// i is row number and it starts
// from 0 and go up to N-1
// Iterate ove all [0, N]
while(i < N)
{
// If is even
if(i % 2 == 0)
{
for(int f = element_value;
f < element_value + N; f++)
{
// If row number is even print
// the row in forward order
cout << f << " ";
}
element_value += N;
}
else
{
for(int k = element_value + N - 1;
k > element_value - 1; k--)
{
// If row number is odd print
// the row in reversed order
cout << k << " ";
}
element_value += N;
}
cout << endl;
i = i + 1;
}
}
// Driver Code
int main()
{
// Given matrix size
int N = 4;
// Function call
UniqueMatrix(N);
}
// This code is contributed by chitranayal
Java
// Java program for the above approach
public class Gfg
{
// Function to print the desired matrix
public static void UniqueMatrix(int N)
{
int element_value = 1;
int i = 0;
// element_value will start from 1
// and go up to N ^ 2
// i is row number and it starts
// from 0 and go up to N-1
// Iterate ove all [0, N]
while(i < N)
{
// If is even
if(i % 2 == 0)
{
for(int f = element_value;
f < element_value + N; f++)
{
// If row number is even print
// the row in forward order
System.out.print(f+" ");
}
element_value += N;
}
else
{
for(int k = element_value + N - 1;
k > element_value - 1; k--)
{
// If row number is odd print
// the row in reversed order
System.out.print(k+" ");
}
element_value += N;
}
System.out.println();
i = i + 1;
}
}
// Driver Code
public static void main(String []args)
{
// Given matrix size
int N = 4;
// Function call
UniqueMatrix(N);
}
}
// This code is contributed by avanitrachhadiya2155
Python3
# Python3 program for the above approach # Function to print the desired matrix def UniqueMatrix(N): element_value = 1 i = 0 # element_value will start from 1 # and go up to N ^ 2 # i is row number and it starts # from 0 and go up to N-1 # Iterate ove all [0, N] while(i < N): # If is even if(i % 2 == 0): for f in range(element_value, element_value + N, 1): # If row number is even print # the row in forward order print(f, end =' ') element_value += N else: for k in range(element_value + N-1, element_value-1, -1): # if row number is odd print # the row in reversed order print(k, end =' ') element_value += N print() i = i + 1 # Driver Code # Given Matrix Size N = 4 # Function Call UniqueMatrix(N)
C#
// C# program for the above approach
using System;
class GFG
{
static void UniqueMatrix(int N)
{
int element_value = 1;
int i = 0;
// element_value will start from 1
// and go up to N ^ 2
// i is row number and it starts
// from 0 and go up to N-1
// Iterate ove all [0, N]
while(i < N)
{
// If is even
if(i % 2 == 0)
{
for(int f = element_value;
f < element_value + N; f++)
{
// If row number is even print
// the row in forward order
Console.Write(f + " ");
}
element_value += N;
}
else
{
for(int k = element_value + N - 1;
k > element_value - 1; k--)
{
Console.Write(k + " ");
}
element_value += N;
}
Console.WriteLine();
i = i + 1;
}
}
// Driver code
static public void Main ()
{
// Given matrix size
int N = 4;
// Function call
UniqueMatrix(N);
}
}
// This code is contributed by rag2127
Javascript
<script>
// Java script program for the above approach
// Function to print the desired matrix
function UniqueMatrix( N)
{
let element_value = 1;
let i = 0;
// element_value will start from 1
// and go up to N ^ 2
// i is row number and it starts
// from 0 and go up to N-1
// Iterate ove all [0, N]
while(i < N)
{
// If is even
if(i % 2 == 0)
{
for(let f = element_value;
f < element_value + N; f++)
{
// If row number is even print
// the row in forward order
document.write(f+" ");
}
element_value += N;
}
else
{
for(let k = element_value + N - 1;
k > element_value - 1; k--)
{
// If row number is odd print
// the row in reversed order
document.write(k+" ");
}
element_value += N;
}
document.write("<br>");
i = i + 1;
}
}
// Driver Code
// Given matrix size
let N = 4;
// Function call
UniqueMatrix(N);
// contributed by sravan kumar
</script>
1 2 3 4 8 7 6 5 9 10 11 12 16 15 14 13
Complejidad de tiempo: O(N^2)
Espacio auxiliar: O(N^2)
Publicación traducida automáticamente
Artículo escrito por poulami21ghosh y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA