1

Capítulo 1

Introducción

En el área de los algoritmos y la programación, son muchos los aspectos en juego

a la hora de diseñar algún programa que realice una tarea final, en esta ocasión la tarea

final es la de elaborar o generar un Sudoku a partir de ciertas características que se

establecieron. El sudoku es un rompecabezas que se juega en una cuadricula 9x9, el total

de números al llenarla es de 81, sin que se repitan los números en todas las filas y

columnas, contando con bloques de 3x3 en donde deben de ir desde el 1 al 9. De acuerdo

con lo anterior, se pueden inferir las normas establecidas para la generación del

rompecabezas, en donde se utilizará en Java la herramienta de ciclos para llenar las

matrices y un random para intercambiar filas y columnas.

 2

Objetivos

Objetivo General

Generar un Sudoku cumpliendo las reglas generales en las que se basa el juego,

para aplicar los conocimientos adquiridos en el curso de Algoritmos y Programación I de

la Universidad Pedagógica y Tecnológica de Colombia - Seccional Sogamoso.

Objetivos Específicos

• Identificar cómo funciona el Sudoku, entendiendo los algoritmos que este

lleva.

• Aplicar las herramientas exploradas como arrays, clases, métodos,

JOptionPane, Random, ciclos y condicionales, a través de la teoría y la

práctica para la construcción del Sudoku.

• Realizar pruebas que permitan llegar a la ejecución del Sudoku

correctamente.
 3

Marco Teórico

2.1. Sudoku con Algoritmos

El Sudoku (Crilly, 2009) es un rompecabezas matemático de colocación

numérica que se popularizó en Japón en 1986 y que se dio a conocer internacionalmente

en el año 2005 en la sección de los periódicos de pasatiempos. Se puede acercar una

definición más acorde en el país de Japón, pues la palabra Sudoku significa Sū número y

doku a solo, que uniendo las palabras daría “Los números deben estar solos”. En la

actualidad, existen múltiples tipos de juego en Sudoku (Figura 1) pues se encuentran entre

otras, la matriz cuadrada, Sudoku samurái, el Sudoku mariposa, el Sudoku asesino, y así

con variadas figuras junto con los números. Para el trabajo con el algoritmo a desarrollar,

se utilizará el más común (Figura 2) que está formado al estilo 9 filas por 9 columnas, por

este motivo es que existen tres definiciones para tener claridad en la construcción del

Sudoku de matriz cuadrada, el cual está basado en cuadrados latinos1.

Figura 1 Varios tipos de Sudokus, que se dan de acuerdo con la dificultad

1
Los cuadrados latinos son matrices n×n elementos en la que en cada casilla está ocupada por uno de los
n símbolos de tal modo que cada uno de ellos aparece exactamente una vez en cada columna y en cada fila
(Wikipedia).
 4

Figura 2 Un Sudoku de matriz

cuadrada 9×9

Así se pueden encontrar las definiciones más aceptadas para el juego Sudoku,

como un cuadrado latino de matriz cuadrada n×n en la que en cada fila y columna son

variaciones de elementos que cumplan la condición de R = {1, 2, n+1} para n > 9. Esto

es un subconjunto del conjunto de cuadrados latinos de 9×9.

Otra definición se puede asociar con la primera, en la que establece que una matriz

9×9 subdividida en nueve submatrices de 3×3, en cuyas celdas se encuentran números

{1, 2, 3, …, 9} de tal forma que solo exista un número de este grupo en cada fila, columna

y las nueve submatrices.

Pero, en base a la realización de un programa por JAVA que genere diferentes

tipos de Sudokus se optará por la definición:

Un Sudoku inicial se obtiene al eliminar m números en las celdas de un Sudoku.

El número m es el orden del Sudoku inicial (1 ≤ 𝑚 ≤ 81). Decimos que un Sudoku

inicial está bien definido si y sólo si existe una única forma de llenar las celdas vacías

para alcanzar un Sudoku (Cabrera Pacheco & Meneses Rodríguez, 2009).

