Introducción
En los sistemas informáticos y en el tercer milenio, la velocidad es muy importante. Por lo tanto, el algoritmo intenta diseñar sistemas que aumenten la eficiencia y la velocidad. En este importante papel, los juegos de computadora son personas entretenidas.
En el diseño de este juego, la mayoría de los algoritmos utilizados en inteligencia artificial y la velocidad de la responsabilidad mutua entre usuarios y sistemas es importante. Sudoku es uno de los juegos que tiene sus fanáticos particulares. Este juego simplemente debido a la falla repetida de producir un alto número de permutaciones y variaciones en el tamaño del lugar es especial. Una parte integral de estos juegos ha estado en periódicos y revistas.
Se han desarrollado muchos algoritmos para la producción de tipos recursivos Othello y Backtracking que pueden ser de búsqueda puntual e informada, y más. Implemente estos algoritmos, cada uno tiene sus límites. El programa presentado en este documento es completar un Sudoku con una falta de resolución en la tabla de entrada y proporcionar una solución única. La salida de este programa es la centésima parte de la velocidad en milisegundos.
Esta vez, el sistema varía con las diferentes estructuras. Pero el código total y las soluciones proporcionadas son competitivas y tienen buena velocidad. Se implementan ejemplos de soluciones en diferentes momentos y esto es visible. Acelera el código utilizando los métodos de búsqueda como la búsqueda binaria. Este artículo ha intentado utilizar una matriz de valores tridimensionales para ayudar al candidato a mantenerse informado por la tabla correspondiente, completa con su elemento original en su lugar.
- Cómo demostrar que [math] \ sum \ limits_ {n = k} ^ {\ infty} \ frac {1} {n ^ 2} <\ frac {2} {k} [/ math]
- ¿Hay algún atajo para encontrar el rango de una matriz?
- ¿Cuántas cadenas podemos generar de longitud n con solo k letras del alfabeto inglés y con al menos un prefijo y sufijo propio en común?
- ¿Cuál sería un protocolo para hacer que dos personas presenten dos números únicos en un intervalo sin revelar sus números?
- Cómo encontrar el punto máximo en un polígono convexo usando la búsqueda ternaria
El Sudoku original resuelve las siguientes tres condiciones:
El valor de cada columna es único.
El valor de cada fila es único.
La cantidad por cuadrado N * N es un interno único
Nota: La unicidad del significado de Sudoku irregular, pero entre uno y N no es repetitiva. (En este código, se asume la matriz bidimensional completa de N = 3 y la Tabla 81).
Cada búsqueda es evaluada. El uso de esta técnica garantiza la unicidad de cada tabla. ¿Informado por qué? El uso de algoritmos para resolver varios problemas para resolver cada problema es la parte más difícil. El uso informado de algoritmos de diferentes soluciones es una de las mejores opciones para resolver problemas con visibilidad limitada y el espacio es finito.
Siempre que el método de selección apropiado pueda tener acceso instantáneo a su elección, el conjunto corto de números finos de Sudoku se repite con una combinación de las condiciones anteriores que están en su lugar. Para este fin, la matriz bidimensional se puede utilizar para mostrar el espacio. Debido a que los números únicos hasta este punto serán reemplazados, el espacio necesario en el algoritmo es considerable. E incluso las matrices con N = 4,5, 6 pueden usar fácilmente este método.
Se recomienda resolver el lado N de la tabla con un deseo infinito de evitarse porque habrá suficiente espacio para la matriz auxiliar. Este algoritmo se deriva de la misma velocidad característica. Es inapropiado e innecesario repetirlo en otros programas y eliminar los aumentos de velocidad. Los algoritmos de búsqueda informada se presentan en el cuadro a continuación:
Análisis de código
Se compone de dos capas:
Capa de presentación
Capa de negocios
La capa de presentación en la matriz recibe una entrada constructiva en los envíos de Business Class Sudoku. Este código verá las dos clases. Es una matriz bidimensional para almacenar la mesa de operaciones y la utiliza en el valor cuadrado de la configuración interna predeterminada de la matriz es 3.
La cantidad varía para tablas de diferentes tamaños. Además, se utiliza una matriz interna de tipo Bool para almacenar la matriz única. Estas variables se definen como una clase de nivel global con un método de operación diferente que se puede realizar con estos valores. Se inserta el siguiente código Sudoku incompleto. Los puntos cero en la cadena de entrada representados en la tabla están vacíos.
Se presenta Sudoku para la precisión completa de la salida. Al comparar estos valores, el usuario puede ver la respuesta correcta. Este código es parte de una clase de Sudoku y el método Fill para enviar los estados que faltan. Este método se utiliza para llenar la matriz de Sudoku interno.
Código de capa de presentación
Sudoku SUdok = nuevo Sudoku ();
cadena [] SolvedSudoku = nueva cadena [81];
cadena temp1 =
“219876435843591276765243891394157628127368954658429317482735169536914782971682543”;
para (int i = 0; i <81; i ++)
{
SolvedSudoku [i] = Convert.ToString (temp1 [i]);
}
SUdok.Fill (SolvedSudoku);
lblCompleteSudoko.Text = SUdok.Show ();
para (int i = 0; i <81; i ++)
{
SolvedSudoku [i] = “0”;
}
// entrada sudoku
// el valor 0 es nulo en la entrada sudoku
temp de cadena =
“219876435803591276065243891394150628127368954658429307482735169536914702970682543”;
para (int i = 0; i <81; i ++)
{
SolvedSudoku [i] = Convert.ToString (temp [i]);
}
SUdok.Fill (SolvedSudoku);
Estas variables han sido creadas e inicializadas por el constructor de las variables que se definen.
Código de capa empresarial
Sudoku de clase pública
{
// N * N Junta
int N = 3;
// Junta principal
int [,] tablero = nuevo int [9, 9];
// esta matriz utilizada por métodos que
// Comprobado que el valor es único en filas y columnas y cubos internos
bool [] checkValue = nuevo bool [10];
//constructor
Sudoku público ()
{
// Rellene el tablero de matriz principal por valor 0
para (int i = 0; i <= (N * N) -1; i ++)
{
para (int j = 0; j <= (N * N) -1; j ++)
{
tablero [i, j] = 0;
}
}
// llena la matriz de verificación con el valor predeterminado
para (int i = 0; i <= 9; i ++)
{
checkValue [i] = verdadero;
}
}
Este método de acceso a la matriz bidimensional del elemento i, j que proporciona la tabla principal.
// establece el valor en el tablero principal
// posición i, j de la matriz de elementos
// valor i, j matriz de elementos
public void setSquare (int i, int j, int value)
{
tablero [i, j] = valor;
}
// obtener valor para el valor de fila y col
// i = fila
// j = col
public int getSquare (int i, int j)
{
tablero de retorno [i, j];
}
Este método de mostrar una tabla bidimensional con los tres personajes principales + y – y | Son los números. Carácter – una fila de | El | Se utiliza la intersección de la columna y fila y columna.
// este método agrega “|” y “-” y “+” para mostrar el resultado en
//output.%3 poner “|” en cada ternario en fila.
//
cadena pública Show ()
{
string Temp = string.Empty;
para (int i = 0; i <= (N * N) -1; i ++)
{
para (int j = 0; j <= (N * N) -1; j ++)
{
// esto si no permite hacer un bucle para la entrada “|” primero
if (j% 3 == 0 && j! = 0)
{
Temp + = “|”;
}
más
{
// esto si verifica poner “+” en poner poner en
// Confluencia de filas y columnas en cada número de cubos
if (i% 3 == 0 && i! = 0 && j == 0)
{
para (int k = 0; k <18; k ++)
{
si (k% 6 == 0 && k! = 0)
{
Temp + = “+”;
}
más
{
Temp + = “-“;
}
}
Temp + = “\ r \ n”;
}
}
// insertar punto en lugar de cero
if (tablero [i, j] == 0)
{
Temp + = “.”;
}
más
{
Temp + = “” + tablero [i, j] + “”;
}
}
Temp + = “\ r \ n”;
}
volver Temp;
}
El método mencionado anteriormente para insertar FILL matriz incompleta de valores de entrada utilizados en la matriz original. Método FancyFill para valores de matriz como entrada en exceso de martes incompleto. caracteres + y – y | Se utilizan para la exhibición.
// llena el tablero principal con una matriz de cadena de entrada
Relleno vacío público (líneas de cadena [])
{
int k = 0;
para (int i = 0; i <= (N * N) -1; i ++)
{
para (int j = 0; j <= (N * N) -1; j ++)
{
tablero [i, j] = int.Parse (líneas [k]);
k ++;
}
}
}
// llena el tablero con una matriz de cadenas de entrada y elimina cualquier + – | en cadena de entrada
// este método para verificar dos condiciones usa la solución de peterson
public void FancyFill (líneas string [])
{
para (int i = 0; i <= (N * N) -1; i ++)
{
para (int j = 0; j <= (N * N) -1; j ++)
{
tablero [i, j] = 0;
}
}
int k = 0;
bandera de bool = verdadero;
para (int i = 0; i <= (N * N) -1; i ++)
{
para (int j = 0; j <= (N * N) -1; j ++)
{
bandera = verdadero;
// solución de peterson
for (int l = k; l <lines.Length && flag; l ++)
{
if (char.IsDigit (char.Parse (líneas [l]))))
{
tablero [i, j] = int.Parse (líneas [l]);
bandera = falso;
}
if (char.Parse (líneas [l]) == ‘.’)
{
tablero [i, j] = 0;
bandera = falso;
}
k ++;
}
}
}
}
IsSolution ()
Comprueba si está resolviendo o no Sudoku? Para este propósito, utiliza cuatro funciones auxiliares. El rendimiento de cuatro métodos de la siguiente manera:
IsComplete (): este método se utiliza para todos los elementos de la matriz.
isRowCheckUnique (): este método es único para todas las filas de la matriz original utilizada.
isColCheckUnique (): este método único para todas las columnas se utiliza en la matriz original.
isCubeUnique (): este método es único para cada uno de los 3 × 3 cubos construidos.
Los cuatro eran métodos de resolución de Sudoku si la respuesta es verdadera.
// comprueba que sudoku está resuelto? si es verdadero, devuelve verdadero
public bool isSolution ()
{
if (isComplete () && isRowCheckUnique () && isColCheckUnique () && isCubeUnique ())
{
volver verdadero;
}
falso retorno;
}
// comprueba que la matriz del tablero está completa por número?
public bool isComplete ()
{
para (int i = 0; i <= (N * N) -1; i ++)
{
para (int j = 0; j <= (N * N) -1; j ++)
{
if (! (tablero [i, j] = 1))
{
falso retorno;
}
}
}
volver verdadero;
}
// ¿los valores en filas son únicos? use la matriz de valores de verificación para verdadero o falso
public bool isRowCheckUnique ()
{
para (int i = 0; i <= (N * N) -1; i ++)
{
para (int j = 0; j <= (N * N) -1; j ++)
{
// checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
}
volver verdadero;
}
// ¿los valores en columnas son únicos? use la matriz de valores de verificación para verdadero o falso
public bool isColCheckUnique ()
{
para (int i = 0; i <= (N * N) -1; i ++)
{
para (int j = 0; j <= (N * N) -1; j ++)
{
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
}
volver verdadero;
}
// ¿este método verifica que cada 3 * 3 es 1..9 valor?
// si es único, devuelve verdadero.
public bool isCubeUnique ()
{
#region iscubeunique
// 1,1
para (int i = 0; i <= 2; i ++)
{
para (int j = 0; j <= 2; j ++)
{
checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
// 1,2
para (int i = 0; i <= 2; i ++)
{
para (int j = 3; j <= 5; j ++)
{
checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
// 1,3
para (int i = 0; i <= 2; i ++)
{
para (int j = 6; j <= 8; j ++)
{
checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
// 2,1
para (int i = 3; i <= 5; i ++)
{
para (int j = 0; j <= 2; j ++)
{
checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
// 2,2
para (int i = 3; i <= 5; i ++)
{
para (int j = 3; j <= 5; j ++)
{
checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
// 2,3
para (int i = 3; i <= 5; i ++)
{
para (int j = 6; j <= 8; j ++)
{
checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
// 3,1
para (int i = 6; i <= 8; i ++)
{
para (int j = 0; j <= 2; j ++)
{
checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
// 3,2
para (int i = 6; i <= 8; i ++)
{
para (int j = 3; j <= 5; j ++)
{
checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
// 3,3,
para (int i = 6; i <= 8; i ++)
{
para (int j = 6; j <= 8; j ++)
{
checkValue [0] = verdadero;
if (checkValue [tablero [i, j]] == verdadero)
{
checkValue [tablero [i, j]] = falso;
}
más
{
falso retorno;
}
}
}
para (int k = 0; k <= 9; k ++)
{
checkValue [k] = verdadero;
}
volver verdadero;
#endregion
}
Array tridimensional InnerCandidateValue
Esta matriz se utiliza para contener valores de elementos para cada candidato. Teniendo en cuenta las 81 casas originales, cada matriz debe tener un valor único en una matriz tridimensional con los valores colocados en la posición correcta.
// lista global de valores candidatos
int [,,] InnerCandidateValue = new int [10, 10, 11];
FillCandidateValue ()
Este método se usa para llenar el conjunto de candidatos para valores conservadores.
// relleno de valor candidato interno
public void FillcandidateValue ()
{
// rellena el valor candidato en la lista interna
para (int i = 0; i <10; i ++)
{
para (int j = 0; j <10; j ++)
{
para (int k = 0; k <11; k ++)
{
InnerCandidateValue [i, j, k] = k;
}
}
}
}
SolvedSudoku ()
Este método se usa para resolver Sudoku incompleto. Este programa es parte del método. En este método, el número de elementos principales incompletos de la matriz es un candidato. Las tres condiciones fueron el conjunto principal de candidatos de Sudoku para la cantidad correcta colocada en el siguiente espacio en blanco. La matriz de candidatos para reemplazar el nuevo valor debe verificarse nuevamente. Finalmente, la cantidad correcta está en el elemento en blanco y busca informada para resolver Sudoku.
// este método resuelve sudoku por solución informada
público vacío SolvedSudoku ()
{
FillcandidateValue ();
//resolver
para (int i = 0; i <= (N * N) – 1; i ++)
{
para (int j = 0; j <= (N * N) – 1; j ++)
{
if (tablero [i, j] == 0)
{
para (int l = 0; l <= 8; l ++)
{
board [i, j] = InnerCandidateValue [i, j, l + 1];
if ((isOneRowCheckUniqe (i) && isOneColCheckUniqe (j) && isCubeUnique ()))
{
l = 10;
}
}
}
}
}
}
Finalmente, la capa de presentación mostrará la cantidad total. Esto se muestra al lado de una matriz vacía. Finalmente, se muestra la resolución de una variedad de programas. La función de cada tabla esSolution () para verificar y garantizar la corrección del programa. También al principio y al final, el tiempo en milisegundos se muestra en el sistema hasta que se presenta el problema.
OutPut.Text = SUdok.Show ();
lblissolution.Text = Convert.ToString (SUdok.isSolution ());
SUdok.SolvedSudoku ();
lblissolution2.Text = Convert.ToString (SUdok.isSolution ());
lblOutput2.Text = SUdok.Show ();
Tiempo = cadena. Vacío;
Time = DateTime.Now.Minute.ToString () + “” +
DateTime.Now.Second.ToString () + “” + DateTime.Now.Millisecond.ToString ();
lblTimeEnd.Text + = Time;
Usando el Código
Para usar el código para crear un proyecto de formularios Windows Forms y agregarlo a la clase Sudoku, se coloca un valor de entrada de la clase en la variable Temp. Por ejemplo, se ha colocado una versión truncada de Sudoku en esta variable.