> For the complete documentation index, see [llms.txt](https://axideli.gitbook.io/osnovy-programmirovaniya-na-yazyke-c/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://axideli.gitbook.io/osnovy-programmirovaniya-na-yazyke-c/massivy-i-kollekcii.md).

# Массивы и коллекции

## Введение в массивы и коллекции

В мире программирования массивы и коллекции являются ключевыми структурами данных, предоставляющими эффективные способы хранения и управления множеством элементов. Эти структуры данных позволяют организовать информацию и обеспечивают множество операций для удобного доступа и манипуляций.

#### **Определение массивов и коллекций**

**Массивы:** Массив - это упорядоченный набор элементов одного типа, которые могут быть легко идентифицированы по их индексам. В C# массивы могут быть одномерными или многомерными и предоставляют удобный способ хранения и доступа к данным.

**Коллекции:** Коллекции представляют собой более гибкий и расширяемый способ хранения данных. В C# коллекции реализуют различные интерфейсы, такие как `IEnumerable`, `ICollection` и `IList`, предоставляя разнообразные функциональные возможности для работы с данными.

#### **Различия между массивами и коллекциями**

* **Фиксированный размер vs. Динамическое расширение:**
  * Массивы имеют фиксированный размер, который определяется при их создании.
  * Коллекции могут динамически увеличиваться или уменьшаться в размере в процессе выполнения программы.
* **Типы данных элементов:**
  * Массивы хранят элементы только одного типа данных.
  * Коллекции могут содержать элементы различных типов данных.
* **Индексация:**
  * Элементы массива доступны по индексу, который начинается с нуля.
  * Коллекции также могут поддерживать индексацию, но не все коллекции обязательно ее поддерживают.

#### **Преимущества использования массивов и коллекций**

**Преимущества массивов:**

* Простота использования и быстрый доступ к элементам по индексу.
* Отличная производительность при известном статическом размере.

**Преимущества коллекций:**

* Гибкость в управлении размером и структурой данных.
* Широкий выбор встроенных коллекций, упрощающих многие задачи.
* Встроенная поддержка LINQ (Language Integrated Query) для удобного запроса и обработки данных.

Выбор между массивами и коллекциями зависит от конкретной задачи и требований к хранению и обработке данных в приложении.

## Массивы в C\#

#### **Определение и объявление массивов**

**Определение массивов:** Массив в C# — это структура данных, которая представляет собой упорядоченный набор элементов одного типа. Для объявления массива в C# используется следующий синтаксис:

```csharp
csharpCopy code// Одномерный массив целых чисел
int[] myArray;

// Инициализация массива
myArray = new int[5]; // Создание массива из 5 элементов

// Инициализация и объявление в одной строке
int[] myInitializedArray = new int[] { 1, 2, 3, 4, 5 };
```

#### **Индексация и доступ к элементам массива**

**Индексация массива:** Элементы массива нумеруются с нуля. Для доступа к элементам используется их индекс:

```csharp
csharpCopy codeint[] myArray = { 10, 20, 30, 40, 50 };

// Доступ к элементам массива
int firstElement = myArray[0];   // 10
int thirdElement = myArray[2];   // 30
```

**Изменение элементов массива:** Элементы массива можно изменять:

```csharp
csharpCopy codemyArray[1] = 25; // Изменение второго элемента на 25
```

#### **Многомерные массивы**

**Определение многомерных массивов:** C# поддерживает создание многомерных массивов. Например, двумерный массив:

```csharp
csharpCopy codeint[,] twoDimensionalArray = new int[3, 4]; // 3 строки, 4 столбца
```

**Индексация многомерных массивов:** Доступ к элементам двумерного массива осуществляется с помощью двух индексов:

```csharp
csharpCopy codetwoDimensionalArray[0, 1] = 10; // Задание значения для элемента в первой строке и втором столбце
```

#### **Методы массивов: Length, CopyTo, Clone**

**Метод Length:** Свойство `Length` возвращает количество элементов в массиве:

```csharp
csharpCopy codeint[] myArray = { 1, 2, 3, 4, 5 };

int arrayLength = myArray.Length; // 5
```

**Метод CopyTo:** Метод `CopyTo` копирует элементы массива в другой массив:

```csharp
csharpCopy codeint[] sourceArray = { 1, 2, 3, 4, 5 };
int[] destinationArray = new int[5];

sourceArray.CopyTo(destinationArray, 0); // Копирование элементов из sourceArray в destinationArray, начиная с индекса 0
```

**Метод Clone:** Метод `Clone` создает новый массив, являющийся точной копией существующего массива:

```csharp
csharpCopy codeint[] originalArray = { 1, 2, 3, 4, 5 };
int[] clonedArray = (int[])originalArray.Clone(); // Создание копии массива
```

Массивы в C# предоставляют эффективный и удобный способ работы с коллекциями данных, а знание и использование методов таких как `Length`, `CopyTo`, и `Clone` обогащает функциональность работы с массивами.

## Коллекции в C\#

#### **Общие интерфейсы коллекций: `IEnumerable`, `ICollection`, `IList`**

**`IEnumerable`**

Интерфейс `IEnumerable` предоставляет базовую функциональность для перебора элементов коллекции. Он включает в себя метод `GetEnumerator()`, который возвращает объект, реализующий интерфейс `IEnumerator`.

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

```csharp
csharpCopy codeusing System;
using System.Collections;

class Program
{
    static void Main()
    {
        ArrayList list = new ArrayList() { 1, 2, 3, 4, 5 };

        // Использование foreach с IEnumerable
        foreach (int item in list)
        {
            Console.WriteLine(item);
        }
    }
}
```

**`ICollection`**

Интерфейс `ICollection` расширяет `IEnumerable` и добавляет базовые методы для управления коллекцией, такие как `Add`, `Clear`, `Contains`, `CopyTo`, `Remove`.

```csharp
csharpCopy codeusing System;
using System.Collections;

class Program
{
    static void Main()
    {
        ArrayList list = new ArrayList() { 1, 2, 3, 4, 5 };

        // Использование методов ICollection
        list.Add(6);
        list.Remove(3);

        Console.WriteLine($"Contains 2: {list.Contains(2)}");
    }
}
```

**`IList`**

Интерфейс `IList` расширяет `ICollection` и добавляет методы для работы с элементами по индексу, такие как `IndexOf`, `Insert`, `RemoveAt`.

```csharp
csharpCopy codeusing System;
using System.Collections;

class Program
{
    static void Main()
    {
        ArrayList list = new ArrayList() { 1, 2, 3, 4, 5 };

        // Использование методов IList
        int index = list.IndexOf(4);
        list.Insert(index, 10);

        Console.WriteLine($"Element at index {index}: {list[index]}");
    }
}
```

#### **Примеры стандартных коллекций: `List`, `Dictionary`, `Queue`, `Stack`**

**`List<T>`**

`List<T>` представляет собой динамический массив, который автоматически расширяется при добавлении элементов.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> myList = new List<int>() { 1, 2, 3, 4, 5 };

        // Добавление элемента
        myList.Add(6);

        // Удаление элемента
        myList.Remove(3);

        // Итерация по списку
        foreach (int item in myList)
        {
            Console.WriteLine(item);
        }
    }
}
```

**`Dictionary<TKey, TValue>`**

`Dictionary<TKey, TValue>` представляет собой коллекцию пар ключ-значение, где каждый ключ должен быть уникален.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Dictionary<string, int> myDictionary = new Dictionary<string, int>();

        // Добавление элемента
        myDictionary.Add("One", 1);

        // Получение элемента по ключу
        int value = myDictionary["One"];

        // Проверка наличия ключа
        bool containsKey = myDictionary.ContainsKey("Two");

        Console.WriteLine($"Value for key 'One': {value}");
        Console.WriteLine($"Contains key 'Two': {containsKey}");
    }
}
```

