Clase MagicSquare (tarea obligatoria seminario IP) - Fernando García Álvarez

MagicSquare

import java.util.Random;
/**
 * Clase MagicSquare realizada para el ejercicio de seminario de IP
 * 
 * @author Fernando
 * @version 
 */
public class MagicSquare
{
    public static final int MAX_SIZE = 10;
    
    private int[][] numbers; 
    private int size;
    
    /**
     * Constructor sin parámetros
     */
    public MagicSquare()
    {
        setSize(MAX_SIZE);
    }
    
    /**
     * Constructor con un parámetro
     * 
     * @param size dimensión del cuadrado
     */
    public MagicSquare(int size)
    {
        this();
        setSize(size);
    }
    
    /**
     * Método que rellena la matriz con números enteros entre 1 y dimensión al cuadrado de forma aleatoria
     */
    public void fillSquare()
    {
        Random random = new Random();
        
        for(int i=0; i<numbers.length; i++)
        {
            for(int j=0; j<numbers[0].length; j++)
            {
                numbers[i][j] = random.nextInt(getSize() * getSize()) + 1;
            }
        }
    }
    
    /**
     * Método que establece la dimensión del cuadrado
     * 
     * @param newSize dimensión del cuadrado
     */
    private void setSize(int newSize)
    {
        if(newSize > 0 && newSize <= MAX_SIZE)
        {
            size = newSize;
            numbers = new int[size][size];
        }
    }
    
    /**
     * Método que devuelve la dimensión del cuadrado
     * 
     * @return int dimensión del cuadrado
     */
    public int getSize()
    {
        return size;
    }
    
    /**
     * Método para colocar un número en una posición determinada
     * 
     * @param row fila en la que se colocará el número
     * @param column columna en la que se colocará el número
     * @param number número a colocar
     */
    public void placeNumber(int row, int column, int number)
    {
        if(row >= 0 && row < numbers.length && column >= 0 && column < numbers[0].length)
        {
            numbers[row][column] = number;
        }
    }
    
    /**
     * Método que devuelve true si las dos diagonales del cuadrado suman lo mismo, false en caso contrario
     * 
     * @return boolean true si las dos diagonales del cuadrado suman lo mismo, false en caso contrario
     */
    private boolean isMagicSquareDiags()
    {
        return sumDiagonalSec() == sumDiagonalPrin();
    }
    
    /**
     * Método que devuelve la suma de los elementos de la diagonal secundaria del cuadrado
     * 
     * @return int suma de los elementos de la diagonal secundaria del cuadrado
     */
    private int sumDiagonalSec()
    {
        int sum = 0;
        for(int i = 0; i<numbers.length; i++){
            for(int j = 0; j < numbers[i].length; j++){
                if(i+j == numbers.length - 1){
                    sum = sum + numbers[i][j];
                }
            }
        }
        return sum;
    }
    
    /**
     * Método que devuelve la suma de los elementos de la diagonal principal del cuadrado
     * 
     * @return int suma de los elementos de la diagonal principal del cuadrado
     */
    private int sumDiagonalPrin()
    {
        int sum = 0;
        for(int i=0; i<numbers.length; i++)
        {
            for(int j=0; j<numbers[i].length; j++)
            {
                if(i == j)
                    sum = sum + numbers[i][j];
            }
        }
        return sum;
    }
    
    /**
     * Método que indica si un cuadrado es un cuadrado mágico o no
     * 
     * @return boolean true si el cuadrado es un cuadrado mágico, false en caso contrario
     */
    public boolean isMagicSquare()
    {
        return isMagicSquareRows() && isMagicSquareColumns() && isMagicSquareDiags();
    }
    
    /**
     * Método que muestra en pantalla el contenido de la matriz en forma de cuadrado (cada fila de la matriz en una línea distinta)
     */
    public void showSquare()
    {
        for(int i=0; i<numbers.length; i++)
        {
            for(int j=0; j<numbers[0].length; j++)
            {
                System.out.print(numbers[i][j]);
            }
            System.out.println();
        }
    }
    
