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

@zalogic · Регистрация: 12.12.2010

Студворк — интернет-сервис помощи студентам

Товарищи! Если у Вас есть желание что-то добавить в данный FAQ, то просьба соблюдать некоторые правила перед публикацией своего примера:
Не выкладывайте примеры кода, которые уже присутствует в данном FAQ (только если метод решения схож с уже предложенным).
Не поленитесь просмотреть уже предложенные примеры.

Обязательно добавляйте к коду комментарии, это всё-таки FAQ для студентов или школьников.
Придерживайтесь приведенного ниже стиля оформления:
Описание задачи:
C#
1
//Решение
Если размер Вашего сообщения очень большой используйте тег форматирования [SPOILER] для его сжатия:
Code
1
[SPOILER="Заголовок"]Текст который будет скрыт.[/SPOILER]
Пример:
Описание задачи (краткое)
Описание задачи (полное):
C#
1
//Решение
Исходный код этого фрагмента:
Code
1
[SPOILER="Описание задачи"][CSHARP]//Решение[/CSHARP][/SPOILER]
Сообщения не отвечающие вышеуказанным требованиям будут удаляться.

Часто на форуме возникают сообщения от студентов или школьников которые не могут решить задачи на массивы, текст и т.д. В этом FAQ кратко опишу основные куски когда которые можно использовать.
Создание консольного приложения
Открываем Visual Studio. Файл -> Создать проект -> Консольное приложение.
Слева написан язык программирования, выберите С#.
Оъявление одномерного и двумерного массива
-одномерный

C#
1
2
int N = 10;
int[] a = new int[N];

-двумерный

C#
1
2
int N = 10, M = 10;
int[,] a = new int[N, M];

Вывод матрицы на экран

C#
1 2 3 4 5 6 7 8 9 10
Console.WriteLine("исходная матрица:"); for (int i = 0; i < N; i++) { for (int j = 0; j < M; j++) Console.Write(a[i, j] + " "); Console.WriteLine(); }

Вывод массива на экран

C#
1 2 3
Console.WriteLine("исходный массив:"); for (int i = 0; i < N; i++) Console.Write(a[i] + " ");

Заполним матрицу случайными числами

C#
1 2 3 4 5 6 7 8 9 10
Random random = new Random(); int rand; for (int i = 0; i < N; i++) { for (int j = 0; j < M; j++) { rand = random.Next(0, 100); a[i, j]=rand; } }

Заполним массив случайными величинами

C#
1 2 3 4 5 6 7
Random random = new Random(); int rand; for (int i = 0; i < N; i++) { rand = random.Next(0, 100); a[i]=rand; }

Сортировка пузырьком(bubble sort)

C#
1 2 3 4 5 6 7 8 9 10 11
int buf; for (int i = 0; i < N - 1; i++) { for (int j = i + 1; j < N; j++) { if (A[i] > A[j]) { buf = A[i]; A[i] = A[j]; A[j] = buf; }
В условии меняйте знак if (A[i] > A[j]) на if (A[i] < A[j]) если нужна сортировка по убыванию.

Определение максимального числа в массиве

C#
1 2 3 4 5 6
int max= int.MinValue; for (int i = 0; i < N; i++) { if (a[i] > max) max = a[i]; }

Определение минимального числа в массиве

C#
1 2 3 4 5 6
int min= int.MaxValue; for (int i = 0; i < N; i++) { if (a[i] < min) min = a[i]; }

Определение суммы чисел в массиве

C#
1 2 3
int sum=0; for (int i = 0; i < N; i++) sum+=a[i];

Чуть позже выложу больше шарпокусков(других алгоритмов и тд)

Список алгоритмов в теме

@Unril · 15.12.2010, 21:21

Вот, решил тоже добавить несколько методов для работы с массивами.

Изменяет порядок элементов последовательности на противоположный

C#
1
2
3
4
5
6
7
8
9
10
11
        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;
        }

Возвращает различающиеся элементы последовательности

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
        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;
        }

Возвращает только те элементы последовательности first, которых нет в последовательности second

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
        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;
        }

Находит пересечение множеств, представленных двумя последовательностями

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
        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;
        }

Проецирует матрицу в одномерный массив

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
        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;
        }

Находит объединение множеств, представленных двумя последовательностями

