Mensajes

...primero debes detectar los bordes salientes...

Esto es:
- Recorre la imagen horizontalmente bajando hasta tocar el primer píxel, luego ídem pero desde abajo hacia arriba.
- Recorre la imagen verticalmente avanzando a la derecha hasta que toques el primer píxel, luego ídem pero desde la derecha y avanzando hacia la izquierda...

La forma más exacta, es resaltar los vértices salientes... Imagina que con un lápiz trazas líneas para encerrar cada figura en un polígono, pero siempre con ángulos convexos ('reentrantes', nunca cóncavos hacia afuera) y siempre tocando la figura, por supuesto.

Mediante la comparación luego de:
A - La superficie interna del polígono. buen candidato para determinar rápidamente los similares (pero no óptimo si varían en tamaño)
B - La cantidad de lados del polígono resultante. Buen candidato para a primera vista determinar similitud incluso entre diferentes tamaños.
C - Los ángulos que forman cada par de lados del polígono. Es la tarea final, las previas son aproximaciones rápidas.

Y con esto  es relativamente asequible determinar su similitud con un porcentaje.
Éste algoritmo sería el adecuado, si además las formas tienen diferente tamaño (dos figuras iguales o muy parecidas pero de diferente tamaño), ya que los ángulos se mantienen así como el número de lados del polígono.




Basicamente  en pseudocódigo son estos pasos:
Esta sería la función principal (tras los pasos que llevas)

Código [Seleccionar] Expandir

Buleano = Funcion Buscarsimilitudes(Lista de Imagenes Figuras )
   Lista Poligonos  // lista de poligono
   Lista Poligono // lista de líneas

   Por cada figura en Figuras
        Poligono = CrearPoligono(figura)
        Poligonos.Add (Poligono)
   Siguiente

   Bucle para j desde 0 Poligonos.Length -2  //el último se debe comparar
       Poligono = Poligonos.Item(j)
       Bucle para k desde j a Poligonos.Length -1
           Si EsSimilar(Poligono, Poligonos.Item(k))  luego
               // Mostrar coincidencia en la forma que tengas previsto.  
               Similares = TRUE
           Fin si
       Siguiente
   Siguiente
 
   Devolver Similares //si al menos hubo 2 similares entre sí, devolverá TRUE.
Fin Funcion

Aquí el pseudocódigo para crear un polígono de cada imagen (a grandes rasgos).
Tu primer paso será entonces un "localizador de puntos salientes" de la figura...
El segundo, será un "trazador de líneas"... primero empezamos con los 4 puntos (uno de cada orientación, se trata de intentar lanzar una línea de uno de ellos al del lado contiguo, si corta en algún punto la figura, se debe buscar otro punto saliente entre medias y repetir).
Es mejor usar una lista que un array porque no se sabe cuanto se va a almacenar.

Código [Seleccionar] Expandir

Lista = Funcion CrearPoligono(imagen Figura)
   Lista Puntos  //donde señaden los puntos.
   Lista Poligono //donde se añaden las líneas
   entero j, k
   punto centro

   centro = PuntoCentral(Figura) // se trata de hallar aprox, el punto central de la imagen, un eje de cordenadas en el centro.
   Puntos = BuscarLos4PuntosMásSalientes // (de las 4 orientaciones), da igual si prefieres buscarlos en diagonal, pero es más complejo recorrer así la imagen.    
   j=0
   k=(j+1)
   Hacer
       Linea = TrazarLinea(puntos.Item(j), Puntos.Item(k) )
       Si Linea CortaFigura(Linea, Figura) luego //Si la línea corta la figura...
           Punto = Buscar nuevo punto saliente entre ambos, y añadir delante del destino
           Puntos.Add(punto, k)            
       Sino
           //OJO: No trato el caso de que k sea el último y el 3º punto debiera ser el primero el 0º
           // queda a tu esfuerzo modificarlo como convenga...
           Si AnguloEsConcavo(puntos.Item(j), Puntos.Item(k),  Puntos.Item(k+1), centro ) = FALSE luego
             
               Poligono.Add(Linea)
               j = k
               Si (k < Puntos.Count) luego                  
                   k +=1
               Sino
                   Si (k=0) luego
                      Conectado = TRUE
                   Sino
                       k = 0
                   Fin si
               Fin si
           Sino
               El punto intermedio entre los dos se elimina // hace concavidad, la búsqueda (la programación) del más saliente no fue 'adecuada', pero bueno esto nos permite avanzar aunque sea más lentamente.
               // j y k no cambian, así al retorno se traza la línea entre esos dos (que antes tenían uno en medio).
           Fin si
       Fin si
   Repetir Mientras (Conectado= FALSE)
   Devolver Poligono
Fin funcion


También puedes buscar similitud por perímetro cuando el número de lados es desigual. Si la superficie y el perímetro son similares hay probabilidades.

