Foro de elhacker.net

public static int Maximo(int[] numeros)
        {
            int maximo = int.MinValue;
            for (int i = 0; i < numeros.Length; i++)
            {
                if (numeros[i] > maximo)
                    maximo = numeros[i];
            }
            return maximo;
        }

public static int SegundoMayor(int[] numeros)
        {
            int mayor = int.MinValue;
            int sMayor = int.MinValue;
            for (int i = 0; i < numeros.Length; i++)
            {
                if (numeros[i] > mayor)
                {
                    sMayor = mayor;
                    mayor = numeros[i];
                }
                else if (numeros[i] > sMayor)
                    sMayor = numeros[i];
            }
            return sMayor;
        }

public static void InvierteV(int[] a)
        {
            for (int i = 0; i < a.Length / 2; i++)
            {
                int temp = a[i]; //Asignamos valor a la variable temporal
                a[i] = a[a.Length - 1 - i]; //Copiamos el valor de la parte trasera del array a la frontal
                a[a.Length - 1 - i] = temp; //Copiamos el valor guardado en la variable temporal a la parte trasera del array
            }
        }

public static int[] InvierteN(int[] a)
        {
            int[] newInt = new int[a.Length];
 
            //Copiamos los elementos del array al nuevo array
            for (int i = 0; i < a.Length; i++)
                newInt[i] = a[i];
 
            for (int i = 0; i < newInt.Length/2; i++)
            {
                int temp = newInt[i]; //Asignamos valor a la variable temporal
                newInt[i] = newInt[newInt.Length - 1-i]; //Copiamos el valor de la parte trasera del array a la frontal
                newInt[newInt.Length - 1-i] = temp; //Copiamos el valor guardado en la variable temporal a la parte trasera del array
            }
            return newInt;
        }

Array.Copy(a, newInt, a.Length);

public static bool EsPrimo(int a)
        {
           int raizDelNumero = (int)Math.Sqrt(a);
            for (int i = 2; i <= raizDelNumero; i++)
                if (a % i == 0) 
                    return false;
            return true;
        }

using ControlChars = Microsoft.VisualBasic.ControlChars;
using Encoding = System.Text.Encoding;
using StringBuilder = System.Text.StringBuilder;
using System;
using Xml = System.Xml;
 
namespace Tools
{
    class XmlUtil
    {
        /// <remarks>
        /// *****************************************************************
        /// Snippet Title: XML Beautifier
        /// Code's Author: Elektro
        /// Date Modified: 18-February-2015
        /// *****************************************************************
        /// </remarks>
        /// <summary>Beautifies the contents of an XML document.</summary>
        /// <param name="XMLText">
        /// The XML text content. 
        /// It can be an entire document or a fragment.
        /// </param>
        /// <param name="IndentChars">
        /// The string that is used to indent the XML. 
        /// Default value is: <see cref="Microsoft.VisualBasic.ControlChars.Tab"/>
        /// </param>
        /// <param name="IndentOnAttributes">
        /// If set to <c>true</c>, attributes will be separated by newlines.
        /// Default value is: <c>false</c>
        /// </param>
        /// <param name="TextEncoding">
        /// The XML text encoding to use. 
        /// Default value is: <see cref="System.Text.Encoding.Default"/>.
        /// </param>
        /// <returns>The beautified XML text.</returns>
        /// <exception cref="System.ArgumentNullException"></exception>
        public static string XmlBeautifier(string xmlText,
                                           string indentChars = null,
                                           bool indentOnAttributes = false,
                                           Encoding textEncoding = null)
        {
            if (string.IsNullOrEmpty(xmlText) || string.IsNullOrWhiteSpace(xmlText))
            {
                throw new ArgumentNullException(xmlText);
            }
 
            StringBuilder sb = new StringBuilder();
            Xml.XmlDocument doc = new Xml.XmlDocument();
            Xml.XmlWriterSettings settings = new Xml.XmlWriterSettings();
 
            settings.Indent = true;
            settings.CheckCharacters = true;
            settings.OmitXmlDeclaration = false;
            settings.ConformanceLevel = Xml.ConformanceLevel.Auto;
            settings.NamespaceHandling = Xml.NamespaceHandling.Default;
            settings.NewLineHandling = Xml.NewLineHandling.Replace;
            settings.NewLineChars = ControlChars.NewLine;
            settings.NewLineOnAttributes = indentOnAttributes;
            settings.IndentChars = indentChars != null ? indentChars : Convert.ToString(ControlChars.Tab);
            settings.Encoding = textEncoding != null ? textEncoding : Encoding.Default;
 
            using (Xml.XmlWriter writer = Xml.XmlWriter.Create(sb, settings))
            {
                doc.LoadXml(xmlText);
                doc.WriteContentTo(writer);
                writer.Flush();
            }
 
            return sb.ToString();
        }
 
    }
}

