elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  .NET (Moderadores: Novlucker, seba123neo, kub0x, Eleкtro)
| | | |-+  Librería de códigos C# (Compartan aquí sus códigos)
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: 1 [2] Ir Abajo Respuesta Imprimir
Autor Tema: Librería de códigos C# (Compartan aquí sus códigos)  (Leído 5,967 veces)
DarK_FirefoX


Desconectado Desconectado

Mensajes: 1.220


Be the change you wanna see in te world


Ver Perfil
Re: Librería de códigos C# (Compartan aquí sus códigos)
« Respuesta #10 en: 18 Julio 2015, 01:25 »

27 - Calcular el determinante de una matriz cuadrada de orden n

Voy a mostrar un código recursivo para calcular el determinante de una matriz cuadrada de orden n. No voy a explicar tan en detalle que cosa es el determinante pues son conocimientos "básicos" de algebra que deben saber si necesitan utilizar esté código.

Veamos que:

Sea A una matriz cuadrada; asociada a esa matriz hay un número llamado determinante, que se simboliza por |A| o det(A) y que se calcula de la siguiente forma:

- Si el orden de A es 2 el determinante es el producto de los elementos de la diagonal principal menos el producto de los elementos de la diagonal secundaria:

Ej:

A = (a00, a01)
      (a10, a11)

Luego: det(A) = a00*a11 - a10*a01

- Si el orden de A es 3 el determinante se calcula utilizando la llamada Regla de Sarrus, según la cual si A es la matriz de orden 3:

A = (a00, a01, a02)
      (a10, a11, a12)
      (a20, a21, a22)

y: det(A) = a00*a11*a22 + a01*a12*a20 + a02*a10*a21 - a02*a11*a20 - a01*a10*a22 - a00*a12*a21

Ahora, si el orden de la matriz es superior a 3 el determinante se reduce al de una matriz de orden 3 o de orden 2 de la siguiente manera (que es la que vamos a implementar):

A partir de la matriz cuadrada arbitraria A, si removemos la fila i y la columna j obtenemos una nueva matriz de orden (una unidad) menor que la matriz A y que la vamos a denotar como Aij, cuyo determinante det(Aij) recibe el nombre de menor complementario del elemento aij. Si a este det(Aij) le acompañamos de su signo (-1)i+j tenemos el adjunto de aij

Resumiendo:

Menor complementario de aij = det(Aij)
Adjunto de aij = cij = (-1)i+j*det(Aij)

Entonces, si A es una matriz cuadrada de orden mayor que 3 el determinante de A se obtiene eligiendo una fila o columna arbitraria de A y multiplicando a cada elemento de esta por su adjunto. De esta forma, si elegimos la fila i, el determinante de A es:

det(A) = SUMATORIA(desde i, j=1 hasta n)(aij * (-1)i+j * det(Aij))

Espero esto se haya entendido, trate de explicarlo lo más sencillo posible.

Ahora vamos al código:

Vamos a tener varios métodos con las siguientes signaturas:

Código
  1. public static int Determinant(int[,] matrix)
  2. static int DeterminantOrder2(int[,] matrix)
  3. static int DeterminantRec(int[,] matrix)
  4. static void FillMatrix(int[,] matrix, int[,] toFill, int row, int column)

Como podemos observar el método Determinant() va a ser el método portal, luego tenemos para calcular el determinante de una matriz de orden 2, luego para calcular el determinante de una matriz de orden mayor que 2 y el último es un método auxiliar para rellenar la matriz adjunta de los menores.

Código
  1. public static int Determinant(int[,] matrix)
  2.        {
  3.            //Comprobamos que sea cuadrada
  4.            if (matrix.GetLength(0) != matrix.GetLength(1))
  5.                throw new ArgumentException("La matriz debe ser cuadrada");
  6.            //Vemos si es de orden 2
  7.            if (matrix.GetLength(0) == 2)
  8.                return DeterminantOrder2(matrix);
  9.            else
  10.                return DeterminantRec(matrix);
  11.  
  12.        }