Código [Seleccionar] Expandir

Buleano = EsSimilar(Lista p1, Lista p2)  // p1 y p2 son sendos polígonos
   Area1 = HallarArea(p1)
   Area2 = HallarArea(p2)
 
   Si SimilitudPorTolerancia(Area1, Area2, ToleranciaArea) = TRUE luego  //tolerancia debe expresarse en forma de porcentaje aceptable, p.e.: '90' por ciento.
        // son de tamaño similar, no hay zoom, o es escaso.
       Si SimilitudAngulos(p1, p2, ToleranciaAngulos) = TRUE luego
           Devolver TRUE
       Fin si
   Sino  // son distintos, puede que uno esté con zoom... comprobamos lados y angulos
       // comprobamos la similitud en el número de lados.
       Si SimilitudPorTolerancia(p1.Length, p2.Length, ToleranciaLados) = TRUE luego
           Si SimilitudAngulos(p1, p2, ToleranciaAngulos) = TRUE luego
               Devolver TRUE
           Fin si
       Si no
           // El número de lados si no cincide ver si hay o falta un lado de tamaño muy corto, pero no se expone aquí...
           // Si cambia el númeor de lados, vamos a exigir más exactitud, con los ángulos
           Si SimilitudAngulos(p1, p2, ToleranciaAngulos+ToleranciaExigente) = TRUE luego
               Devolver TRUE
           Fin si
       Fin si
   Fin si
Fin Funcion

Tolerancia debe ser un valor en el rango 1-100, pero si se pone 100 exige exactitud total, y si se pone 1, una casa será igual que un coche, un valor adecuado podría ser 90% es decir uno es similar a otro si es un 90% del área (esto es solo varía un 10%, no confundir ambos valores, pués puede hacerse  al derecho o al revés).

Código [Seleccionar] Expandir

Buleano = Funcion SimilitudPorTolerancia(entero v1, entero v2, byte Tolerancia)
   Si (v1 >= v2) luego  //
       Si (((v1/100) * Tolerancia) >= v2) luego Devolver TRUE
   Sino
       Si (((v2/100) * Tolerancia) >= v1) luego Devolver TRUE
   Fin si
Fin Funcion

Se traza una línea ente los puntos extremos, y considerando el centro, se ve si p2, a que lado queda
respecto de la línea, según el centro debe quedar en un sitio u otro para saber si es cóncavo o convexo.

Código [Seleccionar] Expandir

Buleano = Funcion  AnguloEsConcavo(Punto p1, Punto p2, Punto p3, Punto centro)
  Linea  
   
   Linea = TrazarLínea(p1,p3) //Trazar una línea desde p1 a p3

   //Ver donde queda p2 respecto de la linea y según p1 y p3 estén orientados respecto del centro
   Si p1.X < centro.x
       // Sin terminar... queda a tu esfuerzo
   Sino
       // Sin terminar... queda a tu esfuerzo
   Fin si
Fin Funcion

Código [Seleccionar] Expandir

Buleano = Funcion SimilitudAngulos(Poligono pol1, Poligono pol2)
   Lista Angs1, Angs2
   Decimal ang1, ang2  //valor en  coma flotante
   Buleano Similares

   Angs1 = AngulosPoligono(pol1)
   Angs2 = AngulosPoligono(pol2)

   // Quizás una figura esté rotada respecto de otra, luego exige encontrar ekl punto de coincidencia.
   // pero puede pasar que haya más de un ángulo en una figura que tenga el mismo que otro en la otra figura...
   Bucle para i desde 0 a Angs1.Length
       ang1 = Angs1.Item(i)
       Bucle para cada j desde 0 a Angs2.length
           ang2 = Angs1.Item(j)
           // se convierten a enteros, tal como exige la función...
           Si SimilitudPorTolerancia(ConvertirAEntero(ang1), ConvertirAEntero(ang2), ToleranciaAngulo) = TRUE luego
               Similares = TRUE
               Bucle para k desde j+1 a Angs1.Length
                   ang2 = Angs1.Item(k)
                   Si SimilitudPorTolerancia(ConvertirAEntero(ang1), ConvertirAEntero(ang2), ToleranciaAngulo) = False luego
                       Similares = FALSE
                       Salir del bucle
                   Fin si
               Fin Bucle
               Si (Similares = TRUE) luego Devolver TRUE
           Fin si
       Fin bucle    
   Fin Bucle
Fin Funcion

Crea una lista con los ángulos del polígono.

Código [Seleccionar] Expandir