Encoding textEncoding = Encoding.Default;
 
string unformattedXmlDocument = File.ReadAllText("C:\\Unformatted Document.xml", textEncoding);
string formattedXmlDocument = XmlBeautifier(xmlText: unformattedXmlDocument, 
                                            indentChars: new string(' ', 2), 
                                            indentOnAttributes: true,
                                            textEncoding: textEncoding);
 
File.WriteAllText("C:\\Formatted Document.xml", formattedXmlDocument, textEncoding);

 public static bool EsPrimo(int a)
        {
            int raizDelNumero = (int)Math.Sqrt(a);
            for (int i = 2; i <= raizDelNumero; i++)
                if (a % i == 0) 
                    return false;
            return true;
        }

 public static int PrimoMasCercano(int n)
        {
            int contadorDer = 0;
            int contadorIzq = 0;
            int numeroDer = n;
            int numeroIzq = n;
            if (n <= 1) return 2;
            if (EsPrimo(n)) return n;
            else
            {
                    while (!EsPrimo(numeroDer))
                    {
                        numeroDer++;
                        contadorDer++;
                    }  
                    while (!EsPrimo(numeroIzq))
                    {
                        numeroIzq--;
                        contadorIzq++;
                    }              
            }
            if (contadorPos < contadorNeg) return numeroDer;
            return numeroIzq;
 
        }

static void Swap(int a, int b)
        {
            int temp = b;
            b = a;
            a = temp;
        }

int resto = dividendo % divisor

 public static int MCD(int a, int b)
        {
            if(a==b) return a;
            if(b>a)
                Swap(a,b);
            int dividendo = a;
            int divisor = b;
            int resto = dividendo % divisor;
            int answer = a;
            while (resto!=0)
            {
                dividendo = divisor;
                divisor = resto;
                resto = dividendo % divisor;
                if (resto != 0) answer = resto;
            }
            return answer;
        }

static int MCD(int a, int b)
        {
            if (a % b == 0) return b;
            return MCD(b, a % b);
        }

Console.WriteLine()

public static void DescomposicionPrimos(int n)
        {
            if (EsPrimo(n)) Console.WriteLine(n);
            else
            {
                int i = 2;
                int numero = n;
                while (numero!=1)
                {
                    if (EsPrimo(i))
                    {
                        if (numero % i == 0)
                        {
                            numero = numero / i;
                            Console.WriteLine(i);
                            i = 2;
                        }
                        else i++;
                    }
                    else i++;
                }
            }
 
        }

public static bool EsPerfecto(int n)
        {
            if (EsPrimo(n)) return false;
            int suma = 1;
            for (int i = 2; i <= n / 2; i++)
                if (n % i == 0)
                    suma += i;
            return suma == n;
        }

static int Fibonacci(int n)
        {
            if (n == 0) return 0;
            if (n == 1) return 1;
            return Fibonacci(n - 2) + Fibonacci(n - 1);
        }

static long[] fibonacci; //Para ir almacenando los valores de los términos calculados.
 
        static void Main(string[] args)
        {
            long n = long.Parse(Console.ReadLine());
            fibonacci = new long[n+1];
            Console.WriteLine(Fibonacci(n));
 
        }
 
        static long Fibonacci(long n)
        {
            if (fibonacci[n] != 0)
                return fibonacci[n];
            if (n == 1 || n==2)
                return 1;
            fibonacci[n - 2] = Fibonacci(n - 2);
            fibonacci[n - 1] = Fibonacci(n - 1);
            return fibonacci[n - 2] + fibonacci[n - 1];
        }

public static string Reverse(string original)
        {
            string reverse = "";
            for (int i = original.Length-1; i >= 0; i--)
                reverse += original[i];
            return reverse;
        }

