/**
 * A classe {@code Sudoku2} tem uma possivel resolucao da 2a fase do trabalho de IP.
 * Trata-se de um programa que permite ler, gerar e transformar quadriculas Sudoku.
 *
 * Compile: javac Sudoku2.java
 * Execute: java Sudoku2
 *
 * @author
 */

import java.util.Scanner;
import java.util.Random;

class Sudoku2 {
    /**
     * Preenche quadricula com valores lidos atraves do leitor dado
     * ligado ao teclado
     * @param quadricula a quadricula sobre a qual a operacao e' efectuada
     * @param leitor o canal de leitura
     * @requires {@code quadricula} e' matriz 9x9
     * @requires {@code leitor != null}
     * @return se a operacao foi efectuada
     */
    static boolean leQuadricula(int[][] quadricula, Scanner leitor) {
        int[][] matrizLida = leMatriz(leitor, 9, 9);
        boolean valida = quadriculaValida(matrizLida);
        if (valida)
            copia(matrizLida, quadricula);
        return valida;
    }

    /**
     * Copia o conteudo de uma array de arrays para outro
     * @param origem array cujos valores vao ser copiados
     * @param destino o array que vai receber os valores copiados
     * @requires {@code origem, destino} tem as mesmas dimensoes
     */
    static void copia(int[][] origem, int[][] destino) {
        for(int i = 0; i < origem.length; i++)
            for(int j = 0; j < origem[i].length; j++)
                destino[i][j] = origem[i][j];
    }

    /**
     * Preenche uma quadricula com valores dados por funcao GQ
     * @param quadricula a quadricula de Sudoku a preencher
     * @requires {@code quadricula} e' matriz 9x9
     */
    static void preencheComFuncaoGQ(int[][] quadricula){
        for(int i = 0; i < 9; i++)
            for(int j = 0; j < 9; j++)
                quadricula[i][j] = (i / 3 + 3 * (i % 3) + j) % 9 + 1;
    }
    /**
     * Verifica se uma matriz 9x9 e' uma quadricula Sudoku
     * @param quadricula a quadricula a validar
     * @requires {@code quadricula} e' matriz 9x9
     * @return se quadricula e' uma quadricula Sudoku valida
     */
    static boolean quadriculaValida(int[][] quadricula){
        //linhas ok
        for (int i = 0; i < 9; i++)
            if (!numeros1a9(quadricula[i]))
                return false;
        //colunas ok
        for (int i = 0; i < 9; i++)
            if (!numeros1a9(coluna(quadricula, i)))
                return false;
        //blocos ok
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
                if (!numeros1a9(bloco(quadricula, i, j)))
                    return false;
        return true;
    }

    /**
     * Obtem vetor com coluna da matriz
     * @param matriz a matriz
     * @param j o numero da coluna a obter
     * @requires {@code matriz} e' matriz
     * @requires {@code 0 <= j && j <= matriz.length }
     * @return o vector contem os valores na coluna j da matriz
     */
    static int[] coluna(int[][] matriz, int j) {
        int[] col = new int[matriz.length];
        for(int i = 0; i < col.length; i++)
            col[i] = matriz[i][j];
        return col;
    }

    /**
     * Obtem vetor com bloco da matriz
     * @param quadricula a quadricula
     * @param l o numero da linha do bloco a obter
     * @param c o numero da coluna do bloco a obter
     * @requires {@code audricula} e' matriz
     * @requires {@code 0 <= l,c < 3}
     * @return o vector contem os valores no bloco k da quadricula
     */
    static int[] bloco(int[][] quadricula, int l, int c) {
        int[] bloco = new int[9];
        for(int i = 0; i < 3; i++)
            for(int j=0; j < 3; j++)
                bloco[3*i+j] = quadricula[i+3*l][j+3*c];
        return bloco;
    }

    /**
     * Verifica se o vector contem exatamente os valores de 1 a 9
     * @param v vector a validar
     * @requires {@code v != null}
     * @return se o vector tem tamanho 9 e contem os valores de 1 a 9
     */
    static boolean numeros1a9(int[] v) {
        if (v.length != 9)
            return false;

        boolean[] nums = new boolean[9];
        for (int x: v) {
            if (x >= 1 && x <= 9)
                nums[x-1] = true;
        }

        boolean result = true;
        for (int i = 0; i < 9; i++)
            result = result && nums[i];
        return result;
    }
}