C#
1
2
3
4
5
6
7
8
9
        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);
        }

Примеры использования

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
        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();
        }

Заполнение массива случайными не повторяющимися числами.

Сначала создаём массив с упорядоченными числами:

C#
1
2
3
4
5
            int[] range =new int[10];
            for (int i = 0; i < 10; i++)
            {
                range[i] = i;
            }

После этого применяем к нему функцию перемешиванию массива.

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
        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;
        }

Полный код метода Main:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
        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();
        }

Универсальный вариант функции перемешивания с использованием шаблонов (для тех, кому нужно):

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
        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;
        }

@NightmareZ · 31.12.2010, 04:40

Никто не обидится, если я предложу некоторые альтернативы?

Вывод массива на экран

C#
1
foreach (int x in a) Console.Write(x + " ");

или даже так

C#
1
2
// using System.Linq;
Console.WriteLine(string.Join(" ", a.Select(x => x.ToString())));

Заполним массив случайными величинами

C#
1
2
3
// using System.Linq;
var rnd = new Random();
int[] a = Enumerable.Repeat(0, 10).Select(x => rnd.Next(0, 100)).ToArray();

Определение минимального числа в массиве
Определение максимального числа в массиве
Для этого в Linq уже есть методы Min и Max:

C#
1
2
3
// using System.Linq;
int min = a.Min();
int max = a.Max();

Определение суммы чисел в массиве

C#
1
2
// using System.Linq;
int sum = a.Sum();

если же нужна не сумма, а некая другая специфическая функция, можно использовать метод Aggregate. Например, перемножим все элементы:

C#
1
2
// using System.Linq;
int mul = a.Aggregate((result, curr) => result * curr);

Изменяет порядок элементов последовательности на противоположный

C#
1
2
// using System.Linq;
int[] reversedArray = a.Reverse().ToArray();

Возвращает различающиеся элементы последовательности

C#
1
2
// using System.Linq;
int[] uniqArray = a.Distinct().ToArray();

Возвращает только те элементы последовательности first, которых нет в последовательности second

C#
1
2
// using System.Linq;
int[] arr = first.Where(x => !second.Contains(x)).ToArray();

Находит пересечение множеств, представленных двумя последовательностями

C#
1
2
// using System.Linq;
int[] arr = first.Intersect(second).ToArray();

Проецирует матрицу в одномерный массив

C#
1
2
3
var tmp = new List<int>(matrix.GetLength(0)*matrix.GetLength(1));
foreach (int x in matrix) tmp.Add(x);
int[] arr = tmp.ToArray();

Находит объединение множеств, представленных двумя последовательностями

C#
1
2
// using System.Linq;
int[] arr = first.Union(second).ToArray();

@Unril · 20.01.2011, 23:21

Небольшая функция для вычисления суммы ряда.

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
        /// <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;
        }

Пример использования

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
            // Аргумент
            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 );

@sandye51 · 05.02.2011, 16:19

Вычисление определителя матрицы рекурсивно

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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;
    }
}

@Unril · 21.03.2011, 13:29

Основные способы сортировки списков или массивов в C#.

Показать код.

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
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 );
        }
    }
}

@m0nax · 21.03.2011, 17:58

Двоичный поиск (в отсортированном массиве)

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
        //возвращает индекс элемента в массиве или -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;
        }

Поиск методом интерполяции (в отсортированном массиве)

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
        //возвращает индекс элемента в массиве или -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; 
        }

@ailia · 28.03.2011, 18:57

Вычисление НОД двух чисел

Вычисление наибольшего общего делителя(НОД) двух чисел используя алгоритм Евклида

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//Наохидт наибольший общий делитель (НОД) чисел а и 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); //...иначе найти НОД меньшего числа и остатка
            }
        }

@CyBOSSeR · 07.05.2011, 01:02

Сообщение от NightmareZ

Никто не обидится, если я предложу некоторые альтернативы?

Предложу альтернативу нескольким альтернативам

:

Вывод массива на экран

C#
1
Array.ForEach(array, Console.WriteLine);

Проецирует матрицу в массив

C#
1
int[] array = matrix.Cast<int>().ToArray();

Возвращает массив элементов последовательности first, которых нет в последовательности second

C#
1
int[] array = first.Except(second).ToArray();

Перемешать массив случайным образом

