package Clases;
import java.util.Random;
public class Metodos {
    static Random ran = new Random();
    static int matriz [][] = new int [9][9];

    public static void main(String[] args) {
        generadorAleatorio();
    }
    
    public static void generadorAleatorio (){
        int i=0,j;
        
        while (i < 9){
            System.out.println("fila:  " + i);
            j = 0;
            while (j < 9){
                System.out.println("Columna" + j);
                int numero = 1 + ran.nextInt(9);
                System.out.println(numero);
                System.out.println(busquedaFilas(numero, i));
                if (busquedaFilas(numero, i).equalsIgnoreCase("no")) {
                    
                    System.out.println(busquedaColumnas(numero, j));
                    if (busquedaColumnas(numero, j).equalsIgnoreCase("no")) {
                        
                        System.out.println(busquedaCaja(numero, i, j));
                        if (busquedaCaja(numero, i, j).equalsIgnoreCase("no")) {
                            
                            matriz[i][j] = numero;
                            System.out.println(numero + "Valido");
                            j++;
                        }
                    }
                }
            }
            i++;
        }
        for (int k = 0; k < 9; k++) {
            System.out.println("");
            for (int l = 0; l < 9; l++) {
                System.out.print(matriz[k][l] + "\t");
            }
        }
        
    }
    
    public static String busquedaFilas (int valor, int filas) {
        
        String resultado = "no";
        for (int i = 0; i < 9; i++) {
            if (valor == matriz[filas][i]) {
                resultado = "si";
                break;
            }
        }
        return resultado;
    }
    
    public static String busquedaColumnas (int valor, int columnas) {
        
        String resultado = "no";
        for (int i = 0; i < 9; i++) {
            if (valor == matriz[i][columnas]) {
                resultado = "si";
                break;
            }
        }
        return resultado;
    }
    
    public static String busquedaCaja (int valor, int filas, int columnas) {
        
        int minfila, maxfila;
        int mincolum, maxcolum;
        
        if (filas >= 0 && filas < 3) {
            minfila = 0;
            maxfila = 2;
        }else if (filas >= 3 && filas < 6) {
            minfila = 3;
            maxfila = 5;
        }else {
            minfila = 6;
            maxfila = 8;
        }     
        
        if (columnas >= 0 && columnas < 3) {
            mincolum = 0;
            maxcolum = 2;
        }else if (columnas >=3 && columnas <6) {
            mincolum = 3;
            maxcolum = 5;
        }else{
            mincolum = 6;
            maxcolum = 8;
        }
               
        String resultado = "no";
        
        for (int i = minfila; i <= maxfila ; i++) {
            for (int j = mincolum; j <= maxcolum; j++) {
                if (valor == matriz[i][j]) {
                    resultado = "si";
                    break;
                }
            }
        }
        return resultado;
    }
}

TmpFila = GetValoresEnFila(Entero Y)  //solo pongo el psedocodigo para esta función, comprendiendo ésta es fácil deducir como han de ser las otras dos funciones...
TmpColumna = GetValoresEnColumna(Entero X)
TmpBloque = GetValoresEnBloque(Entero X, Entero Y)

Tmp = UnificarCubiculos(TmpFila, TmpColumna, TmpBloque)

Array Byte = Funcion TomarAusentes(Array Byte Presentes(), Out Entero NumAusentes)
    Array tipo Byte V(0 a c_Ocho)
    Entero k

    NumAusentes=0
    Bucle para k desde 1 a c_Nueve
        Si (Presentes(k) = 0) luego   // El valor está vacío como casilla, en fila, columna y bloque... se añade 
            V(NumAusentes) = k
            NumAusentes +=1
        Fin si
    Fin Bucle

    Devolver V        
Fin Funcion

Array Byte Sudoku(0 a 80)  //es el array que mantiene internamente los valores. 

Array Byte = Funcion GetValoresEnFila(Entero n)
    Array tipo Byte V(0 a c_Ocho)
    Entero Index, k

    Index= (n * c_Nueve)
    n = 0 // Reutilizamos n (se recibe por valor)
    Bucle para k desde Index a (Index + c_Ocho)
        V(n) = Sudoku(k)  //Aray que contiene los valores
        n +=1
    Fin Bucle
   
    Devolver V