Lista = Funcion AngulosPoligono(Poligono Pol)
   Lista Angulos
   Punto p1, p2, p3
   
   p1 = pol1.Item(0)
   p2 = pol1.Item(1)
   p3 = pol1.Item(2)
   Angulo = AnguloFormado3Pt(p1, p2, p3)
   Angulos.Add(angulo)
   Bucle para j desde 3 a p1.Length - 1 // si es un triángulo, no entrará en el bucle        
       p1=p2
       p2=p3
       p3= pol1.Item(j)
       Angulo = AnguloFormado3Pt(p1, p2, p3)
       Angulos.Add(angulo)
   Fin bucle
   // Faltan 2 ángulos, los formados por el final y el comienzo
   p1=p2
   p2=p3
   p3= pol1.Item(0)    
   Angulo = AnguloFormado3Pt(p1, p2, p3)
   Angulos.Add(angulo)

   p1=p2
   p2=p3
   p3= pol1.Item(1)    
   Angulo = AnguloFormado3Pt(p1, p2, p3)
   Angulos.Add(angulo)
   
   Devolver Angulos
Fin Funcion

Código [Seleccionar] Expandir

Decimal = AnguloFormado3Pt(Punto p1, Punto p2, Punto p3)
  // queda a tu esfuerzo, son simples matemáticas...
Fin funcion

Aumento una de las figuras y realizo un pequeño dibujo a mano alzada. Nota el número de lados del polígono que encierra la figura, sus ángulos, etc... así te formas una idea y con esto debiera valerte... aunque tienes trabajo por delante...

Si ha spagado con tarjeta de crédito y no han pasado aún 15 días (no sé con exactitud cuántos son), basta que le digasa tu banco que regrese atrás la operación, porque resultó ser un timo. Y listo...

Y eso no quita que puedas interponer denuncia en la policía (siempre que puedas demostrar el pago por un servicio incumplido ), los emails y un extracto bancario firmado por el director del banco (donde aparece la salida del dinero desde tu cuenta a la que sea), deberían ser suficientes pruebas.

[queda demostrado como falso que exista una única solución posible, cuando el número de pistas es superior a 17.]

Tengo una mala noticia...

A pesar de que dicen que si hay más de x pistas, un sudoku solo tiene una solución, puedo demostrar que es falso... sin la necesidad de sesudas matemáticas, basta uno donde se demuestre que efectivamente tiene dos soluciones y x pistas.

En la siguiente imagen, se ve un sudoku correctamente resuelto:
Cada fila hay, bloque y columna cumple la condición. Sin embargo, no me lo da por bueno, si comparo el Sudoku que crea el usuario (en este caso yo), con la solución interna.