Asimismo, en base a la anterior, se pueden inferir las reglas del rompecabezas

matemático para un jugador las cuales comprenden que en las 9 submatrices 3 × 3, los

elementos deben de ser del uno al nueve; que en todas las filas debe haber elementos entre
 5

el uno al nueve; y que en todas sus columnas debe haber elementos entre el uno al nueve,

en todas las tres reglas se debe cumplir que los números no tengan repetición.

2.1.1. Construcción Sudoku

En el caso específico de la construcción de dicho rompecabezas, cabe aclarar que

el algoritmo es bastante lógico, aunque existan diversas maneras de hacerlo, el algoritmo

a utilizar consiste en escribir en la primera fila los números del uno al nueve (figura 3),

de manera consecutiva; así cuando se vaya a programar, se usará el mismo proceso lógico.

1 2 3 4 5 6 7 8 9
Figura 3 Construcción de una primera Fila

Luego, en la submatriz que tiene los números 1, 2 y 3, se escribirán debajo la

continuación de la serie, que en el caso sería 4, 5 y 6 (figura 4), le seguiría en esta segunda

fila consecutivamente hasta llegar al nueve, en donde el siguiente número será

nuevamente el uno hasta terminar la fila. Así es como sucesivamente se llenará toda la

primera submatriz, constatando de que no se repitan los números dentro de ella.

1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
Figura 4 Secuencia de los números en la fila 2 y 3.

Como se puede observar, ya se ha llenado las submatrices que componen las tres

primeras, para la siguiente se comenzará con el número 2, continuando con la secuencia

y entendiendo que, en la primera fila, se dio inicio con el número 1 (figura 5).

1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
Figura 5 Llenando la siguiente submatriz.

Así completando la siguiente submatriz, repitiendo el proceso de la primera, en

donde se comienza con el número consecutivo (figura 6), se repetirá el mismo proceso
 6

con la última submatriz (figura 7) y al final se habrá llenado todo el Sudoku sin repetición

de los números.

1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
Figura 6 Segunda submatriz completa

1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8
Figura 7 Sudoku completo

Ahora, el siguiente algoritmo a efectuar será el intercambio de filas, columnas,

submatrices, garantizando que ningún número se repetirá, este se hace con el fin de que

todos los rompecabezas queden de distinta manera, cada vez que se hace un intercambio,

el Sudoku será totalmente diferente (Forret, 2006).

2.1.2. Intercambio Filas

Se hará el intercambio de dos filas del mismo grupo o de la tres primeras

submatrices (figura 8).

1 2 3 4 5 6 7 8 9 7 8 9 1 2 3 4 5 6
4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6 1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8
Figura 8 Intercambio de filas y su resultado
 7

Se hará lo mismo con los dos siguientes grupos de filas en las submatrices

restantes (figura 9).

7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6
4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3
1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9 1 8 9 1 2 3 4 5 6 7
5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7 2 3 4 5 6 7 8 9 1
3 4 5 6 7 8 9 1 2 9 1 2 3 4 5 6 7 8
6 7 8 9 1 2 3 4 5 6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8 3 4 5 6 7 8 9 1 2
Figura 9 Intercambio de las demás filas y resultado final.

2.1.2. Intercambio Columnas

Luego de realizado el intercambio de las filas, se hará el mismo proceso para las

columnas (figura 10).

7 8 9 1 2 3 4 5 6 9 8 7 3 2 1 6 5 4
4 5 6 7 8 9 1 2 3 6 5 4 9 8 7 3 2 1
1 2 3 4 5 6 7 8 9 3 2 1 6 5 4 9 8 7
8 9 1 2 3 4 5 6 7 1 9 8 4 3 2 7 6 5
5 6 7 8 9 1 2 3 4 7 6 5 1 9 8 4 3 2
2 3 4 5 6 7 8 9 1 4 3 2 7 6 5 1 9 8
9 1 2 3 4 5 6 7 8 2 1 9 5 4 3 8 7 6
6 7 8 9 1 2 3 4 5 8 7 6 2 1 9 5 4 3
3 4 5 6 7 8 9 1 2 5 4 3 8 7 6 2 1 9

