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];
                    }
                }
            }
        }

/// ----------------------------------------------------------------------------------------------------
/// <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)
//=======================================================

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace MissingNumbersOnSequence
{
    public class Program
    {
        public static void Main(string[] args)
        {
            List<ulong> longs = (new ulong[] { 1, 2, 3, 6, 7, 8, 12, 13, 14, 17 }).ToList();
 
            //Los dos metodos explicados
            ulong numb = 0;
            bool b = FindFirstMissingNumberFromSequence(longs, out numb); //Se devuelve una bool para saber si realmente había algún número que faltaba, puesto que por defecto se devolverá el 0, y el 0 puede formar parte de una secuencia a la cual no pertenece.
 
            Console.WriteLine("First missing number: {0}\nMissing numbers: {1}", numb, string.Join(", ", FindMissingNumbersFromSequence(longs).Select(x => x.ToString()))); //Para comprobar si la secuencia estaba incompleta solo habría que comprobar x.Count() > 0...
            Console.Read();
        }
 
        public static bool FindFirstMissingNumberFromSequence<T>(IEnumerable<T> arr, out T n)
        {
            if (!arr.Any(x => x.IsNumericType()))
            {
                Console.WriteLine("Type '{0}' can't be used as a numeric type!", typeof(T).Name);
                n = default(T);
                return false;
            }
 
            IOrderedEnumerable<T> list = arr.OrderBy(x => x);
            bool b = false;
            n = default(T);
 
            foreach (T num in list)
            {
                b = (dynamic)num - n > 1;
                if (b) break;
                else n = (dynamic)num;
            }
 
            n = (dynamic)n + 1;
 
            return b;
        }
 
        public static IEnumerable<T> FindMissingNumbersFromSequence<T>(IEnumerable<T> arr) where T : struct
        {
            if (!arr.Any(x => x.IsNumericType()))
            {
                Console.WriteLine("Type '{0}' can't be used as a numeric type!", typeof(T).Name);
                yield break;
            }
 
            IOrderedEnumerable<T> list = arr.OrderBy(x => x);
            T n = default(T);
 
            foreach (T num in list)
            {
                T op = (dynamic)num - n;
                if ((dynamic)op > 1)
                {
                    int max = op.ConvertValue<int>();
                    for (int l = 1; l < max; ++l)
                        yield return (dynamic)n + l.ConvertValue<T>();
                }
                n = (dynamic)num;
            }
        }
 
    }
 
    public static class Extensions
    {
        public static T ConvertValue<T>(this object o) where T : struct
        {
            return (T)Convert.ChangeType(o, typeof(T));
        }
 
        public static bool IsNumericType<T>(this T o)
        {
            return typeof(T).IsNumericType();
        }
 
        public static bool IsNumericType(this Type type)
        {
            switch (Type.GetTypeCode(type))
            {
                case TypeCode.Byte:
                case TypeCode.SByte:
                case TypeCode.UInt16:
                case TypeCode.UInt32:
                case TypeCode.UInt64:
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.Decimal:
                case TypeCode.Double:
                case TypeCode.Single:
                    return true;
                default:
                    return false;
            }
        }
    }
}
 

using System.Threading;
 
namespace GTAMapper.Extensions.Threading
{
    /// <summary>
    /// Thread safe enter once into a code block:
    /// the first call to CheckAndSetFirstCall returns always true,
    /// all subsequent call return false.
    /// </summary>
    public class ThreadSafeBool
    {
        private static int NOTCALLED = 0,
                           CALLED = 1;
 
        private int _state = NOTCALLED;
 
        /// <summary>Explicit call to check and set if this is the first call</summary>
        public bool Value
        {
            get
            {
                return Interlocked.Exchange(ref _state, CALLED) == NOTCALLED;
            }
        }
 
        /// <summary>usually init by false</summary>
        public static implicit operator ThreadSafeBool(bool called)
        {
            return new ThreadSafeBool() { _state = called ? CALLED : NOTCALLED };
        }
 
        public static implicit operator bool(ThreadSafeBool cast)
        {
            if (cast == null)
                return false;
 
            return cast.Value;
        }
    }
}

using GTAMapper.Extensions.Threading;
using System;
using System.Collections;
using UnityEngine;
 
namespace GTAMapper.Extensions
{
    public static class BatchedCoroutines
    {
        public static IEnumerator BatchCoroutines(
            MonoBehaviour monoBehaviour,
            Action finish,
            Func<int, bool>[] waitUntil = null,
            params Tuple<Action<object>, ConcurrentQueuedCoroutines<object>>[] tuple) // Tuple<Action<T>, ConcurrentQueuedCoroutines<T>> || dynamic
                                                                                      // Fix for: https://stackoverflow.com/questions/15417174/using-the-params-keyword-for-generic-parameters-in-c-sharp
        {
            int i = 0;
 
            foreach (var val in tuple)
            {
                if (waitUntil != null && waitUntil[i] != null)
                    yield return new WaitUntil(() => waitUntil[i](i));
 
                yield return val.Item2.GetCoroutine(monoBehaviour, val.Item1);
 
                ++i;
            }
 
            finish?.Invoke();
        }
    }
}

        protected ConcurrentQueuedCoroutines<object> debuggingCoroutine = new ConcurrentQueuedCoroutines<object>(),
                                                     colorCoroutine = new ConcurrentQueuedCoroutines<object>();
 
namespace GTAMapper.Core {
    public class Program : MonoBehaviour {
        public void Start() {
        StartCoroutine(BatchedCoroutines.BatchCoroutines(
                this,
                () => areCoroutinesCollected = true,
                F.GetFuncs(null, (_ii) => debuggingCoroutine.Queue.Count > 0),
                new Tuple<Action<object>, ConcurrentQueuedCoroutines<object>>((obj) =>
                {
                    Tuple<int, Color> tuple = (Tuple<int, Color>)obj;
 
                    int i = tuple.Item1,
                            _x = i % width,
                            _y = i / width;
 
                    UnityEngine.Color actualColor = debugTexture.GetPixel(_x, _y),
                                          mixedColor = UnityEngine.Color.Lerp(actualColor, tuple.Item2, .5f);
 
                    if (actualColor != mixedColor)
                    {
                        debugTexture.SetPixel(_x, _y, mixedColor);
                        debugTexture.Apply();
                    }
                }, colorCoroutine),
                new Tuple<Action<object>, ConcurrentQueuedCoroutines<object>>((obj) =>
                {
                    Color[] colors = (Color[])obj;
 
                    debugTexture.SetPixels32(colors.CastBack().ToArray());
                    debugTexture.Apply();
                }, debuggingCoroutine)));
          }
     }
}

using System;
 
public static class F {
        public static Func<int, bool>[] GetFuncs(params Func<int, bool>[] waitUntil)
        {
            return waitUntil;
        }
}