public static string DecimalABinario(int n)
        {
            if (n == 0) return "0";
            string a = "";
            while (true)
            {
                if (n / 2 == 1)
                {
                    a = n % 2 + a;
                    a = 1 + a;
                    break;
                }
                a = n % 2 + a;
                n = n / 2;
            }
            return a;
        }

/// <summary>
        /// Método portal
        /// </summary>
        public static string DecimalABinario(int dec)
        {
            return DecimalABinario(dec, ""); //Llamamos al método
        }
 
        private static string DecimalABinario(int dec, string result)
        {
            if (dec == 0)
                return "0" + result;
            if (dec == 1)
                return "1" + result;
            return DecimalABinario(dec / 2, (dec % 2) + result);
        }

 static int BinarioADecimal(string bin)
        {
            int dec = 0;
            for (int i = 0; i < bin.Length; i++)
                dec += (bin[i] - '0') * (int)Math.Pow(2, bin.Length - 1 - i);
            return dec;
        }

bin[i]-'0'

bin[i]

bin[i]-'0'

        /// <summary>
        /// Método portal
        /// </summary>
        static int BinarioADecimal(string bin)
        {
            return BinarioADecimal(bin, 0);
        }
 
        static int BinarioADecimal(string bin, int result)
        {
            if (bin.Length == 0)
                return result;
            return BinarioADecimal(bin.Remove(0, 1), result + (int)(Math.Pow(2, bin.Length - 1) * (bin[0] - '0')));
        }

public static bool EsPalindromo(string cadena)
        {
            for (int i = 0; i < cadena.Length / 2; i++)
            {
                if (cadena[i] != cadena[cadena.Length - 1 - i])
                    return false;
            }
            return true;
        }

static bool EsPalindromo(string s)
        {
            int lIzq = 0;
            int lDer = s.Length - 1;
            if (lIzq >= lDer) return true;
            return s[lIzq] == s[lDer] &&
                EsPalindromo(s.Substring(lIzq + 1, lDer - 1));
        }

public static long Factorial(long numero)
        {
            long result = 1;
            for (long i = 2; i <= numero; i++)
                result *= i;
            return result;
        }

static long Factorial(long n)
        {
            if (n == 0) return 1;
            return n * Factorial(n - 1);
        }

public static bool EsBisiesto(int anno)
        {
            return (anno % 4 == 0 && anno % 100 != 0 || anno % 400 == 0);
        }

static long PotenciaIterativo(int _base, int _potencia)
        {
            long result = 1;
            for (int i = 1; i <= _potencia; i++)
                result *= _base;
            return result;
        }

static long Potencia(int _base, int _potencia)
        {
            if (_potencia == 0) return 1;
            if (_potencia == 1) return _base;
            return _base * Potencia(_base, _potencia - 1);
        }

double potencia = Math.Pow(2, 4) //Esto eleva 2 a la 4

/// <summary>
        /// Método portal
        /// </summary>
       public static bool BusquedaBinaria(int[] numerosOrdenado, int aBuscar)
        {
            return BusquedaBinaria(numerosOrdenado, aBuscar, 0, numerosOrdenado.Length - 1);
        }
 
        private static bool BusquedaBinaria(int[] numerosOrdenado, int aBuscar, int inf, int sup)
        {
            if (inf > sup)
                return false;
            int medio = (inf + sup) / 2;
            if(aBuscar==numerosOrdenado[medio])
                return true;
            if (aBuscar > numerosOrdenado[medio])
                return BusquedaBinaria(numerosOrdenado, aBuscar, medio + 1, sup);
            return BusquedaBinaria(numerosOrdenado, aBuscar, inf, medio - 1);
        }
 

int valor = 2;
bool estaElElemento = nombreArray.Contains(valor);

/// <summary>
        /// Método portal
        /// </summary>
        static int IndexOf(int[] orderedArray, int toSearch)
        {
            return IndexOf(orderedArray, toSearch, 0, orderedArray.Length - 1);
        }
 
        static int IndexOf(int[] orderedArray, int toSearch, int min, int max)
        {
            if (min > max)
                return -1;
            int medio = (min + max) / 2;
            if (toSearch > orderedArray[medio])
                return IndexOf(orderedArray, toSearch, medio + 1, max);
            if (toSearch < orderedArray[medio])
                return IndexOf(orderedArray, toSearch, min, medio - 1);
            return medio;
        }