Figura 10 Intercambio de columnas.

2.1.3. Intercambio de submatrices

Por último, se reitera el mismo procedimiento, pero esta vez acorde con los dos

grupos de filas en las submatrices que se encuentran en el medio y la final (figura 11).
 8

9 8 7 3 2 1 6 5 4 9 8 7 3 2 1 6 5 4
6 5 4 9 8 7 3 2 1 6 5 4 9 8 7 3 2 1
3 2 1 6 5 4 9 8 7 3 2 1 6 5 4 9 8 7
1 9 8 4 3 2 7 6 5 2 1 9 5 4 3 8 7 6
7 6 5 1 9 8 4 3 2 8 7 6 2 1 9 5 4 3
4 3 2 7 6 5 1 9 8 5 4 3 8 7 6 2 1 9
2 1 9 5 4 3 8 7 6 1 9 8 4 3 2 7 6 5
8 7 6 2 1 9 5 4 3 7 6 5 1 9 8 4 3 2
5 4 3 8 7 6 2 1 9 4 3 2 7 6 5 1 9 8
Figura 11 Intercambio de submatrices

Del mismo modo, la facilidad con la que se usa el algoritmo evidencia que los

números nunca se van a repetir, cumpliendo con lo establecido anteriormente, así hay

variadas transformaciones que se pueden aplicar para hacer este intercambio, no obstante,

lo importante de ello es que se pueda aplicar una secuencia aleatoria para obtener la

cuadricula con “números ordenados aleatoriamente”.

2.1.4. Borrado de números

Este es el último paso, dependiendo del nivel de dificultad se hará la eliminación

de números al azar. Para el nivel fácil se borrarán 40 números, medio serán 50 y difícil

60. Existen varias maneras para hacer la eliminación, como aplicación de matemáticas o

simplemente escoger los números y eliminarlos (figura 12).

8 3 1 6 4 4
6 5 9 8 7 3 1 6 5 8 7 3 1
1 6 0 8 7 1 6 8 7
2 9 5 3 6 2 5 3 6
9 5 3 9 5 3
5 3 8 6 9 3 8 6 9
1 9 3 9 3
5 3 2 5 3 2
4 3 7 5 1 4 3 5
 9

4
6 3
1 6 8 7
2 5 6
5
3 8 6 9
3
2
4 3 5
Figura 12 Eliminación de números en diferentes niveles

2.2. Sudoku con Java

Ahora para la construcción del Sudoku se usará el lenguaje de programación

JAVA en el que, con distintas herramientas vistas en clase, permitirán el desarrollo de

este basado en las anteriores instrucciones.

Java es un lenguaje de programación sinónimo de sencillez, pues en la facilidad

de su aprendizaje, fue diseñado como un lenguaje pequeño, con el objetivo de que sea

comprendido y que se adopte de una manera amplia y completa (Douglas Bell, 2003).

2.2.1. Programación Orientada a Objetos

Los lenguajes como Java son orientados a objetos, más específicamente es la

programación orientada a objetos (POO), la unidad de programación es la clase a partir

de la cual se crean objetos en su momento dado. Las clases en Jaca contienen métodos y

atributos (Deitel & Deitel, 2012).

Lo que quiere decir que un programa se construye a través de objetos, los que a

su vez se crean a partir de clases. En palabras simples forma una nueva manera de pensar,

para representar acciones o cosas de la vida real basada en objetos. Existen unas

características que identifican al objeto, de acuerdo con el contexto, también son llamadas

acciones o comportamientos. Una clase es la estructura base o característica para crear

 10

objetos. Las clases son para los objetos lo que los planos de construcción son, para las

casas.

En el caso del Sudoku, junto con sus atributos y comportamientos, como se verá

a continuación:

SUDOKU

Atributos: Proyecto, Sudoku, números.

Comportamientos: fácil, medio, difícil, construirSudoku, números, cero.