    /**
     * Método que devuelve la suma de la fila indicada
     * 
     * @param row fila de la que se quiere conocer su suma
     * 
     * @return int suma de la fila indicada
     */
    private int sumRow(int row)
    {
        int sum = 0;
        
        if(row >= 0 && row < numbers.length)
        {
            for(int j = 0; j<numbers[0].length; j++)
            {
                sum = sum + numbers[row][j];
            }
        }
        
        return sum;
    }
    
    /**
     * Método que devuelve la suma de la columna indicada
     * 
     * @param column columna de la que se quiere conocer su suma
     * 
     * @return int suma de la columna indicada
     */
    private int sumColumn(int column)
    {
        int sum = 0;
        if(column >= 0 && column < numbers[0].length)
        {
            for(int i=0; i<numbers.length; i++)
            {
                sum = sum + numbers[i][column];
            }
        }
        
        return sum;
    }


    /**
     * Método que devuelve true si todas las filas del cuadrado suman el mismo valor, false en caso contrario
     * 
     * @return boolean true si todas las filas del cuadrado suman el mismo valor, false en caso contrario
     */
    private boolean isMagicSquareRows()
    {
        int lastSum = sumRow(0);
        for(int i=0; i<numbers.length; i++)
        {
            if(sumRow(i) != lastSum)
            {
                return false;
            }
        }
        return true;
    }
    
    /**
     * Método que devuelve true si todas las columnas del cuadrado suman el mismo valor, false en caso contrario
     * 
     * @return boolean true si todas las columnas del cuadrado suman el mismo valor, false en caso contrario
     */
    private boolean isMagicSquareColumns()
    {
        int lastSum = sumColumn(0);
        for(int j=0; j<numbers[0].length; j++)
        {
            if(sumColumn(j) != lastSum)
            {
                return false;
            }
        }
        return true;
    }
    
    /**
     * Método que genera un cuadrado mágico de orden impar, del siguiente modo:
     * 1.
     *      Colocar el número 1 en la casilla del medio de la fila superior.
     * 2.
     *      Para colocar el número siguiente, es necesario desplazarse una casilla hacia arriba
     *      y una hacia la derecha.
     * 3.
     *      Si el número que se intenta colocar se sale del cuadrado por el límite superior del
     *      contorno del mismo, se salta a la celda de
     *      la columna siguiente hacia la derecha y
     *      en su fila inferior, si se sale por la derecha, se sigue por la primera celda, a partir
     *      de la izquierda, de la fila superior.
     * 4.
     *      Si al intentar colocar un número por la re
     *      gla anterior la celda está ocupada, se
     *      sitúa en la casilla inmediatamente inferior a la del último número que se colocó,
     *      comenzando así un nuevo camino en
     *      la dirección de la diagonal. 
     */
    public void generateSquare()
    {
        setSize(5);
        int dim = getSize();
        int[] lastPos = {0, 0};
        int[] nextPos = {0, dim/2};
        
        if(dim % 2 == 0)
        {
            System.out.println("Las dimensiones del cuadrado no pueden ser pares");
            return;
        }
        
        for(int i=1; i<=dim*dim; i++)
        {
            numbers[nextPos[0]][nextPos[1]] = i;
            lastPos[0] = nextPos[0];
            lastPos[1] = nextPos[1];
            nextPos[0] = lastPos[0] - 1;
            nextPos[1] = lastPos[1] + 1;

            if(nextPos[0] < 0)
            {
                nextPos[0] = dim - 1;       
            }

            if(nextPos[1] >= dim)
            {
                nextPos[0] = lastPos[0] - 1;
                nextPos[1] = 0;
            }

            if(nextPos[0] == -1 || numbers[nextPos[0]][nextPos[1]]!=0)
            {
                nextPos[0] = lastPos[0] + 1;
                nextPos[1] = lastPos[1];
            }
        }
    }
    
    /**
     * Método que devuelve el número almacenado en la fila y columna del cuadrado indicadas, o -1 si los parámetros son incorrectos
     * 
     * @param row fila del cuadrado
     * @param column columna del cuadrado
     * 
     * @return int número almacenado en la fila y columna del cuadrado indicadas
     */
    public int getNumber(int row, int column)
    {
        if(row >= 0 && row < numbers.length && column >= 0 && column < numbers[0].length)
        {
            return numbers[row][column];
        }
        return -1;
    }
}