C#
1
int[] array = array.OrderBy(e => Guid.NewGuid()).ToArray();

@Koran · 11.05.2011, 02:03

последнее время возникает вопрос как переводить из одной системы исчисления в другую

простой перевод
из десятичной в двоичную систему:

C#
1
string s = Convert.ToString(15, 2);

из десятичной в восьмеричную:

C#
1
string s = Convert.ToString(15, 8);

из десятичной в шестнадцатиричную:

C#
1
string s = Convert.ToString(15, 16);

справка

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
        //
        // Сводка:
        //     Преобразует значение заданного 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);

небольшое приложение для перевода из одной системы исчисления в другую в прикрепленных файлах

Не по теме:

файл выложил некто из форумчан, ника не помню, но ему спасибо и думаю он не будет против если я выложу его проект в этот фак

@Петррр · 16.05.2011, 19:50

Класс: Вещественная матрица

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
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);
    }
}

Класс: Список

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
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);
    }
}

Программирование очереди
Динамический список
Работа со стеком

Сортировки

Пузырьковая сортировка

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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);
    }
}

Гномья сортировка

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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);
    }
}

Сортировка вставками

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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);
    }
}

Квадратичный алгоритм сортировки подсчётом

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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);
    }
}

Сортировка выбором

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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);
    }
}

Сортировка расчёской

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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);
    }
}

@Phat D · 23.05.2011, 08:44

Способ работы с четными/нечетными элементами массива

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

@Killster · 11.06.2011, 12:09

Сообщение от ailia

Вычисление НОД двух чисел

C#
1
2
3
4
5
6
int GCD(int a, int b)
{
    while (b != 0)
        b = a % (a = b);
    return a;
}

или даже (т.н. бинарный алгоритм)

C#
1
2
3
4
5
6
7
8
9
10
11
int GCD(int a, int b)
{
   if (a == 0) return b;
   if (b == 0) return a;
   if (a == b) return a;
   if (a == 1 || b == 1) return 1;
   if ((a % 2 == 0) && (b % 2 == 0)) return 2 * GCD(a / 2, b / 2);
   if ((a % 2 == 0) && (b % 2 != 0)) return GCD(a / 2, b);
   if ((a % 2 != 0) && (b % 2 == 0)) return GCD(a, b / 2);
   return GCD(b, (int)Math.Abs(a - b));
}

tezaurismosis · 16.09.2013, 19:14

Среди трёх чисел выбрать максимальное, минимальное и среднее

C#
1
2
3
int max = Math.Max(a, Math.Max(b, c));  // Максимальное
int min = Math.Min(a, Math.Min(b, c));  // Минимальное
int middle = a + b + c - min - max;  // Среднее

@OwenGlendower · 10.03.2016, 17:58

Как определить путь к папке приложения?

Кликните здесь для просмотра всего текста

В консольном приложении, Windows Forms, WPF и ASP.NET можно использовать свойство AppDomain.BaseDirectory:

C#
1
string applicationRoot = AppDomain.CurrentDomain.BaseDirectory;

В Windows Forms можно также использовать Application.StartupPath.

В .NET Core вместо AppDomain.BaseDirectory нужно использовать AppContext.BaseDirectory.

Почему лучше не пользоваться CurrentDirectory для определения пути к папке приложения?

Кликните здесь для просмотра всего текста

Ни в коем случае не используйте так называемый «текущий каталог» который возвращают Environment.CurrentDirectory и Directory.GetCurrentDirectory() так как он не обязан совпадать с каталогом приложения. Путь к «текущему каталогу» зависит от внешней среды откуда запущена программа. Например, «текущий каталог» может не совпадать с каталогом приложения в следующих ситуациях:

При запуске приложения через ярлык с измененным «рабочим каталогом»
При запуске приложения из под планировщика Windows (Windows Scheduler)
При запуске приложения с помощью команды "Run as administrator" (UAC) или утилиты runas
При запуске из другого приложения использующего ProcessStartInfo.WorkingDirectory
При переделке приложения в системную службу Windows
При использовании OpenFileDialog/SaveFileDialog

См. также запись в блоге Rius: Относительное зло или когда пути неисповедимы с примерами на C#/VB.NET/C++/Pascal.

@OwenGlendower · 21.03.2016, 23:52

Почему класс Random иногда генерирует одинаковые последовательности чисел?