2.2.2. Clase en Java

Una clase es un prototipo, matriz o plantilla de las que luego se pueden crear

múltiples instancias del mismo tipo. Es una manera de especificar las características, pero

basados en el mismo prototipo. La clase define las variables y los métodos comunes a las

instancias de ese tipo, pero luego, cada instancia de esta clase tendrá sus propios valores

y compartirán las mismas funciones.

Se usarán dos paquetes, el primero estará en el paquete por defecto, que tendrá la

clase Proyecto y el segundo se llamará lógica, que poseerá la clase llamada Sudoku.

2.2.3. Herramientas

En primer lugar, se establecerá que el IDE (entornos de desarrollo integrados) será

el software Eclipse, que está en código abierto multiplataforma, se usa normalmente en

IDE de Java llamado Java Development Toolkit (JDT) y el compilador (ECJ) que se

entrega como parte de Eclipse (Eclipse, 2018).

Las herramientas que se usarán en la programación del Sudoku serán los arrays

(matrices), ciclos anidados, JOptionPane, random y las líneas de código usadas

 11

regularmente junto con varios contadores que ayudarán en la implementación de este

trabajo.

2.2.5. Arrays

Los arrays son contenedores de información que pueden tener una o varias

dimensiones, dependiendo de este punto, pueden ser vectores o matrices. El número de

celdas de un array se da en el momento de su creación. Según Groussard (2012) la

manipulación de un array se debe componer de tres etapas:

• Declaración de una variable que permita trabajar con el array.

• Creación del array.

• Almacenamiento y manejo de los elementos del array.

Con estos principales pasos, se crea un arreglo; en el caso específico de la creación

del Sudoku, se va a utilizar un arreglo que contiene varias dimensiones, en teoría son

arrays que tienen otros arrays. Los elementos se almacenan de forma contigua y el número

de elementos que almacenan es fijo.

Como se vio en el caso anterior para la creación de un array bidireccional, se dará

en primer lugar la declaración, especificando los pares corchetes como dimensiones se

desee tener (Groussard, 2012). A continuación, se mostrará la línea para su declaración y

creación en la clase Sudoku, la matriz se llamará mata.

Static int mata[] [] = new int [9][9];

Y por último se procede a ingresar dentro los datos, estos elementos son accesibles

de la misma manera que una variable clásica. Para ello se utilizará un ciclo en el que vaya

recorriendo los filas y el otro para que vaya recorriendo las columnas, su nombre formal
 12

es ciclo o bucle anidado. Se verá en el desarrollo la manera de cómo se va a hacer el

llenado de los números a la matriz 9 × 9.

2.2.6. Ciclos de bucle con for

Así, se entiende que la función de la secuencia for es ejecutar un número

determinado de veces una secuencia de instrucciones (Duran, Gutiérrez, & Pimentel,

2012).

Para el caso en el que se va a emplear, se usarán for anidados, es decir, una

secuencia dentro de otra secuencia. Para una mayor aclaración se muestra un reloj (Figura

4) en el que sus contiene tres manecillas, una para las horas, otra para los minutos y otra

para los segundos. En este ejemplo, se pueden comparar cada manecilla con cada

secuencia, puesto que la secuencia que está dentro del ciclo es el que más va a avanzar,

así el segundero hace mover al minutero cada vez que termina de hacer una vuelta, y el

minutero mueve al horario cuando este termina de hacer una vuelta, en este caso, es el

segundero el que va a dar más vueltas. Pero para la elaboración del rompecabezas,

solamente se usarán dos for para el llenado de la matriz mata, en el primero estará la letra

i, que hará la sucesión de las filas y la j que hará la de las columnas.

Figura 13 Muestra las partes de las manecillas de

un reloj.
 13

2.2.7. JOptionPane

JOptionPane es una clase del paquete javax.swing que proporciona cuadros de

diálogo preempaquetados para entrada y salida. Según Deitel & Deitel ( 2012), estos

cuadros de diálogo son ventanas en las cuales los programas muestran mensajes

