Завдання

Відповідно до номера свого варіанта виконайте завдання обраного рівня складності.

Варіанти

Варіант 1. Прості множники

1. Початковий рівень. Створити консольну програму з методом static bool IsPrime(int n) і рекурсивним методом static void PrintFactors(int n, int divisor), яка для числа 3 960 (задане в програмі) виводить розклад на прості множники у вигляді 2 · 2 · 2 · 3 · 3 · 5 · 11.

2. Базовий рівень. Створити консольну програму з перевантаженими методами Factorize для int і long, які повертають рядок розкладу у форматі степенів (2^3 · 3^2 · 5 · 11) і через out-параметр кількість різних простих множників. Програма в циклі запитує числа, перевіряє введення та виводить розклад, кількість дільників числа й відповідь, чи є число простим.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який розкладає на прості множники числа з аргументів (тип long) рекурсивним методом з мемоізацією найменших простих дільників до 10 000 000 (решето у масиві) та виводить таблицю «число – розклад – кількість дільників – сума дільників». Опції --gcd і --lcm обчислюють НСД і НСК усіх чисел через їхні розклади. Кожен метод має XML-коментар; некоректні числа повідомляються в потік помилок; коди завершення: 0, 1, 2.

Варіант 2. Перетворювач одиниць

1. Початковий рівень. Створити консольну програму з методами static double KmToMiles(double km), static double KgToPounds(double kg) і static double LitersToGallons(double liters), яка виводить таблицю перетворення для значень 1, 5, 10 і 42,195 кожної одиниці.

2. Базовий рівень. Створити консольну програму зі статичним класом Units, що містить перевантажені методи Convert(double value, LengthUnit from, LengthUnit to) для довжини (одиниці задаються рядками m, km, mi, ft) з необов’язковим параметром decimals для округлення. Програма запитує значення та одиниці, перевіряє введення і виводить результат; виклики методу використовують іменовані аргументи.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який перетворює величини довжини, маси, об’єму та температури, передані аргументами у форматі значення одиниця to одиниця (наприклад, 10 mi to km, 98.6 F to C). Кожна категорія реалізована окремим методом, що через out повертає результат і bool – чи підтримуються одиниці; спільний метод TryConvert визначає категорію. Опція --table категорія виводить таблицю коефіцієнтів. Помилки виводяться в потік помилок з кодом завершення 2.

Варіант 3. Перестановки та сполучення

1. Початковий рівень. Створити консольну програму з рекурсивним методом static long Factorial(int n) і методами Permutations(int n, int k) та Combinations(int n, int k), яка виводить кількість розміщень і сполучень з 10 по 3 та трикутник значень C(n, k) для n від 0 до 8.

2. Базовий рівень. Створити консольну програму, яка запитує рядок із різних символів (до 8) і рекурсивним методом генерує та виводить усі перестановки символів, використовуючи метод Swap з параметрами ref, а також усі сполучення з k символів; кількості перевіряються формулами, факторіал обчислюється в контексті checked.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який генерує перестановки (--perm), розміщення (--arr k) і сполучення (--comb k) елементів з аргументів, з опцією --unique для множин із повторами (без повторних результатів) і --next (наступна перестановка в лексикографічному порядку без генерації всіх). Кількість результатів обчислюється через checked-арифметику з повідомленням про переповнення; опція --count виводить лише кількість. Помилки – у потік помилок з кодом завершення 2.

Варіант 4. Швидке сортування та злиття

1. Початковий рівень. Створити консольну програму з рекурсивним методом static void QuickSort(int[] a, int left, int right) (опорний елемент – середній) і методом Partition, яка сортує масив із 12 чисел (задані в програмі) та виводить масив до і після сортування.