Почему класс Random иногда генерирует одинаковые последовательности чисел?

Класс Random это генератор так называемых псевдослучайных чисел. Это значит что числа получаются по некоему алгоритму, а не являются действительно случайными. Так сделано потому что для генерации действительно случайных чисел необходим источник случайной информации который есть не в каждом компьютере (таким источником может быть, например, Trusted Platform Module). Для генерации псевдослучайных чисел используется начальное число (затравка или seed по английски). В классе Random такой затравкой является количество миллисекунд прошедших с момента загрузки системы (Environment.TickCount).

ПримечаниеЭто поведение изменилось начиная с .NET Core 2.0. При использовании конструктора по умолчанию каждый раз генерируется новое значение затравки.

Данное значение имеет точность примерно от 10 до 16 миллисекунд. Поэтому при быстром создании экземпляров Random данное значение не успевает поменяться и псевдослучайные числа получаются одинаковые.

Хозяйке на заметку: Есть ли польза от затравки?

Наличие затравки имеет и положительный момент. Она дает возможность генерировать повторяющиеся последовательности чисел. Это можно применять, например, при шифровании с помощью симметричных алгоритмов.

Чтобы избежать этой проблемы нужно сделать так чтобы экземпляр Random не создавался слишком часто. Например, создать его один только раз в одной функции или сделать его полем класса (можно даже static полем).

Если необходимо генерировать случайные числа часто и в разных классах, то можно использовать класс StaticRandom.

StaticRandom

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
// Код взят из библиотеки MiscUtil (c) Jon Skeet
// [url]http://yoda.arachsys.com/csharp/miscutil/[/url]
 
/// <summary>
/// Thread-safe equivalent of System.Random, using just static methods.
/// If all you want is a source of random numbers, this is an easy class to
/// use. If you need to specify your own seeds (eg for reproducible sequences
/// f numbers), use System.Random.
/// </summary>
public static class StaticRandom
{
    private static Random random = new Random();
    private static object myLock = new object();
 
    /// <summary>
    /// Returns a nonnegative random number.
    /// 
    /// </summary>
    /// 
    /// <returns>
    /// A 32-bit signed integer greater than or equal to zero and less than Int32.MaxValue.
    /// </returns>
    public static int Next()
    {
        lock (StaticRandom.myLock)
            return StaticRandom.random.Next();
    }
 
    /// <summary>
    /// Returns a nonnegative random number less than the specified maximum.
    /// 
    /// </summary>
    /// 
    /// <returns>
    /// A 32-bit signed integer greater than or equal to zero, and less than maxValue;
    ///             that is, the range of return values includes zero but not maxValue.
    /// 
    /// </returns>
    /// <exception cref="T:System.ArgumentOutOfRangeException">maxValue is less than zero.</exception>
    public static int Next(int max)
    {
        lock (StaticRandom.myLock)
            return StaticRandom.random.Next(max);
    }
 
    /// <summary>
    /// Returns a random number within a specified range.
    /// 
    /// </summary>
    /// <param name="min">The inclusive lower bound of the random number returned. </param><param name="max">The exclusive upper bound of the random number returned.
    ///             maxValue must be greater than or equal to minValue.
    ///             </param>
    /// <returns>
    /// A 32-bit signed integer greater than or equal to minValue and less than maxValue;
    ///             that is, the range of return values includes minValue but not maxValue.
    ///             If minValue equals maxValue, minValue is returned.
    /// 
    /// </returns>
    /// <exception cref="T:System.ArgumentOutOfRangeException">minValue is greater than maxValue.</exception>
    public static int Next(int min, int max)
    {
        lock (StaticRandom.myLock)
            return StaticRandom.random.Next(min, max);
    }
 
    /// <summary>
    /// Returns a random number between 0.0 and 1.0.
    /// 
    /// </summary>
    /// 
    /// <returns>
    /// A double-precision floating point number greater than or equal to 0.0, and less than 1.0.
    /// </returns>
    public static double NextDouble()
    {
        lock (StaticRandom.myLock)
            return StaticRandom.random.NextDouble();
    }
 
