• Martes 21 de Enero de 2020, 00:29

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - toyamv1

Páginas: [1]
1
C# / Re: Download C# Express!
« 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

Páginas: [1]