En este ^^ método lo primero que hacemos es comprobar que la matriz sea cuadrada, para esto comprobamos el valor del método .GetLength(), el cual devuelve un int que representa la cantidad de elementos en cada dimensión, o sea el orden de la matriz horizontal y vertical. En este caso tenemos dos dimensiones, por lo tanto comprobamos que si se cumple que:

Código
  1. matrix.GetLength(0) != matrix.GetLength(1)

Entonces lanzamos una excepción pues la matriz no es cuadrada.

Luego, ya que sabemos que la matriz es cuadrada vamos a comprobar si es de orden 2 y llamamos al método correspondiente, sino es de orden mayor y llamamos al método recursivo.

Veamos primero el método DeterminantOrder2():

Código
  1. static int DeterminantOrder2(int[,] matrix)
  2.        {
  3.            return (matrix[0, 0] * matrix[1, 1]) - (matrix[0, 1] * matrix[1, 0]);
  4.        }

Este método es muy sencillo lo cual no es necesario explicar nada. (Revisen arriba como se calcula el determinante de orden 2)

Ahora, vamos con el método DeterminatRec() que viene a ser "el más complicado", lo pongo entre comilla, porque no es más que una representación en código de la ecuación que les presenté antes para calcular el determinante de orden mayor que 2:

Código
  1. static int DeterminantRec(int[,] matrix)
  2.        {
  3.            //Caso de parada que sea de orden 2 y lo calculamos con el método para
  4.            //el determinante de orden 2
  5.            if (matrix.GetLength(0) == 2)
  6.            {
  7.                return DeterminantOrder2(matrix);
  8.            }
  9.            else
  10.            {
  11.                int det = 0; //Inicializamos una variable para almacenar el valor del determinante
  12.  
  13.                //En este ciclo recorremos una fila para para obtener el adjunto de cada elemento
  14.                //de esta fila así calcular el determinante de este fijando cada elemento de la fila
  15.                //0
  16.                for (int i = 0; i < matrix.GetLength(1); i++)
  17.                {
  18.                    //Creamos una matriz para rellenarla con la matriz para luego calcular su
  19.                    //determinante llamando recursivo. Esta matriz tiene un orden menor (en una
  20.                    //unidad) que la matriz original
  21.                    int[,] minor = new int[matrix.GetLength(0) - 1, matrix.GetLength(1) - 1];
  22.  
  23.                    //Aquí llamamos al método auxiliar que se encarga de rellenar la matriz auxiliar
  24.                    FillMatrix(matrix, minor, 0, i);
  25.  
  26.                    //Aquí lo que vamos a definir si lo que se hace es sumar o restar. Esto es una
  27.                    //manera de representar el cambio de signo que trae consigo el (-1) elevado a
  28.                    //i+j. En este caso como utilizamos la fila 0 siempre, ese número va a ser
  29.                    //positivo solo cuando estemos en una columna (j) que sea par, negativo en
  30.                    //caso contrario
  31.                    if (i % 2 == 0)
  32.                        //Aquí lo que hacemos es multiplicar el valor del elemento en cuestión
  33.                        //por el  adjunto teniendo en cuenta el signo correspondiente y se lo
  34.                        //sumamos a la variable det (en el else es lo mismo lo que con el signo
  35.                        //negativo). Aquí es donde está la llamada recursiva pues hay que calcular el
  36.                        //determinante de la matriz "minor"
  37.                        det+= (matrix[0, i]) * (DeterminantRec(minor));
  38.                    else
  39.                        det+= (-matrix[0, i]) * (DeterminantRec(minor));
  40.                }
  41.  
  42.                //Una vez que ya recorrimos toda la fila, devolvemos el determinante
  43.                return det;
  44.            }
  45.        }

Ya explique todo en los comentarios del código.

Ahora veamos el método FillMatrix():

Este método recibe la matriz desde la cual se van a sacar los valores, la matriz donde se van a copiar (de un orden menor en una unidad), la fila y la columna que se va a eliminar:

Código
  1. static void FillMatrix(int[,] matrix, int[,] toFill, int row, int column)
  2.        {
  3.            //Ciclo anidado para recorrer la matriz desde la cual se van a sacar los valores
  4.            for (int i = 0; i < matrix.GetLength(0); i++)
  5.            {
  6.                for (int j = 0; j < matrix.GetLength(1); j++)
  7.                {
  8.                    //Si estamos en una fila menor a la que se va a eliminar
  9.                    if (i < row)
  10.                    {
  11.                        //Si estamos en una columna menor a la que se va a eliminar
  12.                        if (j < column)
  13.                            toFill[i, j] = matrix[i, j]; //Copiamos el valor normalmente
  14.                        else
  15.                            if (j > column)
  16.                              //En este momento estamos en una fila menor a la que se va a
  17.                              //eliminar pero por encima de la columna a eliminar, por lo tanto
  18.                              //se saca el valor de la matriz y se coloca en una columna con una
  19.                              //unidad menos (j-1)
  20.                              toFill[i, j - 1] = matrix[i, j];
  21.                    }
  22.                    else
  23.                    //Si estamos en una fila mayor a la que se va a eliminar
  24.                    if (i > row)
  25.                    {
  26.                        //Si estamos en una columna mayor a la que se va a eliminar
  27.                        if (j < column)
  28.                            //En este momento estamos por encima de la fila a eliminar pero por debajo
  29.                            //de la columna a eliminar, por lo tanto tenemos que quitarle una unidad a la fila
  30.                            //(i-1)
  31.                            toFill[i - 1, j] = matrix[i, j];
  32.                        else
  33.                            if (j > column)
  34.                              //Aquí estamos por encima tanto de la fila como de la columna a eliminar por lo
  35.                              //tanto le quitamos una unidad tanto a las filas como a la columna (i-1, j-1)
  36.                              toFill[i - 1, j - 1] = matrix[i, j];
  37.                    }
  38.                }
  39.            }
  40.        }

Espero que este código se haya entendido, sino, ya saben que pueden preguntar, opinar y/o criticar.

Quizás no sea la mejor manera (complejidad temporal) de hacerlo, si tienen alguna sugerencia será bienvenida.

Espero seguir subiendo códigos pronto.

Salu2s


En línea


Ustedes se ríen de mi porque soy diferente, yo me río de ustedes porque son todos iguales
DarK_FirefoX


Desconectado Desconectado

Mensajes: 1.220


Be the change you wanna see in te world


Ver Perfil
Re: Librería de códigos C# (Compartan aquí sus códigos)
« Respuesta #11 en: 20 Julio 2015, 00:35 »

28 - Drag&Drop sobre un TextBox (detectando la codificación de caracteres)

Primer que todo vamos a repasar los conceptos básicos que se van a mostrar.

¿Que es un Drag&Drop?

Drag significa Arrastrar
Drop significa Soltar

Por lo tanto => Drag&Drop => Arrastrar y Soltar. Vamos que es la simple función de arrastrar un documento y soltarlo en algún lado. En este caso vamos a ser capaces de seleccionar un archivo de texto y soltarlo sobre un TextBox dentro del formulario.

Luego tenemos como detectar la codificación de caracteres. La codificación de caracteres es el método que permite convertir un carácter de un lenguaje natural en un símbolo de otro sistema de representación aplicando normas o reglas de codificación

Existen varios tipos de codificación:

  • UTF-8
  • UTF-16 Big Endian
  • UTF-16 Little Endian
  • UTF-7
  • UTF-32

Entre otros.

Ahora, ¿Cómo vamos a detectar que codificación tiene un fichero?

Para esto vamos a analizar la "Marca de orden de bytes (BOM)". BOM es un carácter Unicode que se utiliza para indicar el orden de los bytes de un fichero de texto. Su código es U+FEFF.

Representaciones de las marcas de orden de bytes para cada codificación