    /// <summary>
    /// Fills the elements of a specified array of bytes with random numbers.
    /// 
    /// </summary>
    /// <param name="buffer">An array of bytes to contain random numbers.</param><exception cref="T:System.ArgumentNullException">buffer is a null reference (Nothing in Visual Basic).</exception>
    public static void NextBytes(byte[] buffer)
    {
        lock (StaticRandom.myLock)
            StaticRandom.random.NextBytes(buffer);
    }
}

Кроме этого в .NET есть класс System.Security.Cryptography.RNGCryptoServiceProvider который обеспечивает лучшее качество генерации случайных чисел. Однако он умеет генерировать только байты. Если необходимо генерировать числа типа int/double, то используйте готовый класс CryptoRandom.

CryptoRandom

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
using System;
using System.Security.Cryptography;
 
// Cryptographically-strong random number generator
// Source: MSDN Magazine > 2007 > September > .NET Matters: Tales from the CryptoRandom
// Source URL: [url]http://msdn.microsoft.com/en-us/magazine/cc163367.aspx[/url]
// via [url]https://gist.github.com/prettycode/5471944[/url]
// Authors: Stephen Toub & Shawn Farkas
public sealed class CryptoRandom : Random, IDisposable
{
    private RNGCryptoServiceProvider cryptoProvider = new RNGCryptoServiceProvider();
    private byte[] uint32Buffer = new byte[sizeof(uint)];
 
    /// <summary>
    /// An implementation of System.Random used for cryptographically-strong random number generation.
    /// </summary>
    public CryptoRandom() { }
 
    /// <summary>
    /// An implementation of System.Random used for cryptographically-strong random number generation.
    /// </summary>
    public CryptoRandom(int seedIgnored) { }
 
    /// <summary>
    /// Returns a nonnegative random number.
    /// </summary>
    /// <returns>
    /// A 32-bit signed integer greater than or equal to zero and less than <see cref="F:System.Int32.MaxValue"/>.
    /// </returns>
    public override int Next()
    {
        cryptoProvider.GetBytes(uint32Buffer);
        return BitConverter.ToInt32(uint32Buffer, 0) & 0x7FFFFFFF;
    }
 
    /// <summary>
    /// Returns a nonnegative random number less than the specified maximum.
    /// </summary>
    /// <returns>
    /// A 32-bit signed integer greater than or equal to zero, and less than <paramref name="maxValue"/>; that is, the range of return values ordinarily includes zero but not <paramref name="maxValue"/>. However, if <paramref name="maxValue"/> equals zero, <paramref name="maxValue"/> is returned.
    /// </returns>
    /// <param name="maxValue">The exclusive upper bound of the random number to be generated. <paramref name="maxValue"/> must be greater than or equal to zero.</param>
    /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="maxValue"/> is less than zero.</exception>
    public override int Next(int maxValue)
    {
        if (maxValue < 0) throw new ArgumentOutOfRangeException("maxValue");
        return Next(0, maxValue);
    }
 
    /// <summary>
    /// Returns a random number within a specified range.
    /// </summary>
    /// <returns>
    /// A 32-bit signed integer greater than or equal to <paramref name="minValue"/> and less than <paramref name="maxValue"/>; that is, the range of return values includes <paramref name="minValue"/> but not <paramref name="maxValue"/>. If <paramref name="minValue"/> equals <paramref name="maxValue"/>, <paramref name="minValue"/> is returned.
    /// </returns>
    /// <param name="minValue">The inclusive lower bound of the random number returned.</param>
    /// <param name="maxValue">The exclusive upper bound of the random number returned. <paramref name="maxValue"/> must be greater than or equal to <paramref name="minValue"/>.</param>
    /// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="minValue"/> is greater than <paramref name="maxValue"/>.</exception>
    public override int Next(int minValue, int maxValue)
    {
        if (minValue > maxValue) throw new ArgumentOutOfRangeException("minValue");
        if (minValue == maxValue) return minValue;
 
        long diff = maxValue - minValue;
        long max = (1 + (long)uint.MaxValue);
        long remainder = max % diff;
 
        while (true)
        {
            cryptoProvider.GetBytes(uint32Buffer);
            uint rand = BitConverter.ToUInt32(uint32Buffer, 0);
            if (rand < max - remainder)
            {
                return (int)(minValue + (rand % diff));
            }
        }
    }
 
