magic square java_JAVA "magic square"判定算法的实现。

package com.qiqi;

import java.util.Scanner;

/**

*

* Magic squares. An n*n matrix that is filled with the numbers 1, 2, 3, . . . , n2 is a

* magic square if the sum of the elements in each row, in each column, and in the two

* diagonals is the same value. For example,

*

*　　16 3 2 13

*　　5 10 11 8

*　　9 6 7 12

*　　4 15 14 1

*

* Write a program that reads in n2 values from the keyboard and tests whether they

* orm a magic square when arranged as a square matrix. You need to test three

* features:

* • Did the user enter n2 numbers for some n?

* • Do each of the numbers 1, 2, . . . , n2 occur exactly once in the user input?

* • When the numbers are put into a square, are the sums of the rows, columns,

* and diagonals equal to each other?

* If the size of the input is a square, test whether all numbers between 1 and n2 are

* present. Then compute the row, column, and diagonal sums. Implement a class

* Square with methods

*　public void add(int i)

*　public boolean isMagic()

*

* @author Administrator

*

*/

public class Magic_squares {

public static void main(String[] args) {

// TODO Auto-generated method stub

Square_n square_4 = new Square_n(4);

square_4.print();

System.out.println("whether all numbers between 1 and n*n are present: " + square_4.is_everyone_exist());

System.out.println("is this square a magic one: " + square_4.isMagic());

}

}

/**

* the class use to store a square matrix,and some other informations.

* with some function we can do the test job.

* @author Administrator

*

*/

class Square_n {

/**

* square used to store the square matrix.

* flag help us to check whether all numbers between 1 and n*n are present or not.

* n is the rank of the square.

*/

int[][] square;

int[] flag;

int n;

/**

* non-parameter constructor.we set n = 4 as the default rank.

* we will initialize the square and flag first and the input the

* number of the square.

*/

Square_n() {

n = 4;

square = new int[n][n];

flag = new int[n * n];

input_the_square();

}

/**

* constructor with a parameter l.please check out upstairs.

* @param l

* l is the rank of the square.

*/

Square_n(int l) {

n = l;

square = new int[n][n];

flag = new int[n * n];

input_the_square();

}

/**

* this function help us print the square out as an standard matrix format.

*/

public void print() {

// TODO Auto-generated method stub

for(int row = 0; row < n; row ++){

for(int column = 0; column < n; column ++)

System.out.print(square[row][column] + " ");

System.out.println();

}

}

/**

* accept the numbers form the keyboard.

*/

private void input_the_square() {

// TODO Auto-generated method stub

Scanner scanner = new Scanner(System.in);

for (int row = 0; row < n; row ++){

for (int column= 0; column < n; column ++){

square[row][column] = scanner.nextInt();

flag[row * n + column] = square[row][column];

}

}

scanner.close();

System.out.println();

System.out.println("you have already enter n*n numbers");

}

/**

* here we can test do each of the numbers 1, 2, . . . , n*n

* occur exactly once in the user input.in this method we sort

* the flag by bubble sort, and then check if every number equal

* to the index or not.we return true for every number exist once.

* @return

*/

public boolean is_everyone_exist(){

int max;

int tmp;

for(int i = flag.length - 1; i > 0; i --){

max = 0;

for(int j = 0; j <= i; j ++){

if(flag[max] < flag[j]) max = j;

}

tmp = flag[i];

flag[i] = flag[max];

flag[max] = tmp;

}

for (int index = 0; index < flag.length; index ++){

if(flag[index] != index + 1)

return false;

}

return true;

}

/**

* to tell the truth i don't know why do we should have a function add,

* it's useless for my part so I suspend it.

* @param i

*/

public void add(int i){}

/**

* we just check every sum one by one,it's easy.

* true for what we input is a magic one.

* @return

*/

public boolean isMagic(){

if (!is_everyone_exist()) return false;

else {

int sum = 0;

int sum_temp = 0;

for (int index = 0; index < n; index ++)

sum += square[index][index];

for (int index = 0; index < n; index ++)

sum_temp += square[index][n - 1 - index];

if (sum_temp != sum) return false;

for (int row = 0; row < n; row ++){

sum_temp = 0;

for (int column = 0; column < n; column ++)

sum_temp += square[row][column];

if (sum_temp != sum) return false;

}

for (int column = 0; column < n; column ++){

sum_temp = 0;

for (int row = 0; row < n; row ++)

sum_temp += square[row][column];

if (sum_temp != sum) return false;

}

return true;

}

}

}