Mensajes

[9]

Tengo que irme, no he tenido tiempo de revisar tu código (el último)...
Pero si he alcanzado a ver que en las declaraciones de los arrays tienen todos 9 elementos... fíjate en mi código y verás que hay justo una que debe tener 10 elementos y adivina cual es...
En  mi pseudocódigo verás en casi todas partes
Array x (0 a c_Ocho) //c_ocho e suna contante cuyo valor es precisamente 8
pero en una de ellas verás que  en cambio pone:
Array x (0 a c_Nueve) <-----
Adivina cual de las funciones es ???

static int unificado[] = new int[9];

¿NUEVE??????

Revisa y si lo ves necesario contesta, a mediodía que vuelva, reviso tu código... y las dudas que te hayan surgido hasta entonces.

Código [Seleccionar] Expandir

Funcion TareasDeMates
    entero n, Cuenta, Pares, Impares, Primos

    Hacer
        n = PedirNumero
        Si (n>0) luego
            Cuenta +=1
            Si ((n and 1) = 0) luego
                Pares +=1
                Si (n == 2) luego   // Como par, sólo el número 2 se considera primo, pués no es divisible más que por sí mismo y la unidad, que es lo que define a un primo.
                    Primo +=1
                Fin si
            Si no
                Impares +=1
                Si EsPrimo(n) luego  //un primo solo puede ser impar... luego va solo aquí
                    Primos +=1
                Fin si
            Fin si
        Fin si         
    Repetir Mientras (n sea mayor que 0)
   
    Mostrar mensaje: Cuenta, Pares, Impares, Primos
Fin Funcion

Código [Seleccionar] Expandir

Buleano = EsPrimo(Entero n)
    Entero Max

    Max = RaizCuadrada(n)  //eliminar decimales...
    Bucle para k desde 3 hasta Max en incrementos de 2
        Si ((n modulo k) = 0) luego  // es decir si tras la división el resto es 0
            Devolver FALSE // es divisible por otro valor que no es 1 y sí mismo.
        Fin si
    Fin Bucle
    Devolver TRUE
Fin Funcion

Para optimizarlo, es preferible al inicio crear una tabla de primos (se crea una sola vez). Luego la función EsPrimo se modifica, para mediante una búsqueda binaria (sobre la tabla de primos), se localiza si el número entrado existe en la tabla, si existe es primo, si no se encuentra no lo es.
Como eres nuevo, seguramente no seas capaz de hacer una búsqueda binaria, vale... entonces creas un bucle 'While' y lo recorres mientras el número en el bucle sea menor que el recibido, si se encontró devuelve TRUE, si se llega al límite del bucle, se devuelve FALSE.

El dilema con una tabla de primos, es cuánto de grande es el mayor primo que se va a buscar, por que si no está contenido en la tabla, sin duda devolverá false, cuando en realidad 'no lo sabemos', en ese caso, si finaliza el bucle se compara si el primo mayor en la tabla es menor que el número entrado y e ese caso devolver un valor INCIERTO (esto es un mensaje de advertencia: el valor recibido es mayor que el máximo primo guardado en la tabla...)

Pero una tabla, acelera mucho los cálculos...

[0]

Nebire amigo tengo problemas al unificar los tres arrays en uno no se como pasarlos como parametros a la funcion Unificado.

mmmm... y cómo has pasado el array que contiene todo el sudoku???. Yo veo en tu código una función así:

Código [Seleccionar] Expandir

