lo que hago para contar con la matriz en todo el codigo es declararla como static como si fuera una variable global, eso mismo es lo que estaba intentando con los otros array ponerlos globales a ver si me funcionaba
Bien. Cuando unos parámetros, en este caso arrays se usan para unas funciones que se usan masivamente, es preferible crear el array una sola vez y luego solo sobrescribirlos. Obviamente de cara a explicaciones, es preferible que cada función se acompañe de exactamente los parámetros que necesite o es más fácil perderse por no ver o saber de donde salen esas variables...
De hecho, de cara a optimizarlo (primero haz que funcione y funcione bien, siempre es lo primero, luego ya se optimizará), a veces un array puede ser reutilizado en más de una función (uno debe tener claro cuando esto es así, para no interferir en los valores y tenerlos sucios esperando unos valores que fueron cambiados por otra función).
Por otro lado hay algunas cosas que no entiendo de tu codigo pero lo estoy intentando a mi manera tratando de interpretar tu codigo.
Cuando suceda, lo remarcas y luego que sumes varias (si las hay), preguntas por esas dudas.
A la hora de crear el unificado tengo problemas con el ciclo lo empiezo en 1 hasta <= 9 para que no tome los valores de 0 y me bota error, esto es lo que llevo hasta el momento no esta terminado ni depurado hay sobre la marcha me voy dando cuenta que me falta
static int unificado[] = new int[9];
public static void unificarArray() {
for (int i = 0; i < 9; i++) {
unificado[filas[i]] = unificado[filas[i]] + 1;
unificado[columnas[i]] = unificado[columnas[i]] + 1;
unificado[caja[i]] = unificado[caja[i]] + 1;
}
for (int i = 0; i < 9; i++) {
System.out.print(unificado[i] + "\t");
}
}
No es eso lo que veo en tu código es más, no se ajusta a mi descripción, copio y pego la mía y verás que no se ajusta...
Al caso he retirado los comentarios previos y añadido otros que es donde debes fijarte. También cambio las etiquetas de code por cita, para poner énfasis con negrita:
Array Byte = Funcion UnificarCubiculos(Array Byte Fila(), Array Byte Columna(), Array Byte Bloque())
Array tipo Byte V(0 a c_Nueve) // esto es, 10 ELEMENTOS. Este array es de 10 elementos
// contar el número de presencias de cada valor...
Bucle para k desde 0 a c_Ocho // OJO: 0 a 8
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
V(0) = 0 //Realmente no es necesario, ya que no llevó la cuenta de 'ceros'
// Tu si llevas la cuenta al omitir, los condicionales d emás arriba, luego esto es aconsejable, no tanto como obligado 8más abajo mé extiendo sobre esto).
// En tu versión, falta este bucle
Bucle para k desde 1 a c_Nueve //OJO: el bucle recorre desde 1 a 9
Si (V(k) > 0) luego //esto es imprescindible. Presencia, indica que aparece. Se consigna k, sólo si v(k) es mayor que 0, es decir si aparece.
V(k) = k
Fin si
Fin Bucle
Devolver V
Fin Funcion
En tu código también llevas la cuenta de 0, no importa, es más sencillo eliminar el condicional, pero en ese caso si será útil, al final la línea donde la comento como: " //Realmente no es necesario, ya que no llevó la cuenta de 'ceros'", como tu si has llevado la cuenta, ponlo a 0. Incluso aunque no se utilice ahora, un cambio a futuro, y que hayas olvidado que eso vale 0 podría darte dolores de cabeza intentando buscar el error. Es sólo una línea de código y evita problemas a futuro, es mejor ponerla.
Luego en mi 'versión' hay dos bucles, en uno genero la "tabla de conteo" de cada valor, pero eso es solo la primera parte, falta la segunda parte, donde en el otro la tabla de conteo se convierte en una "tabla de presencia".
En 'tu versión' el segundo bucle no existe, el que hay se remite al "System.out.print" que solo tiene efectos de verificación, pero le falta el 2º bucle que yo le pongo.
Ya he comentado que a efectos de optimización en ese segundo bucle se podría hacer la parte de la siguiente función, pero sería mucho más scuro, haciendo que cadas función haga una sola tarea (eso si, completa), queda perfectamente claro el propósito (único) de cada función...
- Una tabla de conteo: Es una tabla (array, unidimensional, bidimensional etc...) que lleva la cuenta de veces que aparece un determinado valor. Imagina un fichero de imagen, imagina que quieres obtener su histograma, necesitas contar cuantas veces aparece cada nivel de rojo, de verde y de azul en la imagen. Dando una imagen de 8bits por canal (un byte), se necesitará pués 3 arrays para contar los niveles de rojo, verde y azul. el array tendrá256 elementos por 256 son los niveles posibles para el rojo, verde y azul, es decir valores entrte 0 y 255...entonces leyendo la imagen con cada aparición haríamos algo como (para contarlos):
arrRojo(Imagen.Rojo(n)) = arrRojo(imagen.Rojo(n)) +1
Que como se ve, no es distinto de nuestor caso, salvando el origen de los datos y el tamaño del array.
- Tabla de presencia: es una tabla donde lo único que necesitamos saber es que dicho valor aparece y nos da igual cuántas veces aparece... Esto puede hacerse directamente o a partir de la tabla anterior. De cara a entender, es preferible hacerlo indirectamente desde creando antes la tabla de conteo, así se vé con mucha claridad, como se crea esta otra...
si arrRojo(nivel) > 0 luego
arrRojo(nivel) = nivel
Fin si
Antes el array podía tener un valor elevado (más tratándose de una imagen si la imagen fuera casi toda blanca y tuviera pongamos un tamaño de 3500x2500 píxeles de ancho y alto (o al revés) tendríamos 8.750.000 píxeles en total, en total como solo hay 256 canales y lo son para el rojo, verde y azul, ni 8bits ni 16bits, nos valen para contener dicha cuenta, tendríamos que usar un array de 32 bits... Así es la tabla de conteno. En cambio la tabla de presencia basta que tenga como tipo de datos el más alto del valor que haya de contener, en este caso aún tratándose de colores, bastaría un array de bytes, porque los niveles solo van del 0 al 255. Luego es decisión de cada cual si aprovechas el mismo array para ambas tablas o no.
En el caso del sudoku, aunque lo has declarado integer y realmente nos basta con byte reutilizamos el array...
Para ver la diferencia entre ambas tablas, puedes imprimir el resultado de cada una al final de cada bucle. Verás que la tabla de conteo es equivalente a la tabla de presencia, la tabla de presencias, es también una tabla de ausencias, todos aquellos índices cuyo valor es 0, señala que no están ausentes. La tabla de ausencias que creamos luego es 'ordenada', y es básicamente mover al comienzo del array esos valores ausentes. Con el fin justamente de luego al usar una función random, elegir un índice al azar entre 0 el el último que porta un valor ausente. Al estar contiguos, eso es posible, si no habría que ver si el valor al azar entre el 0 y el 9, está ausente... pero si no lo está repetir todo el proceso se eterniza. Del modo en que procedemos se garantiza con una sola vez la elección de azar y una sola vez la
verificación (previa), sacar el siguiente número a consignar.
--------------------
P.d.:
En tu función de ausentes observo dos fallos:
Quito las etiquetas de code, para comentar encima con engrita.
Bueno al quirtar las etiquetas de code, como usas llaves con 'i', el codigo BBcode, lo interpreta como itálica, así que lo cambio, saco los comentarios y en su lugar dejo asteriscos
public static void TomarAusentes (){
int numeros; //no se usa...
for (int i = 0; i < 10; i++) { // **********01
if (unificado[i] == 0) {
ausentes[i] = i; // **********02
}
}
}
// **********01
Este bucle debe empezar en 1, no en 0. Los valores UTILES para el sudoku van del 1 al 9, el 0 no es un valor elegible, indica 'casilla vacía', 'casilla libre', 'casilla sin valor aún'
// **********02
NO: Este debe llevar su propio contador, no puede ser 'i'. Con cada aparición aumenta, si no, no estarían los valores contiguos...// Imagina que te dicen aqui tienes una lista de alumnos. Todos los que tengan más de 18 años, los escribes en ESTA OTRA lista... acaso en esa nueva lista, no irían contiguos?. el primero hallado en la posición 0, el siguiente en la 1, el siguiente hallado en la 2, etc... sería absurdo que en esa nueva lista, aparezca un alumno en la posición 43, y en la nueva lista, tu lo consignes también en la posición 43... ¿Capisci, el significado de 'nueva lista' y 'valores contiguos'? . cuando se tenga esa lista de alumnos con más de 18 años quien la trate, la tratará contigua, imagina que entre ellos se va ahacer un sorteo para ver una peli para mayor de 18 años, si en la lista hay inscritos 61 alumnos, se harían papeletas entre 1 y 61 (0 y 60 si lo consideramos técnicamente). Si la lista el último alumno se hubiera inscrito con su posición original pongamos 1563, sería complicado elegir al azar a un alumno, por número, se podría hacer por nombre, peor las matemáticas están para socorrernos, simplifiquemos cuando es posible. Entre 1 y 61 8ó 0 y 60), todos en una sala solitos, es más aislado que sortearlo entre los 1850 alumnos d ela escuela y luego preguntarle si tiene más de 18 años y si es que no, dejarle con un palmo de narices. Usando nombres, los que son menores no entran en el sorteo, pero ven 'en directo' el sorteo saltando por encima de sus cabezas 'produciendo algo de envidia'
Mejos con la lista aparte en otra función (una sala, se los llama ) y a puerta cerrada se hace el sorteo solo entre los implicados...
Bueno, cuando ya 'furrulen' estas dos funciones si tienes más dudas, pregunta.