Marcado en rojo (y rodeado en azul a mano), las discrepancias que existen con la solución que se generó para el sudoku (en amarillo las pistas, que como se ve son 30ytantas.

En la solución 'real', donde pone 8 es 6 y donde pone 6 es 8 (en ambos casos). Sin embargo este mapa es legítimamente correcto, luego:

queda demostrado como falso
que exista una única solución posible,
cuando el número de pistas es superior a 17.

En consecuencia, es razonable que la solución se verifique no por comparación de la solución almacenada, si no por comprobación de todas las filas, columnas y bloques.

En algún punto hay que poner alguna función que permita al usuario pasar los valores que va marcando y podría ser algo como esto (yo he preferido una propiedad)

Código [Seleccionar] Expandir


Byte = Propiedad Leer Valor(X, Y)
  n = ((Y * c_Nueve) + X)
  Devolver User(n)
Fin Propiedad

Propiedad Escribir Valor(X, Y, V)
       byte n
       TiposDeValor  t  //una enumeración para indicar al dibujar que tipo de tinta usar
       
       n = ((Y * c_Nueve) + X)
       Si (Pistas(n) = 0) luego  //Si la casilla es una pista, no se toca
           Si (User(n) = 0) luego  //la casilla está ocupada ya?
               Si (v > 0) luego ' que se llena
                   Faltas = (Faltas - 1)  //Descontamos una falta cuando se ingresa un valor, si antes estaba vacía.
                   t = VALOR_TIPO_USER  //la casilla tendrá un valor (1-9)
               Sino
                   t = VALOR_TIPO_VACIO // la casilla se dejará libre.
               Fin si
           Sino  // la casilla ya está ocupada, aquí se cambiará valor o se borrará.
               Si (v = 0) luego
                   Faltas += 1 // antes había un valor, ahora se borra, aumentan las faltas uno más...
                   t = VALOR_TIPO_VACIO // la casilla se dejará libre.
               Sino
                   t = VALOR_TIPO_USER  // se remplaza el valor actual por otro.
               Fin si
           Fin si
           
           User(n) = v  //Asignamos el valor recibido
           
           //valor, casilla(x,y), tipo de tinta a usar
           Disparar Evento DibujarValor(v, X, Y, t)  
           
           Si (Faltas = 0) luego  // Solo se verifica el sudoku, cuando se hayan entrado todos los valores.
               Si (VerificarSudoku = True) luego                    
                   Disparar Evento FinDePartida(True) //True, porqueel mismo evento con False, puede usarse si el usuario decide Resetear la partida.
               Fin si
           Fin si
       Fin si
   Fin Propiedad




Ésta (la siguiente) es una función intermedia, que llama a una u otra para verificar si la solución es corecta, visto lo visto (verificado que NO SIEMPRE existe una UNICA solución), es preferible descartarla e  invocar siempre a  ValidarSolucionMultiple. Y en consecuencia no e spreciso mantener en memoria el array de la solución una vez generado y obtenido las pistas (dicho de otro modo, dicho array podría ser reutilizado para las pistas, eso al gusto)

Código [Seleccionar] Expandir

Buleano = Funcion VerificarSudoku
   Si  (SolucionUnica = True) luego
       VerificarSudoku = ValidarSolucionSimple
   Sino
       VerificarSudoku = ValidarSolucionMultiple
   Fin si
Fin Funcion

Como decía más arriba:
En consecuencia, es razonable que la solución se verifique no por comparación de la solución almacenada, si no por comprobación de todas las filas, columnas y bloques.




Con ocasión de reponer las imágenes peridas a causa d ela web que las alojaba, aprovecho para editar este último mensaje y añadir aquellas imágenes de la interfaz que le hice... después de crearlas, pero que olvidé ponerlas...

El menú 'partida'...



...permite jugar una partida introduciendo las pistas de un sudoku aparecido en otro lado...
En el menú al término (normal o forzado) de una partida, se elige introducir pistas, y luego basta pincha en una casilla en un valor y darle al botón introducir pista, para fijar dicho valor en la casilla seleccionada... cuando se hayan introducido todas, se pulsa en el menú 'fin pistas' y empieza la partida...



El menú 'opciones' desplegado:



El menú 'ayuda'... por supuesto, las pistas del sudoku, que aparece en las estadísticas, son reales... para hacer un sudoku.



Dos partidas en diferente estado, una más cerca del comienzo y otra casi al final:

es lo mismo... un bucle do...

Código [Seleccionar] Expandir

Cazado = FALSE
Hacer
   Intentar
       EnRango = FALSE
       Hacer
          ... dia ' Hacemos la idea de que esta línea representa el ´codigo para el día
        Repetir mientras EnRango = FALSE       

       Cazado = TRUE
   Cazar error
       Mensaje "Escriba solo números 'porfaplis'..."
   Final intento
Repetir mientras Cazado = FALSE

Esto solo para el día, haz lo mismo para mes y lo mismo para año, si quieres generar un solo bucle para todos, crea una función para devolver el valor correcto en el rango:

Código [Seleccionar] Expandir

Entero = Funcion PedirValorEnRango(Maximo, minimo, MensajeRango, MensajeError)
    Intentar
          EnRango=FALSE
          Hacer
              Pedir valor
              si (Valor >=Minimo) y (valor <=Maximo) luego
                   EnRango=TRUE
              Sino
                   Mostrar MensajeRango
              Fin si
          Repetir mientras EnRango=False
          Devolver Valor
    Cazar Error
         Mostrar MensajeError
         Devolver -1
   Final intento
Fin Funcion

Y esta función se llamaríamás simple desde un código similar a:

Código [Seleccionar] Expandir


    Hacer
        Dia = PedirValorEnRango(1,31, "Números delmes entre 1 y 31", "Por favor solo números, no letras ni palabras.")
    Repetir mientras Dia = -1

    Hacer
        Mes = PedirValorEnRango(1,12, "Mes debe ser un número entre 1 y 12", "Por favor solo números, no letras ni palabras.")
    Repetir mientras Mes = -1

    Hacer
        Año = PedirValorEnRango(1800,2020, "Año debe ser entre 2800 y 2020", "Por favor solo números, no letras ni palabras.")
    Repetir mientras Año = -1

    Mostrar día, mes y año

       

[serie aritmética]

Te respondo por aquí el mensaje privado (útil para todos).

Bien, las pistas pueden ir en efecto entre 17 y las que quieras.
Probablemente alguien que no sea muy entusiasta de las matemáticas y todo lo que sea pensar, necesite la mitad de las casilla como pistas, incluso alguna más...

Yo propondría un límite de 45 pistas como máximo y un mínimo de 17 (para que en efecto tenga una única solución).
Esto implica de alguna manera establecer niveles de dificultad. El nivel de dificultad, va a depender de 3 factores básicos:
A - Número de pistas (cuantas menos, más difícil).
B - Distribución en el 'mapa'.
C - Destribución de valores.

Lo básico es centrarse en el número de pistas, pero de soslayo miramos las otras dos posibilidades.

B - Supongamos que aportamos 27 pistas y que estas se colocan usando exactamente 3 bloques (el 1º, el 5º y el 9º)... esta distribución es algo distinta a si las colocamos de forma aleatoria.
C - Supongamos ahora que las pistas, nos centramos en que valores vamos a colocar (no importa dónde para este caso). Supongamos que sigue siendo 27 pistas, no es lo mismo proporcionar los nueves valores 2,3 y 4 que proporcionar 3 pistas de cada valor (111,222,333,444,555,666,777,888,999), y es disitnto de si los valores son elegidos al azar, puede que haya tres 9, y cuatro 1, pero solo un 5.

Estos dos casos (B y C) es para estudiarlos más a fondo. Su estudio exhaustivo escapa de la ayuda a proporcionar en el foro. A falta de ello es mejor dividirlo en 2 grupos, si son elegidos al azar les concedemos un valor de 'no difícil' y si los elegimos pensando en 'putear' al usuario, le concederíamos un valor de 'difícil'.

Queda por tratar el caso A (el número de pistas). hay que repartirlos en tantos grupos como niveles de dificultad. El reparto no debería ser 'fijo', es decir que aumente la misma cantidad de pistas a medida que baja la dificultad. Ya que esto sería una serie aritmética y es más razonable y ajustado a la realidad una serie serie geométrica.

En matemáticas, una serie se deifne por: un rango de valores llamados términos o medios interpolados, los valores extremos del rango, y la proporción entre cada elemento en el rango, llamada razón.
Si tienes oxidada tus matemáticas, repásalas... busca progresiones aritméticas y progresiones geométricas...

Entonces decidamos cuantos niveles de dificultad queremos tener?. ¿3, 4, 5, 6, 7?. Supongamos 5. Entonces lo primero es crear la serie. Luego esto se fija en un array. el array lo que va a contener será el número de pistas donde comienza ese nivel de dificultad...
Por ejemplo si la serie fuera aritmetica y la razón 5, el array NivDificultad podría tener estos valores.
NivDificultad(0) = 17
NivDificultad(1) = 23
NivDificultad(2) = 29
NivDificultad(3) = 35
NivDificultad(4) = 41
NivDificultad(5) = 47 // este no entra en nivel, es el punto límite.

Entonces si está en el nivel 0 (el más difícil, aunque puede invertirse el número y el más alto expresar más dificultad), se elige una cantidad entre:
NivDificultad(0) y NivDificultad(1)-1
...es decir si elige al azar un número entre 17 y 22
Si nivel 1 entre 23 y 28, etc...

pero... pero hemos elegido una progresión geométrica... Así que cada grupo no tendrá la misma cantidad de valores, pero el enfoque del array y su uso, es el mismo.

Código [Seleccionar] Expandir

Array Byte = Funcion InterpolacionGeom(Niveles, Minimo, Maximo)
   Decimal Razon, n, p //números con decimales.
   Array Byte Im(0 a Niveles) //Uno más, para guardar el valor final

   razon = RazonGeometrica(Maximo, Minimo, Niveles-1)

   Im(k) = Minimo
   p = im(0)
   Bucle para k desde 1 hasta Niveles-1
      n = p   // Im(k-1) //ídem d elo que se comenta abajo, se pierde precisión y no se alcanza el valor máximo ni lo reparte bien.
      p = (n * razon)
      Im(k) = valor entero de p
      // im(k) = entero de (im(k - 1) * Razon)  
      //podría valer esto, que es una sola línea, pero perdemos precisión en cada iteración. El problema sería tanto mayor cuannto más ciclos tuviere el bucle.
   Fin bucle
   Im(Niveles) = Maximo  //si el código del bucle fue bien esta línea sería inenecesaria,
    //pero si los decimales varían uno arriba o abajo, esto lo fija al punto exacto.
   
   Devolver array Im
Fin Funcion

Generalmente, todos los lenguajes de programación disponen de raíz cuadrada, pero no de raíz cúbica, raíz cuarta ni raíz 125, etc...
Sin embargo, si poseen potenciación y la radicación se define como el inverso de las potencias, al igual que la división es el inverso de las multiplicaciones y la resta el inverso de la suma.
Esto es lo que hacemos aquí:

Código [Seleccionar] Expandir

Decimal = Funcion RazonGeometrica(Maximo, minimo, Terminos) // terminos intermedios entre ambos extremos
  Devolver ((Maximo/Minimo) elevado a la (1/ (Terminos+1))
Fin Funcion

Una vez que imprimas el resultado del array devuelto, no te vas a sorprender mucho, porque son pocos niveles, también puedes fijar los valores del array 'manualmente', te evitas ambas funciones... pero dejas de aprender cosas.

Tu ya sabiendo que el usuario ha elegido x nivel, seleccionas al azar el número de pistas en cada partida:
NumPistas = Seleccional azar un valor entre( NivDificultad(Dificultad) y NivDificultad(Dificultad+1) -1 )

Y por hoy vale...

p.d.: Espón donde tengas dudas, para no dar vueltas a cosas que no pudierna interesarte e ir al grano.

Bien. Ves com te has respondido tú mismo?.

Efectivamente si lo piensas... al yo darte respuesta, tu deber es comprobarla, y si yo te doy una fecha errada, tu deber es indicarme que un mensaje 'no es correcto, proporciones un valor en el rango x-y y volverme a pedir de nuevo el dato... y repetir hasta que 'aborte' o dé un valor correcto. (el problema de las consolas, cuando se dispone de interfaz de usuario, se pone un control y los valores mínimo y maximo ajustan el rango, entonces no hay posibilidad de salirse del rango).

Entonces del pensamiento, de la idea, pasamos al pseudocódigo:

Código [Seleccionar] Expandir

Hacer
   Pedir entrada 'x' con el mensaje 'm'
   Comprobar si 'x' está en el rango
Repetir mientras x fuera de rango


Ese pseudocódigo, representa la idea, y es breve porque es 'genérico', pero se puede expandir, desde el momento en que conocemos ciertos detalles, y podemos hacerlo más 'específico':

Código [Seleccionar] Expandir

buleano EnRango = FALSE //declaración de una variable...
Hacer
   Pedir 'año' al usuario con el mensaje "Ingrese un año entre los límites: 1800 y 2020 (ambos incluído)"
   Si ((año mayor o igual que 1800) y (año es igual o menor que 2020)) luego
       EnRango = TRUE
   Fin si
Repetir mientras (EnRango=FALSE)

...y esto debieras tu ya poder traducirlo a algo más específco como es el lenguaje que quieras usar...
No hay nada complejo, un bucle do...while, entrada de datos, condicional y comparación matemática...

p.d.: dejemos de lado la posibilidad de que el usuario aborte, se trata de un simple ejercicio..

Piensa un poco... Cómo lo resolverías de 'forma humana'?. Supongamos que me pides el año y yo te doy por respuesta: 1518 ... qué harías tú, para asegurarte que te dé un valor en el rango 1800-2020?

Sobre las pistas, piensa que teniendo ya resuelto el sudoku, obtener las pistas es simplemente decidir que valores del sudoku dejar ó a la inersa cuales retirar, lo que resulte más breve.

También es preciso saber que si las pistas son menos del 20% de los valores, tiene múltiples soluciones.

Entonces:
- Si un sudoku, tiene una sola solución; la validación la harás con tu matriz del sudoku (resuelta). Comprobando en un bucle que el array Sudoku() (tu le llamas Matriz() ), coincide uno a uno con el array User(). El array User() inicialmente es copia del array Pistas() (por si decide restablecer, se copia de nuevo Pistas() en User()...)
- En cambio si tienes múltiples soluciones, la validación sería recurrir a 1 bucle donde reclamas los ausentes de cada fila, bloque y columna, será validado siempre que en todos los casos dé 0 ausentes.

Código [Seleccionar] Expandir

Buleano = Funcion ValidarSudokuDeMultiplesSoluciones
    buleano ausentes

    Bucle para k desde 0 a 8
        ausentes = Ausencia (Presencia( GetFila(k) ))
        Si ausentes = false Devolver False //y salir de la función
               
        ausentes = Ausencia (Presencia( GetColumna(k) ))
        Si ausentes = false Devolver False //y salir de la función

        ausentes = Ausencia (Presencia( GetBloque(k) ))
        Si ausentes = false Devolver False //y salir de la función
    Fin bucle
    Devolver True // aparecen todos, una sola vez en fila, columna y bloque.
Fin funcion


NOTA que:

ausentes = Ausencia (Presencia( Getxxxx(k)))

es una llamada a otra función con la salida de la interna...
Es decir, primero se llama a 'GetXXXX(k) que nos devuelve el array solicitado del array User(). OJO: del array User, no del array Sudoku (Matriz, la llamas tu).
Luego que devuelve ese array es el parámetro de entrada para invocar a la función Presencia(array), y la salida de esta, que también devuelve un array pero de 10 elementos, es usada como la entrada de la función Ausencia(array) que devuelve finalmente un valor buleano.
Es equivalente a esto mismo (pero requiere entonces declarar un array dentro de la función, para recibir y pasar a la siguiente función y más líneas de código).
   

   array tipo byte Arr() // sería antes del bucle.

   Arr = GetFila(k)
   Arr = Presentes(arr)
   ausentes = Ausencia(arr)

   Si ausentes = false Devolver False //y salir de la función

Esta función ya la conoces, es equivalente a la segunda parte de unificar arrays:

Código [Seleccionar] Expandir

Array byte = Funcion Presencia(array tipo byte Arr() )
    array tipo byte Tmp(0 a 9) // 10 elementos.

    Bucle para k = 0 a 8
        tmp( arr(k)) = arr(k)
    Fin Bucle
    Devolver Tmp
Fin Funcion

Esta función también la conoces, pero aquí en vez de devolver el array con los ausentes, devolvemos si hay o no ausentes (o la cantidad de ausentes y en destino convertirlo en False si es mayor que 0).

Código [Seleccionar] Expandir

Buleano = Funcion Ausencia(array tipo byte Presentes() )
    Bucle para k desde 1 a 9 //OJO: 10 elementos, hasta 9
        Si (Presentes(k) <> k) luego
            Devolver FALSE //y salir de la función
        Fin si
    Fin bucle
    Devolver True
Fin funcion

Un último consejo... mira de optimizar el código una vez te funciones bien. Estas dos funciones, podrían llamar a otras que realicen el trabajo 8ya en el código previo) y  aquí solo evaluar el resultado y devolverlo...

No pongo el pseudocódigo de lo que sería la función: 'ValidarSudokuDeUnaSolaSolucion', porque es bastante sencilla.
Ya sabes que puedes ponerle el nombre que quieras a las funciones, siempre que el propio nombre revele su intencionalidad... sin necesidad de llegar a ser tan largo y explícito como: 'ValidarSudokuDeUnaSolaSolucion', que tiene por objeto además ser auto-explicativo... podría ser 'ValidarSolucionSimple' y el otro 'ValidarSolucionMultiple'...

Recuerda que deberás tener varios arrays, como mínimo estos 3:
- El de la Solución (que se genera cuando creas el sudoku).
- El de Pistas (que es una selección-extracción de la solución).
- Y el del Usuario (que inicialmente es copia del array Pistas), y que es donde el usuario va introduciendo los valores que él mismo decida.
Por tanto tras crear el Sudoku (la solución, el array Matriz) satisfactoriamente), tras ello invoca a sendas funciones para inicializar ambos arrays adicionales (pistas y User). Crear el de User también conviene que sea una función aparte, porque si el usuario reclama 'Resetear' la partida, entre otras cosas deberás volver a clonar el array Pistas() en User().