Fin Funcion

Array Byte = Funcion UnificarCubiculos(Array Byte Fila(), Array Byte Columna(), Array Byte Bloque())
    Array tipo Byte V(0 a c_Nueve)

    // contar el número de presencias de cada valor...
    Bucle para k desde 0 a c_Ocho
        Si (Fila(k) > 0) luego   // Si no está vacía la casilla...
            V(Fila(k)) += 1
        fin si
        Si Columna(k) > 0 luego   // Si no está vacía la casilla...
            V(Columna(k)) += 1
        fin si
        Si (Bloque(k) > 0) luego   // Si no está vacía la casilla...
            V(Bloque(k)) += 1
        fin si
    Fin Bucle
  
    // Ahora se reagrupan arriba en el array (las ausencias (valor 0), quedan 'huecas' en la parte alta del array.
    V(0) = 0 //Realmente no es necesario, ya que no llevó la cuenta de 'ceros'
    Bucle para k desde 1 a c_Nueve
        Si (V(k) > 0) luego
            V(k) = k            
        Fin si
    Fin Bucle

    Devolver V        
Fin Funcion

Byte = funcion SeleccionarValorAzar(Entero X, Entero Y) 
    Array tipo Byte TmpFila()
    Array tipo Byte TmpColumna()
    Array tipo Byte TmpBloque()
    Array tipo Byte Tmp()
    Array tipo Byte Azar()

    // Primero consultamos que tenemos, en la 'vecindad' de esa casilla.
    //      Puede optimizarse si se mantienen en memoria 9 arrays de filas, 9 de columnas y los 9 de bloques y se actualizan convenientemente. Será mas veloz, pero más complejo y másgasto de memoria... Hacerlo, queda a tu esfuerzo si te interesa.
    // Recuérdese que las casillas 'vacías', tienen valor 0
    TmpFila = GetValoresEnFila(Entero Y)
    TmpColumna = GetValoresEnColumna(Entero X)
    TmpBloque = GetValoresEnBloque(Entero X, Entero Y)

    // Ya tenemos, los 3 cubículos con los que comparar el valor al azar... pero...
    // ya dije que no vamos a comparar, en su defecto, integraremos los 3 en 1 ( a modo de resumen, que simplica
    // por completo la verificación a un simple bucle).
    Tmp = UnificarCubiculos(TmpFila, TmpColumna, TmpBloque)

    // Ahora rellenamos otro array con los valores ausentes en el array resumen unificado.
    Byte n 
    Azar = TomarAusentes(Tmp, n)

    // OJO: si el array queda vacío implica que hay que desecha los valores actuales de la fila y volver a reconstruirla entera
    Si (n=0) luego devolver 0

    // Finalmente se toma un valor al azar entre 0 y n-1, que representa el indice del array Azar. Este array tiene exclusivamente los números que no aparecen ni en la fila, ni en columna, ni en bloque. 
    k = Aleatorio( entre 0 y n-1)

    Devolver Azar(k)
Fin Funcion

Funcion RellenarSudokuAlAzar()    
    Entero Fila, columna
    Byte Valor

    Fila=0 // la primera fila, la podrías obtener al azar completamente en ese caso marcar aquí 1, para comenzar en la fila 1, la 0 no va a requerir todas las comprobaciones que pueden requerir las siguientes.
    Hacer  '// esto es fila, puede ser un bucle que va de 0 a 8
        Columna = 0
        Hacer    
            Valor = SeleccionarValorAzar(Columna, Fila)  //la función que obtiene un valor de cada vez.
            Si (Valor>0) luego
                Sudoku((Fila * c_Nueve) + Columna) = valor //Sudoku() es el array que mantiene internamente los valores.     
                // Si el array es bidimensional se pondría así...    
                //Sudoku(Columna, Fila) = valor     
                Columna +=1
            Si no
                // Borra los valores de la fila actual
                Bucle para k desde 0 a columna
                    Sudoku((Fila * c_Nueve) + k) = 0
                Fin bucle
                Columna = 0
            Fin si
        Repetir Mientras (Columna <9)
        Fila +=1
    Repetir Mientra (Fila<9) 