2. Базовий рівень. Створити консольну програму з методами QuickSort і MergeSort (з допоміжним масивом), які через ref-параметр рахують кількість порівнянь. Програма запитує розмір масиву, заповнює його випадковими числами, сортує дві копії, перевіряє впорядкованість окремим методом IsSorted і виводить кількість порівнянь для обох алгоритмів.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який порівнює рекурсивні quicksort (опорний елемент --pivot first|middle|random), merge sort і Array.Sort на масивах розмірів --sizes і типів --data random|sorted|reversed. Програма вимірює час Stopwatch, максимальну глибину рекурсії (параметр depth) і кількість порівнянь та виводить таблицю; для quicksort на впорядкованих даних показує, як зростає глибина рекурсії. Помилки опцій – у потік помилок з кодом 2.

Варіант 5. Трикутник Серпінського

1. Початковий рівень. Створити консольну програму з рекурсивним методом, який заповнює символьну матрицю розміром 16×32 трикутником Серпінського порядку 4 (трикутник порядку n складається з трьох трикутників порядку n − 1), і методом Print(char[,] canvas), що виводить матрицю.

2. Базовий рівень. Створити консольну програму, яка запитує порядок фрактала (від 0 до 6) та символ заповнення і рекурсивними методами будує й виводить трикутник Серпінського та килим Серпінського, а також кількість заповнених клітинок кожного фрактала, обчислену окремим рекурсивним методом без побудови малюнка.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який малює фрактали --fractal triangle|carpet|cantor|h-tree порядку --order у символьній матриці та зберігає результат у стандартний вихід. Розмір матриці обчислюється окремим методом; якщо він перевищує --max-width, програма повідомляє про це в потік помилок з кодом завершення 1. Опція --count виводить таблицю кількості елементів для порядків від 0 до заданого та перевіряє її рекурсивною формулою.

Варіант 6. Розмін суми монетами

1. Початковий рівень. Створити консольну програму з рекурсивним методом CountWays(int amount, int[] coins, int index), яка обчислює кількість способів розміняти 50 копійок монетами 1, 2, 5, 10, 25 і 50 копійок та виводить результат.

2. Базовий рівень. Створити консольну програму, яка запитує суму та номінали монет, обчислює кількість способів розміну рекурсивним методом з мемоізацією (масив long[,]), виводить час обчислення з мемоізацією й без неї для суми до 200, а також мінімальну кількість монет окремим рекурсивним методом.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який для суми --amount і номіналів --coins обчислює кількість способів розміну, мінімальну кількість монет і з опцією --list N виводить перші N способів у вигляді 25 × 1 + 10 × 2 + 5 × 1. Опція --limit задає обмежену кількість монет кожного номіналу. Результати в типі long обчислюються з перевіркою переповнення; помилки – у потік помилок з кодом завершення 2.

Варіант 7. Визначник матриці

1. Початковий рівень. Створити консольну програму з рекурсивним методом static double Determinant(double[,] m), що обчислює визначник розкладом за першим рядком, і допоміжним методом Minor, яка виводить визначник матриці 3×3 (задана в програмі).

2. Базовий рівень. Створити консольну програму, яка запитує порядок матриці (від 1 до 7) та її елементи, обчислює визначник рекурсивним розкладом за рядком і методом Гаусса (окремі методи), порівнює результати з допуском і виводить кількість рекурсивних викликів, передану через ref-лічильник.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який зчитує квадратну матрицю зі стандартного введення та з опціями --method laplace|gauss, --inverse і --solve (стовпець вільних членів) обчислює визначник, обернену матрицю методом алгебраїчних доповнень і розв’язок системи за формулами Крамера. Методи мають XML-коментарі; вироджена матриця повідомляється в потік помилок з кодом завершення 1, некоректне введення – з кодом 2.

Варіант 8. Результати забігу

1. Початковий рівень. Створити консольну програму з методом static int ParseTime(string text), що перетворює час забігу гг:хх:сс на секунди, і методом FormatTime(int seconds), яка для п’яти результатів (задані в програмі) виводить час у секундах, найкращий результат і середній темп на кілометр для дистанції 10 км.