Las autoridades venezolanas capturaron al comandante de la llamada "operación David", Juan Caguaripano Scott, ex capitán de la Guardia Nacional Bolivariana, quien junto a un grupo de hombre se sublevó contra el presidente Nicolás Maduro y asaltó una base militar la semana pasada.

Lástima que no se sumaran más militares en cadena al golpe. ahora a ver que les hacne a estos chicos.

...pero un golpe así, es destruir una casa a martillazos... el golpe debe asestarse en la cocorota de Maduro, así basta uno, uno sólo, en un par de segundos... asaltar cuarteles es destruir la casa a martillazos...

[n = ...rand.nextInt(12-5) + 5]

Vaya... me alegro, porque te estaba respondiendo y casi había terminado cuando me llamaron para ir a cenar fuera, y a la vuelta he acabado de terminar y enviaba respuesta... de todos modos, la publico...


Vamos por partes....

mira pido disculpas por no haberte comentado nada de hace tiempo pero no me encontraba en la ciudad y no habia podido continuar con este proyecto.

No te preocupes. Cada uno dispone del tiempo que dispone y nadie tiene derecho a reclamar nada al respecto.


-----------------------
El tema del parámetro de devolución...

Array Byte = Funcion TomarAusentes(Array Byte Presentes(), Out Entero NumAusentes)
entiendo que es el indice del vector ausentes pero no se manejarlo como tu lo haces