/// <summary>
        /// Método portal
        /// </summary>
        static int PalindromInsertions(string line)
        {
            if (line.Length == null)
                throw new NullReferenceException("La cadena no puede ser null");
            if (line.Length == 1)
                return 0;
            return PalindromInsertions(line, 0, line.Length - 1);
        }
 
        static int PalindromInsertions(string line, int inf, int sup)
        {
            if (inf > sup)
                return 0;
            if (line[inf] == line[sup])
                return PalindromInsertions(line, inf + 1, sup - 1);
            else
                return Math.Min(1 + PalindromInsertions(line, inf + 1, sup), 
                    1 + PalindromInsertions(line, inf, sup - 1));
        }

public static void RotarDerecha(int[] a, int veces)
        {
            if (veces == a.Length || veces % a.Length == 0) return;
            int aMover = a[0];
            int posicion = 0;
            int contador = 0;
            while (contador < a.Length)
            {
                int proxPosicion = (posicion + veces) % a.Length; //Calculamos nueva posición
                int proxValor = a[proxPosicion]; //Guardamos el elemento que esta en esa nueva posición
                a[proxPosicion] = aMover; //Ponemos el elemento a mover en la nueva posición
                aMover = proxValor; //Asignamos a la variable del elemento a mover el valor que estaba en la nueva posición
                posicion = proxPosicion; //Guardamos la posición del nuevo elemento
                contador++; //Hicimos un movimiento
            }
        }

public static bool SonAnagramas(string a, string b)
        {
            if (a.Length != b.Length) return false;
            for (int i = 0; i < a.Length; i++)
            {
                bool igualdad = false;
                for (int j = 0; j < b.Length; j++)
                {
                    if (a[i] == b[j])
                    {
                        b = b.Remove(j,1);
                        igualdad = true;
                        break; 
                    }
                }
                if (!igualdad) return false;
            }
            return b.Length == 0;
        }

Func<FileInfo, bool>

/// <summary>
        /// Método portal
        /// </summary>
        public static int ContarFicheros(string path, string extension)
        {
            DirectoryInfo dir = new DirectoryInfo("Prueba"); //Creamos el DirectoryInfo pasándole la ruta del directorio
 
            Func<FileInfo, bool> extensionCondition = delegate(FileInfo fileInfo) { return fileInfo.Extension == extension; }; //Creamos el delegate
 
            return ContarFicheros(dir, extension, extensionCondition);
        }

public static int ContarFicheros(DirectoryInfo directory, string extension, Func<FileInfo, bool> extensionCondition)
        {
            int total = 0;
            if (directory.GetDirectories().Count() == 0)
            {
                total = directory.GetFiles().Count(extensionCondition);
                return total;
            }
            else
            {
                total += directory.GetFiles().Count(extensionCondition);
                foreach (var directorio in directory.GetDirectories())
                    total += ContarFicheros(directorio, extension, extensionCondition);
                return total;
            }
        } 

Func<FileInfo, bool>

Func<FileInfo, bool> extensionCondition = s => s.Extension == extension; ;

static bool ParentesisBalanceados(string cadena)
        {
            Stack<char> pila = new Stack<char>();
            for (int i = 0; i < cadena.Length; i++)
            {
                if (cadena[i] == '(')
                    pila.Push('(');
                else if (cadena[i] == '{')
                    pila.Push('{');
                else if (cadena[i] == '[')
                    pila.Push('[');
                else
                {
                    if (cadena[i] == ')')
                        if (pila.Count != 0 && pila.Peek() == '(')
                            pila.Pop();
                        else return false;
                    else if (cadena[i] == '}')
                        if (pila.Count != 0 && pila.Peek() == '{')
                            pila.Pop();
                        else return false;
                    else if (cadena[i] == ']')
                        if (pila.Count != 0 && pila.Peek() == '[')
                            pila.Pop();
                        else return false;
                }
            }
            return pila.Count == 0;
        }