2. Базовий рівень. Створити консольну програму з методом bool TryParseTime(string text, out int seconds) і методом Analyze(int[] times, out int best, out int worst), що повертає середній час. Програма зчитує результати бігунів у форматі ім’я гг:хх:сс до порожнього рядка, відхиляє некоректні записи та виводить таблицю з темпом, відставанням від лідера й місцем кожного учасника.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який обробляє протокол забігу зі стандартного введення (номер;ім’я;стать;рік;час) з опціями --distance км, --category (вікові групи) і --top N. Методи з out-параметрами розбирають рядки, обчислюють місця в абсолютному заліку та в категоріях (однаковий час – однакове місце) і темп; результат виводиться таблицями. Некоректні рядки – у потік помилок із номером рядка; коди завершення: 0, 1, 2.

Варіант 9. Ротація масиву

1. Початковий рівень. Створити консольну програму з методом static void Reverse(int[] a, int from, int to) і методом RotateLeft(int[] a, int k), що виконує циклічний зсув ліворуч трьома розворотами частин масиву, яка виводить масив із 10 чисел (задані в програмі) після зсуву на 3 позиції.

2. Базовий рівень. Створити консольну програму з методом Rotate(int[] a, int k, bool left = true) (зсув на k позицій алгоритмом трьох розворотів) і методом Swap(ref int x, ref int y). Програма зчитує масив і послідовність команд L k / R k до порожнього рядка, виводить масив після кожної команди та загальну кількість обмінів, накопичену через ref-лічильник.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який реалізує три алгоритми циклічного зсуву масиву: послідовні зсуви на 1, три розвороти та цикли заміни (через НСД довжини і k), рахує кількість присвоювань через ref-параметр і порівнює їх для розмірів --sizes і зсувів --shifts. Опція --swap-blocks a,b,c міняє місцями два суміжні блоки масиву. Результати виводяться таблицею; помилки опцій – у потік помилок з кодом завершення 2.

Варіант 10. Числа Каталана

1. Початковий рівень. Створити консольну програму з рекурсивним методом static long Catalan(int n) за формулою C₀ = 1, C_n+1 = Σ C_i·C_n−i, яка виводить перші 12 чисел Каталана.

2. Базовий рівень. Створити консольну програму, яка запитує n (до 35) та обчислює n-не число Каталана трьома методами: прямою рекурсією, рекурсією з мемоізацією та через біноміальний коефіцієнт (checked), виводячи результат, кількість рекурсивних викликів (ref-лічильник) і час кожного методу.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який рекурсивно генерує всі правильні дужкові послідовності з n пар дужок (--brackets n), усі способи розставити дужки в добутку --products n і всі тріангуляції опуклого многокутника (--triangulations n), перевіряючи, що кількість результатів дорівнює числу Каталана. Опція --count-only виводить лише кількості для n від 1 до заданого. Помилки опцій – у потік помилок з кодом завершення 2.

Варіант 11. Вихід з лабіринту