Encoding Representación (Hex)
UTF-7 2B 2F 76
UTF-8 EF BB BF
UTF-16 Little Endian FF FE
UTF-16 Big Endian FE FF
UTF-32 Big Endian 00 00 FE FF

Veamos el método que vamos a utilizar para analizar la BOM:

Código
  1. /// <summary>
  2.        /// Determina la codificación de un fichero de texto analizando la marca de orden de bytes (BOM)
  3.        /// Devuelve la codificación por defecto de la página ANSI del sistema en caso de que el análisis falle
  4.        /// </summary>
  5.        /// <param name="filename">El fichero de texto a analizar</param>
  6.        /// <returns>La codificación detectada.</returns>
  7.        public static Encoding GetEncoding(string filename)
  8.        {
  9.            // Read the BOM
  10.            byte[] bom = new byte[4]; //Buffer para almacenar los datos leidos del fichero
  11.  
  12.            //Utilizamos un FileStream para abrir el fichero
  13.            using (FileStream file = new FileStream(filename, FileMode.Open, FileAccess.Read))
  14.            {
  15.                file.Read(bom, 0, 4); //Leemos los 4 primeros bytes del fichero
  16.            }
  17.  
  18.            // Analizamos la BOM y devolvemos la codificación correcta
  19.            if (bom[0] == 0x2b && bom[1] == 0x2f && bom[2] == 0x76) return Encoding.UTF7;
  20.            if (bom[0] == 0xef && bom[1] == 0xbb && bom[2] == 0xbf) return Encoding.UTF8;
  21.            if (bom[0] == 0xff && bom[1] == 0xfe) return Encoding.Unicode; //UTF-16LE
  22.            if (bom[0] == 0xfe && bom[1] == 0xff) return Encoding.BigEndianUnicode; //UTF-16BE
  23.            if (bom[0] == 0 && bom[1] == 0 && bom[2] == 0xfe && bom[3] == 0xff) return Encoding.UTF32;
  24.  
  25.            //Devolvemos la codificacion por defecto de la página ANSI del sistema.
  26.            return Encoding.Default;
  27.        }

Nota: Para usar FileStream, debemos añadir a los using:

Código
  1. System.IO;

Nota: Ese ^^ nombre de espacio contiene tipos que permiten leer y escribir de archivos y flujos de datos, y tipos que brindan soporte básico para el trabajo con directorios.

Un FileStream, nos permite crear un flujo alrededor de un fichero, soportando operaciones de lectura y escritura tanto sincrónicas como asincrónicas.

Veamos que lo utilizamos con la declaración using que nos brinda una sintaxis conveniente para asegurar el uso correcto de objetos que implementen la interfaz IDisposable. Esta interfaz define un método que nos permite cerrar (de-allocate) los recursos de un objeto. Por lo tanto luego que se salga del ámbito de la declaración using los recursos del objeto sobre el cual se esta trabajando serán liberados. En este caso (FileStream) no será necesario hacerle Close()

El FileStream tiene un constructor con varias sobrecargas, en este caso vamos a utilizar la sobrecarga que tiene esta signatura:

Código
  1. FileStream(String, FileMode, FileAccess)

Donde el primer parámetro viene dado por la ruta del archivo, o sea, fileList[0]. El segundo es un enum que especifica como el sistema operativo debe abrir el archivo, en este caso FileMode.Open, lo cual indica que el sistema operativo debe abrir un fichero existente. La habilidad de abrir un fichero es dependiente del valor especificado por el enum  FileAccess en el próximo parámetro el cual define que permiso se tiene al acceder al archivo (Read, Write o Read/Write). En este caso vamos a utilizar FileAccess.Read, pues solo vamos a leer el archivo.

El método Read() que pertenece a la clase FileStream, nos permite leer un bloque de bytes desde el fichero apuntado por el flujo y guardarlo en un buffer dado. En este caso el método devuelve un int que representan la cantidad de bytes leídos. Pero modifica el primer parámetro, pues al ser un array, este es pasado al método por referencia, y por lo tanto es modificado. En él se guardan los bytes leídos. Este parámetro es un byte[]. El segundo parámetro es un int que representa el offset (digámosle la posición) en el array (primer parámetro) donde los bytes se comenzarán a guardar. Y el tercer parámetro es el máximo número de bytes a leer.