Console.WriteLine(ParentesisBalanceados("ab(xa[y*c](..[.]+++){{}}cc)*”")); //Devuelve true
Console.WriteLine(ParentesisBalanceados("ab(xa[y*c)bb]**")); //Devuelve false
Console.WriteLine(ParentesisBalanceados("a(b))(")); //Devuelve false

static bool ParentesisBalanceadosSwitch(string cadena)
        {
            Stack<char> pila = new Stack<char>();
            for (int i = 0; i < cadena.Length; i++)
            {
                switch (cadena[i])
                {
                    case '(':
                        pila.Push('(');
                        break;
                    case '{':
                        pila.Push('{');
                        break;
                     case '[':
                        pila.Push('[');
                        break;
 
                     case ')':
                        if (pila.Count != 0 && pila.Peek() == '(')
                            pila.Pop();
                        else return false;
                        break;
                    case '}':
                         if (pila.Count != 0 && pila.Peek() == '{')
                            pila.Pop();
                        else return false;
                        break;
                     case ']':
                        if (pila.Count != 0 && pila.Peek() == '[')
                            pila.Pop();
                        break;
                    default:
                        break;
                }
            }
            return pila.Count == 0;
        }

string[] valores = {"a", "b", "c", "d", "e"};

 //Variaciones con repetición de N elementos en M
        /// <summary>
        ///  Método portal
        /// </summary>
        static void VariacionesConRepeticion(string[] original, int size)
        {
            VariacionesConRepeticion(original, new string[size], 0);
        }
 
        static void VariacionesConRepeticion(string[] original, string[] variacion, int pos)
        {
            if (pos == variacion.Length)
            {
                Print(variacion); //Llama al método Print(), el cual lo que hace es imprimir un array en pantalla.
                Console.WriteLine();
            }
            else
            {
                for (int i = 0; i < original.Length; i++)
                {
                    variacion[pos] = original[i];
                    VariacionesConRepeticion(original, variacion, pos + 1);
                }
            }
        }

static void Print<T>(T[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                if (i == array.Length - 1)
                    Console.Write(array[i]); //Imprimimos el elemento del array es el último elemento
                else
                    Console.Write(array[i] + " "); //Imprimimos el elemento del array más un espacio si no es el último elemento
            }
        }

string[] valores = {"a", "b", "c", "d", "e"};

string[] valores = {"a", "b", "c", "d", "e"};

 static void Swap<T>(ref T a, ref T b)
        {
            T temp = a;
            a = b;
            b = temp;
        }

static void Main(string[] args)
{
     int numberOne = 1;
     Inc(ref numberOne);
     Console.WriteLine(numberOne); //El valor que se imprimirá será 2
}
 
public static void Inc(ref int number)
{
     number++;
}
 

//Variaciones sin repetición de N elementos en M
        /// <summary>
        ///  Método portal
        /// </summary>
        static void VariacionesSinRepeticion(string[] original, int size)
        {
            VariacionesSinRepeticion(original, size, 0);
        }
 
        static void VariacionesSinRepeticion(string[] original, int size, int pos)
        {
            if (pos == size)
            {
                Print(original, size);
                Console.WriteLine();
            }
            else
            {
 
                for (int i = pos; i < original.Length; i++)
                {
                    Swap(ref original[pos], ref original[i]);
                    VariacionesSinRepeticion(original, size, pos+1);
                    Swap(ref original[pos], ref original[i]);
                }
 
            }
 
        }

string[] letras = { "a", "b", "c" };

string[] destino = new string[size];
Array.Copy(original, destino, size);

string[] valores = {"a", "b", "c", "d", "e"};

        /// <summary>
        /// Método portal
        /// </summary>
        static void Combinaciones<T>(T[] letras, int m)
        {
            Combinaciones(letras, new T[m], 0, 0);
        }

static void Combinaciones<T>(T[] original, T[] combinacion,
            int posOriginal, int posCombinacion )
        {
            if (posCombinacion == combinacion.Length)
            {
                Print(combinacion); //Imprimimos la combinación
                Console.WriteLine(); //Hacemos un salto de linea en la consola
            }
            else if (posOriginal == original.Length)
                return;
            else
            {
                combinacion[posCombinacion] = original[posOriginal];
                Combinaciones(original, combinacion, posOriginal + 1, posCombinacion + 1);
                Combinaciones(original, combinacion, posOriginal + 1, posCombinacion);
            }
        }