importantes al usuario, o que obtienen información solicitada de éste.

En el programa, se hará la utilización de dos herramientas, la primera será

showMessageDialog, que básicamente muestra un diálogo de mensaje. La segunda es

showOptionDialog que permite según la elección del usuario, ir al método que se

programe, en este caso se muestran cuatro botones en los que tres pasarán a la dificultad

del Sudoku y un botón a salir del programa.

2.2.8. Random

La clase random es un elemento de azar, en el que se introduce en el paquete

java.util. Los objetos de esa clase producen valores aleatorios de distintos tipos, en el caso

específico será de tipo int¸ pues en el intercambio que se plantea (filas y columnas) se

necesita que sea al azar cuando se genere un nuevo Sudoku. En ese sentido, la aplicación

del método nextInt, dependerá del rango en el que se encuentre, pero se utilizará varios

números de acuerdo con una operación que esta dentro de ese rango, en este caso los

valores devueltos por nextInt son en realidad números pseudoaleatorios generados por un

cálculo, de tal forma que cada ejecución de un programa produzca una secuencia distinta

de valores aleatorios.

Asimismo, random se usará para que borre o cambie los números que se

encuentran en el Sudoku, dependiendo el valor que reciba este método, se pondrán de

manera aleatoria en toda la matriz.

 14

3. Desarrollo de la Aplicación

Ahora se procederá a dar la explicación para conllevar a la generación de Sudokus

aleatorios, tomando como base las herramientas vistas en clase, para ello se usará UML2

y capturas de pantalla.

3.1. Empezando con las Clases

En primer lugar, como ya se tenia establecido, se trabajarán en dos paquetes,

donde cada uno de ellos tenga una clase, en el que estará la interfaz y la lógica. Para usar

en la interfaz lo que está en la lógica (figura 14), se procede a usar import bajo el nombre

de la carpeta, que en este caso se llamó lógica (línea 6) y crear el package, que iría la

clase Sudoku (línea 1).

Luego de ello, se crea un objeto Proyecto y lo asigna a py, mientras que para crear

un objeto Sudoku se lo asigna a sd (líneas 10 y 11). La línea 13 procede con la función

principal en Java para ejecutar una clase.

Figura 14 Creación de los paquetes, importación y uso de main

Ahora, se tendrá que mostrar un mensaje en el que indique la función del

programa, que se ve en la línea 14 con la herramienta JOptionPane¸ cabe aclarar que en

la línea 7 se hizo la importación para que este funcionará, este se ejecutará mostrando un

mensaje (showMessageDialog) en el que dará la bienvenida y que con un clic enviará al

2
Es el esquema de representación gráfica para modelar sistemas orientados a objetos.
 15

usuario al menú de selección, de igual manera se dará a la creación y declaración del array

que tendrá el Sudoku (figura 15).

Figura 15 (De derecha a izquierda) Diagrama de clases de UML, que indica que
en el paquete default hay una clase Proyecto que tiene al main y en el paquete
Logica hay una clase Sudoku y una matriz definida.

En el paquete default, se procederá a hacer la acción del menú (línea 17)

anteriormente invocada, así se usará nuevamente JOptionPane, pero esta vez con el

componente showOptionDialog, que en pocas palabras muestra botones para que el

usuario pueda escoger el nivel de dificultad, en este componente se deberá de escribir que

la respuesta o el botón a escoger se almacene en un entero llamado op (línea 18), luego

lo que va dentro del mensaje de texto, el titulo de la ventana, la invocación de

JOptionPane.YES_NO_CANCEL_OPTION (que es el tipo de botones que van a salir),

también JOptionPane.QUESTION_MESSAGE (el tipo de mensaje que se requiere), un

ícono que en este caso no será ninguno y se agrega la palabra null, el array o contenedor

que va a tener el texto que van a ir en los botones y por ultimo la opción inicial (figura

16).

Figura 16 Lo contenido en un showOptionDialog

Y por último, de acuerdo con el condicional if (línea 24) se enviará a otra acción