Ahora, como lo que queremos es mostrar el contenido de un fichero de texto en un TextBox vamos a insertar un TextBox en el formulario.

Nota: En este ejemplo>

Propiedad Name del Form -> mainForm
Propiedad Name del TextBox -> textBox


Ahora, para permitirle a textBox recibir información que haya sido arrastrada y soltada sobre él, le vamos a poner la propiedad AllowDrop = true

Ahora nos vamos subscribir a los eventos textBox_DragEnter y textBox_DragDrop. Luego vamos a necesitar un string[] para almacenar las rutas de el/los fichero/s que se soltaron sobre textBox. Para eso declaramos un campo privado dentro de la clase de mainForm:

Código
  1. string[] fileList;

Veamos que hacemos una vez que se capture el evento textBox_DragEnter

Código
  1. private void textBox_DragEnter(object sender, DragEventArgs e)
  2.        {
  3.            if (e.Data.GetDataPresent(DataFormats.FileDrop))
  4.            {
  5.                fileList = (string[])e.Data.GetData(DataFormats.FileDrop);
  6.                if (fileList.Length == 1 && Path.GetExtension(fileList[0]) == ".txt")
  7.                {
  8.                    e.Effect = DragDropEffects.Copy;
  9.                }
  10.                else
  11.                    e.Effect = DragDropEffects.None;
  12.            }
  13.        }

Lo primero que vemos es la propiedad Data del tipo DataEventArgs e que devuelve un objeto que implementa IDataObject, que contiene datos asociado con este evento. Entonces lo que hacemos es llamar al método GetDataPresent() de la interfaz IDataObject el cual nos permite determinar si la información almacenada en esta instancia está asociada a un formato especifico. En este caso le pasamos como parámetro el campo estático (solo-lectura) FileDrop de la clase DataFormats - DataFormats.FileDrop. El cual especifica el formato de Windows para arrastrar y soltar ficheros.

Una vez explicado esto, lo que comprobamos es que si lo que se está soltando encima de textBox es un archivo vamos a hacer una cosa:

Primero que todo:

Código
  1. fileList = (string[])e.Data.GetData(DataFormats.FileDrop);

Con el método GetData() sobre la propiedad Data del tipo DragEventArgs e obtenemos la información (con el formato establecido [DataFormats.FileDrop]) que estamos arrastrando sobre el textBox. Luego, vemos que le estamos haciendo un cast a string[] y se lo asignamos al campo que habíamos declarado. Aquí tendremos toda la información que viene siendo arrastrada y capturada por el evento. Como el formato es FileDrop lo que nos va a añadir en el array son las rutas a los documentos que están siendo arrastrados.

Ahora vamos a hacer 2 comprobaciones:

1 - Que solo estemos arrastrando 1 solo fichero, para esto solo tenemos que comprobar que la longitud del array sea 1

2 - Que la extensión del archivo sea ".txt".

Para comprobar esta segunda condición vamos a utilizar el método GetExtension() de la clase Path que pertenece al namespace System.IO. La clase estática Path realiza operaciones sobre strings que contienen información de rutas de ficheros o directorio. En este caso utilizamos el método estático GetExternsion(), el cual recibe un string que representa "la ruta" de la cual queremos sacar la extensión. En este caso: fileList[0], el cual es el único archivo que estamos arrastrando y comprobamos si es igual a ".txt". En ese caso vamos a definir la propiedad Effect del tipo DragEventArgs e a DragDropEffects.Copy, en caso contrario (que no se cumplan las dos condiciones) a DragDropEffects.None.

La propiedad Effect aplica el efecto determinado para el cursor cuando se hace una operación de Drag & Drop sobre el control.

