FAQ для студентов или школьников

        public static int[] Reverse(int[] array)
        {
            var outArray = new int[array.Length];
            int j = 0;
            for (int i = array.Length - 1; i >= 0; i--)
            {
                outArray[j] = array[i];
                j++;
            }
            return outArray;
        }

        public static int[] Distinct(int[] array)
        {
            var intermediateArray = new int[array.Length];
            int uniqueCount = 0;
            for (int index = 0; index < array.Length; index++)
            {
                bool unique = true;
                for (int intermediateIndex = 0; intermediateIndex < uniqueCount; intermediateIndex++)
                {
                    if (intermediateArray[intermediateIndex] == array[index])
                    {
                        unique = false;
                        break;
                    }
                }
                if (unique)
                {
                    uniqueCount++;
                    intermediateArray[uniqueCount - 1] = array[index];
                }
            }
            var outArray = new int[uniqueCount];
            Array.Copy(intermediateArray, 0, outArray, 0, uniqueCount);
            return outArray;
        }

        public static int[] Except(int[] first, int[] second)
        {
            var intermediateArray = new int[first.Length];
            int resultCount = 0;
            for (int index = 0; index < first.Length; index++)
            {
                bool unique = true;
                for (int secondIndex = 0; secondIndex < second.Length; secondIndex++)
                {
                    if (first[index] == second[secondIndex])
                    {
                        unique = false;
                        break;
                    }
                }
                if (unique)
                {
                    resultCount++;
                    intermediateArray[resultCount - 1] = first[index];
                }
            }
            var outArray = new int[resultCount];
            Array.Copy(intermediateArray, 0, outArray, 0, resultCount);
            return outArray;
        }

        public static int[] Intersect(int[] first, int[] second)
        {
            var intermediateArray = new int[Math.Min(first.Length, second.Length)];
            int resultCount = 0;
            for (int index = 0; index < first.Length; index++)
            {
                bool found = false;
                for (int secondIndex = 0; secondIndex < second.Length; secondIndex++)
                {
                    if (first[index] == second[secondIndex])
                    {
                        found = true;
                        break;
                    }
                }
                if (found)
                {
                    bool unique = true;
                    for (int resultIndex = 0; resultIndex < resultCount; resultIndex++)
                    {
                        if (first[index] == intermediateArray[resultIndex])
                        {
                            unique = false;
                            break;
                        }
                    }
                    if (unique)
                    {
                        resultCount++;
                        intermediateArray[resultCount - 1] = first[index];
                    }
                }
            }
            var outArray = new int[resultCount];
            Array.Copy(intermediateArray, 0, outArray, 0, resultCount);
            return outArray;
        }

        public static int[] Flatten(int[,] matrix)
        {
            int[] outArray = new int[matrix.Length];
            int count = 0;
            for (int i = 0; i < matrix.GetLength(0); i++)
            {
                for (int j = 0; j < matrix.GetLength(1); j++)
                {
                    outArray[count] = matrix[i, j];
                    count++;
                }
            }
            return outArray;
        }

        public static int[] Union(int[] first, int[] second)
        {
            var intermediateArray = new int[first.Length + second.Length];
            for (int index = 0; index < first.Length; index++)
                intermediateArray[index] = first[index];
            for (int secondIndex = 0; secondIndex < second.Length; secondIndex++)
                intermediateArray[secondIndex + first.Length] = second[secondIndex];
            return Distinct(intermediateArray);
        }

        private static void Main()
        {
            var arr = new[] {0, 1, 1, 2, 4, 1, 0, 6, 5, 6};
            var arr2 = new[] {1, 0, 9, 8};
 
            Console.WriteLine("Reverse");
 
            foreach (int i in Reverse(arr))
                Console.WriteLine(i);
 
            Console.WriteLine("Distinct");
 
            foreach (int i in Distinct(arr))
                Console.WriteLine(i);
 
            Console.WriteLine("Except");
 
            foreach (int i in Except(arr, arr2))
                Console.WriteLine(i);
 
            Console.WriteLine("Intersect");
 
            foreach (int i in Intersect(arr, arr2))
                Console.WriteLine(i);
 
            Console.WriteLine("Flatten");
 
            foreach (int i in Flatten(new[,] {{1, 2, 3}, {4, 5, 6}}))
                Console.WriteLine(i);
 
            Console.WriteLine("Union");
 
            foreach (int i in Union(arr, arr2))
                Console.WriteLine(i);
 
            Console.ReadKey();
        }

            int[] range =new int[10];
            for (int i = 0; i < 10; i++)
            {
                range[i] = i;
            }

        public static int[] RandomShuffle(int[] list)
        {
            Random random = new Random();
            int[] shuffle = new int[list.Length];
            list.CopyTo(shuffle, 0);
            for (int i = 2; i < list.Length; ++i)
            {
                int temp = shuffle[i];
                int nextRandom = random.Next(i - 1);
                shuffle[i] = shuffle[nextRandom];
                shuffle[nextRandom] = temp;
            }
            return shuffle;
        }

        private static void Main()
        {
            int[] range =new int[10];
            for (int i = 0; i < 10; i++)
            {
                range[i] = i;
            }
            int[] shuffle = RandomShuffle(range);
            for (int i = 0; i < shuffle.Length; i++)
            {
                Console.WriteLine(shuffle[i]);
            } 
            Console.ReadKey();
        }

        public static IList<T> RandomShuffle<T>(this*IEnumerable<T> list)
        {
            var random = new Random();
            var shuffle = new List<T>(list);
            for (var i = 2; i < shuffle.Count; ++i)
            {
                var temp = shuffle[i];
                var nextRandom = random.Next(i - 1);
                shuffle[i] = shuffle[nextRandom];
                shuffle[nextRandom] = temp;
            }
            return shuffle;
        }

        /// <summary>
        ///   Функция суммирования ряда с заданной точностью.
        /// </summary>
        /// <param name = "func">Функция вычисления слагаемого ряда</param>
        /// <returns>Сумма ряда</returns>
        private static double Sum( Func<int, double> func ) {
            // Погрешность
            const double epsilon = 1E-10;
            double total = 0;
            int n = 0;
            double member;
            do {
                member = func( n );
                n++;
                total += member;
            }
            while ( Math.Abs( member ) > epsilon );
            return total;
        }

            // Аргумент
            const double x = 0.89312d;
 
            // Функция для вычисления слагаемого ряда
            Func<int, double> atanRow = n => Math.Pow( -1, n ) * Math.Pow( x, 2 * n + 1 ) / (2 * n + 1);
 
            // Вычисляем значение суммы ряда
            double actual = Sum( atanRow );
 
            // Точное значение
            Console.WriteLine( Math.Atan( x ) );
 
            // Полученное значение
            Console.WriteLine( actual );