Fin Funcion

 Funcion RellenarSudokuAlAzar()    
    Entero Fila, columna
    Byte Valor, Intentos

    Fila=0 // la primera fila, la podrías obtener al azar completamente en ese caso marcar aquí 1, para comenzar en la fila 1, la 0 no va a requerir todas las comprobaciones que pueden requerir las siguientes.
    Hacer  '// esto es fila, puede ser un bucle que va de 0 a 8
        Intentos = 0
        Columna = 0
        Hacer    
            Valor = SeleccionarValorAzar(Columna, Fila)  //la función que obtiene un valor de cada vez.
            Si (Valor>0) luego
                Sudoku((Fila * c_Nueve) + Columna) = valor   //Sudoku() es el array que mantiene internamente los valores.             
                Columna +=1
            Si no
                // Borra los valores de la fila actual
                Bucle para k desde 0 a columna
                    Sudoku((Fila * c_Nueve) + k) = 0
                Fin bucle

                // Tras 10 intentos en la misma fila, borramos también la fila previa
                Intentos += 1
                Si (Intentos = 10) luego
                    Si (Fila > 0) luego  // no podemos retroceder a filas más atrás que la primera.
                        Fila = (Fila - 1) // Borramos también la fila anterior (y si sucede otra vez, la previa, etc...)
                        Bucle para k desde 0 To c_Ocho
                            Sudoku((Fila * c_Nueve) + k) = 0                            
                        Fin Bucle
                    Fin si
                    Intentos = 0
                Fin si
                Columna = 0
            Fin si
        Repetir Mientras (Columna <9)
        Fila +=1
    Repetir Mientra (Fila<9) 
Fin Funcion
// Al término de esta función se podría dibujar los valores en el tablero para verificar visualmente el resultado.

bucle para k desde 1 a 9
  si tmp(k) Es mayor que 0 luego
     tmp(k) = k // tmp(1) = 1 .... tmp(5)= 5 ... tmp(9) = 9
  fin si
fin bucle

Array Byte = Funcion TomarAusentes(Array Byte Presentes(), Out Entero NumAusentes)
    Array tipo Byte V(0 a c_Ocho)
    Entero k

    NumAusentes=0
    Bucle para k desde 1 a c_Nueve
        Si (Presentes(k) = 0) luego   // El valor está vacío como casilla, en fila, columna y bloque... se añade 
            V(NumAusentes) = k
            NumAusentes +=1
        Fin si
    Fin Bucle

    Devolver V        
Fin Funcion

    k = Aleatorio( entre 0 y n-1) //n es aquí el valor devuelto por referencia de la cantidad de 'valores válidos' en el array.
    Devolver Azar(k)

Byte = funcion SeleccionarValorAzar(Entero X, Entero Y) 
    Array tipo Byte Tmp()
    Byte n 
    
    Tmp = GetArrayAusentes(X, Y)
    Si (n>0) luego
        n = DevolverValorAzar(Tmp, n)
    Fin si
    Devolver n
Fin Funcion

Array byte = GetArrayAusentes(Entero X, Entero Y,  Out Entero NumAusentes)
    Array tipo Byte TmpFila()
    Array tipo Byte TmpColumna()
    Array tipo Byte TmpBloque()
    Array tipo Byte Tmp()
    Array tipo Byte Azar()

    // Primero consultamos que tenemos, en la 'vecindad' de esa casilla.
    //      Puede optimizarse si se mantienen en memoria 9 arrays de filas, 9 de columnas y los 9 de bloques y se actualizan convenientemente. Será mas veloz, pero más complejo y másgasto de memoria... Hacerlo, queda a tu esfuerzo si te interesa.
    // Recuérdese que las casillas 'vacías', tienen valor 0
    TmpFila = GetValoresEnFila(Entero Y)
    TmpColumna = GetValoresEnColumna(Entero X)
    TmpBloque = GetValoresEnBloque(Entero X, Entero Y)

    // Ya tenemos, los 3 cubículos con los que comparar el valor al azar... pero...
    // ya dije que no vamos a comparar, en su defecto, integraremos los 3 en 1 ( a modo de resumen, que simplica
    // por completo la verificación a un simple bucle).
    Tmp = UnificarCubiculos(TmpFila, TmpColumna, TmpBloque)

    // Ahora rellenamos otro array con los valores ausentes en el array resumen unificado.
    
    Devolver = TomarAusentes(Tmp, NumAusentes)