**`Queue<T>`**

`Queue<T>` представляет собой очередь элементов, работающую по принципу "первым пришел — первым вышел" (FIFO).

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Queue<string> myQueue = new Queue<string>();

        // Добавление элемента в очередь
        myQueue.Enqueue("First");
        myQueue.Enqueue("Second");
        myQueue.Enqueue("Third");

        // Извлечение элемента из очереди
        string firstItem = myQueue.Dequeue();

        Console.WriteLine($"First item: {firstItem}");
    }
}
```

**`Stack<T>`**

`Stack<T>` представляет собой стек элементов, работающий по принципу "последним пришел — первым вышел" (LIFO).

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Stack<int> myStack = new Stack<int>();

        // Добавление элемента в стек
        myStack.Push(1);
        myStack.Push(2);
        myStack.Push(3);

        // Извлечение элемента из стека
        int poppedItem = myStack.Pop();

        Console.WriteLine($"Popped item: {poppedItem}");
    }
}
```

#### **Работа с коллекциями: добавление, удаление, поиск элементов**

Рассмотрим общие методы для работы с коллекциями: `Add`, `Remove`, `Contains`.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> myCollection = new List<string>() { "One", "Two", "Three" };

        // Добавление элемента
        myCollection.Add("Four");

        // Удаление элемента
        myCollection.Remove("Two");

        // Проверка наличия элемента
        bool containsElement = myCollection.Contains("Three");

        Console.WriteLine($"Contains element 'Three': {containsElement}");
    }
}
```

Методы `Add` и `Remove` используются для добавления и удаления элементов из коллекции. Метод `Contains` проверяет, содержится ли элемент в коллекции.

Коллекции в C# предоставляют удобные средства для организации данных и обеспечивают широкие возможности по управлению и работе с элементами.

## Итерация по массивам и коллекциям

#### **Использование циклов для перебора элементов**

**Итерация по массиву с использованием цикла for:**

Цикл `for` предоставляет возможность последовательного обхода элементов массива по индексам. Обратите внимание, что индексы начинаются с 0, и цикл выполняется до значения `Length - 1`.

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        int[] myArray = { 1, 2, 3, 4, 5 };

        // Итерация по массиву с использованием цикла for
        for (int i = 0; i < myArray.Length; i++)
        {
            Console.WriteLine(myArray[i]);
        }
    }
}
```