Bien, no importa si no sabes devolver un parámetro por referencia, se recalcula de nuevo, es muy simple...

Varíamos la función, seguimos devolviendo el array y solo el array...

Array Byte = Funcion TomarAusentes(Array Byte Presentes() )

voy a tu código, donde se llama a todas las funciones y finalmente a TomarAusentes:

int temp[] = GetArrayAusentes(matriz, x, y);

Ahora entonces hacemos un bucle para tomar el valor que no has sabido devolver:

Código [Seleccionar] Expandir

Bucle para k desde 1 a 9
 si temp(k) es mayor que cero luego
    NumAusentes = k  // esto se puede hacer de diferentes maneras, esta es la mas sencilla, otra es saliendo del bucle cuando se encuentre un valor 0, etc...
    // se actualiza con cada ocasión que sea cierta la condición, ...no importa es un bucle pequeño.
 Fin si
Fin Bucle
Ya tenemos el valor de NumAusentes.

Ahora la funcion rand.nextInt debe devolver un valor al azar entre 1 y numausentes, pero solo si NumAusentes es mayor que cero

Código [Seleccionar] Expandir

Si NumAusentes > 0 luego
  azar = rand.nextInt(entre 1 y NumAusentes)  
Si no
  // este es el caso de que no haya números ausentes, se devlvería 0.