Fin Funcion

Byte = DevolverValorAzar(Array byte Ausentes(), Byte Cantidad)
    byte k
     
    k = Aleatorio( entre 0 y Cantidad-1)
    Devolver Ausentes(k)
Fin Funcion

Buleano = funcion ValorEsAdmisible(Entero X, Entero Y, Byte ValorUser) 
    Array tipo Byte Tmp()
    Byte n 
    
    Tmp = GetArrayAusentes(X, Y)
    Si (n>0) luego
        Devolver ExisteValorEnAusentes(Tmp, n, ValorUser)
    Si no 
        Devolver FALSE
    Fin si
    Devolver n
Fin Funcion

Buleano = ExisteValorEnAusentes(Array byte Ausentes(), Byte Cantidad, byte ValorUser)
    byte k
    
    Bucle para k desde 0 a Cantidad-1 
        Si (Ausentes(k) = ValorUser) luego
            Devolver TRUE
        Fin si
    Fin Bucle
Fin Funcion

.... //código previo
            Valor = SeleccionarValorAzar(Columna, Fila)  //la función que obtiene un valor de cada vez.
            Si (Valor>0) luego
                Sudoku((Fila * c_Nueve) + Columna) = valor   //Sudoku() es el array que mantiene internamente los valores.             
                Columna +=1
            Si no
                // Borra los valores de la fila actual
                Bucle para k desde 0 a columna
                    Sudoku((Fila * c_Nueve) + k) = 0
                Fin bucle

                // Tras 10 intentos en la misma fila, borramos también la fila previa
                Intentos += 1
                Si (Intentos = 10) luego
                    Si (Fila > 0) luego  // no podemos retroceder a filas más atrás que la primera.
                        Fila = (Fila - 1) // Borramos también la fila anterior (y si sucede otra vez, la previa, etc...)
                        Bucle para k desde 0 To c_Ocho
                            Sudoku((Fila * c_Nueve) + k) = 0                            
                        Fin Bucle
                    Fin si
                    Intentos = 0
                Fin si
                Columna = 0
            Fin si
.... // código después...

public static int [] obtenerFila (int matriz[][], int filas, int columnas){
        int renglon[] = new int[9];
        for (int i = 0; i < 9; i++) {
            renglon[i]=matriz[i][columnas];
        }
        return renglon;
    }
    
    public static int [] obtenerColumna (int matriz[][], int filas, int columnas){
        int colum[] = new int[9];
        for (int i = 0; i < 9; i++) {
            colum[i]=matriz[filas][i];
        }
        return colum;
    }
    
    public static int [] obtenerCaja (int matriz[][], int filas, int columnas){
        
        int minfila, maxfila;
        int mincolum, maxcolum;
        
        if (filas >= 0 && filas < 3) {
            minfila = 0;
            maxfila = 2;
        }else if (filas >= 3 && filas < 6) {
            minfila = 3;
            maxfila = 5;
        }else {
            minfila = 6;
            maxfila = 8;
        }     
        
        if (columnas >= 0 && columnas < 3) {
            mincolum = 0;
            maxcolum = 2;
        }else if (columnas >=3 && columnas <6) {
            mincolum = 3;
            maxcolum = 5;
        }else{
            mincolum = 6;
            maxcolum = 8;
        }
        
        int k=0;
        int caja[] = new int[9];
        for (int i = minfila; i < maxfila; i++) {
            for (int j = mincolum; j < maxcolum; j++) {
                caja[k]=matriz[i][j];
                k++;
            }
        }
        return caja;
    }