que dará la construcción del Sudoku, ya sea si se cumple, caso contrario else evaluará la

siguiente condición y así hasta que algún if sea verdadero. En los tres casos (fácil, medio
 16

y difícil) se aplicará las mismas líneas de código y su creación están en las líneas 42, 58

y 74 respectivamente, pero para el último if, que en este caso no será ninguno de los tres

niveles, será el que de la salida al usuario del programa.

La condición para evaluar será si en op se cumple el JOptionPane (figura 17), ya

sea para un YES_OPTION, NO_OPTION, CANCEL_OPTION y CLOSED_OPTION.

Proporcionalmente se le agrega a cada una los niveles. Con py hace que vaya a la acción

y que cuando este la termina, vuelva nuevamente al menú, puesto que la única salida que

tiene el usuario es cuando oprima salir en el menú principal.

Figura 17 Uso de Condicionales, con sus respectivas acciones

3.2. Creación de las acciones y llenado de matriz

Ahora, luego de establecer los condicionales, se procederá a crear cada acción,

recordando que en todas las tres será el mismo código, con el único cambio del número

de espacios en blanco, que en este caso se harán con ceros. Luego de definidas las

acciones, se procederá a mostrar el mensaje en el que indique el nivel y el número de

ceros que se pondrán, se usará JOptionPane.showMessageDialog. Pero primero, se

 17

indicará el tamaño del arreglo en el paquete Logica (línea 5) que será 9 x 9, dentro de la

clase Sudoku.

Ahora, en el mismo paquete se hará la acción construirSudoku (línea 7), que es un

bucle for¸ en el que se establece hasta que coordenada de fila y columna deberá de llenar

la matriz, en este caso será menor a 9, puesto que dicha comienza con la coordenada 0,0

y termina en 0,8. Se tendrá dos contadores m y o (línea 8), que hará las veces de poner

los números en la primera fila del 1 al 9, comenzará con uno, y se lo asignará a la

coordenada 0,0 (línea 13). Luego de que se lo asigna, aumentará en 1, es decir que ahora

m valdrá dos, lógicamente bajo la condición de que m tiene que ser igual o menor a 9

(línea 12), después a m se le sumará un tres que será asignado al otro contador o (línea

21), con el fin de que en la siguiente fila se inicie con 4, para ello se instaura un

condicional if en el que comprobará que si m es igual a 10 (línea 22) a o se le asigne un

cuatro. Además de ello, se encontró que al dividir los números resultantes de la suma en

la línea 21, su modulo podrá ser 2 o 3 (línea 24 y 25) y que sumado darían el número

necesario para seguir llenando la matriz, cumpliendo con las reglas (figura 18).

Figura 18 Declaración del tamaño de la matriz y llenado de la misma, así como su diagrama de clases
 18

3.3. Generación de Coordenadas aleatorias

Luego, siguiendo las instrucciones para construir un Sudoku, gracias a la

herramienta random¸ se puede generar números aleatorios para intercambiar filas y

columnas (línea 35 y 37) dentro de un mismo grupo, para ello se selecciona dos filas al

azar y se intercambia. Del mismo modo se hace con las columnas, dependiendo del entero

que le llegue en el paquete default en el método números (línea 28).

En este caso, se cuenta con dos contadores llamados desde y hasta (línea 31 y 32),

ellos serán los encargados de hacer el calculo interno para que los números que salgan en

el random estén acordes a las submatrices. Después, se creará el objeto de random, que

hará la selección de las coordenadas aleatorias llamado roca (línea 33). Así, dentro de un

bucle for (línea 34), que su condición lo limita a realizar la acción intercambioFilas (línea

42) tres veces, pues este numero son las submatrices que se intercambiarán las filas.

El calculo es sencillo, pues random tendrá la opción de escoger entre el 0, 1 o 2,

este cambia cuando hasta le agrega el número que tenga asignado y se lo cambie

totalmente (línea 35 y 37) al trio de números 3, 4 y 5. Cuando vuelva a terminar dicho el