string[] original = {"a", "b", "c", "d", "e"};

combinacion[posCombinacion] = original[posOriginal];

Combinaciones(original, combinacion, posOriginal + 1, posCombinacion + 1);

Combinaciones(original, combinacion, posOriginal + 1, posCombinacion);

combinacion[posCombinacion] = original[posOriginal];

'4' '2' '10' '+' '*' '5' '-' = '43'

static long EvalPosFixed(string[] exp)
        {
            Stack<long> values = new Stack<long>();
            long first, second = 0;
            for (int i = 0; i < exp.Length; i++)
            {
                switch (exp[i])
                {
                    case "+":
                        if (values.Count < 2)
                            throw new Exception("There are not enough arguments to operate");
                        second = values.Pop();
                        first = values.Pop();
                        values.Push(first + second);
                        break;
                    case "-":
                        if (values.Count < 2)
                            throw new Exception("There are not enough arguments to operate");
                        second = values.Pop();
                        first = values.Pop();
                        values.Push(first - second);
                        break;
                    case "*":
                        if (values.Count < 2)
                            throw new Exception("There are not enough arguments to operate");
                        second = values.Pop();
                        first = values.Pop();
                        values.Push(first * second);
                        break;
                    case "/":
                        if (values.Count < 2)
                            throw new Exception("There are not enough arguments to operate");
                        second = values.Pop();
                        if (second == 0)
                            throw new DivideByZeroException("Can't divide by 0");
                        first = values.Pop();
                        values.Push(first / second);
                        break;
                    default:
                        values.Push(long.Parse(exp[i]));
                        break;
                }
            }
            if (values.Count > 1)
                throw new Exception("The expression had more arguments than it should have");
            return values.Peek();
        }

string[] expresion = { "4", "2", "10", "+", "*", "5", "-"};

public static int Determinant(int[,] matrix)
static int DeterminantOrder2(int[,] matrix)
static int DeterminantRec(int[,] matrix)
static void FillMatrix(int[,] matrix, int[,] toFill, int row, int column)

public static int Determinant(int[,] matrix)
        {
            //Comprobamos que sea cuadrada
            if (matrix.GetLength(0) != matrix.GetLength(1))
                throw new ArgumentException("La matriz debe ser cuadrada");
            //Vemos si es de orden 2
            if (matrix.GetLength(0) == 2)
                return DeterminantOrder2(matrix);
            else
                return DeterminantRec(matrix);
 
        }

matrix.GetLength(0) != matrix.GetLength(1)

 static int DeterminantOrder2(int[,] matrix)
        {
            return (matrix[0, 0] * matrix[1, 1]) - (matrix[0, 1] * matrix[1, 0]);
        }

static int DeterminantRec(int[,] matrix)
        {
            //Caso de parada que sea de orden 2 y lo calculamos con el método para
            //el determinante de orden 2
            if (matrix.GetLength(0) == 2)
            {
                return DeterminantOrder2(matrix);
            }
            else
            {
                int det = 0; //Inicializamos una variable para almacenar el valor del determinante
 
                //En este ciclo recorremos una fila para para obtener el adjunto de cada elemento
                //de esta fila así calcular el determinante de este fijando cada elemento de la fila 
                //0
                for (int i = 0; i < matrix.GetLength(1); i++)
                {
                    //Creamos una matriz para rellenarla con la matriz para luego calcular su
                    //determinante llamando recursivo. Esta matriz tiene un orden menor (en una
                    //unidad) que la matriz original
                    int[,] minor = new int[matrix.GetLength(0) - 1, matrix.GetLength(1) - 1];
 
                    //Aquí llamamos al método auxiliar que se encarga de rellenar la matriz auxiliar
                    FillMatrix(matrix, minor, 0, i);
 
                    //Aquí lo que vamos a definir si lo que se hace es sumar o restar. Esto es una
                    //manera de representar el cambio de signo que trae consigo el (-1) elevado a
                    //i+j. En este caso como utilizamos la fila 0 siempre, ese número va a ser
                    //positivo solo cuando estemos en una columna (j) que sea par, negativo en
                    //caso contrario
                    if (i % 2 == 0)
                        //Aquí lo que hacemos es multiplicar el valor del elemento en cuestión
                        //por el  adjunto teniendo en cuenta el signo correspondiente y se lo
                        //sumamos a la variable det (en el else es lo mismo lo que con el signo
                        //negativo). Aquí es donde está la llamada recursiva pues hay que calcular el
                        //determinante de la matriz "minor"
                        det+= (matrix[0, i]) * (DeterminantRec(minor));
                    else 
                        det+= (-matrix[0, i]) * (DeterminantRec(minor));
                }
 
                //Una vez que ya recorrimos toda la fila, devolvemos el determinante
                return det;
            }
        }