using System;
 
class MyCSharp
{
    // точка входа;
    static private void Main()
    {
        const int n = 5;
        const int BASE = 100;
        Random rand = new Random(); 
        double[,] matrix = new double[n, n];
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
                matrix[i, j] = rand.Next() % BASE; // заполняем матрицу случайными элементами;
        printMatrix(matrix, n); // распечатываем сгенерированную матрицу;
        double det = Determinant(matrix, 5); // вычисляем определитель матрицы;
        Console.WriteLine("Определитель равен = {0}", det); 
        Console.ReadKey();
    }
    // статический метод вычисления определителя матрицы;
    static private double Determinant(double[,] matrix, int n)
    {
        if (n == 1) // если матрица первого порядка, то ее определитель есть единственный элемент;
            return matrix[0, 0]; // возвращаем его;
        if (allOfFirstElenemtAreZero(matrix, n)) // если есть нулевой столбец, то определитель равен 0;
            return 0;
        int comparisons; // число перестановок строк;
        sortArrayByFirstElenemt(matrix, n, out comparisons); // сортируем матрицу по первым элементам строк;
        for (int i = 1; i < n; ++i) // итерация методом Гаусса;
        {
            double index = matrix[i, 0] / matrix[0, 0];
            for (int j = 0; j < n; ++j)
                matrix[i, j] -= index * matrix[0, j];
        } // где зануляется первый столбец с 1 по n - 1 строки;
        //printMatrix(matrix, n);  можно распечатывать промежуточную матрицу;
        return matrix[0, 0] * Math.Pow(-1, comparisons) * Determinant(generateSubMatrix(matrix, n), n - 1);
        // возвращаем определитель рекурсивно;
    }
    // статический метод для сваппинга 2х линейных массивов; 
    static private void swapArray(double[,] matrix, int index, int lengthOfMatrix)
    {
        for (int i = 0; i < lengthOfMatrix; ++i)
            swapDouble(ref matrix[index, i], ref matrix[index + 1, i]);
    }
    // статический метод для своппинга 2х элементов;
    static private void swapDouble(ref double Buffer1, ref double Buffer2)
    {
        double Tmp = Buffer1;
        Buffer1 = Buffer2;
        Buffer2 = Tmp;
    }
    // сортировка матрицы по первым элементам строк модифицированным методом пузырька;
    static private void sortArrayByFirstElenemt(double[,] matrix, int n, out int comparisons)
    {
        comparisons = new int();
        bool flagOfSwapping = true;
        int numberOfIteration = new int();
        while (flagOfSwapping) // цикл выполняется пока есть хотя бы одна перестановка в ходе итерации;
        {
            flagOfSwapping = false;
            for (int i = 0; i < n - 1 - numberOfIteration; ++i)
                if (matrix[i, 0] < matrix[i + 1, 0])
                {
                    swapArray(matrix, i, n);
                    flagOfSwapping = true;
                    ++comparisons;
                }
            numberOfIteration++;
        }
    }
    // статический метод вывода матрицы на экран;
    static private void printMatrix(double[,] matrix, int n)
    {
        Console.WriteLine();
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < n; ++j)
                Console.Write("{0:f2}\t", matrix[i, j]);
            Console.WriteLine();
        }
    }
    // статический метод выделения подматрицы размера n - 1;
    static private double[,] generateSubMatrix(double[,] matrix, int n)
    {
        double[,] subMatrix = new double[n - 1, n - 1];
        for (int i = 1; i < n; ++i) // выделяется подматрица со строк [1, n);
            for (int j = 1; j < n; ++j) // .. cтолбцов [1; n);
                subMatrix[i - 1, j - 1] = matrix[i, j];
        return subMatrix;
    }
    // статический метод проверки первого столбца на равенства нулевому;
    static private bool allOfFirstElenemtAreZero(double[,] matrix, int n)
    {
        for (int i = 0; i < n; ++i)
            if (matrix[i, 0] != 0)
                return false;
        return true;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace ConsoleApplicationTest {
    public static class Program {
        private static void Main() {
            var myClasses = new List<MyClass>();
 
            // Заполним случайными элементами
            AddRandomElements( myClasses );
 
            // Сортировака по именам с использованием делегата
            myClasses.Sort( ( a, b ) => a.Name.CompareTo( b.Name ) );
 
            Print( myClasses );
 
            // Сортировка по номеру с использованием класса компаратора
            myClasses.Sort( new MyNumberComparer() );
 
            Print( myClasses );
 
            // Сортировка с использованием Linq в начале по номеру, потом по имени
            IOrderedEnumerable<MyClass> result = myClasses.OrderBy( c => c.Number ).ThenBy( c => c.Name );
 
            Print( result );
 
            Console.ReadKey();
        }
 
        private static void AddRandomElements( List<MyClass> myClasses ) {
            var r = new Random();
 
            for ( int i = 0; i < 10; i++ ) {
                var randomString = new string( Enumerable.Range( 0, 5 )
                                           .Select( n => r.Next( 'a', 'z' ) )
                                           .Select( Convert.ToChar )
                                           .ToArray() );
                myClasses.Add( new MyClass( r.Next( 3 ), randomString ) );
            }
        }
 
        private static void Print( IEnumerable<MyClass> myClasses ) {
            foreach ( MyClass myClass in myClasses ) {
                Console.WriteLine( myClass );
            }
            Console.WriteLine();
        }
    }
 
    internal class MyNumberComparer : IComparer<MyClass> {
        #region IComparer<MyClass> Members
 
        public int Compare( MyClass x, MyClass y ) {
            return x.Number.CompareTo( y.Number );
        }
 
        #endregion
    }
 
    public class MyClass {
        public MyClass( int number, string name ) {
            Number = number;
            Name = name;
        }
 
        public int Number { get; set; }
        public string Name { get; set; }
 
        public override string ToString() {
            return string.Format( "Number: {0}\tName: {1}", Number, Name );
        }
    }
}

        //возвращает индекс элемента в массиве или -1 если не найден
        public static int BinarySeach( int[] sortedArray, int toFind )
        {
            int low = sortedArray.GetLowerBound(0);
            int high = low + sortedArray.Length - 1;
 
            if (toFind < sortedArray[low] || toFind > sortedArray[high])
                return -1;
 
            while (low <= high)
            {
                int mid = (high + low) / 2;
 
                if (sortedArray[mid] > toFind)
                    high = mid - 1;
                else if (sortedArray[mid] < toFind)
                    low = mid + 1;
                else
                    return mid;
            }
 
            return -1;
        }

        //возвращает индекс элемента в массиве или -1 если не найден
        public static int InterpolationSearch(int[] sortedArray, int toFind )
        {
            long low = 0;
            long high = (long)sortedArray.Length - 1;
 
            while (sortedArray[low] < toFind && sortedArray[high] >= toFind)
            {
                long mid = low + ((toFind - sortedArray[low]) * (high - low))
                           / (sortedArray[high] - sortedArray[low]) ;
 
                if (sortedArray[mid] < toFind)
                    low = mid + 1;
                else if (sortedArray[mid] > toFind)
                    high = mid - 1;
                else
                    return (int)mid;
            }
 
            if (sortedArray[low] == toFind)
                return (int)low;
 
            return -1; 
        }

//Наохидт наибольший общий делитель (НОД) чисел а и b
int nod(int a,int b)
        {
            //Алгоритм Евклида: если а = bq + r, то НОД(а,b) = НОД(b,r)
            int max, min;
            if (Math.Abs(a) > Math.Abs(b)) //Находим большее число по модулю
            {
                max = Math.Abs(a);
                min = Math.Abs(b);
            }
            else
            {
                max = Math.Abs(b);
                min = Math.Abs(a);
            }
            int r = max % min; //Находим остаток от деления большего числа на меньшее
            if (r == 0) //Eсли остаток равен нулю...
            {
                return min; //...то вернуть меньшее число...
            }
            else
            {
                return nod(min, r); //...иначе найти НОД меньшего числа и остатка
            }
        }

        //
        // Сводка:
        //     Преобразует значение заданного 32-битового целого числа со знаком в эквивалентное
        //     представление в виде значения типа System.String в системе счисления с заданным
        //     основанием.
        //
        // Параметры:
        //   value:
        //     32-битовое целое число со знаком.
        //
        //   toBase:
        //     Основание системы счисления возвращаемого значения, равное 2, 8, 10 или 16.
        //
        // Возвращает:
        //     Представление value в виде значения типа System.String в системе счисления
        //     с основанием toBase.
        //
        // Исключения:
        //   System.ArgumentException:
        //     Значение параметра toBase не равно 2, 8, 10 или 16.
        public static string ToString(int value, int toBase);

using System;
 
/// <summary>
/// Вещественная матрица
/// </summary>
class Matrix
{
    /// <summary>
    /// Количество строк
    /// </summary>
    uint n;
    /// <summary>
    /// Количество столбцов
    /// </summary>
    uint m;
    /// <summary>
    /// Матрица
    /// </summary>
    double[,] array;
    /// <summary>
    /// Конструктор
    /// </summary>
    /// <param name="n">Количество строк в матрице</param>
    /// <param name="m">Количество столбцов в матрице</param>
    public Matrix(uint n, uint m)
    {
        this.n = n;
        this.m = m;
        Random random = new Random();
        array = new double[n, m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                array[i, j] = random.NextDouble();
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица квадратной.
    /// </summary>
    public bool IsSquare
    {
        get
        {
            if (n == m)
                return true;
            return false;
        }
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица единичной.
    /// </summary>
    public bool IsIdentity
    {
        get
        {
            if (n != m)
                return false;
            for (int i = 0; i < n; i++)
                if (array[i, i] != 1.0)
                    return false;
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (i != j)
                    {
                        if (array[i, j] != 0.0)
                            return false;
                    }
                    else
                        continue;
            return true;
        }
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица нулевой.
    /// </summary>
    public bool IsZero
    {
        get
        {
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (array[i, j] != 0.0)
                        return false;
            return true;
        }
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица диагональной.
    /// </summary>
    public bool IsDiagonalic
    {
        get
        {
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (i != j)
                    {
                        if (array[i, j] != 0.0)
                            return false;
                    }
                    else
                        continue;
            return true;
        }
    }
    /// <summary>
    /// Свойство, показывающее является ли матрица симметричной.
    /// </summary>
    public bool IsSimmetric
    {
        get
        {
            if (n != m)
                return false;
            if (this.IsDiagonalic || this.IsIdentity || this.IsZero)
                return true;
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (i - j < 0)
                        if (array[i, j] != array[j, i])
                            return false;
            return true;
        }
    }
    public double this[int i, int j]
    {
        get
        {
            return array[i, j];
        }
        set
        {
            array[i, j] = value;
        }
    }
    /// <summary>
    /// Метод, создающий нулевую матрицу.
    /// </summary>
    public void MakeZero()
    {
        if (!this.IsSquare)
            throw new Exception("Матрица должна быть квадратной.");
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                array[i, j] = 0.0;
    }
    /// <summary>
    /// Метод, создающий единичную матрицу.
    /// </summary>
    public void MakeIdentity()
    {
        if (!this.IsSquare)
            throw new Exception("Матрица должна быть квадратной.");
        MakeZero();
        for (int i = 0; i < n; i++)
            array[i, i] = 1.0;
    }
    /// <summary>
    /// Вывод матрицы на экран
    /// </summary>
    /// <param name="spliter">Разделитель между элементами массива</param>
    /// <param name="d">Количество символов после запятой.</param>
    public void ShowMatrix(string spliter, uint d)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
                Console.Write(array[i, j].ToString("F" + d.ToString()) + spliter);
            Console.WriteLine();
        }
    }
    /// <summary>
    /// Вывод матрицы на экран.
    /// </summary>
    public void ShowMatrix()
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
                Console.Write(array[i, j].ToString("F2") + " ");
            Console.WriteLine();
        }
    }
    /// <summary>
    /// Метод создающий диагональную матрицу.
    /// </summary>
    public void MakeDiagonalic()
    {
        if (!this.IsSquare)
            throw new Exception("Матрица должна быть квадратной.");
        MakeZero();
        Random random = new Random();
        for (int i = 0; i < n; i++)
            array[i, i] = random.NextDouble();
    }
    /// <summary>
    /// Метод создающий симметричную матрицу.
    /// </summary>
    public void MakeSimmetric()
    {
        if (!this.IsSquare)
            throw new Exception("Матрица должна быть квадратной.");
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (i - j < 0)
                    array[i, j] = array[j, i];
    }
    /// <summary>
    /// Метод, перезаполняющий исходную матрицу.
    /// </summary>
    public void MakeRandom()
    {
        Random random = new Random();
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                array[i, j] = random.NextDouble();
    }
    /// <summary>
    /// Возвращает колечество строк матрицы
    /// </summary>
    public uint RowCount
    {
        get
        {
            return n;
        }
    }
    /// <summary>
    /// Возвращает количество столбцов матрицы
    /// </summary>
    public uint ColumnCount
    {
        get
        {
            return m;
        }
    }
    public static bool operator !=(Matrix m1, Matrix m2)
    {
        if (m1.RowCount != m2.RowCount)
            return true;
        if (m1.ColumnCount != m2.ColumnCount)
            return true;
        for (int i = 0; i < m1.RowCount; i++)
            for (int j = 0; j < m2.ColumnCount; j++)
                if (m1[i, j] != m2[i, j])
                    return true;
        return false;
    }
    public static bool operator ==(Matrix m1, Matrix m2)
    {
        if (m1.RowCount != m2.RowCount)
            return false;
        if (m1.ColumnCount != m2.ColumnCount)
            return false;
        for (int i = 0; i < m1.RowCount; i++)
            for (int j = 0; j < m2.ColumnCount; j++)
                if (m1[i, j] != m2[i, j])
                    return false;
        return true;
    }
    /// <summary>
    /// Изменение размеров матрицы.
    /// </summary>
    /// <param name="n">Количество строк.</param>
    /// <param name="m">Количество столбцов.</param>
    public void Resize(uint n, uint m)
    {
        this.n = n;
        this.m = m;
        array = new double[n, m];
        MakeRandom();
    }
    /// <summary>
    /// Получение двумерного массива
    /// </summary>
    /// <returns></returns>
    public double[,] ToArray()
    {
        double[,] buf = new double[n, m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                buf[i, j] = array[i, j];
        return buf;
    }
    /// <summary>
    /// Получение одномерного массива.
    /// </summary>
    /// <returns></returns>
    public double[] ToArrayOne()
    {
        double[] buf = new double[n * m];
        int index = 0;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
            {
                buf[index] = array[i, j];
                index++;
            }
        return buf;
    }
    /// <summary>
    /// Максимальный элемент в матрице
    /// </summary>
    public double Maximum
    {
        get
        {
            double max = array[0, 0];
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (array[i, j] > max)
                        max = array[i, j];
            return max;
        }
    }
    /// <summary>
    /// Возвращает минимальный элемент в матрице.
    /// </summary>
    public double Minimum
    {
        get
        {
            double min = array[0, 0];
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (array[i, j] < min)
                        min = array[i, j];
            return min;
        }
    }
    /// <summary>
    /// Сумма элементов массива.
    /// </summary>
    public double Sum
    {
        get
        {
            double sum = 0;
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++, sum += array[i, j]) ;
            return sum;
        }
    }
}
 
class program
{
    public static void Main()
    {
        Matrix matrix = new Matrix(5, 5);
        matrix.ShowMatrix(" ", 2);
        matrix.MakeZero();
        Console.WriteLine(matrix.IsZero);
        matrix.MakeIdentity();
        matrix.ShowMatrix(" ", 2);
        Console.WriteLine(matrix.IsIdentity);
        matrix.MakeDiagonalic();
        matrix.ShowMatrix(" ", 2);
        Console.WriteLine(matrix.IsDiagonalic);
        matrix.MakeRandom();
        matrix.MakeSimmetric();
        Console.WriteLine(matrix.IsSimmetric);
        matrix.ShowMatrix();
        Matrix m2 = new Matrix(5, 5);
        if (matrix == m2)
            Console.WriteLine("Матрицы равны");
        else
            Console.WriteLine("Матрицы не равны");
        m2 = matrix;
        if (matrix == m2)
            Console.WriteLine("Матрицы равны");
        else
            Console.WriteLine("Матрицы не равны");
        Console.WriteLine(matrix.ColumnCount);
        Console.WriteLine(matrix.RowCount);
        matrix.Resize(6, 4);
        Console.WriteLine(matrix.IsSquare);
        matrix.ToArray();
        matrix.ToArrayOne();
        Console.WriteLine(matrix.Maximum);
        Console.WriteLine(matrix.Minimum);
        Console.ReadKey(true);
    }
}

using System;
 
/// <summary>
/// Список. 
/// Автор: Петррр
/// </summary>
class GList
{
    int[] array;
    /// <summary>
    /// Констуктор
    /// </summary>
    public GList()
    {
        array = new int[0];
    }
    /// <summary>
    /// Количество элементов в списке
    /// </summary>
    public int Count
    {
        get
        {
            return array.Length;
        }
    }
    /// <summary>
    /// Добавление нового элемента в список
    /// </summary>
    /// <param name="value">Элемент который необходимо вставить</param>
    public void Add(int value)
    {
        int[] buf = new int[array.Length];
        for (int i = 0; i < buf.Length; i++)
            buf[i] = array[i];
        array = new int[buf.Length + 1];
        for (int i = 0; i < buf.Length; i++)
            array[i] = buf[i];
        array[array.Length - 1] = value;
    }
    /// <summary>
    /// Вставляет новый элемент в укзананную позицию.
    /// </summary>
    /// <param name="value">Новый элемент</param>
    /// <param name="pos">Позиция</param>
    public void Insert(int value, int pos)
    {
        if (pos > array.Length || pos < 0)
            throw new Exception("Неверная позиция");
        int[] buf = new int[array.Length];
        for (int i = 0; i < buf.Length; i++)
            buf[i] = array[i];
        array = new int[buf.Length + 1];
 
        for (int i = 0; i < buf.Length; i++)
            array[i] = buf[i];
 
        int buffer = array[pos];
        for (int i = array.Length - 2; i >= pos; i--)
        {
            int d = array[i];
            array[i + 1] = d;
        }
        array[pos] = value;
    }
    /// <summary>
    /// Вывод списка.
    /// </summary>
    public void Show()
    {
        for (int i = 0; i < array.Length; i++)
            Console.Write(array[i] + " ");
    }
    /// <summary>
    /// Удаление элемента по указанной позиции
    /// </summary>
    /// <param name="pos">Позиция. Нумерация начинается с нуля.</param>
    public void Remove(int pos)
    {
        if (pos > array.Length || pos < 0)
            throw new Exception("Неверная позиция");
 
        int[] buf = new int[array.Length];
 
        for (int i = 0; i < buf.Length; i++)
            buf[i] = array[i];
 
        array = new int[buf.Length - 1];
 
        for (int i = 0; i < pos; i++)
            array[i] = buf[i];
 
        for (int i = pos; i < buf.Length - 1; i++)
            array[i] = buf[i + 1];
    }
    /// <summary>
    /// Удаляет заданный элемент из списка.
    /// </summary>
    /// <param name="element">Элемент списка.</param>
    public void RemoveElement(int element)
    {
        for (int i = 0; i < array.Length; i++)
            if (array[i] == element)
                Remove(i);
    }
    /// <summary>
    /// Получения массива элементов.
    /// </summary>
    /// <returns></returns>
    public int[] ToArray()
    {
        return array;
    }
    /// <summary>
    /// Максимальный элемент в списке.
    /// </summary>
    public int Maximum
    {
        get
        {
            int max = array[0];
            for (int i = 0; i < array.Length; i++)
                if (array[i] > max)
                    max = array[i];
            return max;
        }
    }
    /// <summary>
    /// Максимальный элемент в списке.
    /// </summary>
    public int Minimum
    {
        get
        {
            int min = array[0];
            for (int i = 0; i < array.Length; i++)
                if (array[i] < min)
                    min = array[i];
            return min;
        }
    }
    /// <summary>
    /// Сумма элементов списка.
    /// </summary>
    public int Sum
    {
        get
        {
            int sum = 0;
            for (int i = 0; i < array.Length; i++) 
                sum += array[i];
            return sum;
        }
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        GList l = new GList();
        l.Add(1);
        l.Add(2);
        l.Add(3);
        l.Insert(4, 1);
        l.Show();
        l.Remove(1);
        l.RemoveElement(1);
        Console.WriteLine();
        l.Show();
        Console.WriteLine();
        Console.WriteLine(l.Sum);
        Console.ReadKey(true);
    }
}

using System;
 
class Program
{
    static void Main(string[] args)
    {
        Random random = new Random();
        int[] a = new int[10];
        for (int i = 0; i < a.Length; i++)
        {
            a[i] = random.Next(0, 100);
            Console.Write(a[i] + " ");
        }
        bool flag = true;
        Console.WriteLine();
        while (flag)
        {
            flag = false;
            for(int i = 0; i < a.Length - 1; i++)
                if (a[i] > a[i + 1])
                {
                    int b = a[i];
                    a[i] = a[i + 1];
                    a[i + 1] = b;
                    flag = true;
                }
        }
        for (int i = 0; i < a.Length; i++)
            Console.Write(a[i] + " ");
        Console.ReadKey(true);
    }
}

using System;
 
class Program
{
    static void Main(string[] args)
    {
        Random random = new Random();
        int[] a = new int[10];
        int i = 1;
        for (i = 0; i < a.Length; i++)
        {
            a[i] = random.Next(0, 100);
            Console.Write(a[i] + " ");
        }
        Console.WriteLine();
        i = 1;
        int j = 2;
        while (i < a.Length)
        {
            if (a[i - 1] <= a[i])
            {
                i = j;
                j++;
            }
            else
            {
                int b = a[i - 1];
                a[i - 1] = a[i];
                a[i] = b;
                i--;
                if (i == 0)
                {
                    i = j;
                    j++;
                }
            }
        }
        for (i = 0; i < a.Length; i++)
            Console.Write(a[i] + " ");
        Console.ReadKey(true);
    }
}

using System;
 
class Program
{
    static void Main(string[] args)
    {
        Random random = new Random();
        int[] a = new int[10];
        int i;
        for (i = 0; i < a.Length; i++)
        {
            a[i] = random.Next(0, 100);
            Console.Write(a[i] + " ");
        }
        Console.WriteLine();
 
        int j, tmp;
        for (i = 1; i < a.Length; i++)
        {
            j = i;
            while (j > 0 && a[j - 1] > a[j])
            {
                tmp = a[j];
                a[j] = a[j - 1];
                a[j - 1] = tmp;
                j--;
            }
        }
 
        for (i = 0; i < a.Length; i++)
            Console.Write(a[i] + " ");
        Console.ReadKey(true);
    }
}

using System;
 
class Program
{
    static void Main(string[] args)
    {
        Random random = new Random();
        int[] a = new int[10];
        int i;
        for (i = 0; i < a.Length; i++)
        {
            a[i] = random.Next(0, 100);
            Console.Write(a[i] + " ");
        }
        Console.WriteLine();
        int j;
        int[] b = new int[a.Length];
        for (i = 0; i < a.Length; i++)
        {
            int c = 0;
            for (j = 0; j < i; j++)
                if (a[j] <= a[i])
                    c++;
            for (j = i + 1; j < a.Length; j++)
                if (a[j] < a[i])
                    c++;
            b[c] = a[i];
        }
        for (i = 0; i < a.Length; i++)
             Console.Write(b[i] + " ");
        Console.ReadKey(true);
    }
}

using System;
 
class Program
{
    static void Main(string[] args)
    {
        Random random = new Random();
        int[] a = new int[10];
        int i;
        for (i = 0; i < a.Length; i++)
        {
            a[i] = random.Next(0, 100);
            Console.Write(a[i] + " ");
        }
        Console.WriteLine();
 
        for (i = 0; i < a.Length - 1; i++)
            for (int j = i + 1; j < a.Length; j++ )
                if (a[i] > a[j])
                {
                    int b = a[i];
                    a[i] = a[j];
                    a[j] = b;
                }
        for (i = 0; i < a.Length; i++)
            Console.Write(a[i] + " ");
        Console.ReadKey(true);
    }
}

using System;
 
class Program
{
    static void Main(string[] args)
    {
        Random random = new Random();
        int[] a = new int[10];
        int i;
        for (i = 0; i < a.Length; i++)
        {
            a[i] = random.Next(0, 100);
            Console.Write(a[i] + " ");
        }
        Console.WriteLine();
 
        int jump = a.Length;
        bool swapped = true;
        while (jump > 1 || swapped)
        {
            if (jump > 1)
                jump = (int)(jump / 1.25);
            swapped = false;
            for(i = 0; i + jump < a.Length; i++)
                if (a[i] > a[i + jump])
                {
                    int b = a[i];
                    a[i] = a[i + jump];
                    a[i + jump] = b;
                }
        }
 
        for (i = 0; i < a.Length; i++)
            Console.Write(a[i] + " ");
        Console.ReadKey(true);
    }
}

int sum = 0;
for (int i = 0; i < arr.Length; i++)
{
    if (i % 2 != 1) // 1 - нечетные элементы, 0 - четные элементы
    {
    sum += arr[i]; // Возможно также заменить сумму на умножение, деление или вычитание :)
    }
}

string applicationRoot = AppDomain.CurrentDomain.BaseDirectory;