Divide N^2 números en N grupos de igual suma

Dado un número par N. La tarea es considerar números del 1 al N ² , dividirlos en N grupos de la misma suma.
Ejemplos : 

Input: N = 2
Output: {1, 4}, {2, 3}
Two groups of equal sum are 1, 4 and 2,3

Input: N = 4
Output: 
{ 1, 16} { 2, 15} 
{ 3, 14} { 4, 13} 
{ 5, 12} { 6, 11} 
{ 7, 10} { 8, 9}

Enfoque: Fórmula para la suma de los primeros N ² números: Suma = (N ² * (N ² + 1))/ 2 .
Por tanto, la suma de cada grupo sería = (N ² + 1)* N ² / 2
Consideremos pares del siguiente tipo (1, N ² ), (2, N ² -1) y así sucesivamente.
Dado que N ² es un número par, cada grupo se puede formar usando exactamente N/2 de tales pares. 
A continuación se muestra la implementación del enfoque anterior: 

// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print N groups of equal sum
void printGroups(int n)
{
    int x = 1;
    int y = n * n;
 
    // No. of Groups
    for (int i = 1; i <= n; i++) {
 
        // n/2 pairs
        for (int j = 1; j <= n / 2; j++) {
            cout << "{ " << x << ", " << y << "} ";
            x++;
            y--;
        }
 
        cout << endl;
    }
}
 
// Driver code
int main()
{
    int n = 4;
    printGroups(n);
 
    return 0;
}

// Java implementation of the above approach
 
import java.io.*;
 
class GFG {
     
 
 
// Function to print N groups of equal sum
static void printGroups(int n)
{
    int x = 1;
    int y = n * n;
 
    // No. of Groups
    for (int i = 1; i <= n; i++) {
 
        // n/2 pairs
        for (int j = 1; j <= n / 2; j++) {
            System.out.print("{ " + x + ", " + y + "} ");
            x++;
            y--;
        }
 
        System.out.println();
    }
}
 
// Driver code
 
    public static void main (String[] args) {
            int n = 4;
    printGroups(n);
    }
}
// This code is contributed by shs

# Python implementation of the above approach
 
# Function to print N groups of equal sum
def printGroups(n) :
     
    x = 1
    y = n * n
     
    # No. of Groups
    for i in range(1, n + 1) :
         
        # n/2 pairs
        for j in range(1, n // 2 + 1) :
             
            print("{",x,",",y,"}",end = " ")
             
            x += 1
            y -= 1
         
        print()
         
        
# Driver code
if __name__ == "__main__" :
     
    n = 4
     
    # Function call
    printGroups(n)
 
# This code is contributed by Ryuga

// Java implementation of the
// above approach
using System;
 
class GFG
{
     
// Function to print N groups
// of equal sum
static void printGroups(int n)
{
    int x = 1;
    int y = n * n;
 
    // No. of Groups
    for (int i = 1; i <= n; i++)
    {
 
        // n/2 pairs
        for (int j = 1; j <= n / 2; j++)
        {
            Console.Write("{ " + x + ", " + y + "} ");
            x++;
            y--;
        }
 
        Console.WriteLine();
    }
}
 
// Driver code
public static void Main ()
{
    int n = 4;
    printGroups(n);
}
}
 
// This code is contributed by shs

<?php
// PHP implementation of the
// above approach
 
// Function to print N groups
// of equal sum
function printGroups($n)
{
    $x = 1;
    $y = $n * $n;
 
    // No. of Groups
    for ($i = 1; $i <= $n; $i++)
    {
 
        // n/2 pairs
        for ($j = 1; $j <= $n / 2; $j++)
        {
            echo "{ " , $x , ", " , $y , " } ";
            $x++;
            $y--;
        }
 
        echo "\n";
    }
}
 
// Driver code
$n = 4;
printGroups($n);
     
// This code is contributed by shs
?>

<script>
 
// Javascript implementation of the above approach
 
// Function to print N groups of equal sum
function prletGroups(n)
{
    let x = 1;
    let y = n * n;
 
    // No. of Groups
    for (let i = 1; i <= n; i++) {
 
        // n/2 pairs
        for (let j = 1; j <= n / 2; j++) {
            document.write("{ " + x + ", " + y + "} ");
            x++;
            y--;
        }
 
        document.write("<br/>");
    }
}
 
// driver program
     
    let n = 4;
    prletGroups(n);
    
</script>

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

Complejidad temporal: O(n ² )

Espacio Auxiliar: O(1)