bucle, los nuevos números a escoger serían 6, 7 y 8; esto se debe a que dentro de la

selección del número que hará el random existe una resta y suma (línea 35) agregando

además a que los tres números arriba mencionados, así en el primer bucle que haga hasta

habrá cambiado (línea 40). En dado caso de que el número de la coordenada w1 y w2 sea

el mismo, el ciclo do while hará nuevamente la selección del número para w2 (figura 19).
 19

Figura 19 Creación del método números, junto con la

generación de las coordenadas aleatorias

3.4. Intercambio de filas y columnas

En la línea 41 o 45, se evidencia que de acuerdo con el número entero que le llegue

a vigil, este tomará la acción hacia el intercambioFilas (línea 49) o intercambioColumnas

(línea 57), en ambos casos se hace el mismo procedimiento. Viendo que los anteriores

métodos les llega w1 y w2, que son las coordenadas para cambiar, se creará una variable

ward (línea 50) que será la encargada de guardar el número que se encuentra en la celda

determinada bajo w1 y j (línea 52), con esto se crea un bucle for (línea 51) para que recorra

la fila explícita, pero la columna es una variable fija hasta que termine el bucle.

Inmediatamente lo que hay en toda la columna establecida w2 y en la fila j se lo asignara

a w1, j (línea 53). Y por último lo que se había guardado en ward, pasa a w2, j (línea 54).

Es el mismo procedimiento para intercambioColumnas (línea 57) solo que la

variable que va a guardar el número que esta en la celda será wars (línea 58). El cambio

estará encaminado en la letra que tenga el bucle; en este caso, la letra recorrerá la columna

y la variable fija será las filas w1 y w2 (figura 20).

 20

Figura 20 Creación de los métodos para intercambiar filas y columnas

3.5. Eliminación de Números Aleatoriamente

Siguiendo las instrucciones, se emanará a la eliminación de números y el

reemplazarlos por ceros creando el método cero (línea 65) que le llegará la cantidad que

deberá cambiar por el entero ceroz. Nuevamente se instituirá un random bajo el nombre

de rc (línea 66) y con un bucle, hará el respectivo cambio (línea 68) basándose en que rc

generará las coordenadas aleatorias, que en este caso f será la coordenada de la fila y c

será la columna (línea 69 y 70), lógicamente dentro del rango 0 al 8.

Para corroborar que no se transcriban ceros, se establece el condicional if (línea

71) en donde valorara si en las coordenadas declaradas por rc existe un número diferente

de cero, en caso afirmativo, lo pondrá en la celda (línea 72). Si no se cumple, decrementa

i (línea 74) para que no se afecte la cantidad de ceros suministrada (figura 21), que en el

caso de fácil será de 40, medio 50 y difícil 60.

Figura 21 Método cero, que borrará aleatoriamente los

números del Sudoku
 21

3.6. Mostrar Sudoku en Paquete Logica

Para el último método de la clase Sudoku, se define como un entero llamado mama

(línea 78), que se encargará con un return de regresar la matriz completa (línea 79). Cabe

aclarar que para mostrarla se necesita un ciclo que se encuentra en el paquete default

(figura 22).

Figura 22 Método para mostrar la matriz y el diagrama UML final de la clase Sudoku

3.7. Invocar Métodos del Paquete Logica

Ahora, con el objeto sd se comienza a invocar los métodos anteriormente

realizados, nuevamente aclarando que para los tres métodos se usará el mismo código,

bajo el siguiente orden (figura 23):

1. Se tiene que construir el Sudoku, para ello se invoca el método

construirSudoku (línea 44).

2. Se pasa a la generación de las coordenadas aleatorias, para el intercambio se

deja dentro del método 1 (línea 45), que tomara el nombre de vigil.

3. Igual que en el numeral 2, solo que en vez de que a vigil se tome por 1, será

un cero (línea 46).

 22

4. Para la eliminación de números y reemplazarlos por ceros, se invocará el

método cero (línea 47), en donde ceroz se le asignará un numero de acuerdo