Luego, vemos que le asignamos un valor utilizando el enum DragDropEffects, y su valor Copy, que crea el efecto de que lo que se está arrastrando es copiado a donde se va a soltar.

En el otro caso está DragDropEffects.None que implica que donde se va a soltar no acepta datos. Por lo tanto no aceptará los datos cuando se suelten los datos.

Ahora veamos el EventHandler para textbox_DragDrop:

Código
  1. private void textBox_DragDrop(object sender, DragEventArgs e)
  2.        {
  3.            Encoding fileEncoding = GetEncoding(fileList[0]);
  4.            using (StreamReader file = new StreamReader(fileList[0], fileEncoding))
  5.            {
  6.                textBox.Text = file.ReadToEnd();
  7.            }
  8.        }

Lo primero que hacemos es capturar lo que devuelve el método GetEncoding() (explicado anteriormente), el cual devuelve la codificación de caracteres correspondiente al fichero (fileList[0]) tras analizar la BOM.

Luego, utilizando un StreamReader, que también pertenece al namespace System.IO vamos a leer el fichero.

Un StreamReader nos permite leer caracteres de un flujo de bytes en una codificación específica. En este caso utilizamos la declaración using con el mismo objetivo que explique arriba con el FileStream. Utilizaremos una sobrecarga del constructor del StreamReader que recibe la ruta del fichero al cual le queremos crear el flujo (fileList[0]) y la codificación de caracteres con la cual queremos abrirla. En este caso le pasamos lo que nos devolvió el método GetEncoding().

Entonces dentro del ámbito de la declaración using vamos a asignarle a la propiedad Text de textBox, lo que nos devuelve el método ReadToEnd() perteneciente a la clase StreamReader. Este método lee todos los caracteres desde la posición actual (en el stream) hasta el final del stream. Se dice desde la posición actual, pues se pueden haber hecho lecturas desde el stream anteriormente y se queda guardada hasta que posición se leyó, en este caso no se había leído nada, por lo tanto se lee desde el principio hasta el final.

Bueno, esto es todo para este código, solo les queda probarlo. Espero que entiendan todo, quizás no sea la mejor manera de explicarlo, pero lo hice lo mejor y más sencillo que pude.

Cualquier duda/comentario/crítica será bienvenida.

Espero seguir subiendo códigos pronto.

Salu2s


« Última modificación: 18 Agosto 2015, 16:40 por DarK_FirefoX » En línea


Ustedes se ríen de mi porque soy diferente, yo me río de ustedes porque son todos iguales
Eleкtro
Novato Astral y
Moderador Global
***
Desconectado Desconectado

Mensajes: 8.707


El sentido común es el menos común de los sentidos


Ver Perfil
Re: Librería de códigos C# (Compartan aquí sus códigos)
« Respuesta #12 en: 13 Septiembre 2015, 13:04 »

Comparar solamente 5 codificaciones y en caso de no coincidir ninguna devolver la codificación que representa a la página de códigos del sistema no es lo mejor que se puede hacer, lo que deberías hacer es iterar las codificaciones con la función System.Text.Encoding.GetEncodings y usar la función Encoding.GetEncoding para obtener la codificación y Encoding.GetPreamble para obtener el preámbulo (BOM) con el que comparar la secuencia de bytes.
De esta manera pasamos de comparar 5 codificaciones, a unas 150.