static void FillMatrix(int[,] matrix, int[,] toFill, int row, int column)
        {
            //Ciclo anidado para recorrer la matriz desde la cual se van a sacar los valores
            for (int i = 0; i < matrix.GetLength(0); i++)
            {
                for (int j = 0; j < matrix.GetLength(1); j++)
                {
                    //Si estamos en una fila menor a la que se va a eliminar
                    if (i < row)
                    {
                        //Si estamos en una columna menor a la que se va a eliminar
                        if (j < column)
                            toFill[i, j] = matrix[i, j]; //Copiamos el valor normalmente
                        else 
                            if (j > column)
                              //En este momento estamos en una fila menor a la que se va a
                              //eliminar pero por encima de la columna a eliminar, por lo tanto
                              //se saca el valor de la matriz y se coloca en una columna con una
                              //unidad menos (j-1)
                              toFill[i, j - 1] = matrix[i, j];
                    }
                    else
                    //Si estamos en una fila mayor a la que se va a eliminar
                    if (i > row)
                    {
                        //Si estamos en una columna mayor a la que se va a eliminar
                        if (j < column)
                            //En este momento estamos por encima de la fila a eliminar pero por debajo
                            //de la columna a eliminar, por lo tanto tenemos que quitarle una unidad a la fila
                            //(i-1)
                            toFill[i - 1, j] = matrix[i, j];
                        else 
                            if (j > column)
                              //Aquí estamos por encima tanto de la fila como de la columna a eliminar por lo
                              //tanto le quitamos una unidad tanto a las filas como a la columna (i-1, j-1)
                              toFill[i - 1, j - 1] = matrix[i, j];
                    }
                }
            }
        }

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

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

System.IO;

FileStream(String, FileMode, FileAccess)

string[] fileList;

private void textBox_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                fileList = (string[])e.Data.GetData(DataFormats.FileDrop);
                if (fileList.Length == 1 && Path.GetExtension(fileList[0]) == ".txt")
                {
                    e.Effect = DragDropEffects.Copy;
                }
                else
                    e.Effect = DragDropEffects.None;
            }
        }

fileList = (string[])e.Data.GetData(DataFormats.FileDrop);

private void textBox_DragDrop(object sender, DragEventArgs e)
        {
            Encoding fileEncoding = GetEncoding(fileList[0]);
            using (StreamReader file = new StreamReader(fileList[0], fileEncoding))
            {
                textBox.Text = file.ReadToEnd();
            }
        }

/// ----------------------------------------------------------------------------------------------------
/// <remarks>
/// Title : Get Encoding of textfile.
/// Author: Elektro
/// Date  : 17-January-2015
/// </remarks> 
/// ----------------------------------------------------------------------------------------------------
/// <example><code>
/// Dim encoding As Encoding = TextfileUtil.GetEncoding("C:\file.txt")
/// Dim encodingName As String = TextfileUtil.GetEncoding("C:\file.txt").WebName
/// </code></example>
/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Determines the <see cref="Encoding"/> of the source textfile.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <param name="sourceFilepath">
/// The source textfile path.
/// </param>
/// ----------------------------------------------------------------------------------------------------
/// <returns>
/// If the encoding can be detected, the return value is the detected <see cref="Encoding"/>,
/// if the encoding can't be detected, the return value is <see cref="Encoding.Default"/>.
/// </returns>
/// ----------------------------------------------------------------------------------------------------
[DebuggerStepThrough()]
[DebuggerHidden()]
public static Encoding GetEncoding(string sourceFilepath)
{
 
	Encoding encoding = null;
	byte[] bytes = File.ReadAllBytes(sourceFilepath);
 
	foreach (EncodingInfo encodingInfo in encoding.GetEncodings()) {
		Encoding currentEncoding = encodingInfo.GetEncoding();
		byte[] preamble = currentEncoding.GetPreamble();
		bool match = true;
 
		if ((preamble.Length > 0) && (preamble.Length <= bytes.Length)) {
 
			for (int i = 0; i <= (preamble.Length - 1); i++) {
				if (preamble(i) != bytes(i)) {
					match = false;
					break; // TODO: might not be correct. Was : Exit For
				}
 
			}
 
		} else {
			match = false;
 
		}
 
		if (match) {
			encoding = currentEncoding;
			break; // TODO: might not be correct. Was : Exit For
		}
 
	}
 
	if (encoding == null) {
		return encoding.Default;
 
	} else {
		return encoding;
 
	}
 
}
 
