// Модифікатор доступу | Тип повернення | Ім'я | Параметри
public                  int              Add   (int a, int b)
{
    // Тіло методу (method body)
    return a + b;
}

// Без параметрів
public void SayHello()
{
    Console.WriteLine("Привіт!");
}

// З одним параметром
public void Greet(string name)
{
    Console.WriteLine($"Привіт, {name}!");
}

// З декількома параметрами
public double CalculateArea(double width, double height)
{
    return width * height;
}

// Виклики
SayHello();                           // Привіт!
Greet("Марія");                       // Привіт, Марія!
double area = CalculateArea(5.0, 3.0); // 15.0

public void IncrementValue(int num)
{
    num++; // Модифікується лише локальна копія
    Console.WriteLine($"Всередині методу: {num}");
}

int counter = 5;
Console.WriteLine($"До виклику: {counter}");     // До виклику: 5
IncrementValue(counter);                         // Всередині методу: 6
Console.WriteLine($"Після виклику: {counter}");  // Після виклику: 5 (не змінилось!)

public void IncrementValue(ref int num)
{
    num++; // Модифікує оригінальну змінну
    Console.WriteLine($"Всередині методу: {num}");
}

int counter = 5;
Console.WriteLine($"До виклику: {counter}");        // До виклику: 5
IncrementValue(ref counter);                        // Всередині методу: 6
Console.WriteLine($"Після виклику: {counter}");     // Після виклику: 6 (змінилось!)

public void Swap(ref int a, ref int b)
{
    int temp = a;
    a = b;
    b = temp;
}

int x = 10, y = 20;
Console.WriteLine($"До обміну: x={x}, y={y}");   // До обміну: x=10, y=20
Swap(ref x, ref y);
Console.WriteLine($"Після обміну: x={x}, y={y}"); // Після обміну: x=20, y=10

public bool TryDivide(int dividend, int divisor, out double result)
{
    if (divisor == 0)
    {
        result = 0; // Обов'язково присвоїти значення
        return false;
    }

    result = (double)dividend / divisor;
    return true;
}

// Виклик методу
double quotient;
if (TryDivide(10, 2, out quotient))
{
    Console.WriteLine($"Результат: {quotient}"); // Результат: 5
}
else
{
    Console.WriteLine("Ділення неможливе");
}

// Декларація змінної безпосередньо у виклику методу
if (TryDivide(10, 0, out double result))
{
    Console.WriteLine($"Результат: {result}");
}
else
{
    Console.WriteLine("Ділення неможливе"); // Це виконається
}

public void GetMinMax(int[] numbers, out int min, out int max)
{
    if (numbers.Length == 0)
    {
        min = 0;
        max = 0;
        return;
    }

    min = numbers[0];
    max = numbers[0];

    foreach (int num in numbers)
    {
        if (num < min) min = num;
        if (num > max) max = num;
    }
}

// Виклик
int[] data = { 5, 2, 9, 1, 7 };
GetMinMax(data, out int minimum, out int maximum);
Console.WriteLine($"Min: {minimum}, Max: {maximum}"); // Min: 1, Max: 9

public readonly struct LargeStruct
{
    public readonly double X, Y, Z;

    public LargeStruct(double x, double y, double z)
    {
        X = x;
        Y = y;
        Z = z;
    }
}

public double CalculateDistance(in LargeStruct point)
{
    // point.X = 5; // ПОМИЛКА КОМПІЛЯЦІЇ: не можна модифікувати 'in' параметр
    return Math.Sqrt(point.X * point.X + point.Y * point.Y + point.Z * point.Z);
}

// Виклик
LargeStruct p = new LargeStruct(3, 4, 5);
double distance = CalculateDistance(in p); // Передача за посиланням без копіювання
Console.WriteLine($"Відстань: {distance}");

public void Process(int x)
{
    Console.WriteLine("Process(int)");
}

public void Process(double x)
{
    Console.WriteLine("Process(double)");
}

Process(5);      // Process(int) - точний збіг
Process(5.0);    // Process(double) - точний збіг
Process(5L);     // ПОМИЛКА: неоднозначність (long може бути int або double)

public int CalculateFactorial(int n)
{
    // Валідація вхідних даних
    if (n < 0)
        throw new ArgumentOutOfRangeException(nameof(n), "Input must be non-negative.");

    return LocalFactorial(n);

    // Локальна функція
    int LocalFactorial(int num)
    {
        if (num == 0) return 1;
        return num * LocalFactorial(num - 1);
    }
}

// Виклик
Console.WriteLine(CalculateFactorial(5)); // 120

public void ProcessNumbers(int[] numbers)
{
    int multiplier = 2; // Зовнішня змінна

    // Локальна функція захоплює 'multiplier'
    void PrintMultiplied(int num)
    {
        Console.WriteLine(num * multiplier);
    }

    foreach (int num in numbers)
    {
        PrintMultiplied(num);
    }
}

// Виклик
ProcessNumbers(new[] { 1, 2, 3, 4, 5 }); // 2, 4, 6, 8, 10

public IEnumerable<int> GetEvenNumbers(int limit)
{
    // Валідація виконується негайно при виклику GetEvenNumbers
    if (limit > 100)
    {
        throw new ArgumentOutOfRangeException(nameof(limit), "Limit cannot exceed 100.");
    }

    return Iterator();

    // Локальна функція-ітератор
    IEnumerable<int> Iterator()
    {
        for (int i = 0; i <= limit; i += 2)
        {
            yield return i;
        }
    }
}

// Виклик
try
{
    foreach (var num in GetEvenNumbers(150)) // Виняток викидається тут!
    {
        Console.WriteLine(num);
    }
}
catch (ArgumentOutOfRangeException ex)
{
    Console.WriteLine($"Помилка: {ex.Message}");
}

// Звичайна рекурсія (НЕ tail recursion)
public int FactorialNormal(int n)
{
    if (n <= 1) return 1;
    return n * FactorialNormal(n - 1); // Після виклику ще є операція множення
}

// Tail recursion з акумулятором
public int FactorialTail(int n, int accumulator = 1)
{
    if (n <= 1) return accumulator;
    return FactorialTail(n - 1, n * accumulator); // Останній виклик - це рекурсія
}

error CS0029: Cannot implicitly convert type 'double' to 'int'

error CS1620: Argument 2 must be passed with the 'ref' keyword

Process is terminated due to StackOverflowException

error CS0136: A local or parameter named 'x' cannot be declared in this scope

A(m, n) =
  n + 1,                якщо m = 0
  A(m - 1, 1),          якщо m > 0 і n = 0
  A(m - 1, A(m, n - 1)), якщо m > 0 і n > 0

public int Ackermann(int m, int n)
{
    // TODO: реалізувати через локальну рекурсивну функцію
}

// Тест (ОБЕРЕЖНО: значення швидко зростають!)
Console.WriteLine(Ackermann(0, 5));  // 6
Console.WriteLine(Ackermann(1, 3));  // 5
Console.WriteLine(Ackermann(2, 2));  // 7
Console.WriteLine(Ackermann(3, 2));  // 29
// НЕ викликайте з великими значеннями! Ackermann(4, 2) вже містить тисячі рекурсивних викликів