Fin si

Cuando una función para devolver un número al azar, no permite especificar un rango, y siempre fuerza desde '0' hasta 'x', se puede truncar... veamos como:
Sea el rango entre 5 y 12, entonces en la función se toma el mismo espacio del rango pero empezando en 0, esto es, si empeiza en 0 y no en 5, es que (es como si) hemos restado 5, luego al valor mayor del rango también le restamos 5. Luego al valor que salga (que será: 0,1,2,3,4,5,6 ó 7), pués le sumamos 5 y efectivamente tendremos el valor en el rango 5-12 , la demostración sencilla sería: (0+5, 1+5, 2+5, 3+5, 4+5, 6+5 ó 7+5), que en efecto es entre 5 y 12
 n = ...rand.nextInt(12-5) + 5  

Unificando un poco el código de esta sección, sería más o menos así

Código [Seleccionar] Expandir

SeleccionarValorAzar (matriz(), x, y)
       int n, Numausentes
       int temp[] = GetArrayAusentes(matriz, x, y)

       Bucle para i desde 1 a temp.length //OJO: desde 1, porque el indice 0, sabemos que SIEMPRE vale 0
           Si matriz(i) > 0 luego
               NumAusentes = i
            Fin si
       Fin bucle

       Si NumAusentes > 0 luego  //falta esta condición en tu código.
           Random rand = new Random()
           n =  rand.nextInt(Numausentes-1) +1
       
           System.out.println(":" + temp[n])
           return temp[n];
       Si no
           devolver 0
      Fin si
