// Створення масиву на 5 елементів
int[] numbers = new int[5];

// Присвоювання значень
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;

Console.WriteLine(numbers[0]); // 10

// Ініціалізація з явним типом та розміром
int[] numbers = new int[] { 10, 20, 30, 40, 50 };

// Скорочений синтаксис (тип виводиться автоматично)
int[] numbers2 = { 10, 20, 30, 40, 50 };

Console.WriteLine(numbers.Length); // 5

// Найсучасніший синтаксис
int[] numbers = [10, 20, 30, 40, 50];

// Порожній масив
int[] empty = [];

// Інші типи
string[] names = ["Alice", "Bob", "Charlie"];

// Оголошення зубчастого масиву з 3 рядків
int[][] jaggedArray = new int[3][];

// Ініціалізація кожного внутрішнього масиву окремо
jaggedArray[0] = new int[] { 1, 2, 3 };       // 3 елементи
jaggedArray[1] = new int[] { 4, 5 };          // 2 елементи
jaggedArray[2] = new int[] { 6, 7, 8, 9 };    // 4 елементи

// Доступ
Console.WriteLine(jaggedArray[0][0]); // 1
Console.WriteLine(jaggedArray[1][1]); // 5
Console.WriteLine(jaggedArray[2][3]); // 9

// Повна ініціалізація при створенні
int[][] numbers =
{
    new int[] { 1, 2, 3 },
    new int[] { 4, 5 },
    new int[] { 6, 7, 8, 9 }
};

// Скорочений синтаксис (C# 12+)
int[][] data =
[
    [1, 2, 3],
    [4, 5],
    [6, 7, 8, 9]
];

int[] numbers = [10, 20, 30, 40, 50];

// Перебір з індексом
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine($"Index {i}: {numbers[i]}");
}

// Зворотний перебір
for (int i = numbers.Length - 1; i >= 0; i--)
{
    Console.WriteLine(numbers[i]);
}

string[] fruits = ["Apple", "Banana", "Orange"];

// Простий перебір (read-only)
foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}

// ❌ Не можна змінювати елементи через foreach
// foreach (string fruit in fruits)
// {
//     fruit = "New"; // Помилка компіляції
// }

int[,] matrix = {
    { 1, 2, 3 },
    { 4, 5, 6 },
    { 7, 8, 9 }
};

// Вкладені цикли
for (int row = 0; row < matrix.GetLength(0); row++)
{
    for (int col = 0; col < matrix.GetLength(1); col++)
    {
        Console.Write($"{matrix[row, col]} ");
    }
    Console.WriteLine();
}

// Output:
// 1 2 3
// 4 5 6
// 7 8 9

int[][] jagged =
[
    [1, 2, 3],
    [4, 5],
    [6, 7, 8, 9]
];

// Перебір з вкладеними циклами
for (int i = 0; i < jagged.Length; i++)
{
    Console.Write($"Row {i}: ");
    for (int j = 0; j < jagged[i].Length; j++)
    {
        Console.Write($"{jagged[i][j]} ");
    }
    Console.WriteLine();
}

// Output:
// Row 0: 1 2 3
// Row 1: 4 5
// Row 2: 6 7 8 9

string[] fruits = ["Apple", "Banana", "Orange", "Banana"];

// IndexOf - перше входження
int index1 = Array.IndexOf(fruits, "Banana");
Console.WriteLine(index1); // 1

// LastIndexOf - останнє входження
int index2 = Array.LastIndexOf(fruits, "Banana");
Console.WriteLine(index2); // 3

// Якщо не знайдено - повертає -1
int index3 = Array.IndexOf(fruits, "Grape");
Console.WriteLine(index3); // -1

int[] numbers = [1, 5, 10, 15, 20, 25];

// Find - перший елемент, що відповідає умові
int first = Array.Find(numbers, x => x > 10);
Console.WriteLine(first); // 15

// FindAll - всі елементи, що відповідають умові
int[] filtered = Array.FindAll(numbers, x => x > 10);
Console.WriteLine(string.Join(", ", filtered));
// Output: 15, 20, 25

// FindIndex - індекс першого елемента
int index = Array.FindIndex(numbers, x => x > 10);
Console.WriteLine(index); // 3

int[] numbers = [2, 4, 6, 8, 10];

// Exists - чи є хоча б один елемент, що відповідає умові
bool hasOdd = Array.Exists(numbers, x => x % 2 != 0);
Console.WriteLine(hasOdd); // false