    /// <summary>
    /// Returns a random number between 0.0 and 1.0.
    /// </summary>
    /// <returns>
    /// A double-precision floating point number greater than or equal to 0.0, and less than 1.0.
    /// </returns>
    public override double NextDouble()
    {
        cryptoProvider.GetBytes(uint32Buffer);
        uint rand = BitConverter.ToUInt32(uint32Buffer, 0);
        return rand / (1.0 + uint.MaxValue);
    }
 
    /// <summary>
    /// Fills the elements of a specified array of bytes with random numbers.
    /// </summary>
    /// <param name="buffer">An array of bytes to contain random numbers.</param>
    /// <exception cref="T:System.ArgumentNullException"><paramref name="buffer"/> is null.
    public override void NextBytes(byte[] buffer)
    {
        if (buffer == null) throw new ArgumentNullException("buffer");
        cryptoProvider.GetBytes(buffer);
    }
 
    public void Dispose()
    {
        InternalDispose();
    }
 
    ~CryptoRandom()
    {
        InternalDispose();
    }
 
    void InternalDispose()
    {
        if (cryptoProvider != null)
        {
            cryptoProvider.Dispose();
            cryptoProvider = null;
        }
    }
}

Как можно исправить ошибку в своем коде?
Часто вышеописанная проблема возникает потому что создание Random находится внутри цикла или внутри метода который вызывается из цикла. В первом случае нужно поставить создание Random перед циклом. Во втором сделать Random экземплярным или статическим полем.

@OwenGlendower · 08.02.2017, 22:48

Работа с XML

Работа с элементами с пространством имен

Кликните здесь для просмотра всего текста

Допустим у нас есть следующий XML документ:

test.xml

XML
1
2
3
4
5
<?xml version="1.0" encoding="utf-8"?>
<root xmlns="http://example.com">
    <item id="1">text1</item>
    <item id="2">text2</item>
</root>

Наличие атрибута xmlns говорит о том что данный элемент и вложенные в него принадлежат данному пространству имен. Для обращения к ним нужно указывать не только имя, но и это пространство.

С помощью XmlDocument и XPath

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load("test.xml");
XmlNamespaceManager xmlnsMgr = new XmlNamespaceManager(xmlDoc.NameTable);
// Регистрируем пространство имен и псевдоним для него
// Первый аргумент - псевдоним, может быть любым
// Второй аргумент - идентикатор пространства имен. Должен в точности совпадать с указанным в xml
xmlnsMgr.AddNamespace("ex", "http://example.com");
 
// Выбираем все элементы item используя ранее зарегистрированный псевдоним
// Обратите внимание что также нужно передать экхемпляр XmlNamespaceManager
XmlNodeList nodes = xmlDoc.SelectNodes("//ex:item", xmlnsMgr);
foreach (XmlElement itemElement in nodes)
{
    Console.WriteLine(
        "Id={0}, Text={1}",
        itemElement.GetAttribute("id"),
        itemElement.InnerText
    );
}

С помощью LINQ to XML

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
XDocument xdoc = XDocument.Load("test.xml");
// Ввводим пространство имен
// Присвоение строки экземпляру XNamespace возможно благодаря оператору неявного преобразования из string в XNamespace 
XNamespace xmlns = "http://example.com";
 
IEnumerable<XElement> elements = xdoc.Root.Elements(xmlns + "item");
foreach (XElement itemElement in elements)
{
    Console.WriteLine(
        "Id={0}, Text={1}",
        itemElement.Attribute("id").Value,
        itemElement.Value
    );
}

С помощью LINQ to XML и XPath

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
XDocument xdoc;
XmlNamespaceManager xmlnsMgr;
using (XmlReader reader = XmlReader.Create(File.OpenRead("test.xml")))
{
    xdoc = XDocument.Load(reader);
    XmlNameTable nameTable = reader.NameTable;
    xmlnsMgr = new XmlNamespaceManager(nameTable);
}
// Регистрируем пространство имен и псевдоним для него
// Первый аргумент - псевдоним, может быть любым
// Второй аргумент - идентикатор пространства имен. Должен в точности совпадать с указанным в xml
xmlnsMgr.AddNamespace("ex", "http://example.com");
 
IEnumerable<XElement> elements = xdoc.XPathSelectElements("//ex:item", xmlnsMgr);
foreach (XElement itemElement in elements)
{
    Console.WriteLine(
        "Id={0}, Text={1}",
        itemElement.Attribute("id").Value,
        itemElement.Value
    );
}