1. Початковий рівень. Створити консольну програму з рекурсивним методом static bool FindPath(char[,] maze, int row, int col), який шукає шлях від лівого верхнього до правого нижнього кута лабіринту 6×8 (заданого в програмі, # – стіна), позначає шлях символом * і виводить лабіринт.

2. Базовий рівень. Створити консольну програму, яка зчитує лабіринт рядками до порожнього рядка, знаходить позиції S і F окремим методом з out-параметрами і рекурсивним пошуком у глибину з поверненням знаходить шлях, виводячи лабіринт зі шляхом, довжину шляху та кількість відвіданих клітинок.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який для лабіринту зі стандартного введення рекурсивним перебором з поверненням знаходить усі прості шляхи (--all, з обмеженням --limit), найкоротший шлях (перебір з відсіканням довших за знайдений) і кількість різних шляхів. Опція --generate W×H --seed S генерує лабіринт рекурсивним алгоритмом «пошук у глибину». Глибина рекурсії контролюється параметром; перевищення --max-depth повідомляється в потік помилок з кодом 1.

Варіант 12. Вісім ферзів

1. Початковий рівень. Створити консольну програму з рекурсивним методом розстановки ферзів на дошці 8×8 з поверненням і методом IsSafe(int[] queens, int row, int col), яка знаходить і виводить першу розстановку у вигляді шахової дошки.

2. Базовий рівень. Створити консольну програму, яка запитує розмір дошки N (від 4 до 12) і рекурсивним перебором з поверненням знаходить кількість усіх розстановок N ферзів, виводить першу з них та кількість викликів рекурсивного методу, накопичену через ref-параметр.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який для дошок --sizes 4-14 підраховує кількість розв’язків задачі про ферзів, використовуючи оптимізований перебір із масивами зайнятих стовпців і діагоналей (або бітові маски з --bits), кількість унікальних розв’язків без урахування поворотів і віддзеркалень (--unique) і час роботи. Опція --show N виводить N розв’язків. Помилки – у потік помилок з кодом завершення 2.

Варіант 13. Судоку

1. Початковий рівень. Створити консольну програму з методами IsValidRow, IsValidColumn і IsValidBox (параметри – масив int[,] і номер рядка, стовпця або блоку) та методом IsValid, яка перевіряє заповнену сітку судоку 9×9 (задану в програмі) і виводить результат перевірки.

2. Базовий рівень. Створити консольну програму, яка зчитує судоку з 9 рядків (0 або . – порожня клітинка), перевіряє коректність початкових значень і рекурсивним перебором з поверненням розв’язує головоломку, виводячи сітку з рамкою та кількість спроб; якщо розв’язку немає, програма повідомляє про це.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який розв’язує судоку зі стандартного введення (кілька головоломок, розділених порожнім рядком), обираючи на кожному кроці клітинку з найменшою кількістю можливих значень, перевіряє єдиність розв’язку (--unique) і виводить таблицю «номер – складність (кількість повернень) – час». Некоректні головоломки повідомляються в потік помилок; коди завершення: 0, 1 (є нерозв’язні), 2.

Варіант 14. Перевірка РНОКПП

1. Початковий рівень. Створити консольну програму з методом static bool IsValidTaxId(string id), який для 10-значного реєстраційного номера облікової картки платника податків (заданого в програмі) обчислює контрольну цифру: сума перших дев’яти цифр, помножених на ваги −1, 5, 7, 9, 4, 6, 10, 5, 7, береться за модулем 11, а потім за модулем 10.

2. Базовий рівень. Створити консольну програму з методом bool TryParseTaxId(string text, out DateTime birthDate, out bool isMale): перші п’ять цифр номера – кількість днів від 31.12.1899, дев’ята цифра непарна для чоловіків і парна для жінок. Програма в циклі зчитує номери, перевіряє формат і контрольну цифру та виводить дату народження, стать і вік.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main і набором статичних методів перевірки з однаковою сигнатурою bool Check(string id, out string error), який перевіряє номери зі стандартного введення (формат, контрольна цифра, реальність дати, вік від 14 до 120 років) і виводить звіт «номер (замаскований) – результат – причини». Опція --generate дата стать генерує коректний номер. Коди завершення: 0, 1 (є некоректні), 2.

Варіант 15. Податок ФОП

1. Початковий рівень. Створити консольну програму з методом static decimal SingleTax(decimal income, decimal rate = 0.05m), яка для квартальних доходів ФОП третьої групи (задані в програмі) обчислює єдиний податок за ставкою 5 % і виводить податок за кожен квартал та за рік.

2. Базовий рівень. Створити консольну програму з перевантаженими методами CalculateTax: для третьої групи (дохід і необов’язкова ставка 3 або 5 %) та для першої й другої груп (фіксована щомісячна сума й кількість місяців), а також з методом військового збору. Ставки, фіксовані суми й ліміти доходу задаються константами. Програма запитує групу, дані й виводить податки, викликаючи методи з іменованими аргументами.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який зчитує журнал доходів ФОП за рік (дата;сума;валюта) зі стандартного введення, перераховує валюту за курсами з опції --rates, обчислює доходи й податки за кварталами для групи --group, перевіряє перевищення річного ліміту та порівнює податкове навантаження в різних групах. Параметри (ставки, ліміти) передаються методам як необов’язкові з можливістю перевизначення опціями. Помилки – у потік помилок; коди завершення: 0, 1, 2.

Варіант 16. Розбір дат

1. Початковий рівень. Створити консольну програму з методом static bool IsLeapYear(int year) і методом static int DaysInMonth(int month, int year), яка без DateTime перевіряє коректність дат 29.02.2024, 29.02.2026, 31.04.2026 і 15.13.2026 (задані в програмі) та виводить результат для кожної.

2. Базовий рівень. Створити консольну програму з методом bool TryParseDate(string text, out int day, out int month, out int year), який приймає формати дд.ММ.рррр, рррр-ММ-дд і д/М/рррр, та з методом int DayOfYear(int day, int month, int year). Програма в циклі зчитує дати й виводить номер дня в році, кількість днів до кінця року та день тижня, обчислений окремим методом без DateTime.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main з набором методів TryParseXxx з out-результатами для дат, часу (гг:хх[:сс]) і тривалостей (1h 30m, 90min, PT1H30M), які перевіряються на аргументах і стандартному введенні. Опція --add дата тривалість додає тривалість до дати, --diff дата1 дата2 виводить різницю в днях, годинах і хвилинах. Результати звіряються з DateTime при --verify. Помилки – у потік помилок; коди завершення: 0, 1, 2.

Варіант 17. Функція Аккермана

1. Початковий рівень. Створити консольну програму з рекурсивним методом static long Ackermann(long m, long n) (A(0, n) = n + 1, A(m, 0) = A(m − 1, 1), A(m, n) = A(m − 1, A(m, n − 1))), яка виводить таблицю значень для m від 0 до 3 і n від 0 до 4.

2. Базовий рівень. Створити консольну програму, яка запитує m (0–3) і n (0–10) та обчислює функцію Аккермана рекурсивним методом, що через ref-параметри рахує кількість викликів і максимальну глибину рекурсії, і виводить значення, кількість викликів і глибину; для небезпечно великих аргументів програма попереджає і не запускає обчислення.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який обчислює функцію Аккермана трьома способами: рекурсивно, з мемоізацією для малих значень і без рекурсії з явним стеком на масиві, а також функцію Маккарті 91 і функцію Такеучі. Для кожного способу виводиться значення, кількість викликів або ітерацій і максимальна глибина; опція --max-depth обмежує рекурсію та повідомляє в потік помилок про перевищення з кодом завершення 1.

Варіант 18. Швидке піднесення до степеня

1. Початковий рівень. Створити консольну програму з двома методами піднесення до степеня: простим множенням у циклі та рекурсивним швидким алгоритмом (xⁿ = (x^n/2)²), які через out-параметр повертають кількість множень, яка виводить результати для 3²⁰ обома методами.

2. Базовий рівень. Створити консольну програму з перевантаженими методами Power для long (з перевіркою переповнення) і double (зокрема для від’ємного степеня) та методом PowerMod(long x, long n, long mod). Програма запитує основу, показник і модуль, перевіряє введення та виводить результати й кількість множень для рекурсивного та ітеративного варіантів.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який реалізує швидке піднесення до степеня за модулем для long без переповнення (множення за модулем через додавання або Math.BigMul), тест простоти Міллера – Рабіна для чисел з аргументів і обчислення n-го числа Фібоначчі за модулем через піднесення матриці 2×2 до степеня. Опція --steps виводить кроки алгоритму. Помилки – у потік помилок з кодом завершення 2.

Варіант 19. Геометричні фігури

1. Початковий рівень. Створити консольну програму з перевантаженими методами Area у статичному класі Geometry: Area(double radius) для круга, Area(double width, double height) для прямокутника та Area(double a, double b, double c) для трикутника (формула Герона), яка виводить площі фігур із заданими в програмі розмірами.

2. Базовий рівень. Створити консольну програму зі статичним класом Geometry, що містить перевантажені методи Area і Perimeter для круга, прямокутника й трикутника та метод bool TryTriangle(double a, double b, double c, out double area). Програма в меню запитує тип фігури й розміри, перевіряє існування фігури та виводить результати з необов’язковим параметром кількості знаків після коми.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який обробляє фігури з аргументів у форматі circle:r, rect:w:h, tri:a:b:c, poly:x1,y1;x2,y2;… (площа многокутника за формулою шнурування), обчислює площу, периметр і радіуси вписаного та описаного кіл (де можливо) перевантаженими методами та виводить таблицю з підсумковою площею. Опції --units і --decimals передаються методам як іменовані аргументи; некоректні фігури – у потік помилок; коди завершення: 0, 1, 2.

Варіант 20. Робот на сітці

1. Початковий рівень. Створити консольну програму з рекурсивним методом static long CountPaths(int rows, int cols), який рахує кількість маршрутів робота з лівого верхнього в правий нижній кут сітки, якщо робот рухається лише праворуч або вниз, і виводить результати для сіток від 2×2 до 6×6.

2. Базовий рівень. Створити консольну програму, яка запитує розміри сітки (до 18×18) і координати перешкод, обчислює кількість маршрутів рекурсивним методом з мемоізацією (масив long[,], значення −1 – не обчислено), порівнює з прямою рекурсією для сіток до 12×12 і виводить кількість рекурсивних викликів в обох випадках.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який для сітки зі стандартного введення (. – вільно, # – перешкода, цифри – вартість клітинки) обчислює кількість маршрутів, маршрут мінімальної вартості та виводить його на сітці. Опція --moves right,down,diag задає дозволені ходи, --max-length обмежує довжину маршруту. Мемоізація реалізується окремим методом з параметрами-масивами; некоректна сітка – у потік помилок з кодом 2.

Варіант 21. Розбиття числа

1. Початковий рівень. Створити консольну програму з рекурсивним методом static int CountPartitions(int n, int max), який обчислює кількість способів записати число як суму натуральних доданків (порядок не важливий), і виводить кількості розбиттів для чисел від 1 до 20.

2. Базовий рівень. Створити консольну програму, яка запитує число n (до 30) і рекурсивним методом виводить усі розбиття n на доданки в порядку незростання (5 = 3 + 1 + 1), використовуючи масив поточних доданків і параметр глибини, а також кількість розбиттів, обчислену методом з мемоізацією.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який генерує розбиття числа з обмеженнями: --distinct (різні доданки), --odd (непарні доданки), --parts k (рівно k доданків), --max m (доданки не більші за m), перевіряє теорему Ейлера (кількість розбиттів на різні доданки дорівнює кількості розбиттів на непарні) для n до заданого та виводить таблицю кількостей. Помилки опцій – у потік помилок з кодом завершення 2.

Варіант 22. Розворот рядка рекурсією

1. Початковий рівень. Створити консольну програму з рекурсивними методами static string Reverse(string s) і static int CountChar(string s, char c, int index), яка для рядка «рекурсія» (заданого в програмі) виводить обернений рядок і кількість літер «р».

2. Базовий рівень. Створити консольну програму, яка в циклі зчитує речення та рекурсивними методами без циклів виводить речення з оберненим порядком слів, кожне слово в оберненому вигляді, кількість голосних і рядок без повторних сусідніх символів; порожній рядок завершує роботу.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який обробляє рядки зі стандартного введення рекурсивними методами з параметрами-індексами (без створення підрядків): перевірка збалансованості дужок ()[]{}, пошук найдовшого спільного префікса аргументів, рекурсивне стиснення aaabcc → a3bc2 і розпакування a3bc2, порівняння з ітеративними реалізаціями за часом для рядків довжини --length. Помилки – у потік помилок з кодом завершення 2.

Варіант 23. Гра «Ним»

1. Початковий рівень. Створити консольну програму з методами static bool IsWinning(int[] heaps) (XOR розмірів купок не дорівнює нулю) і static void BestMove(int[] heaps, out int heap, out int take), яка для купок 3, 4, 5 (задані в програмі) виводить виграшний хід.

2. Базовий рівень. Створити консольну програму для гри «Ним» людини з комп’ютером: купки вводить користувач, гравці по черзі забирають будь-яку кількість предметів з однієї купки, хто забирає останній – виграє. Хід комп’ютера обирає метод з out-параметрами; хід людини перевіряє метод TryReadMove.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, у якому комп’ютер обирає хід рекурсивним перебором з мемоізацією позицій (для варіанта гри --variant subtract:1,3,4 – дозволені кількості) або формулою XOR для класичного варіанта, і перевіряє, що перебір і формула дають однаковий результат для всіх позицій до --max. Опція --misere змінює правило (програє той, хто бере останнім). Помилки – у потік помилок з кодом завершення 2.

Варіант 24. Двійкові рядки

1. Початковий рівень. Створити консольну програму з рекурсивним методом static void Generate(string prefix, int length), який виводить усі двійкові рядки довжини 5 без двох одиниць поспіль, та методом, що рахує їх кількість.

2. Базовий рівень. Створити консольну програму, яка запитує довжину n (до 25) і рекурсивними методами генерує рядки без двох одиниць поспіль, рядки з рівною кількістю нулів і одиниць та коди Грея довжини n, виводячи перші 20 рядків кожного виду та їх кількість (перевіряється формулою).

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який генерує двійкові рядки довжини --length з обмеженнями --no "11,000" (заборонені підрядки), --ones k (рівно k одиниць) і --palindrome, використовуючи рекурсивну генерацію з відсіканням, а також підраховує їх кількість рекурсією з мемоізацією за станом (позиція, кінцівка). Результати порівнюються; помилки опцій – у потік помилок з кодом 2.

Варіант 25. Метеостанція

1. Початковий рівень. Створити консольну програму з методами Average(double[] values), Max(double[] values, out int index) і CountBelow(double[] values, double limit = 0), яка для температур за тиждень (задані в програмі) виводить середню, максимальну температуру з днем тижня та кількість морозних днів.

2. Базовий рівень. Створити консольну програму зі статичним класом Weather, що містить перевантажені методи аналізу для масиву температур за тиждень (double[]) і матриці температур за кілька тижнів (double[,]): середнє, амплітуда, найтепліший день або тиждень через out-параметри. Програма зчитує дані, перевіряє їх і виводить звіт.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який обробляє погодинні виміри температури, вологості та тиску зі стандартного введення, групує їх методами за днями й тижнями, обчислює статистики перевантаженими методами (params double[] для довільних рядів) і виводить звіт із рекордами та днями різкої зміни тиску (--pressure-drop). Некоректні рядки – у потік помилок; коди завершення: 0, 1, 2.

Варіант 26. Задача про рюкзак

1. Початковий рівень. Створити консольну програму з рекурсивним методом static int Best(int[] weights, int[] values, int index, int capacity), яка для 5 предметів (ваги й цінності задані в програмі) та рюкзака місткістю 10 кг виводить максимальну сумарну цінність.

2. Базовий рівень. Створити консольну програму, яка зчитує предмети у форматі назва вага цінність до порожнього рядка та місткість рюкзака, обчислює максимальну цінність рекурсією з мемоізацією (int[,]), відновлює набір обраних предметів окремим методом і виводить таблицю предметів, сумарну вагу й цінність та кількість рекурсивних викликів.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який розв’язує задачу про рюкзак для предметів зі стандартного введення трьома методами: повним рекурсивним перебором, рекурсією з мемоізацією та жадібним алгоритмом за питомою цінністю, порівнює результати й час та, з опцією --unbounded, дозволяє брати предмет кілька разів. Опція --capacity обов’язкова; помилки – у потік помилок з кодом 2.

Варіант 27. Ієрархія підрозділів

1. Початковий рівень. Створити консольну програму, у якій структура підприємства задана паралельними масивами назв підрозділів, індексів батьківських підрозділів (−1 для кореня) і кількості працівників, і яка рекурсивним методом PrintTree(int node, int level) виводить дерево з відступами.

2. Базовий рівень. Створити консольну програму з рекурсивними методами, які для структури підприємства (зчитується рядками назва;батько;працівники;фонд оплати) обчислюють загальну кількість працівників і фонд оплати кожного підрозділу разом із підпорядкованими, глибину дерева та шлях від кореня до підрозділу, назву якого вводить користувач.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який зчитує ієрархію зі стандартного введення, перевіряє її коректність рекурсивним методом (один корінь, відсутність циклів, існування батьків), виводить дерево з рамками ├──, └──, підсумки за гілками, найглибший підрозділ і з опцією --move вузол новий_батько переносить гілку з перевіркою відсутності циклу. Помилки – у потік помилок; коди завершення: 0, 1, 2.

Варіант 28. Хід коня

1. Початковий рівень. Створити консольну програму з методом static bool IsValidMove(int row, int col, int[,] board) і методом, що виводить усі можливі ходи коня з клітинки b1 на порожній дошці 8×8 у шаховій нотації.

2. Базовий рівень. Створити консольну програму, яка запитує розмір дошки (5–8) і початкову клітинку та рекурсивним перебором з поверненням знаходить обхід дошки конем (кожна клітинка відвідується один раз), виводячи дошку з номерами ходів і кількість викликів рекурсивного методу або повідомлення, що обходу немає.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який знаходить обхід дошки конем для розмірів до 30×30, використовуючи евристику Варнсдорфа (хід у клітинку з найменшою кількістю подальших ходів) з рекурсивним поверненням у разі глухого кута, перевіряє замкненість обходу (--closed) і порівнює кількість повернень з чистим перебором для малих дошок. Результат виводиться дошкою або списком ходів (--format board|moves); помилки – у потік помилок з кодом 2.

Варіант 29. Вартість доставки

1. Початковий рівень. Створити консольну програму з перевантаженими методами Cost у статичному класі Delivery: для документа (кількість сторінок), посилки (вага в кг) і вантажу (вага та об’єм), яка виводить вартість доставки для прикладів, заданих у програмі.

2. Базовий рівень. Створити консольну програму зі статичним класом Delivery з перевантаженими методами Cost для посилки й вантажу, які мають необов’язкові параметри express = false, insuranceValue = 0 і courier = false, та методом TryReadWeight. Програма запитує тип відправлення та параметри, перевіряє введення й виводить деталізацію вартості; виклики використовують іменовані аргументи.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який обчислює вартість відправлень зі стандартного введення (тип;вага;розміри;відстань;опції) з тарифною сіткою з опції --tariffs, об’ємною вагою (довжина × ширина × висота / 4000), знижками для кількох відправлень (params-метод підсумку) і округленням до копійок у decimal. Звіт – таблиця з підсумком; некоректні рядки – у потік помилок; коди завершення: 0, 1, 2.

Варіант 30. Заливка області

1. Початковий рівень. Створити консольну програму з рекурсивним методом static void Fill(char[,] image, int row, int col, char oldChar, char newChar), яка заливає область символьного зображення 8×12 (задане в програмі), починаючи із заданої клітинки, та виводить зображення до і після.

2. Базовий рівень. Створити консольну програму, яка зчитує символьне зображення рядками до порожнього рядка, запитує координати та символ заливки, виконує рекурсивну заливку з 4-зв’язністю або 8-зв’язністю (необов’язковий параметр методу) і виводить результат, кількість змінених клітинок (повертається методом) і кількість окремих областей у зображенні.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який для символьного зображення зі стандартного введення виконує заливку рекурсивно та без рекурсії (явний стек на масиві координат), порівнює максимальну глибину рекурсії та розмір стеку для великих областей (--generate W×H), знаходить усі зв’язні області з їхніми площами та межами (--regions). Якщо глибина рекурсії перевищує --max-depth, рекурсивний варіант не запускається, а про це повідомляється в потік помилок.

Порядок виконання та захисту роботи

1. Опрацювати теоретичні відомості та приклади розв’язання завдань.
2. Розбити задачу свого варіанта на методи: для кожного визначити назву, параметри, спосіб їх передавання та тип результату; основна програма має лише викликати методи.
3. Створити рішення та проєкт для свого варіанта завдання.
4. Реалізувати методи відповідно до обраного рівня складності; задокументувати публічні методи XML-коментарями ///.
5. Перевірити кожен метод на звичайних і граничних значеннях; для рекурсивних методів переглянути вікно Call Stack і переконатися, що рекурсія завершується.
6. Продемонструвати роботу програми викладачеві, пояснити програмний код і відповісти на контрольні питання.