/* Auteur: Nicolas JANEY          */
/* nicolas.janey@univ-fcomte.fr   */
/* Fevrier 2005                   */

import java.io.*;

public class TestMatriceMagique {
  static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));

  /* Fonction de calcul de la somme des valeurs           */
  /* d'une colonne d'une matrice carree                   */
  /* m : Tableau d'entiers                                */
  /* c : entier                                           */
  /* Resultat fonction : entier                           */

  public static int sommeColonneMatrice(int [][] m,int c) {
  /* Declaration et initialisation a 0 de la variable     */
  /* d'accumulation pour le calcul de la somme            */
    int s = 0;
  /* Declaration d'une variable et affectation            */
  /* avec la taille de la matrice                         */
    int n = m.length;
  /* Pour toutes les lignes i de la matrice               */
    for ( int i = 0 ; i < n ; i++ )
  /* s est incremente de l'entier d'indice (i,c)          */
      s += m[i][c];
  /* Resultat de la fonction                              */
    return(s);
  }

  /* Fonction de calcul de la somme des valeurs           */
  /* d'une ligne d'une matrice carree                     */
  /* m : Tableau d'entiers                                */
  /* c : entier                                           */
  /* Resultat fonction : entier                           */

  public static int sommeLigneMatrice(int [][] m,int l) {
  /* Declaration et initialisation a 0 de la variable     */
  /* d'accumulation pour le calcul de la somme            */
    int s = 0;
  /* Declaration d'une variable et affectation            */
  /* avec la taille de la matrice                         */
    int n = m.length;
  /* Pour toutes les colones i de la matrice              */
    for ( int i = 0 ; i < n ; i++ )
  /* s est incremente de l'entier d'indice (l,i)          */
      s += m[l][i];
  /* Resultat de la fonction                              */
    return(s);
  }

  /* Fonction de calcul de la somme des valeurs           */
  /* d'une colonne d'une diagonale descendante            */
  /* m : Tableau d'entiers                                */
  /* d : entier                                           */
  /* Resultat fonction : entier                           */

  public static int sommeDiagonale1Matrice(int [][] m,int d) {
  /* Declaration et initialisation a 0 de la variable     */
  /* d'accumulation pour le calcul de la somme            */
    int s = 0;
  /* Declaration d'une variable et affectation            */
  /* avec la taille de la matrice                         */
    int n = m.length;
  /* Pour toutes les lignes i de la matrice               */
    for ( int i = 0 ; i < n ; i++ )
  /* s est incremente de l'entier d'indice (i,(d+i)%n)    */
  /* le d+i permet de descendre la diagonale d            */
  /* le %n permet de parcourir cycliquement les colonnes  */
      s += m[i][(d+i)%n];
  /* Resultat de la fonction                              */
    return(s);
  }

  /* Fonction de calcul de la somme des valeurs           */
  /* d'une colonne d'une diagonale montante               */
  /* m : Tableau d'entiers                                */
  /* d : entier                                           */
  /* Resultat fonction : entier                           */

  public static int sommeDiagonale2Matrice(int [][] m,int d) {
  /* Declaration et initialisation a 0 de la variable     */
  /* d'accumulation pour le calcul de la somme            */
    int s = 0;
  /* Declaration d'une variable et affectation            */
  /* avec la taille de la matrice                         */
    int n = m.length;
  /* Pour toutes les lignes i de la matrice               */
    for ( int i = 0 ; i < n ; i++ )
  /* s est incremente de l'entier d'indice (i,(d-i+n)%n)  */
  /* le d-i permet de monter la diagonale d               */
  /* le (...+n)%n permet de parcourir cycliquement        */
  /* les colonnes en gerant correctement le probleme      */
  /* du calcul de modulo sur les nombres negatifs         */
  /* (pas de nombre negatif)                              */
      s += m[i][(d-i+n)%n];
  /* Resultat de la fonction                              */
    return(s);
  }

  /* Fonction de test si une matrice d'entiers est        */
  /* pandiagonale magique                                 */
  /* m : Tableau d'entiers                                */
  /* Resultat fonction : booleen                          */

  public static boolean testMatriceMagique(int [][] m) {
  /* Declaration d'une variable et affectation            */
  /* avec la taille de la matrice                         */
    int n = m.length;
  /* Declaration d'une variable v et affectation          */
  /* avec la somme de la colonne 0                        */
    int v = sommeColonneMatrice(m,0);
  /* Toute somme differente de v trouvee entrainera       */
  /* la sortie de la fonction avec faux pour resultat     */
  /* Test des n-1 colonnes restantes                      */
    for ( int i = 1 ; i < n ; i++ )
  /* Si une valeur differente de v est trouvee            */
      if ( v != sommeColonneMatrice(m,i) )
  /* Resultat de la fonction : faux                       */
        return(false);
  /* Test des n lignes                                    */
    for ( int i = 0 ; i < n ; i++ )
  /* Si une valeur differente de v est trouvee            */
      if ( v != sommeLigneMatrice(m,i) )
  /* Resultat de la fonction : faux                       */
        return(false);
  /* Test des n diagonales descendantes                   */
    for ( int i = 0 ; i < n ; i++ )
  /* Si une valeur differente de v est trouvee            */
      if ( v != sommeDiagonale1Matrice(m,i) )
  /* Resultat de la fonction : faux                       */
        return(false);
  /* Test des n diagonales montantes                      */
    for ( int i = 0 ; i < n ; i++ )
  /* Si une valeur differente de v est trouvee            */
      if ( v != sommeDiagonale2Matrice(m,i) )
  /* Resultat de la fonction : faux                       */
        return(false);
  /* Plus aucune valeur n'est a tester et                 */
  /* aucune de celles testees n'a entraine de sortie      */
  /* a faux                                               */
  /* Resultat de la fonction : vrai                       */
    return(true);
  }

  /* Fonction de creation d'une matrice carree d'entiers  */
  /* initialisee avec des nombres aleatoires              */
  /* n : nombres de lignes et de colonnes de la matrice   */
  /* max : valeur maximale des nombres aleatoires         */
  /* Resultat fonction : Matrice d'entiers                */

  public static int [][] creationMatriceAleatoire(int n,int max) {
  /* Allocation de la matrice                             */
    int [][] m = new int[n][n];
  /* Pour toutes les lignes de la matrice a initialiser   */                                    
    for ( int i = 0 ; i < n ; i++ )
  /* Pour toutes les colonnes de la matrice a initialiser */
      for ( int j = 0 ; j < n ; j++ ) {
  /* Initialisation avec un nombre aleatoire compris      */
  /* entre 0 et max                                       */
        m[i][j] =(int) (Math.random()*(max+1)); }
  /* Resultat de la fonction                              */
    return(m);
  }

  /* Fonction de creation d'une matrice carree d'entiers  */
  /* pandiagonale magique                                 */
  /* ATTENTION: Cette fonction ne marche que pour         */
  /* les matrices de taille 4 et 5 et rend toujours       */
  /* la meme matrice                                      */
  /* Une autre taille a pour consequence la creation      */
  /* d'une matrice ne contenant que des 0                 */
  /* n : nombres de lignes et de colonnes de la matrice   */
  /* Resultat fonction : Matrice d'entiers                */

  public static int [][] matriceMagique(int n) {
    if ( n == 4 ) {
      int [][] m = { {  7,12, 1,14 },
                     {  2,13, 8,11 },
                     { 16, 3,10, 5 },
                     {  9, 6,15, 4 } };
      return(m); }
    if ( n == 5 ) {
      int [][] m = { {  1,15,24, 8,17 },
                     { 23, 7,16, 5,14 },
                     { 20, 4,13,22, 6 },
                     { 12,21,10,19, 3 },
                     {  9,18, 2,11,25 } };
      return(m); }
    int [][] m = new int[n][n];
    return(m);
  }

  /* Fonction de creation d'une chaine de caracteres      */
  /* representant un nombre justifie a droite complemente */
  /* par des espaces                                      */
  /* v : entier a formater                                */
  /* larg : nombre de caracteres de la chaine resultat    */
  /* Resultat fonction : Chaine de caracteres             */

  public static String justifieADroite(int v,int larg) {
  /* Definition et initialisation de la chaine            */
  /* avec l'entier a formater                             */
    String s = ""+v;
  /* Ajout a gauche a la chaine d'autant de caracteres    */
  /* espace qu'il le faut pour que sa longueur devienne   */
  /* superieure ou egale a la largeur recherchee          */
    while ( s.length() < larg )
      s = " "+s;
  /* Resultat de la fonction                              */
    return(s);
  }

  /* Fonction d'affichage d'une matrice d'entiers         */
  /* m : tableau d'entiers a afficher                     */
  /* larg : largeur de chaque colonne                     */

  public static void affichageMatrice(int [][] m,int larg) {
    for ( int i = 0 ; i < m.length ; i++ ) {
  /* Pour toute les lignes de la matrice a afficher       */
      for ( int j = 0 ; j < m[0].length ; j++ ) {
  /* Affichage d'un entier de la ligne i                  */
  /* (sans aller a la ligne                               */
        System.out.print(justifieADroite(m[i][j],larg+1)); }
  /* On va a la ligne quand tous les entiers d'une ligne  */
  /* ont ete affiches                                     */
      System.out.println(); }
  }

  /* Fonction principale                                  */

  public static void main(String [] args) throws IOException {
  /* Lecture au clavier du nombre de lignes               */
  /* et du nombre de colonnes de la matrice               */
    System.out.print("Quelle taille  : ");
    int n = Integer.valueOf(flux.readLine()).intValue();
  /* Creation d'une matrice aleatoire de taille n         */
    int [][] m1 = creationMatriceAleatoire(n,100);
  /* Affichage du resultat du remplissage                 */
    System.out.println("La matrice est :");
    affichageMatrice(m1,6);
  /* Affichage du resultat du test                        */
    System.out.println("Matrice magique ? : "+testMatriceMagique(m1));
  /* Creation d'une matrice magique de taille n           */
    int [][] m2 = matriceMagique(n);
  /* Affichage du resultat du remplissage                 */
    System.out.println("La matrice est :");
    affichageMatrice(m2,6);
  /* Affichage du resultat du test                        */
    System.out.println("Matrice magique ? : "+testMatriceMagique(m2));
  }
}