//=======================================================
//Service provided by Telerik (www.telerik.com)
//=======================================================

 
    /*************************************************************************************
     * This class implements a bit board                                                 *
     *                                                                                   *
     * Foreach bit we have one cell. If we turn on a bit means occupied cell. By the     *
     * opposite, if we turn off the bit, means empty cell                                *
     * The main gain of a bitBoard is to decrease the amount of memory used.             *
     * this fact is so important in algorithms like Minimax                              *
     * foreach byte we can cover 8 positions                                             *
     * For instance: If we have and 8x8 board, we can save 64 cells in a 8x1 board       *
     * (8 bytes) because 1 byteCell can save 8 cells                                     *
     *************************************************************************************/
 
 
   public class Board
    {
 
        protected readonly byte[,] board;
        protected readonly int height;
        protected readonly int byteWidth;
        protected readonly int width;
 
        protected Board(int height, int width)
        {
            this.height = height;
            this.byteWidth =(int) Math.Ceiling(width * 0.125); // 0.125 * width = width /8  
            this.width = width; 
            board = new byte[height, byteWidth];
        }
 
 
        private byte IncreaseBitPosn(int n)
        {
 
            return (byte)(0x1 << n);
        }
        private byte ReverseByte (byte b)
        {
            return  (byte) (b ^ 0xFF);
        }
 
        private int ToByteColumn(int y)
        {
            return (int) 0.125 * y;
        }
 
        private int ToBitColumn(int y)
        {
            return (y >= 8) ? y - (ToByteColumn(y) * 8) : y;
        }
 
        /* 
        *  Checks if [x,y] is empty with an and bitwise
        *  For instance: 
        *  x = 3
        *  y = 7  -> Matchs to byteCol 0, bitCol 7 
        *  board (3,0)        = 1 0 0 1 0 1 0 0 
        *  IncreaseBitPosn(7) = 1 0 0 0 0 0 0 0
        *  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               
        */
        protected bool PosIsEmpty(int x, int y)
        {
            return (board[x, ToByteColumn(y)] & IncreaseBitPosn(ToBitColumn(y))) == 0;
	    }
        /* 
        *  Increases bit at position (x,y)
        *  For instance: 
        *  x = 3
        *  y = 7  -> Matchs to byteCol 0, bitCol 7 
        *  board (3,0)        = 1 0 0 1 0 1 0 0 
        *  IncreaseBitPosn(7) = 1 0 0 0 0 0 0 0
        *  0 0 0 1 0 1 0 0  |  1 0 0 0 0 0 0 0 = 1 0 0 1 0 1 0 0  
        */ 
        protected void turnOnBit(int x, int y)
        {
            board[x, ToByteColumn(y)] |= IncreaseBitPosn(ToBitColumn(y));
        }
        /* 
         *  Decreases bit at position (x,y)
         *  For instance: 
         *  x = 3
         *  y = 7  -> Matchs to byteCol 0, bitCol 7 
         *  board (3,0)        = 1 0 0 1 0 1 0 0 
         *  ReverseByte(IncreaseBitPosn(7)) = 0 1 1 1 1 1 1 1
         *  1 0 0 1 0 1 0 0  &  0 1 1 1 1 1 1 1 = 0 0 0 1 0 1 0 0  
         */
 
        protected void turnOffBit(int x, int y)
        {
            board[x, ToByteColumn(y)] &=  ReverseByte(IncreaseBitPosn(ToBitColumn(y)));
        }
 
    }