@Masson1848 · 15.05.2018, 19:00

Графы

Нахождение всех путей в графе от данной точки.

Код программы

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
using System;
using System.Collections.Generic;
 
namespace ConsoleApp5
{
    /// <summary>
    /// Класс описывающий ребро графа.
    /// </summary>
    class Edge
    {
        public int u, v;
        /// <summary>
        /// Ребро соединяющее две вершины.
        /// </summary>
        /// <param name="Вершина U"></param>
        /// <param name="Вершина V"></param>
        public Edge(int u, int v)
        {
            this.u = u;
            this.v = v;
        }
    }
 
    class Program
    {
        /// <summary>
        /// Проверка нахождения вершины в списке.
        /// </summary>
        /// <param name="Текущий путь"></param>
        /// <param name="Вершина"></param>
        /// <returns>True - есть такая вершина. False - такая вершина отсутствует.</returns>
        static bool FindEdge(List<int> listWay, int edge)
        {
            if (listWay == null) return false;//Если список пустой, то данная вершина не входит в список.
            else
            {
                foreach(var i in listWay)//Проверка на наличие вершины в нашем пути.
                {
                    if (i == edge) return true;//Если нашлась такая вершина.
                }
            }
            return false;
        }
 
        /// <summary>
        /// Сравнения двух путей
        /// </summary>
        /// <param name="list1"></param>
        /// <param name="list2"></param>
        /// <returns>True-Списки похожи. False-Списки отлчаются между собой</returns>
        static bool Compare(List<int> list1,List<int> list2)
        {
            if (list1.Count == list2.Count)// Если два списка равны по количеству элементов, то начинает проверять каждый элемент.
            {
                for (var i = 0; i < list1.Count; i++)
                    if (list1[i] != list2[i]) return false;//Если находится хотя-бы одно несовпадение, то возращается false
            }
            else return false;
            return true;//Возращает значение true, если списки похожи между собой
        }
 
        /// <summary>
        /// Добавление найденного пути в общий список путей.
        /// </summary>
        /// <param name="listWay"></param>
        /// <param name="listWays"></param>
        /// <returns>Список Путей</returns>
        static List<List<int>> AddWay(List<int> listWay, List<List<int>> listWays)
        {
            int i = 0;
            bool temp = true;
            while ((i < listWays.Count) && (temp)) //Проверяем есть ли указанный путь в нашем списке путей.
            {  
                if (Compare(listWay, listWays[i])) temp = false;
                else i++;
            }
            if (temp || i == listWays.Count)// Если такого пути нет, то добавляем его в наш список.
            {
                listWays.Add(new List<int>());
                foreach (var j in listWay)//Поэлементно добавляем новый список
                {
                    listWays[listWays.Count - 1].Add(j);
                }
            }
            return listWays;//Возвращем список наших путей
        }
 
        /// <summary>
        /// Обработка параметров
        /// </summary>
        /// <param name="listEdges"></param>
        /// <param name="listWays"></param>
        /// <param name="listWay"></param>
        /// <param name="edge"></param>
        /// <param name="numberEdge"></param>
        static void Treatment(List<Edge> listEdges, List<List<int>> listWays, List<int> listWay, int edge, int numberEdge)
        {
            listWay.Add(numberEdge);//добавляем вершину в список
            if (!FindEdge(listWay, edge)) listWays = Ways(listEdges, listWay, listWays, edge);//если не нашли вершину в списке, то продолжаем обработку.
            else listWays = AddWay(listWay, listWays);//Иначе это конечный путь. Добавляем путь в наш список путей.
            listWay.Remove(numberEdge);//Очищаем
        }
 
        /// <summary>
        /// Находит все возможные пути до всех вершин.
        /// </summary>
        /// <param name="listEdges"></param>
        /// <param name="listWay"></param>
        /// <param name="listWays"></param>
        /// <param name="numberEdge"></param>
        /// <returns>Список путей из данной вершины</returns>
        static List<List<int>> Ways(List<Edge> listEdges, List<int> listWay, List<List<int>> listWays, int numberEdge)
        {
            foreach (var edge in listEdges)
            {
                if (!FindEdge(listWay, numberEdge))
                {
                    if (edge.u==numberEdge)
                    {
                        Treatment(listEdges, listWays, listWay, edge.v, numberEdge);
                    }
                    else if (edge.v==numberEdge)
                    {
                        Treatment(listEdges, listWays, listWay, edge.u, numberEdge);
                    }
                }
            }
            return listWays;
        }
 