con el nivel de dificultad.

3.8. Mostrar Sudoku

Finalizando, se escribirá el código para que la matriz sea visible usando la

herramienta JOptionPane, haciendo uso de un bucle (línea 49) e invocando a mama (línea

51), que retornara la matriz. Para ello se usa un String llamado arg (línea 48), para que

deje espacios en blanco y permita que toda la matriz se visualice en un cuadro de mensaje.

Así a arg se simplifica la asignación con+= para que la matriz se sume con las comillas

(línea 51) y aparte generé una raya para poder diferenciar los números y no queden tan

juntos. En la linea 54 se aprecia un salto de línea con el fin de que no queden en una sola

columna y de esta manera, con showMessageDialog se pueda reflejar la matriz con el

String arg (línea 56).

Figura 23 Elaboración de la invocación de diferentes métodos en facil().

 23

3.9. Métodos Medio y Difícil

Para estos métodos, se usará el mismo código establecido en facil, solamente se

cambian la cantidad de ceros según sea el nivel, que serán 50 (línea 63) y 60 (línea 79)

respectivamente (figura 24).

Figura 24 Métodos medio y dificil, junto con el diagrama UML finalizado.

 24

Conclusiones

• Se pudieron utilizar las herramientas de Programación Orientada a Objetos

de manera completa y analítica, entendiendo y aplicando lo visto en clase

de Algoritmos y Programación.

• Existen diversas maneras de combinación para la construcción del

Sudoku, se pueden aplicar en la programación ya que permite una mayor

facilidad con los cálculos.

REFERENCIAS

Cabrera Pacheco, A., & Meneses Rodríguez, E. (2009). Un algoritmo sencillo de Sudokus

de 9 × 9 (Universidad Autónoma de Yucatán). Retrieved from

https://studylib.es/doc/4702296/un-algoritmo-sencillo-de-sudokus-de-9-×-9

Crilly, T. (2009). 50 cosas que hay que saber sobre matemáticas. Retrieved from

https://books.google.com.ua/books/about/50_cosas_que_hay_que_saber_sobre_las

_mat.html?id=Pg4NT5vBFyYC&printsec=frontcover&source=kp_read_button&re

dir_esc=y#v=onepage&q=sudoku&f=false

Deitel, P., & Deitel, H. M. (2012). Como programar en Java 9/e. Retrieved from

https://books.google.com.ua/books?hl=es&lr=lang_es&id=is2J44U4DpsC&oi=fnd

&pg=PA71&dq=java&ots=105i4mxitw&sig=34P3I7x7qqchnnNj2oHsvsgDhBI&r

edir_esc=y#v=onepage&q&f=false

Douglas Bell, M. P. (2003). Java para estudiantes (Vol. 8). https://doi.org/’

Duran, F., Gutiérrez, F., & Pimentel, E. (2012). PROGRAMACION ORIENTADA A

OBJETOS CON JAVA. Retrieved from

 25

https://books.google.com.ua/books?hl=es&lr=lang_es&id=3EQdUbkOVGIC&oi=f

nd&pg=PP1&dq=matriz+java&ots=04gVzBGDMO&sig=gfl02jgqidTK1CBvqCZ

ydb42aAg&redir_esc=y#v=snippet&q=for&f=false

Eclipse. (2018). Eclipse desktop & web IDEs. Retrieved July 30, 2019, from

www.eclipse.org website: https://www.eclipse.org/ide/

Forret, P. (2006). A Sudoku challenge generator. Science. Retrieved from

https://blog.forret.com/2006/08/14/a-sudoku-challenge-generator/

Groussard, T. (2012). JAVA 7 : los fundamentos del lenguaje Java. Retrieved from

https://books.google.com.ua/books?hl=es&lr=lang_es&id=JaPTzKZxbN4C&oi=fn

d&pg=PA9&dq=matriz+java&ots=pV5FtcDnZj&sig=pAXvxFaKsnwQuZJKApG

DAUcMy6M&redir_esc=y#v=onepage&q=matriz&f=false