**Итерация по коллекции с использованием цикла for:**

Для коллекций, имеющих свойство `Count`, можно использовать цикл `for` аналогичным образом.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> myCollection = new List<string>() { "One", "Two", "Three" };

        // Итерация по коллекции с использованием цикла for
        for (int i = 0; i < myCollection.Count; i++)
        {
            Console.WriteLine(myCollection[i]);
        }
    }
}
```

#### **Использование ключевого слова foreach**

**Итерация по массиву с использованием foreach:**

Ключевое слово `foreach` предоставляет удобный способ перебора элементов массива или коллекции без явного использования индексов. Это особенно полезно, когда порядок перебора не важен.

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        int[] myArray = { 1, 2, 3, 4, 5 };

        // Итерация по массиву с использованием foreach
        foreach (int item in myArray)
        {
            Console.WriteLine(item);
        }
    }
}
```

**Итерация по коллекции с использованием foreach:**

`foreach` также применим к коллекциям, реализующим интерфейс `IEnumerable`.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> myCollection = new List<string>() { "One", "Two", "Three" };

        // Итерация по коллекции с использованием foreach
        foreach (string item in myCollection)
        {
            Console.WriteLine(item);
        }
    }
}
```

## Сортировка и поиск в массивах и коллекциях

#### **Методы сортировки для массивов и коллекций**

**Сортировка массива с использованием метода Array.Sort:**

Массивы в C# предоставляют метод `Sort()`, который позволяет отсортировать элементы в порядке возрастания.

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        int[] myArray = { 5, 3, 1, 4, 2 };

        // Сортировка массива
        Array.Sort(myArray);

        // Вывод отсортированного массива
        foreach (int item in myArray)
        {
            Console.WriteLine(item);
        }
    }
}
```

**Сортировка коллекции с использованием метода List.Sort:**