Fin Funcion


-----------------------
Siguiente el error: Si miras la cascada de llamadas hasta el error, (dentro del programa desde main) se llama inicialmente a la función 'GeneradorAleatorio', la cual llama a su vez a 'SeleccionarValorAzar' y en esta se invoca a la función: 'Random.nextInt', que verás que es la última función ejecutada (es la que origina el error)...

Exception in thread "main" java.lang.IllegalArgumentException: bound must be positive
   at java.util.Random.nextInt(Random.java:388)

Básicamente el error está generado por la elección del número al azar. En el caso de este juego, los valores deben estar comprendidos siempre entre 1 y 9, y específicamente en cada momento concreto entre 1 y 'numausentes'. Ya que lo que elegimos es el índice de aquel array de ausentes y devolvemos el valor contenido en ese indice del array.

Ahora miro el código, para ver por qué dicha función trata de elegir un número negativo.... bien pego la línea donde se origina el error:

n = + rand.nextInt(temp.length);

...de entrada, el valor pasado a rand.nextInt, no es correcto.
Sabemos que ese array tiene 10 elementos, porque procede de la función TomarAusentes, pero no son elegibles todos los índices, solo son elegibles desde el índice 1 hasta el índice de 'numausentes' (que algunas veces podrá ser 9). Justo lo acabo de explicar en el punto anterior.
Recuerda que el array de TomarAusentes, podría no arrojar valores, porque todos los valores estén ocupados; algunos en la fila, otros en la columna y otros en el bloque.

En ese caso, no hay que forzar a elegir un valor al azar, directamente la función SeleccionarValorAzar  (más arriba puse su pseudocódigo) devuelve 0. Y la función que recibe el resultado (GeneradorAleatorio), ya tiene previsto el caso para solucionar el bloqueo (ese '0', indica el bloqueo).

NOTA: que pongo parcialmente el código de la función (no conviene poner todo un libro, solo para citar 2 párrafos):
             

Código [Seleccionar] Expandir

...  
               valor  = SeleccionarValorAzar(matriz, fila, columna);
               if (valor > 0) {
                   matriz[fila][columna] = valor;
                   columna++;
               }else{
                  //ResolverBloqueo
               fin si
...


...por otro lado el metodo 'generarSudoku' ya lo hice si tenias razon era algo muy sencillo probe el codigo hasta donde me devuelve los valores ausentes y todo esta correcto pero aun asi me sigue presentando el bloqueo y solo me llena aproximadamente unos 36 a 44 valores de ahi no me pasa...

Si, bueno, yo lo que veo es que has pueto el límite de intentos en 5, yo lo puse en 12 y luego lo bajé a 10... y lo pongo a generar sudokus (y al tiempo dibujar cada valor generado) durante una hora o algo más y tras 15500 sudokus calculados, lo he parado... es decir no se bloquea. Cambia el número de intentos a 10...

----------------

p.d.: Como ejercicio de optimización, te aclaro que todas las funciones de: getFila, getColumna, getBloque, UnificarArrays y TomarAusentes, puede ser muy optimizado en apenas 5 bucles (uno detrás del otro) usando siempre el mismo y único array, para los 3 get y otro para las otra dos secciones...