        /// <summary>
        /// Красивая распечатка пути в виде 2-3-5
        /// </summary>
        /// <param name="listWay"></param>
        static void Print(List<int> listWay)
        {
            for (var i=0;i<listWay.Count;i++)
            {
                if (i != listWay.Count - 1) Console.Write($"{listWay[i]}-");
                else Console.Write(listWay[i]);
            }
            Console.WriteLine();
        }
 
        static void Main(string[] args)
        {
            List<Edge> edges = new List<Edge>();
            List<List<int>> listWays = new List<List<int>>();
            edges.Add(new Edge(1, 2));
            edges.Add(new Edge(2, 3));
            edges.Add(new Edge(3, 5));
            edges.Add(new Edge(4, 5));
            edges.Add(new Edge(2, 4));
            edges.Add(new Edge(2, 5));
            //List<List<int>>- список всех путей от данной точки.
            //List<int>- список точек, которые уже обработаны
            listWays = Ways(edges, new List<int>(), new List<List<int>>(), 2);
            foreach (var i in listWays) Print(i);
            Console.ReadLine();
        }
    }
}

@worldandlife · 28.05.2018, 00:37

Предлагаю еще альтернативы по поиску максимального и минимального числа в массиве

Определение максимального числа в массиве:

C#
1
2
3
4
5
6
   int max= a[0];
            for (int i = 1; i < N; i++)
            {
                if (a[i] > max)
                    max = a[i];
            }

Определение минимального числа в массиве:

C#
1
2
3
4
5
6
   int min= a[0];
            for (int i = 1; i < N; i++)
            {
                if (a[i] < min)
                    min = a[i];
            }

@OwenGlendower · 27.01.2019, 13:49

Чтение чисел из файла (каждое число на отдельной строке)

C#
1
2
using System.Collections.Generic;
using System.IO;

C#
1
2
3
4
5
6
7
string filePath = @"c:\folder\file.txt";
List<int> numbers = new List<int>();
foreach (string line in File.ReadLines(filePath))
{
    int n;
    if (int.TryParse(line, out n)) numbers.Add(n);
}

Чтение чисел из файла (в одной строке несколько чисел разделенных пробелом или другим символом)

C#
1
2
using System.Collections.Generic;
using System.IO;

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
string filePath = @"c:\folder\file.txt";
List<int> numbers = new List<int>();
foreach (string line in File.ReadLines(filePath))
{
    // В качестве разделителя в примере используется пробел
    // Если нужен другой, то измените первый аргумент в Split
    // Например:
    //   new[]{','} - разделитель запятая
    //   new[]{' ', '\t'} - разделитель пробел или табуляция
    string[] array = line.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    foreach (string s in array)
    {
        int n;
        if (int.TryParse(s, out n)) numbers.Add(n);
    }
}

Новые блоги и статьи Все статьи Все блоги /
PhpStorm 2025.3: WSL Terminal всегда стартует в ~ and_y87 14.12.2025 PhpStorm 2025. 3: WSL Terminal всегда стартует в ~ (home), игнорируя директорию проекта Симптом: После обновления до PhpStorm 2025. 3 встроенный терминал WSL открывается в домашней директории. . .	Access VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.	Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 05.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .	От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .
Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .	Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .	Ломающие изменения в C#.NStar Alpha Etyuhibosecyu 20.11.2025 Уже можно не только тестировать, но и пользоваться C#. NStar - писать оконные приложения, содержащие надписи, кнопки, текстовые поля и даже изображения, например, моя игра "Три в ряд" написана на этом. . .	Мысли в слух kumehtar 18.11.2025 Кстати, совсем недавно имел разговор на тему медитаций с людьми. И обнаружил, что они вообще не понимают что такое медитация и зачем она нужна. Самые базовые вещи. Для них это - когда просто люди. . .	Создание Single Page Application на фреймах krapotkin 17.11.2025 Статья исключительно для начинающих. Подходы оригинальностью не блещут. В век Веб все очень привыкли к дизайну Single-Page-Application . Быстренько разберем подход "на фреймах". Мы делаем одну. . .