1
« en: Lunes 16 de Noviembre de 2009, 05:02 »
Hola amigos:
Yo soy nueva en el foro y los necesito con suma urgencia pues este código me tiene loca y me gustaría si me pudieran decir dónde encuentro el error, o el error.
Al depurar me sale codigo inalcanzable y se requiere una referencia a objeto no estático y que no todas las rutas me arrojan un valor. Estoy cansada de darle vueltas. A ver si por caridad alguno me hecha una manito. Graicas.
Ahí va el código para crear sudoku
using
System;
using
System.Collections.Generic;
using
System.Text;
namespace
ConsoleApplication1
{
class Sudoku
{
bool verificadacolumna;
int i, j;//declara e inicializa la matriz
int p;//declara e inicializa matriz auxiliar de núemros aleatorios
int[,] matriz = new int[9, 9];
int[] aux = new int[30];//utilizo esta matriz unidiemnsional de 30 celdas 30 el número de celdas que debo llenar en el sudoku
Random r = new Random();
//creemos un nuevo array para organizar las regiones
//Declaración del array
int m; //variable de filas para la nueva matriz límitesRegiones
int n;// variable para columnas de matriz límitesREgiones
int inicioFila;
bool verificadaregion;
//instanciación ó creación del nuevo "new" objeto del array 9 filas 2 columnas
int[,] limitesRegiones = { { 0, 0 }, { 0, 3 }, { 0, 6 }, { 3, 0 }, { 3, 3 }, { 3, 6 }, { 6, 0 }, { 6, 3 }, { 6, 6 } };//inicialización del array
// debe haber quedado un arreglo de 9 filas y dos columnas donde se ubican
//los valores de inicio de la primera celda para cada una de las nueve regiones
//miremos cómo se vería en consola
int NumeroRegion;
int numeroPrueba;
//podríamnos hacer que genere cualquiera todo y luego revice si cumple condiciones sisi imprime si no generar otro problema tiempo
//lo mejor seria que cada número sea analizado antes para asignarlo
//un número cualquiera entero
//entre 1 y 9 para probar si sirve en esa posición
//Ahora vamos
//a verificar si ese número sirve en esa posición y que no
//repetido en la región
//========================================================================================================================================
//Método para codificar las regiones del sudoku
//Entrada: vacío
//salida: num_secreto
//Notas: codifica las 9 regiones
public int CodificarRegiones(int i, int j)
{
if (i >= 0 && i <= 2)
{
if (j >= 0 && j <= 2)
{
return 1;
}
}
if (i >= 0 && i <= 2)
{
if (j >= 3 && j <= 5)
{
return 2;
}
}
if (i >= 0 && i <= 2)
{
if (j >= 6 && j <= 8)
{
return 3;
}
}
if (i >= 3 && i <= 5)
{
if (j >= 0 && j <= 2)
{
return 4;
}
}
if (i >= 3 && i <= 5)
{
if (j >= 3 && j <= 5)
{
return 5;
}
}
if (i >= 3 && i <= 5)
{
if (j >= 6 && j <= 8)
{
return 6;
}
}
if (i >= 6 && i <= 8)
{
if (j >= 0 && j <= 2)
{
return 7;
}
}
if (i >= 6 && i <= 8)
{
if (j >= 3 && j <= 5)
{
return 8;
}
}
if (i >= 6 && i <= 8)
{
if (j >= 6 && j <= 8)
{
return 9;
}
return 10;
}
return 10;
}
//========================================================================================================================================
//empecemos en orden a crear los métodos para verificar los números
//Método para crear un número aleatorio
//Entrada: vacío
//salida: num_secreto
//Notas: crea números aleatorios r entre 1 y 9
public int NumerosAleatorios() //debe ser static para que no sea necesario crear objetos para usarla, int para que sea entero el número creado
{
Random r = new Random();
return r.Next(1, 10);
}
//========================================================================================================================================
//Método para verificar que un número aleatorio pertenece a una región determinada
//Entrada: numeroPrueba
//salida: bool
//Notas: no se permiten números repetidos en la misma región
public bool VerificarRegion(int numeroPrueba, int i, int j, int NumeroRegion) //si fuera public vouid, se usa para escribir mensajes en la consola
{
switch (NumeroRegion)
{
case 1:
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
if (numeroPrueba == matriz[i, j])
{
return false;
}
else return true;
break;
case 2:
for (i = 0; i < 3; i++)
for (j = 3; j < 6; j++)
if (numeroPrueba == matriz[i, j])
{
return false;
}
else return true;
break;
case 3:
for (i = 0; i < 3; i++)
for (j = 6; j < 9; j++)
if (numeroPrueba == matriz[i, j])
{
return false;
}
else return true;
break;
case 4:
for (i = 3; i < 6; i++)
for (j = 0; j < 3; j++)
if (numeroPrueba == matriz[i, j])
{
return false;
}
else return true;
break;
case 5:
for (i = 3; i < 6; i++)
for (j = 3; j < 6; j++)
if (numeroPrueba == matriz[i, j])
{
return false;
}
else return true;
break;
case 6:
for (i = 3; i < 6; i++)
for (j = 6; j < 9; j++)
if (numeroPrueba == matriz[i, j])
{
return false;
}
else return true;
break;
case 7:
for (i = 6; i < 9; i++)
for (j = 0; j < 3; j++)
if (numeroPrueba == matriz[i, j])
{
return false;
}
else return true;
break;
case 8:
for (i = 6; i < 9; i++)
for (j = 3; j < 6; j++)
if (numeroPrueba == matriz[i, j])
{
return false;
}
else return true;
break;
case 9:
for (i = 6; i < 9; i++)
for (j = 6; j < 9; j++)
if (numeroPrueba == matriz[i, j])
{
return false;
}
else return true;
break;
default:
return false;
}
}
//========================================================================================================================================
//Método para verificar que un número aleatorio pertenece a una fila determinada
//Entrada: numeroPrueba
//salida: bool
//Notas: no se permiten números repetidos en la misma fila. El conjunto de la intersección entre los elementos que pertenecen
//a la fila y el conjunto unitario de número aleatorio deber ser vacío para continuar. Lo que se hace aquí
//es que empezamos con j=0, es decir columna 0, mientras esta sea menor que 9 vamos incrementando y probando si el
//numPrueba es igual a lo que hay dentro de la matriz en la posición i,j. Si si la variable verificafila sale falso
//Los tres tipos de verificación deben ser verdaderos para que el número se pueda asignar a esa celda de la matriz
public bool VerificarFila(int numeroPrueba, int i, int j)
{
{
for (j = 0; j < 9; j++)
{
if (numeroPrueba == matriz[i, j])
return false;
else return true;
}
}
}
//========================================================================================================================================
//Método para verificar que un número aleatorio pertenece a una columna determinada
//Entrada: numeroPrueba
//salida: bool
//Notas: no se permiten números repetidos en la misma columna
public bool VerificarColumna(int numeroPrueba, int i , int j)
{
{
for (i = 0; i < 9; i++)
{
if (numeroPrueba == matriz[i, j])
return false;
return true;
break;
}
}
}
//======================================================================================================================================
//Método para asignar el número probado a la posición ij
//Entrada:
//Salida: matriz?
//Notas: se genera matriz 9x9, se selecciona una celda al azar
public bool AsignacionNumero(int numeroPrueba, int i, int j)
{
if (Sudoku.VerificarRegion(numeroPrueba, i, j, NumeroRegion) && (Sudoku.VerificarFila(numeroPrueba, i, j)) && ( Sudoku.VerificarColumna( numeroPrueba, i, j)))
{
return true;
}
else
{
return false;
}
}
//======================================================================================================================================
//Método para crear la matriz y visualizarla en consola
//Entrada:
//Salida: matriz?
//Notas: se genera matriz 9x9, se selecciona una celda al azar
}
//====================================================================================
//====================================================================================
class SudokuApp
{
static void main()
{
Sudoku sudo = new Sudoku();
int i, j;//declara e inicializa la matriz
int[,] matriz = new int[9, 9];
int numeroPrueba;
int z;
bool prueba;
//creemos un nuevo array para organizar las regiones
//Declaración del array
//instanciación ó creación del nuevo "new" objeto del array 9 filas 2 columnas
// debe haber quedado un arreglo de 9 filas y dos columnas donde se ubican
//los valores de inicio de la primera celda para cada una de las nueve regiones
//miremos cómo se vería en consola
for (z = 0; z < 91; z++)//este es un contador hasta 91 números para llenar el sudoku
{
i = sudo.NumerosAleatorios() - 1;
//esto para grantizar números desde 0 hasta 8
j = sudo.NumerosAleatorios() - 1;
//aquí es totalmente azar
//condición de simetría
/*aquí hay que establecer una condición especial porque si
i ó j pertenecen al conjunto 3 4 5, existe probablidad de
* repetirse el número por lo que es mejor empezar a probar
* desde aquí.*/
//establezcamos aquí la prueba para cada número si sí se asigna si no se devuelve y prueba con otros
//definitivamente voy a crear una matriz donde se guarden los números aleatorios para poder
//apuntarlos y variar la posicion si no sirven
do //aquí hacemos las pruebas necesarias para que el número sea el correcto
{
numeroPrueba = sudo.NumerosAleatorios();
prueba = sudo.AsignacionNumero(numeroPrueba, i, j);
}
while (prueba == false);
matriz[i, j] = numeroPrueba;
do
{
numeroPrueba = sudo.NumerosAleatorios();
prueba = sudo.AsignacionNumero(numeroPrueba, 8 - i, 8 - j);//condicion de simetría
}
while (prueba == false);
matriz[8 - i, 8 - j] = numeroPrueba;
//Espero que los tres números aleatorios sean diferentes. Toca probar...
// matriz[8 - i, 8 - j] ;
}
for (i = 0; i < 9; i++)//bucle for anidado forfor para leer toda la matriz
{
for (j = 0; j < 9; j++) Console.Write("{0,3}", matriz[i, j]);
Console.WriteLine();
}
string a = Console.ReadLine();
}
//=======================================================================================================================================
//cierre del método Main, que es el que utiliza los difernetes métodos de la clase SudokuApp
//=======================================================================================================================================
}
//cierre de la clase SudokuApp
}
//Cierre de namespace
Mostrar Mensajes