// TrueForAll - чи всі елементи відповідають умові
bool allEven = Array.TrueForAll(numbers, x => x % 2 == 0);
Console.WriteLine(allEven); // true

int[] scores = [85, 92, 78, 95, 88, 76];

// Сума
int sum = 0;
foreach (int score in scores)
{
    sum += score;
}
Console.WriteLine($"Sum: {sum}"); // 514

// Середнє значення
double average = (double)sum / scores.Length;
Console.WriteLine($"Average: {average:F2}"); // 85.67

// Максимум та мінімум
int max = scores[0];
int min = scores[0];
foreach (int score in scores)
{
    if (score > max) max = score;
    if (score < min) min = score;
}
Console.WriteLine($"Max: {max}, Min: {min}"); // Max: 95, Min: 76

string[] students = ["Anna", "Bohdan", "Olena", "Dmytro"];
string searchName = "Olena";

// Лінійний пошук
int foundIndex = -1;
for (int i = 0; i < students.Length; i++)
{
    if (students[i] == searchName)
    {
        foundIndex = i;
        break;
    }
}

if (foundIndex != -1)
{
    Console.WriteLine($"Found at index: {foundIndex}");
}
else
{
    Console.WriteLine("Not found");
}

// Використання Array.IndexOf
int index = Array.IndexOf(students, searchName);
Console.WriteLine(index != -1 ? $"Found at {index}" : "Not found");

int[] numbers = [12, 5, 23, 8, 15, 30, 7];

// Фільтр: тільки парні числа більші за 10
int count = 0;
foreach (int num in numbers)
{
    if (num > 10 && num % 2 == 0)
        count++;
}

int[] filtered = new int[count];
int index = 0;
foreach (int num in numbers)
{
    if (num > 10 && num % 2 == 0)
        filtered[index++] = num;
}

Console.WriteLine(string.Join(", ", filtered));
// Output: 12, 30

int[,] matrixA = {
    { 1, 2 },
    { 3, 4 }
};

int[,] matrixB = {
    { 5, 6 },
    { 7, 8 }
};

int rows = matrixA.GetLength(0);
int cols = matrixB.GetLength(1);
int[,] result = new int[rows, cols];

for (int i = 0; i < rows; i++)
{
    for (int j = 0; j < cols; j++)
    {
        result[i, j] = 0;
        for (int k = 0; k < matrixA.GetLength(1); k++)
        {
            result[i, j] += matrixA[i, k] * matrixB[k, j];
        }
    }
}

// Виведення результату
for (int i = 0; i < rows; i++)
{
    for (int j = 0; j < cols; j++)
    {
        Console.Write($"{result[i, j]} ");
    }
    Console.WriteLine();
}
// Output:
// 19 22
// 43 50

int[] numbers = [1, 2, 3, 4, 5];

// Помилка: індекс виходить за межі
for (int i = 0; i <= numbers.Length; i++) // <=  замість <
{
    Console.WriteLine(numbers[i]);
    // ❌ Exception при i = 5
}

int[] numbers = [1, 2, 3, 4, 5];

// Правильна умова
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

int[] numbers = [1, 2, 3, 4, 5];

// Безпечний доступ з перевіркою
int index = 10;
if (index >= 0 && index < numbers.Length)
{
    Console.WriteLine(numbers[index]);
}
else
{
    Console.WriteLine("Invalid index");
}

int[] numbers = null;

// ❌ NullReferenceException
Console.WriteLine(numbers.Length);

int[]? numbers = null;

// Перевірка на null перед доступом
if (numbers != null)
{
    Console.WriteLine(numbers. Length);
}
else
{
    Console.WriteLine("Array is null");
}

// Або з null-conditional operator
Console.WriteLine(numbers?.Length ?? 0);

int[,] matrix = new int[3, 4];

// ❌ Неправильно: використання Length
for (int i = 0; i < matrix.Length; i++) // Length = 12!
{
    // matrix[i] - синтаксична помилка
}

int[,] matrix = new int[3, 4];

// ✅ Правильно: GetLength для кожного виміру
for (int i = 0; i < matrix.GetLength(0); i++)
{
    for (int j = 0; j < matrix.GetLength(1); j++)
    {
        Console.Write($"{matrix[i, j]} ");
    }
    Console.WriteLine();
}