`List<T>` также предоставляет метод `Sort()`, который используется для сортировки элементов.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> myList = new List<int>() { 5, 3, 1, 4, 2 };

        // Сортировка коллекции
        myList.Sort();

        // Вывод отсортированной коллекции
        foreach (int item in myList)
        {
            Console.WriteLine(item);
        }
    }
}
```

#### **Поиск элементов: методы `IndexOf`, `Contains`**

**Поиск элемента в массиве с использованием метода `Array.IndexOf`:**

Массивы поддерживают метод `IndexOf`, который возвращает индекс первого вхождения элемента или -1, если элемент не найден.

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        int[] myArray = { 1, 2, 3, 4, 5 };

        // Поиск индекса элемента в массиве
        int index = Array.IndexOf(myArray, 3);

        Console.WriteLine($"Index of element 3: {index}");
    }
}
```

**Поиск элемента в коллекции с использованием метода `List.Contains`:**

Коллекции, реализующие интерфейс `ICollection<T>`, обычно предоставляют метод `Contains`, который проверяет наличие элемента.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> myCollection = new List<string>() { "One", "Two", "Three" };

        // Проверка наличия элемента в коллекции
        bool containsElement = myCollection.Contains("Two");

        Console.WriteLine($"Contains element 'Two': {containsElement}");
    }
}
```

Эти методы обеспечивают удобные инструменты для сортировки и поиска элементов в массивах и коллекциях, что позволяет эффективно управлять данными.

## Работа с коллекциями в LINQ

#### **Введение в LINQ**

**LINQ (Language Integrated Query)** представляет собой набор языковых расширений в C#, которые добавляют возможности для выполнения запросов к данным наподобие SQL запросов. LINQ позволяет удобно и эффективно работать с различными источниками данных, включая массивы, коллекции, базы данных и другие.

LINQ состоит из двух основных частей:

1. **LINQ to Objects:** Предоставляет возможности для выполнения запросов к объектам и коллекциям в памяти.
2. **LINQ to SQL, LINQ to Entities:** Предоставляют возможности для выполнения запросов к базам данных.

#### **Основные операции LINQ: Where, Select, OrderBy**

**Оператор `Where`:**

Оператор `Where` используется для фильтрации элементов коллекции, основываясь на условии.

```csharp
csharpCopy codeusing System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        // Выбор только четных чисел
        var evenNumbers = numbers.Where(n => n % 2 == 0);

        // Вывод результата
        foreach (var number in evenNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
```

**Оператор `Select`:**

Оператор `Select` используется для проекции (выбора) определенных свойств или преобразования элементов коллекции.

```csharp
csharpCopy codeusing System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

        // Проекция: умножение каждого числа на 2
        var doubledNumbers = numbers.Select(n => n * 2);

        // Вывод результата
        foreach (var number in doubledNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
```

**Оператор `OrderBy`:**

Оператор `OrderBy` используется для сортировки элементов коллекции по возрастанию.

```csharp
csharpCopy codeusing System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 7 };

        // Сортировка чисел по возрастанию
        var sortedNumbers = numbers.OrderBy(n => n);

        // Вывод результата
        foreach (var number in sortedNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
```

#### **Применение LINQ к коллекциям**

LINQ часто применяется для выполнения сложных запросов к коллекциям. Например, объединение операторов `Where`, `Select` и `OrderBy`:

```csharp
csharpCopy codeusing System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 7 };

        // Выбор и сортировка четных чисел
        var result = numbers
            .Where(n => n % 2 == 0)    // Фильтрация четных чисел
            .OrderBy(n => n);          // Сортировка по возрастанию

        // Вывод результата
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}
```

Этот код выбирает только четные числа из списка и сортирует их по возрастанию. LINQ предоставляет мощные инструменты для упрощения кода и выполнения операций с коллекциями.

## Практические примеры использования массивов и коллекций

#### **Сценарии применения массивов**

**Пример 1: Хранение и обработка данных о студентах.**

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        // Использование массива для хранения имен студентов
        string[] studentNames = { "Alice", "Bob", "Charlie", "David" };

        // Вывод списка студентов
        Console.WriteLine("Список студентов:");
        foreach (var name in studentNames)
        {
            Console.WriteLine(name);
        }
    }
}
```

**Пример 2: Обработка оценок студентов.**

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        // Использование массива для хранения оценок студентов
        int[] grades = { 90, 85, 92, 88, 95 };

        // Вычисление средней оценки
        double averageGrade = 0;
        foreach (var grade in grades)
        {
            averageGrade += grade;
        }
        averageGrade /= grades.Length;

        // Вывод результата
        Console.WriteLine($"Средняя оценка: {averageGrade}");
    }
}
```

#### **Эффективное использование коллекций**

**Пример: Добавление и удаление элементов из списка.**

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Использование List для хранения и обработки данных
        List<string> fruits = new List<string> { "Apple", "Banana", "Orange" };

        // Добавление нового фрукта
        fruits.Add("Grapes");

        // Удаление фрукта по индексу
        fruits.RemoveAt(1);

        // Вывод обновленного списка фруктов
        Console.WriteLine("Список фруктов:");
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}
```

#### **Решение задач: фильтрация, сортировка, поиск**

**Пример: Фильтрация и сортировка чисел.**

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 7 };

        // Выбор и сортировка четных чисел
        var result = numbers
            .Where(n => n % 2 == 0)    // Фильтрация четных чисел
            .OrderBy(n => n);          // Сортировка по возрастанию

        // Вывод результата
        Console.WriteLine("Отфильтрованные и отсортированные числа:");
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}
```

## Лучшие практики при работе с массивами и коллекциями

#### **Оптимизация доступа к элементам массивов**

* **Использование foreach:** При итерации по всем элементам массива предпочтительнее использовать ключевое слово `foreach` вместо цикла `for`, так как оно обеспечивает безопасный доступ к элементам.

```csharp
csharpCopy codeint[] numbers = { 1, 2, 3, 4, 5 };

// Плохо
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

// Хорошо
foreach (var number in numbers)
{
    Console.WriteLine(number);
}
```

#### **Избегание изменения коллекций в процессе итерации**

* **Использование копии коллекции:** Если необходимо изменять коллекцию в процессе итерации, создайте ее копию, чтобы избежать ошибок.

```csharp
csharpCopy codeList<string> fruits = new List<string> { "Apple", "Banana", "Orange" };

// Плохо
foreach (var fruit in fruits)
{
    if (fruit == "Banana")
    {
        fruits.Remove(fruit);  // Приведет к ошибке!
    }
}

// Хорошо
foreach (var fruit in fruits.ToList())
{
    if (fruit == "Banana")
    {
        fruits.Remove(fruit);  // Безопасное удаление
    }
}
```

#### **Выбор правильной коллекции для конкретной задачи**

* **List vs. HashSet vs. Dictionary:** Выбирайте коллекцию в зависимости от требований задачи. Например, `List` подходит для хранения упорядоченных элементов, `HashSet` - для уникальных элементов без порядка, `Dictionary` - для пар ключ-значение.

```csharp
csharpCopy code// Пример использования HashSet для уникальных значений
HashSet<int> uniqueNumbers = new HashSet<int> { 1, 2, 3, 1, 4, 5 };

// Пример использования Dictionary для хранения пар ключ-значение
Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 25 },
    { "Bob", 30 },
    { "Charlie", 22 }
};
```

Эти практики помогут улучшить читаемость кода, повысить его эффективность и избежать распространенных ошибок при работе с массивами и коллекциями.

***

{% embed url="<https://www.youtube.com/watch?v=1TvjgRJ34v8>" fullWidth="true" %}

***

## Упражнения

#### **Упражнение 1: Работа с массивами**

Создайте массив целых чисел и заполните его значениями. Выведите на экран сумму всех элементов массива.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 1: Работа с массивами
using System;

class Program
{
    static void Main()
    {
        // Создание массива и заполнение значениями
        int[] numbers = { 1, 2, 3, 4, 5 };

        // Вычисление и вывод суммы элементов массива
        int sum = 0;
        foreach (int number in numbers)
        {
            sum += number;
        }

        Console.WriteLine($"Сумма элементов массива: {sum}");
    }
}
```

</details>

#### **Упражнение 2: Работа с коллекцией List**

Используя коллекцию List, добавьте несколько строковых значений (например, имен) и выведите их на экран.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 2: Работа с коллекцией List
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и заполнение коллекции List
        List<string> names = new List<string> { "Анна", "Иван", "Мария" };

        // Вывод элементов коллекции на экран
        foreach (string name in names)
        {
            Console.WriteLine(name);
        }
    }
}
```

</details>

#### **Упражнение 3: Поиск элемента в массиве**

Создайте массив строк и попросите пользователя ввести значение для поиска. Проверьте, содержится ли введенное значение в массиве, и выведите соответствующее сообщение.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 3: Поиск элемента в массиве
using System;

class Program
{
    static void Main()
    {
        // Создание массива строк
        string[] words = { "apple", "banana", "orange", "grape" };

        // Ввод значения для поиска
        Console.Write("Введите слово для поиска: ");
        string searchWord = Console.ReadLine();

        // Проверка наличия введенного значения в массиве
        bool found = false;
        foreach (string word in words)
        {
            if (word == searchWord)
            {
                found = true;
                break;
            }
        }

        // Вывод результата
        if (found)
        {
            Console.WriteLine($"Слово '{searchWord}' найдено в массиве.");
        }
        else
        {
            Console.WriteLine($"Слово '{searchWord}' не найдено в массиве.");
        }
    }
}
```

</details>

#### **Упражнение 4: Работа с двумерным массивом**

Создайте двумерный массив (матрицу) и заполните его значениями. Выведите на экран сумму элементов каждой строки.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 4: Работа с двумерным массивом
using System;

class Program
{
    static void Main()
    {
        // Создание двумерного массива и заполнение значений
        int[,] matrix = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

        // Вывод суммы элементов каждой строки
        for (int i = 0; i < matrix.GetLength(0); i++)
        {
            int sum = 0;
            for (int j = 0; j < matrix.GetLength(1); j++)
            {
                sum += matrix[i, j];
            }
            Console.WriteLine($"Сумма элементов строки {i + 1}: {sum}");
        }
    }
}
```

</details>

#### **Упражнение 5: Использование коллекции Dictionary**

Создайте коллекцию Dictionary для хранения пар ключ-значение (например, слово-перевод). Добавьте несколько элементов и выведите их на экран.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 5: Использование коллекции Dictionary
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и заполнение коллекции Dictionary
        Dictionary<string, string> translations = new Dictionary<string, string>
        {
            { "apple", "яблоко" },
            { "banana", "банан" },
            { "orange", "апельсин" }
        };

        // Вывод элементов коллекции на экран
        foreach (var pair in translations)
        {
            Console.WriteLine($"{pair.Key} - {pair.Value}");
        }
    }
}
```

</details>

#### **Упражнение 6: Сортировка массива**

Создайте массив чисел и отсортируйте его в порядке возрастания. Выведите отсортированный массив на экран.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 6: Сортировка массива
using System;

class Program
{
    static void Main()
    {
        // Создание массива чисел
        int[] numbers = { 5, 3, 8, 1, 2 };

        // Сортировка массива
        Array.Sort(numbers);

        // Вывод отсортированного массива
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine();
    }
}
```

</details>

#### **Упражнение 7: Удаление элемента из коллекции List**

Создайте коллекцию List строк и попросите пользователя ввести значение для удаления. Удалите все вхождения этого значения из списка и выведите результат.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 7: Удаление элемента из коллекции List
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и заполнение коллекции List строк
        List<string> colors = new List<string> { "red", "blue", "green", "red", "yellow" };

        // Вывод элементов коллекции на экран
        Console.WriteLine("Исходная коллекция:");
        foreach (string color in colors)
        {
            Console.Write(color + " ");
        }
        Console.WriteLine();

        // Ввод значения для удаления
        Console.Write("Введите цвет для удаления: ");
        string colorToRemove = Console.ReadLine();

        // Удаление всех вхождений введенного значения из списка
        colors.RemoveAll(c => c == colorToRemove);

        // Вывод измененной коллекции на экран
        Console.WriteLine("Измененная коллекция:");
        foreach (string color in colors)
        {
            Console.Write(color + " ");
        }
        Console.WriteLine();
    }
}
```

</details>

#### **Упражнение 8: Работа с коллекцией HashSet**

Используя коллекцию HashSet, добавьте несколько чисел и проверьте, содержится ли число, введенное пользователем, в этой коллекции.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 8: Работа с коллекцией HashSet
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и заполнение коллекции HashSet числами
        HashSet<int> numbers = new HashSet<int> { 1, 3, 5, 7, 9 };

        // Вывод элементов коллекции на экран
        Console.Write("Введите число для проверки наличия в коллекции: ");
        int userNumber = int.Parse(Console.ReadLine());

        // Проверка наличия введенного числа в коллекции HashSet
        if (numbers.Contains(userNumber))
        {
            Console.WriteLine($"Число {userNumber} содержится в коллекции.");
        }
        else
        {
            Console.WriteLine($"Число {userNumber} не содержится в коллекции.");
        }
    }
}
```

</details>

#### **Упражнение 9: Многомерные коллекции**

Создайте List\<List\<int>> для представления таблицы умножения. Заполните его значениями и выведите таблицу на экран.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 9: Многомерные коллекции
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание List<List<int>> для представления таблицы умножения
        List<List<int>> multiplicationTable = new List<List<int>>();

        // Заполнение таблицы умножения значениями
        for (int i = 1; i <= 10; i++)
        {
            List<int> row = new List<int>();
            for (int j = 1; j <= 10; j++)
            {
                row.Add(i * j);
            }
            multiplicationTable.Add(row);
        }

        // Вывод таблицы умножения на экран
        foreach (List<int> row in multiplicationTable)
        {
            foreach (int value in row)
            {
                Console.Write($"{value}\t");
            }
            Console.WriteLine();
        }
    }
}
```

</details>

#### **Упражнение 10: Работа с коллекцией Queue**

Создайте коллекцию Queue для моделирования очереди. Добавьте несколько элементов, выведите их на экран, а затем извлеките и выведите первый элемент.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 10: Работа с коллекцией Queue
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и работа с коллекцией Queue
        Queue<string> queue = new Queue<string>();

        // Добавление элементов в очередь
        queue.Enqueue("Первый");
        queue.Enqueue("Второй");
        queue.Enqueue("Третий");

        // Вывод элементов очереди на экран
        Console.WriteLine("Элементы очереди:");
        foreach (string item in queue)
        {
            Console.WriteLine(item);
        }

        // Извлечение и вывод первого элемента
        string removedItem = queue.Dequeue();
        Console.WriteLine($"Извлеченный элемент: {removedItem}");
    }
}
```

</details>

***

## Вопросы

#### **Работа с массивами**

Как создать массив целых чисел и заполнить его значениями в языке программирования C#?

#### **Работа с коллекцией List**

Как добавить элементы в коллекцию List в C#?

#### **Поиск элемента в массиве**

Как осуществить поиск определенного значения в массиве и определить, содержится ли это значение в нем?

#### **Работа с двумерным массивом**

Как объявить и заполнить двумерный массив в C#? Как вывести сумму элементов каждой строки?

#### **Использование коллекции Dictionary**

Как создать и использовать коллекцию Dictionary для хранения пар ключ-значение?

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

Как выполнить сортировку массива в порядке возрастания в языке программирования C#?

#### **Удаление элемента из коллекции List**

Как удалить все вхождения определенного элемента из коллекции List в C#?

#### **Работа с коллекцией HashSet**

Как создать и использовать коллекцию HashSet в C#? Как проверить, содержится ли значение в HashSet?

#### **Многомерные коллекции**

Как создать и заполнить многомерную коллекцию List\<List\<int>> в C#?

#### **Работа с коллекцией Queue**

Как создать и использовать коллекцию Queue в C#? Как извлечь и вывести первый элемент из очереди?

***

## Тесты

{% embed url="<https://docs.google.com/forms/d/e/1FAIpQLSeuCLGrHTPcJov-iUvVxJ-wlqNQpJ3ypTLjp_i_mmbTsZYdmA/viewform?usp=sf_link>" fullWidth="true" %}