public static int [] obtenerFila (int matriz[][], int filas, int columnas){ ...


 
 Y bueno, en esta función...   

Código [Seleccionar] Expandir

    public static int [] obtenerCaja (int matriz[][], int filas, int columnas){

Esta parte se puede simplificar y mejorar mucho:
 

 

Código [Seleccionar] Expandir

     
        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;
        }

Mira, yo lo tengo así de simple:

Código [Seleccionar] Expandir

bX = ((X \ c_Tres) * c_Tres)
bY = ((Y \ c_Tres) * c_Tres)
X,Y son las cordenadas de la casilla sobre la que estamos operando.
bX y bY, serían el X e Y de bloques, que en efecto serán 0,3 ó 6
Y en efecto, si haces la cuenta, para todas ellas del 0 al 8:

bX = ((0\3)*3) = 0
bX = ((1\3)*3) = 0
bX = ((2\3)*3) = 0

bX = ((3\3)*3) = 3
bX = ((4\3)*3) = 3
bX = ((5\3)*3) = 3

bX = ((6\3)*3) = 6
bX = ((7\3)*3) = 6
bX = ((8\3)*3) = 6

Date cuenta que es una división entera...       

Por último, no pases parámetros a una función si no los necesita para nada. Por ejemplo si la función 'obtenerFila ' no usa 'filas', elimina ese parámetro. Si la función 'obtenerColumna' no utiliza para nada el parámetro 'columnas', retíralo de la función.
También sería más acorde llamar a esos parámetros 'X' e 'Y', 'Filas' y 'Columnas' dan sentido como nombre a una cantidad de filas y columnas, para una posición única al menos que sea singular.

Sí, creo que detemrinadas sries y pelis pueden generar en 'cerebros inmaduros' ideales equivocados...
No es extraño por ejemplo que en un capítulo de 'Hermano mayor', un chico tuvier aidealizado como solución económica dedicarse traficar con droga y peor aún de fabricarla... probablemente vio aquella serie donde un profesor de escuela y un alumno, se dedicaban a fabricar droga...o quizás vió aquella serie de Pablo escóbar (o ambas)...

Lo malo de la ficción es que es muy fácil dejarse llevar con el guión y poner como romántico alo que no lo es.... y no hace falta más que ver esa series y pelis de vampiros que 'son buenos', y la chica de turno se enamora del 'conde Drácula'...

En fin, si un cerebro inmaduro no sabe diferenciar la realidad d ela ficción es fácil que elija una opciónequivocada basado en lo que ve en la tv.

No sé bien... creo que nadie puede decir que 'éste o áquel' es el último bastión de algo, cuando es anónimo'...

De todos modos, a mi siempre me pareció que 'anonymous' eran adolescentes y que una vez han crecido, se les pasó/pasaría la tontería de encima...

Como carajo vas tu a matar a tu propia madre, a tu abuela, a tus hijos o amigos solo por ser zurdos.. que no ves que en ese pais hay muchas familias divididas ideologicamente.. Mucha gente que sigue el chavismo aunque este equivocada cree que hace lo correcto o se ve obligada hacerlo por que trabaja con una entidad del estado (algo muy comun en venezuela) o en algun momento de su historia tuvo algun vinculo con el chavismo aunque lo haya dejado.. esa caseria de brujas generaria sospechas y paranoias a diestra y siniestra y duraria una eternidad.. ademas que tambien tienen manos y armas para defenderse osea que tambien habrian muchas bajas del lado opositor.

Después de una situación grave, viene una situación desesperada, detrás el hambre, y detrás a las puertas está la guerra civil...

Por eso en alguna ocasión he comentado que la situación pasa por eliminar el 'sustento' a los seguidores del chavismo.
Muchos estarán por ideales y contra ellos nada cabe hacer, morirán si hace falta por un ideal aunque esté equivocado, pero aquellos que están por el interés (la comida, el dinero, las promesas, un puesto), entre ellos el ejército... cuando empiecen a pasar hambre, se acabó el soporte y serán ellos mismos quienes cuelguen del palo al 'líder supremo'...
Ésta es la solución menos mala posible (pensar en una rendición incondicional, creo que no entra en la cabeza ni de Maduro ni de sus seguidores, ni elecciones democráticas ni nada que sea voluntario y pacífico). Si ésta no se produce a tiempo, arañando más tiempo la guerra civil será inevitable.
Cuando lo que tengas que perder es la vida sí o sí, por hambre o por hablar y manifestarte, entonces no te importará portar un arma y matar al 'enemigo' así sea tu vecino, tu primo o quien sea... Morirás a gusto si sabes que al menos tu hijo no morirá de hambre como sucederá si no luchas. Cuando lo tienes todo perdido, si la única salida es la lucha, por estrecha que sea la salida, se lucha.

Y bueno yo no veo errado una intervención militar, pero no para invadir el país, ni mucho menos si no para liquidar a los cabecillas. Cortada la cabeza, el cuerpo no sabe por donde tirar...
Prefiero que mueran 12 asesinados, que miles de hambre o cientos de miles en una contienda militar.

[contenido de la última fila... (y con ello del bloque, pero se mantiene el de la columna.Actualizo los datos que debieran devolver los 3 arrays conforme a la nueva imagen:- función GetvaloresEnFila (x), serán: 3,7,8,5,4,0,0,0,0 en el array tmpFila- función GetValoresEncolumna(y), serán: 9,4,5,3,7,0,0,0,0 en el array tmpColumna- función GetValoresEnBloque(x,y), serán: 9,8,3, 6,2,7, 5,4,0 en el array tmpBloqueAhora al unificar los 3 arrays en 1, obtenemos (en el primer paso): 0 1 3 3 3 1 3 2 2 tmp(1) = 0tmp(2) = 1tmp(3) = 3tmp(4) = 3 //aparece 3 veces, una en la fila, otra en la columna y otra en el bloque.tmp(5) = 3tmp(6) = 1tmp(7) = 3tmp(8) = 2tmp(9) = 2Esto es, la cuenta de cuantas veces aparece cada valor. el valor referenciado por el índice. Así el 9 aparece 2 veces, una vez en la columna y otra en el bloque.Ahora terminamos la unificación, como ya dije para tener como valor no la cuenta si no contancia de la 'presencia'.Lo previo se puede considerar una tabla de apariciones, donde se cuenta cuantas veces aparece cada valor (en este caso de los 3 arrays).La siguiente es una tabal de presencia, donde se constar que valores aparecen, sin importar el número de veces, y como dije el código encargado de ello es el que ya puse:]

Continuamos, ahora con la siguiente imagen... como puede verse, el contenido es casi el mismo que la vez anterior, solo ha cambiado el contenido de la última fila... (y con ello del bloque, pero se mantiene el de la columna.

Actualizo los datos que debieran devolver los 3 arrays conforme a la nueva imagen:
- función GetvaloresEnFila (x), serán: 3,7,8,5,4,0,0,0,0 en el array tmpFila
- función GetValoresEncolumna(y), serán: 9,4,5,3,7,0,0,0,0 en el array tmpColumna
- función GetValoresEnBloque(x,y), serán: 9,8,3,  6,2,7,  5,4,0 en el array tmpBloque


Ahora al unificar los 3 arrays en 1, obtenemos (en el primer paso):
0  1  3  3  3  1  3  2  2
tmp(1) = 0
tmp(2) = 1
tmp(3) = 3
tmp(4) = 3 //aparece 3 veces, una en la fila, otra en la columna y otra en el bloque.
tmp(5) = 3
tmp(6) = 1
tmp(7) = 3
tmp(8) = 2
tmp(9) = 2
Esto es, la cuenta de cuantas veces aparece cada valor. el valor referenciado por el índice. Así el 9 aparece 2 veces, una vez en la columna y otra en el bloque.
Ahora terminamos la unificación, como ya dije para tener como valor no la cuenta si no contancia de la 'presencia'.
Lo previo se puede considerar una tabla de apariciones, donde se cuenta cuantas veces aparece cada valor (en este caso de los 3 arrays).
La siguiente es una tabal de presencia, donde se constar que valores aparecen, sin importar el número de veces, y como dije el código encargado de ello es el que ya puse:

Código [Seleccionar] Expandir

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
Y el resultado del array será:
tmp(1) = 0
tmp(2) = 2
tmp(3) = 3
tmp(4) = 4 //aparece 3 veces, una en la fila, otra en la columna y otra en el bloque.
tmp(5) = 5
tmp(6) = 6
tmp(7) = 7
tmp(8) = 8
tmp(9) = 9
Nótese que en esta función es la única que construye un array de 9 valores (10 elementos), porque el índice 9, ha de contener cuantas veces aparece el 9.
Finalmente llegamos a la siguiente función que nos entregará un array con todos los ítems que no aparecen, para ello recibe como parámetro 'éste array'...

Función: TomarAusentes
Este array hace algo opuesto a la última parte de la fase anterior. de hecho se podría haber remplazado esa fase con lo que hace esta función, si se quiere optimizar, sin embargo resultaría un código más oscuro de cara a entenderlo...

Código [Seleccionar] Expandir

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

Nótese que como el array de entrada tiene 10 elementos, el bucle termina en el índice 9, y comienza en el 1, porque no nos interesan los 0 (los valores del sudoku van del 1 al 9).
Cada vez que se encuentra que un valor no aparece se añade al array y se aumenta el índice. Casualmente solo hay un valor que no aparece en el array el '1', luego cuando se elija al azar de este array devolverá el índice 0 con contenido 1...
Que será el valor a consignar en la casilla x,y.
En la siguiente casilla nos encontramos de nuevo que solo qeueda un valor elegible, el 2...
Pero en la siguiente casilla (penúltima de la fila), da dos opciones, veamos el resultado que arroja el array tras la llamada a 'UnificarCubiculos' (el indice del 0, lo pongo con guión, señalando con ello que no importa):
array tmp:  -,1,2,3,4,5,0,7,8,0
Como se ve ya mismo hay ausentes el 6 y el 9, que es lo que nos debe arrojar la función 'TomarAusentes':
tmp(0) = 6
tmp(1) = 9
Lo siguiente en el código es elegir al azar entre el 0 y el 1, para devolver justo el valor del elemento en el índice 'azaroso'. en mi caso mi equipo ha seleccionado el '0' que crresponde al valor 6, luego si no se da situación de bloqueo en la siguiente columna, allí quedará por consignar el 9... La columna admitiría más valores que ese,  pero la fila y el bloque lo impiden, solo les falta el 9 a ambos.


Vamos a mostrar algo más interesante de modo que haya más elementos ausentes tras la unificación de los arrays... seguramente nos suceda al comenzar la siguiente fila, pués también se comienza el bloque y solo existen 'presentes' los valores que tiene la columna '0' al caso pongo un nuevo dibujo actualizado.

El resultado de los 3 arrays... para la ca:
tmpFila:  0,0,0,0,0,0,0,0,0  porque está vacía.
tmpColumna:  7,8,9,4,5,3,0,0,0
tmpBloque: 0,0,0,0,0,0,0,0,0  porque está vacío.
Y pasamos al resultado de reunificar los tres arrays, y ya en la devolución, no en pasos intermedios, también por brevedad, los pondré en fila:
tmp:  -,0,0,3,4,5,0,7,8,9
Y ahora el array de ausentes La misma función devuelve por referencias cuantos elementos son válidos en el array al caso 3 (el array sigue teneiendo 9 elementos):
tmp:  1,2,6
Esto nos indica que al azar debemos elegir entre 0 y 2, que son los índices válidos.. sea cual sea el elegido (al caso me sale el índice 1), se entrwega el valor cuyo índice ha salido:

Código [Seleccionar] Expandir

   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)

En resumen es más inteligente, porque no elegimos a al azar un valor a ciegas entre 0 y 9, y luego comprobamos que no exista en fila, columna ni bloque y si está vuelta a elegir y vuelta a comprobar y así hasta que no esté. Es más inteligente orque esa comprobación se hace una sola vez al inicio y así cuando elegimos ala azar elegimos solo entre los valores que no constan ya.

Todavía se puede ir más lejos y crear una función (con parte de la que existe en 'SeleccionarValorAzar'), para que cuando el usuario pretenda meter un valor verifique si ese valor es válido para la casilla o no...
Y para optimizarlo, dicha función podría partirse en dos, una hasta obtener el array de ausentes y otra para de entre esos ausentes elegir el valor al azar y luego cuando el usuario quiera poner un valor, llamamos igualmente a esa primera función para entregar el array de ausentes y creamos una segunda para con ese array ver si contiene el valor que el usuario pretende introducir, devolviendo un buleano de 'existe'...

Desmontando la función como he dicho (esta ahora llama a dos, cuyo contenido se repartió entre ellas):
Cuando se va a rellenar el Sudoku:

Código [Seleccionar] Expandir

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

Código [Seleccionar] Expandir

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

Se toma un valor al azar entre 0 y Cantidad-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.

Código [Seleccionar] Expandir

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


Cuando se va a verificar si el valor que introduce el usuario es correcto:
Será válido si está ausente en Fila, Columna y bloque que refiere la casilla...

Código [Seleccionar] Expandir

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

Código [Seleccionar] Expandir

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

Me falta explicarte solamente un poco más lo de los bloqueos, asíq eu seré breve y si no lo entiendes me lo dices...

El bloqueo se produce cuando tanto en la fila como en la columna como en el bloque ya hay puesto (al menos entre todos ellos (valores unificados)), todos los 9 valores, y en consecuencia no existe posibilidad de elgir uno que no esté... en tu caso (me refiero a tu código) elijas el que elijas, ya está, por tanto da igual que elijas 1000 veces como está la comprobación forzará a elegir otra vez...

En mi código, en el mensaje de ayer, al final puse un cambio para salir del bloqueo, y consiste en que cuando se alcance un bloqueo, se elimine por completo esa fila y se recomience d enuevo la fila, y si tras 10 intentos sigue sin poderse completar la fila, borra también la anterior (yaq que es posible que e la actual no haya solución, porque con la anterior ya cais no deja opciones). en teoría es posible que si tras borra rla actual y la prevuia aparecieren al recrear la previa 10 bloqueos seguidos, borrara también la anterior... en fin, en cualquier caso cuantos menos filas haya más difícil que se dé una situación de bloqueo, por eso suele basta con borrar la fila actual...
Pongo el código que se ocupa de esa parte (que corresponde a la función 'RellenarSudokuAlAzar'), para refrescar la memoria:

Código [Seleccionar] Expandir


.... //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...



-------------
p.d.: Puedes modificar el tema del hilo para que refleje lo que realmente es, y así si alguien utiliza el buscador pueda encontrarlo?. Nadie pone a buscar "necesito ayuda" ni "ayuda con mi código", ....pero alguien sí buscaría algo como: "sudoku"...

Así te reclamo que cambies el título del tema a algo más acorde como: "Código para Sudoku"

Editado para reponer las imágenes...

[Ahora mismo tengo que hacer unas cosas]

Una imagen para hacernos una idea de qué hablamos...


En la imagen puedes apreciar:
A - Una fila
B - Una columna
C - Un bloque

Hay 9 filas, 9 columnas y 9 bloques, es fácil contrarlos.
Cuando digo que necesitamos 3 arrays, son uno para guardar los valores de una fila dada, otro para una columna dada y otro para un bloque dado... los 3 son de 9 elementos, porque 9 son las casillas que tienen, aunque el array va del 0 al 8.
------------------------------

Así cuando digo este pseudocodigo:

Código [Seleccionar] Expandir

TmpFila = GetValoresEnFila(Entero Y)  
TmpColumna = GetValoresEnColumna(Entero X)
TmpBloque = GetValoresEnBloque(Entero X, Entero Y)

Me estoy refiriendo a 3 funciones distintas que reciben uno o dos parámetros y devuelven un array... en la siguiente imagen vemos que datos deberían devolver estas 3 funciones, con más claridad.


He marcado un circulito en la casilla que queremos rellenar, al caso es la posición:
X= 5
Y = 5

- Bien si llamo a la función GetvaloresEnFila (x), me debe devolver un array con los valores en la fila x (fila 5), el array siempre será de 9 elementos, y los valores (en este orden) serán: 3,7,8,1,4,0,0,0,0 y se almacena en el array tmpFila
- Cuando llame a la función GetValoresEncolumna(y), me debe devolver un array con los valores en la columna y (columna 5), el array siempre será de 9 elementos, y los valores (también en el orden en que aparecen) serán: 9,4,5,3,7,0,0,0,0 y se almacena en el array tmpColumna
- Finalmente cuando llame a la función GetValoresEnBloque(x,y), me debe devolver un array con los valores que contiene el bloque que contiene la casilla que le paso. La casilla puede ser cualquiera en el bloque. La función debe calcular cual es la posición dx y dy donde se localiza la primera casilla de dicho bloque, a partir de ahí lee 3 casillas, aumenta una fila y lee otras 3 aumenta otra fila y lee las 3 últimas... el bloque se compone de 3 filas de las cuales toma 3 columnas. Así los valores que devuelve en orden serán: 9,8,3,  6,2,7,  1,4,0 y se almacenan en el array tmpBloque

En la imagen he seleccionado, la fila, columna y bloques afectados, por tanto un modo de ver que las funciones operan bien es verificar que en efecto devuelven correctamente esos valores.  Nota también como los valores de las casillas vacías devuelve un 0, es la forma de identificar que una casilla está libre.
Lógicamente todos los valores que vamos alamcenando van a para a un array de 81 elementos (9x9), un array unidimensional, pero podrías hacerlo bidimensional (aunque las explicaciones del pseudocódigo dado están pensadas para un array unidimensional. al caso es lo mismo. Uno debe ser capaz de traducir de un array unidimensional a uno bidimensional y viceversa, son matemáticas de suma, resta, multiplicación y división, además de módulo.

Y para qué necesitamos estos arrays de valores. Bueno tu eliges al azar un valor del 1 al 9, y luego verificas que no esté en la fila, la columna y el bloque, pero las más de las veces ya estará, así que de nuevo tendrás que pedir otro valor al azar entre 1 y 9 y será muy lento, tanto más cuanto más cerca de estar completo esté el sudoku.

Aquí la forma de ser más inteligentes es primero recoger qué valores están... (ya lo hemos hecho con esas 3 funciones en sendos arrays), lo siguiente es unificar los 3 arrays en uno solo... es decir eliminar los valores repetidos, así la función UnificarCubiculos, hace esto mismo.
Y cómo lo hace. básicamente se crea un array cuyos índices 1,2,3,4,5,6,7,8,9 serán contadores del valor cuyo índice son. es decir cuando en uno de los arrays aparezca por ejemplo tmpFila(3) = 9 entonces en el unificado se hsumará uno al índice 9 tmpUnificado(9) +=1 pero no podemos poner directamente 9, ya que dicho valor está contenido en el array, o lo pasamosa  una variable:
v = tmpfila(3)  // 'v' vale 9 en este caso
tmpUnificado(v) +=1
o bien lo hacemos directamente sin una varible auxiliar:
tmpUnificado(tmpFila(3)) +=1
Haciendo lo mismo con todo el array tmpFila, tmpColumna, tmpBloque tendremos al final el array con estos valores de cuenta (valores reales obtenidos de la imagen):
tmp(1) = 2
tmp(2) = 1
tmp(3) = 3
tmp(4) = 3 //aparece 3 veces, una en la fila, otra en la columna y otra en el bloque.
tmp(5) = 1
tmp(6) = 1
tmp(7) = 3
tmp(8) = 2
tmp(9) = 2
Obviamente algunos están contados más de una vez, según que formen parte 8por ejemplo) de una fila y una columna, o una columna y un bloque o un bloque y la fila, o incluso de los 3 arrays. No importa, queremos saber cuales aparecen y si hay más de 1 vez aparecen.
Luego este array lo simplificamos para que no sea el índice, si no el valor quien refleje su presencia (al final el valor estará el el mismo índice, pero eso no nos importará luego).
Por eso se hace un bucle de reasignaciónde valores:

Código [Seleccionar] Expandir

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
Esta parte no es estrictamente necesaria, pero es buena práctica a la hora de optimizar, uno puede hacer luego algo de 'código espagueti' siempre y cuando lo entienda... el array de salida, nos sería válido tanto antes como después de este último bcle, solo sería cuestión de en la siguiente función interpretarlo correctamente, para evitar equívocos, hacemos que el valor sea lo importante... por so el bucle final.

Ahora ya hemos únificado los 3 arrays en 1 sólo. y el resumen es que el array contiene todos los valores que están presentes en la fila, columna o bloque a la que la casilla x,y hace referencia.

Lo siguiente entonces es generar un array con los valores que faltan. Para ello con el array de salida de la función UnificarCubiculos (tu ponle el nombre que te dé la gana, siempre que te oriente con su significado), es el parámetro de entrada para la función: TomarAusentes
Da la casulaidad de que en este punto hemos llegado a una situación de bloqueo. Luego te explico por qué...

Ahora mismo tengo que hacer unas cosas, así que envío esto aunque no esté terminado y luego (2-3 horas) pongo otra imagen sin bloqueo y sigo explicando (a partir de ella) y detrás la situación de bloqueo, por qué se produce y la solución para salir adelante...


Editado para reponer las imágenes que parece que la página web las ha eliminado... (afortunadamente las guardaba en la misma carpeta donde hice el programa).

Ok, te lo explicaré más sencillo, con palabras ..y dibujitos, pero entonces será a la tarde, ahora(después de comer, tengo el tiempo muy justo) no tengo tiempo para hacer los dibujitos y escribir las explicaciones.

A veces se les va "la pinza" a los jueces...

Una red social (como Facebook), ofrece perfiles y éstos seas cuales sean son personales incluso aunque se utilicen de forma profesional.

Si un político decide bloquear a un 'usuario', sus razones tendrá. Y desde luego no es 'atentar contra el derecho a expresión', toda vez que la red social no pertenece al gobierno, ni es una página que el gobierno mantenga o tenga contratada y luego cedida en uso al político en cuestión.

Por tanto su pagina es personal y tiene todo el derecho del mundo a bloquear a quien le salga de los GÜ3V05, y por la razón que le salga de los mismos GÜ3V05 ...que a fin de cuentas, vendrá a ser la misma razón que tiene cualquiera...