Un ejemplo (convertido de VB.Net a C#):
Código
  1. /// ----------------------------------------------------------------------------------------------------
  2. /// <remarks>
  3. /// Title : Get Encoding of textfile.
  4. /// Author: Elektro
  5. /// Date  : 17-January-2015
  6. /// </remarks>
  7. /// ----------------------------------------------------------------------------------------------------
  8. /// <example><code>
  9. /// Dim encoding As Encoding = TextfileUtil.GetEncoding("C:\file.txt")
  10. /// Dim encodingName As String = TextfileUtil.GetEncoding("C:\file.txt").WebName
  11. /// </code></example>
  12. /// ----------------------------------------------------------------------------------------------------
  13. /// <summary>
  14. /// Determines the <see cref="Encoding"/> of the source textfile.
  15. /// </summary>
  16. /// ----------------------------------------------------------------------------------------------------
  17. /// <param name="sourceFilepath">
  18. /// The source textfile path.
  19. /// </param>
  20. /// ----------------------------------------------------------------------------------------------------
  21. /// <returns>
  22. /// If the encoding can be detected, the return value is the detected <see cref="Encoding"/>,
  23. /// if the encoding can't be detected, the return value is <see cref="Encoding.Default"/>.
  24. /// </returns>
  25. /// ----------------------------------------------------------------------------------------------------
  26. [DebuggerStepThrough()]
  27. [DebuggerHidden()]
  28. public static Encoding GetEncoding(string sourceFilepath)
  29. {
  30.  
  31. Encoding encoding = null;
  32. byte[] bytes = File.ReadAllBytes(sourceFilepath);
  33.  
  34. foreach (EncodingInfo encodingInfo in encoding.GetEncodings()) {
  35. Encoding currentEncoding = encodingInfo.GetEncoding();
  36. byte[] preamble = currentEncoding.GetPreamble();
  37. bool match = true;
  38.  
  39. if ((preamble.Length > 0) && (preamble.Length <= bytes.Length)) {
  40.  
  41. for (int i = 0; i <= (preamble.Length - 1); i++) {
  42. if (preamble(i) != bytes(i)) {
  43. match = false;
  44. break; // TODO: might not be correct. Was : Exit For
  45. }
  46.  
  47. }
  48.  
  49. } else {
  50. match = false;
  51.  
  52. }
  53.  
  54. if (match) {
  55. encoding = currentEncoding;
  56. break; // TODO: might not be correct. Was : Exit For
  57. }
  58.  
  59. }
  60.  
  61. if (encoding == null) {
  62. return encoding.Default;
  63.  
  64. } else {
  65. return encoding;
  66.  
  67. }
  68.  
  69. }
  70.  
  71. //=======================================================
  72. //Service provided by Telerik (www.telerik.com)
  73. //=======================================================

Saludos
« Última modificación: 13 Septiembre 2015, 13:10 por Eleкtro » En línea


SnzCeb

Desconectado Desconectado

Mensajes: 10


Ver Perfil
Re: Librería de códigos C# (Compartan aquí sus códigos)
« Respuesta #13 en: 12 Diciembre 2015, 13:26 »

Hola chicos, pues voy a hacer mi primera aportación de código a ver si os parece útil. Es una clase que está pensada como almacén de datos de juegos basado en tablero de celdas. Me ha servido para implementar el juego de la vida y seguro que os puede servir para juegos como el tres, el cuatro en raya, damas, que se yo xD.

Código
  1.  
  2.    /*************************************************************************************
  3.      * This class implements a bit board                                                 *
  4.      *                                                                                   *
  5.      * Foreach bit we have one cell. If we turn on a bit means occupied cell. By the     *
  6.      * opposite, if we turn off the bit, means empty cell                                *
  7.      * The main gain of a bitBoard is to decrease the amount of memory used.             *
  8.      * this fact is so important in algorithms like Minimax                              *
  9.      * foreach byte we can cover 8 positions                                             *
  10.      * For instance: If we have and 8x8 board, we can save 64 cells in a 8x1 board       *
  11.      * (8 bytes) because 1 byteCell can save 8 cells                                     *
  12.      *************************************************************************************/
  13.  
  14.  
  15.   public class Board
  16.    {
  17.  
  18.        protected readonly byte[,] board;
  19.        protected readonly int height;
  20.        protected readonly int byteWidth;
  21.        protected readonly int width;
  22.  
  23.        protected Board(int height, int width)
  24.        {
  25.            this.height = height;
  26.            this.byteWidth =(int) Math.Ceiling(width * 0.125); // 0.125 * width = width /8  
  27.            this.width = width;
  28.            board = new byte[height, byteWidth];
  29.        }
  30.  
  31.  
  32.        private byte IncreaseBitPosn(int n)
  33.        {
  34.  
  35.            return (byte)(0x1 << n);
  36.        }
  37.        private byte ReverseByte (byte b)
  38.        {
  39.            return  (byte) (b ^ 0xFF);
  40.        }
  41.  
  42.        private int ToByteColumn(int y)
  43.        {
  44.            return (int) 0.125 * y;
  45.        }
  46.  
  47.        private int ToBitColumn(int y)
  48.        {
  49.            return (y >= 8) ? y - (ToByteColumn(y) * 8) : y;
  50.        }
  51.  
  52.        /*
  53.         *  Checks if [x,y] is empty with an and bitwise
  54.         *  For instance:
  55.         *  x = 3
  56.         *  y = 7  -> Matchs to byteCol 0, bitCol 7
  57.         *  board (3,0)        = 1 0 0 1 0 1 0 0
  58.         *  IncreaseBitPosn(7) = 1 0 0 0 0 0 0 0
  59.         *  1 0 0 1 0 1 0 0 &  1 0 0 0 0 0 0 0 = 1 0 0 0 0 0 0 0 != 0 -> returns false              
  60.         */
  61.        protected bool PosIsEmpty(int x, int y)
  62.        {
  63.            return (board[x, ToByteColumn(y)] & IncreaseBitPosn(ToBitColumn(y))) == 0;
  64.    }
  65.        /*
  66.         *  Increases bit at position (x,y)
  67.         *  For instance:
  68.         *  x = 3
  69.         *  y = 7  -> Matchs to byteCol 0, bitCol 7
  70.         *  board (3,0)        = 1 0 0 1 0 1 0 0
  71.         *  IncreaseBitPosn(7) = 1 0 0 0 0 0 0 0
  72.         *  0 0 0 1 0 1 0 0  |  1 0 0 0 0 0 0 0 = 1 0 0 1 0 1 0 0  
  73.         */
  74.        protected void turnOnBit(int x, int y)
  75.        {
  76.            board[x, ToByteColumn(y)] |= IncreaseBitPosn(ToBitColumn(y));
  77.        }
  78.        /*
  79.          *  Decreases bit at position (x,y)
  80.          *  For instance:
  81.          *  x = 3
  82.          *  y = 7  -> Matchs to byteCol 0, bitCol 7
  83.          *  board (3,0)        = 1 0 0 1 0 1 0 0
  84.          *  ReverseByte(IncreaseBitPosn(7)) = 0 1 1 1 1 1 1 1
  85.          *  1 0 0 1 0 1 0 0  &  0 1 1 1 1 1 1 1 = 0 0 0 1 0 1 0 0  
  86.          */
  87.  
  88.        protected void turnOffBit(int x, int y)
  89.        {
  90.            board[x, ToByteColumn(y)] &=  ReverseByte(IncreaseBitPosn(ToBitColumn(y)));
  91.        }
  92.  
  93.    }
  94.  
« Última modificación: 14 Diciembre 2015, 20:17 por SnzCeb » En línea

Páginas: 1 [2] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Codigos asm???? :S
Dudas Generales
Firos 8 1,786 Último mensaje 11 Marzo 2004, 16:44
por Firos
Cd de codigos de C
Programación General
nachosama 0 462 Último mensaje 23 Noviembre 2004, 07:41
por nachosama
Para todos los amantes del irc aqui les dejo codigos de Guerra de Irc
Chats; IRC y Messengers
KxM 0 2,005 Último mensaje 17 Septiembre 2010, 20:56
por KxM
Librería de Snippets para VB.Net !! (Compartan aquí sus snippets) « 1 2 ... 50 51 »
.NET
Eleкtro 505 160,349 Último mensaje 13 Abril 2017, 12:50
por Eleкtro
Librería de Plantillas !! (Compartan aquí sus plantillas)
.NET
Eleкtro 5 8,199 Último mensaje 22 Octubre 2014, 13:42
por 1quark1
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines