Завдання

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

Варіанти

Варіант 1. Числа Фібоначчі

1. Початковий рівень. Створити консольну програму, яка виводить перші 20 чисел Фібоначчі (кожне наступне дорівнює сумі двох попередніх, перші два – 0 і 1) у рядок через пробіл та окремо кількість парних чисел серед них.

2. Базовий рівень. Створити консольну програму, яка запитує в користувача ціле число N (від 1 до 10¹⁸), повторює запит у разі некоректного введення та виводить усі числа Фібоначчі, що не перевищують N, по 5 у рядку, їх кількість і суму в типі long, а також відповідь, чи є саме N числом Фібоначчі.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який приймає опції --count N або --max N та --start a,b (перші два члени, за замовчуванням 0,1). Програма виводить таблицю «номер – число – відношення до попереднього», обчислюючи числа в перевіреному контексті checked: у разі переповнення long вона повідомляє в потік помилок, на якому члені це сталося, і виводить уже обчислені значення. Під таблицею виводиться, наскільки останнє відношення відрізняється від золотого перерізу (1 + √5)/2. Коди завершення: 0 – успіх, 1 – переповнення, 2 – помилка опцій; --help виводить довідку.

Варіант 2. Вгадай число

1. Початковий рівень. Створити консольну програму-гру, у якій комп’ютер загадує випадкове число від 1 до 100 (Random.Shared.Next), а користувач вгадує його; після кожної спроби програма підказує «більше» або «менше», а після вгадування виводить кількість спроб.

2. Базовий рівень. Створити консольну програму-гру «Вгадай число» з вибором рівня складності виразом switch: легкий (1–50, 10 спроб), середній (1–100, 7 спроб), складний (1–1000, 10 спроб). Некоректне введення не зараховується як спроба; якщо спроби закінчилися, програма показує загадане число. Після гри програма пропонує зіграти ще раз.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, у якому користувач і комп’ютер грають по черзі: у першому раунді вгадує користувач, у другому – комп’ютер вгадує число, загадане користувачем, методом поділу навпіл за відповідями >, <, =. Опції --rounds N, --max M і --seed S (для відтворюваних випадкових чисел) задають параметри гри. Програма виявляє суперечливі відповіді користувача, виводить таблицю раундів «раунд – хто вгадував – число – спроби» і переможця за сумою спроб; --help виводить довідку, помилки опцій – у потік помилок з кодом завершення 2.

Варіант 3. Банкомат

1. Початковий рівень. Створити консольну програму, яка для суми 3 780 грн (задана в програмі) визначає найменшу кількість купюр номіналом 1000, 500, 200, 100, 50, 20 і 10 грн, якими її можна видати, та виводить кількість купюр кожного номіналу.

2. Базовий рівень. Створити консольну програму-банкомат із меню в циклі do/while: перевірка балансу, поповнення, зняття готівки, вихід. Сума зняття має бути кратною 10 і не більшою за баланс і добовий ліміт 20 000 грн; видача виконується найменшою кількістю купюр номіналом 1000, 500, 200, 100, 50, 20, 10 грн з виведенням кількості кожної купюри.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який моделює банкомат з обмеженим запасом купюр, заданим опцією --cassettes 1000:5,500:10,200:20,100:30,50:10, і обробляє суми, передані аргументами. Для кожної суми програма шукає спосіб видачі з урахуванням залишку купюр (якщо жадібний спосіб не вдається, перебирає менші кількості великих купюр), зменшує запас і виводить таблицю «сума – купюри – результат». Суми, які неможливо видати, повідомляються в потік помилок; наприкінці виводиться залишок купюр. Коди завершення: 0, 1 (частину сум не видано), 2 (помилка опцій); --help виводить довідку.

Варіант 4. Прогресивний податок

1. Початковий рівень. Створити консольну програму, яка для річного доходу 480 000 умовних одиниць (значення задане в програмі) обчислює податок за прогресивною шкалою: до 100 000 – 0 %, від 100 000 до 300 000 – 10 %, від 300 000 до 600 000 – 20 %, понад 600 000 – 30 % (кожна ставка застосовується лише до частини доходу у своєму діапазоні).

2. Базовий рівень. Створити консольну програму, яка в циклі запитує доходи до порожнього рядка, для кожного обчислює податок за прогресивною шкалою (0 % до 100 000, 10 % до 300 000, 20 % до 600 000, 30 % понад), визначає ставку для верхньої частини доходу виразом switch з реляційними шаблонами та виводить податок, чистий дохід і ефективну ставку, а в кінці – загальні суми.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, у якому шкала оподаткування задається опцією --brackets 100000:0,300000:10,600000:20,max:30, а доходи – аргументами або рядками з клавіатури. Програма перевіряє, що межі шкали зростають, обчислює податок для кожного доходу в decimal, виводить таблицю «дохід – податок за діапазонами – загальний податок – ефективна ставка» і, з опцією --compare ставка, порівнює прогресивну шкалу з пласкою ставкою. Помилки виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 5. Мобільний тариф

1. Початковий рівень. Створити консольну програму, яка для абонента, що використав 540 хвилин дзвінків, 18 ГБ інтернету і надіслав 35 SMS за тарифу 250 грн на місяць із пакетом 400 хвилин, 15 ГБ і 50 SMS (значення задані в програмі), обчислює вартість перевищень (1,5 грн за хвилину, 40 грн за кожен розпочатий ГБ) і загальну суму до сплати.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який отримує журнал використання за день у форматі день:хвилини:МБ:sms і опцію --plan lite|smart|max. Програма накопичує споживання за місяць, фіксує день, коли було вичерпано кожен пакет, обчислює вартість перевищень і виводить таблицю тарифів «тариф – абонплата – перевищення – разом» з позначкою найвигіднішого. Некоректні записи (день поза межами 1–31, від’ємні значення) повідомляються в потік помилок; коди завершення: 0, 1 (частину записів відхилено), 2 (помилка опцій).

Варіант 6. Числа Армстронга та досконалі числа

1. Початковий рівень. Створити консольну програму, яка знаходить і виводить усі тризначні числа Армстронга (число дорівнює сумі кубів своїх цифр, наприклад 153 = 1 + 125 + 27).

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який приймає опції --from, --to і --kind armstrong|perfect|amicable|abundant|all та класифікує числа діапазону: числа Армстронга, досконалі, надлишкові (сума дільників більша за число) і пари дружніх чисел (сума дільників кожного дорівнює іншому). Дільники перебираються до √n. Програма виводить таблицю «число – сума дільників – тип», кількість чисел кожного типу та час роботи. Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 7. Послідовність Колатца

1. Початковий рівень. Створити консольну програму, яка для числа 27 (задане в програмі) будує послідовність Колатца (парне число ділиться на 2, непарне замінюється на 3 · n + 1, доки не буде отримано 1) і виводить кількість кроків та максимальне значення послідовності.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який для діапазону, заданого опціями --from і --to (до 10 000 000), знаходить число з найдовшою послідовністю Колатца та число, послідовність якого досягає найбільшого значення. Обчислення виконуються в типі long у перевіреному контексті checked; опція --top N виводить таблицю N чисел із найдовшими послідовностями, а --show – саму послідовність для переможця. Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 8. Таблиця значень функції

1. Початковий рівень. Створити консольну програму, яка виводить таблицю значень функції y = x² − 4 · x + 3 на відрізку [−1; 5] з кроком 0,5 у двох вирівняних стовпцях і під таблицею – найменше значення функції та точку, у якій його досягнуто.

2. Базовий рівень. Створити консольну програму, яка запитує в користувача номер функції (1 – sin x, 2 – x² − 4 · x + 3, 3 – 1/x; вибір виразом switch), початок, кінець і крок табулювання, перевіряє введені дані та виводить таблицю значень; у точках, де функція не визначена, виводиться «не визначено». Під таблицею виводяться найменше й найбільше значення та кількість змін знаку функції.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який приймає опції --function sin|cos|poly|inverse|sqrt, --from, --to, --steps і --width та виводить таблицю значень і текстовий графік функції: для кожного рядка – ряд символів * відповідної довжини відносно мінімуму та максимуму на відрізку. Програма обробляє точки розриву та виходу з області визначення, знаходить наближені корені на інтервалах зміни знаку. Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 9. Календар місяця

1. Початковий рівень. Створити консольну програму, яка виводить календар місяця з 30 днів, перший день якого – середа (значення задані в програмі), у вигляді сітки із заголовком «Пн Вт Ср Чт Пт Сб Нд», використовуючи вкладені цикли.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який виводить календар на рік (--year) або на місяць (--month) без використання DateTime: місяці розташовуються по три в ряд, тижні починаються з понеділка або неділі (--first-day mon|sun), а дати зі списку --holidays 01.01,08.03,24.08 позначаються символом !. Під календарем виводиться кількість робочих днів у кожному місяці. Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 10. Камінь, ножиці, папір

1. Початковий рівень. Створити консольну програму, яка проводить один раунд гри «камінь, ножиці, папір»: запитує вибір користувача (к, н, п), генерує вибір комп’ютера Random.Shared і за допомогою виразу switch та умов визначає та виводить результат раунду.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main для гри «камінь, ножиці, папір, ящірка, Спок» (5 фігур) з опціями --wins N, --seed S і --strategy random|repeat|counter: стратегія counter обирає фігуру, яка перемагає найчастіший вибір користувача за попередні раунди. Програма виводить рахунок після кожного раунду, наприкінці – таблицю частот вибору користувача, найдовшу серію перемог і відсоток перемог. Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 11. Кавовий автомат

1. Початковий рівень. Створити консольну програму, яка виводить меню кавового автомата (еспресо 35 грн, американо 40 грн, капучино 55 грн), запитує номер напою, визначає ціну виразом switch і виводить назву та ціну обраного напою або повідомлення про невідомий номер.

2. Базовий рівень. Створити консольну програму-кавовий автомат, яка в циклі приймає монети та купюри номіналом 1, 2, 5, 10, 20, 50 грн (інші номінали відхиляються), доки внесена сума не покриє ціну обраного напою, а потім видає решту найменшою кількістю монет 10, 5, 2, 1 грн і пропонує обрати наступний напій.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який моделює кавовий автомат із запасом інгредієнтів (вода, кава, молоко в грамах, задаються опцією --stock) і монет для решти. Кожен напій витрачає інгредієнти відповідно до рецепта; якщо інгредієнтів або монет для решти недостатньо, замовлення скасовується з поверненням внесених коштів. Сервісна команда service виводить таблицю залишків і виручки. Помилки виводяться в потік помилок; коди завершення: 0 або 2 (помилка опцій); --help виводить довідку.

Варіант 12. Шкала Бофорта

1. Початковий рівень. Створити консольну програму, яка для швидкості вітру 12,4 м/с (значення задане в програмі) визначає бал за шкалою Бофорта виразом switch з реляційними шаблонами (0 – менше 0,5 м/с, 1 – до 1,5, 2 – до 3,3, 3 – до 5,4, 4 – до 7,9, 5 – до 10,7, 6 – до 13,8, 7 – до 17,1, 8 – до 20,7, 9 – до 24,4, 10 – до 28,4, 11 – до 32,6, 12 – 32,7 і більше) та виводить бал і назву вітру.

2. Базовий рівень. Створити консольну програму, яка в циклі запитує швидкості вітру (м/с або км/год із суфіксом, наприклад 45kmh) до порожнього рядка, для кожної виводить бал Бофорта та назву вітру, а наприкінці – кількість вимірювань, середню та максимальну швидкість і кількість вимірювань зі штормовим вітром (8 балів і більше).

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який отримує вимірювання у форматі гг:хх@швидкість@напрямок (напрямок у градусах) і опцію --units ms|kmh|kn. Програма виводить таблицю «час – швидкість – бал – назва – румб» (16 румбів виразом switch), тривалість найдовшого періоду з вітром не менше заданого опцією --alert бала та гістограму балів із символів #. Некоректні записи повідомляються в потік помилок; коди завершення: 0, 1 (частину записів відхилено), 2 (помилка опцій).

Варіант 13. Ряди Тейлора для sin x і cos x

1. Початковий рівень. Створити консольну програму, яка обчислює sin x для x = 1 (задане в програмі) сумою ряду x − x³/3! + x⁵/5! − … до доданка, меншого за 10⁻⁸ за модулем, обчислюючи кожен доданок з попереднього, та виводить результат, кількість доданків і значення Math.Sin.

2. Базовий рівень. Створити консольну програму, яка запитує в користувача x (у градусах) і точність, перевіряє введені дані, переводить кут у радіани та обчислює sin x і cos x сумами рядів Тейлора; виводить результати, кількість доданків для кожного ряду та абсолютну похибку порівняно з Math.Sin і Math.Cos.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який приймає опції --function sin|cos|ln1p|atan, --from, --to, --step і --eps та виводить таблицю «x – сума ряду – кількість доданків – значення Math – похибка». Для ln(1 + x) і arctg x програма перевіряє область збіжності ряду (|x| < 1) і позначає точки, де ряд розбіжний або кількість доданків перевищує --max-terms. Для великих кутів sin і cos спочатку зводяться до проміжку [−π; π]. Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 14. Метод поділу навпіл

1. Початковий рівень. Створити консольну програму, яка методом поділу навпіл знаходить корінь рівняння x³ − 2 · x − 5 = 0 на відрізку [2; 3] з точністю 10⁻⁶ та виводить корінь, значення функції в ньому та кількість ітерацій.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який для функції, обраної опцією --function, знаходить усі корені на відрізку --from/--to: відрізок ділиться на частини кроком --scan, на кожній частині зі зміною знаку корінь уточнюється методами поділу навпіл і хорд. Програма виводить таблицю «корінь – ітерацій (поділ) – ітерацій (хорди) – |f(x)|» і попередження, якщо метод не збігся за --max-iter ітерацій. Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 15. Щасливі квитки

1. Початковий рівень. Створити консольну програму, яка перебирає всі шестизначні номери квитків від 000000 до 999999 і підраховує «щасливі» квитки, у яких сума перших трьох цифр дорівнює сумі останніх трьох, та виводить їх кількість.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який для квитків із довжиною номера --digits (4, 6 або 8) і діапазону --from/--to підраховує щасливі квитки за правилами --rule sum|parity|both, виводить таблицю «сума половини – кількість комбінацій» і найдовший проміжок між сусідніми щасливими квитками. Для перевірки програма рахує кількість щасливих квитків двома способами: повним перебором і через кількість комбінацій сум половин. Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 16. Римські числа

1. Початковий рівень. Створити консольну програму, яка переводить число 2026 (задане в програмі) у римський запис (MMXXVI), використовуючи цикл і вираз switch або послідовність перевірок для значень 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1.

2. Базовий рівень. Створити консольну програму, яка в циклі запитує значення до порожнього рядка: якщо введено ціле число від 1 до 3999, виводить його римський запис, якщо рядок із римських цифр – переводить його в арабське число. Некоректні римські записи (наприклад, IIII, VX) відхиляються: запис вважається коректним, якщо зворотне перетворення дає той самий рядок.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який обчислює вирази з римськими числами, передані аргументами (наприклад, XLII + VIII, MCM - XC, XII * III, C / VII). Програма перевіряє коректність операндів, виконує дію, виводить результат римськими й арабськими цифрами (для ділення – частку й остачу) та повідомляє в потік помилок, якщо результат виходить за межі 1–3999. Опція --table від-до виводить таблицю переведення. Коди завершення: 0, 1 (є помилкові вирази), 2 (помилка аргументів); --help виводить довідку.

Варіант 17. Системи числення

1. Початковий рівень. Створити консольну програму, яка переводить число 2026 (задане в програмі) у двійкову, вісімкову та шістнадцяткову системи числення, отримуючи цифри остачами від ділення в циклі (без Convert), та виводить результати.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який переводить числа між системами з основами від 2 до 36 (опції --from, --to), підтримує від’ємні числа та дробову частину (опція --precision задає кількість знаків дробової частини результату) і виводить таблицю «введено – десяткове значення – результат». Переповнення long виявляється checked і повідомляється в потік помилок; опція --verify виконує зворотне перетворення та порівнює результат. Коди завершення: 0, 1 (є помилки), 2 (помилка опцій); --help виводить довідку.

Варіант 18. Наступна дата

1. Початковий рівень. Створити консольну програму, яка для дати 28.02.2028 (день, місяць і рік задані в програмі) визначає наступну дату без використання DateTime: кількість днів у місяці обчислюється виразом switch з урахуванням високосного року.

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

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

Варіант 19. План тренувань бігуна

1. Початковий рівень. Створити консольну програму, яка для бігуна, що починає з 5 км на тиждень і щотижня збільшує дистанцію на 10 % (значення задані в програмі), виводить дистанцію кожного тижня, доки вона не досягне 42 км, кількість тижнів і загальний кілометраж.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який будує план підготовки до забігу: опції --start, --goal, --increase, --race-date дд.ММ.рррр, --runs-per-week (3–6). Програма розподіляє тижневий кілометраж на тренування (довга пробіжка – 30 %, решта порівну), обмежує довгу пробіжку значенням --long-max, планує зниження навантаження за два тижні до забігу й повідомляє в потік помилок, якщо мету неможливо досягти до дати забігу. Виводиться таблиця тижнів; --help виводить довідку, коди завершення: 0, 1 (мету не досягнуто), 2.

Варіант 20. Рахунок у тенісі

1. Початковий рівень. Створити консольну програму, яка для послідовності виграних очок гравців у геймі AABBBAAA (задана в програмі) визначає поточний рахунок після кожного очка в тенісних позначеннях (0, 15, 30, 40, «рівно», «більше») і переможця гейму.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який обробляє протокол матчу (послідовність A/B з аргументу або файлу стандартного введення) з опцією --sets 3|5: рахує очки, гейми, сети й тай-брейк за рахунку 6:6 (до 7 очок з перевагою у 2), виводить рахунок після кожного сету, переможця матчу та статистику: кількість виграних очок, геймів «всуху» і брейк-пойнтів. Зайві очки після завершення матчу повідомляються в потік помилок; коди завершення: 0, 1 (протокол некоректний), 2 (помилка опцій).

Варіант 21. Ліфт

1. Початковий рівень. Створити консольну програму, яка для ліфта, що перебуває на 1-му поверсі й виконує виклики на поверхи 7, 3, 9, 2 (задані в програмі по черзі), виводить кожне переміщення та загальну кількість пройдених поверхів.

2. Базовий рівень. Створити консольну програму, яка моделює ліфт у будинку з 16 поверхів: у циклі запитує номер поверху до введення 0, перевіряє діапазон, виводить напрямок руху й кількість поверхів для кожного виклику, а наприкінці – загальну кількість поверхів, кількість поїздок угору й униз і найдовшу поїздку.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який моделює ліфт із чергою викликів, переданих аргументами у форматі час@поверх (час у секундах), і опціями --floors, --speed (секунд на поверх) і --stop (секунд на зупинку). Ліфт рухається в поточному напрямку, зупиняючись на всіх викликах на шляху, і змінює напрямок лише тоді, коли викликів попереду немає. Програма виводить журнал подій «час – поверх – подія», середній і максимальний час очікування. Некоректні виклики повідомляються в потік помилок; --help виводить довідку.

Варіант 22. Світлофор

1. Початковий рівень. Створити консольну програму, яка для світлофора з циклом «зелений 30 с, жовтий 3 с, червоний 25 с, червоний із жовтим 2 с» (значення задані в програмі) визначає сигнал через 1 000 секунд після початку роботи, використовуючи операцію % і вираз switch.

2. Базовий рівень. Створити консольну програму, яка запитує в користувача тривалості фаз світлофора та час у секундах від початку роботи, перевіряє введені дані й виводить поточний сигнал, скільки секунд він ще триватиме та розклад наступних п’яти змін сигналу у форматі хх:сс.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який моделює перехрестя з двома світлофорами (головна та другорядна дорога) з фазами, заданими опціями, і перевіряє безпеку: зелені сигнали не можуть збігатися. Опція --from гг:хх:сс --to гг:хх:сс виводить розклад сигналів обох світлофорів на проміжок часу, опція --night 23:00-06:00 вмикає нічний режим (миготливий жовтий). Небезпечна конфігурація повідомляється в потік помилок з кодом завершення 1; помилки опцій – код 2.

Варіант 23. Заряд акумулятора дрона

1. Початковий рівень. Створити консольну програму, яка для дрона з акумулятором 100 %, що витрачає 2,5 % заряду на хвилину польоту й 0,8 % на хвилину зависання, моделює план «політ 6 хв, зависання 10 хв, політ 12 хв» (задано в програмі) і виводить заряд після кожного етапу.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який отримує маршрут як послідовність точок x,y,висота (м) і опції --speed, --battery (Вт·год), --power-fly, --power-hover, --power-climb (Вт) та --reserve (%). Програма обчислює для кожного відрізка час і витрату енергії, перевіряє, чи вистачить заряду повернутися від кожної точки до старту з резервом, і виводить таблицю «відрізок – відстань – час – витрата – залишок», позначаючи точку, після якої політ слід припинити. Помилки виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 24. НСД і НСК

1. Початковий рівень. Створити консольну програму, яка для чисел 1071 і 462 (задані в програмі) знаходить найбільший спільний дільник алгоритмом Евкліда з остачами, виводить кожен крок алгоритму, а також найменше спільне кратне.

2. Базовий рівень. Створити консольну програму, яка запитує в користувача звичайний дріб у форматі a/b (цілі числа, b ≠ 0), перевіряє введення, скорочує дріб за допомогою НСД, нормалізує знак і виводить результат, цілу частину та правильний дріб (наприклад, -50/15 → -10/3 = -3 1/3).

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який обчислює НСД і НСК довільної кількості чисел типу long, переданих аргументами, з опціями --method euclid|binary (двійковий алгоритм НСД на зсувах і побітових операціях) і --pairs, що виводить таблицю пар взаємно простих чисел серед аргументів. НСК обчислюється в перевіреному контексті checked; переповнення повідомляється в потік помилок. Програма порівнює кількість ітерацій обох алгоритмів. Коди завершення: 0, 1 (переповнення), 2 (помилка аргументів).

Варіант 25. Візерунки із символів

1. Початковий рівень. Створити консольну програму, яка за допомогою вкладених циклів виводить рівнобедрений трикутник із символів * висотою 7 рядків (висота задана в програмі).

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який виводить візерунки diamond, tree, chess, spiral, frame з опціями --size, --char, --hollow (лише контур) і --border. Для спіралі програма обчислює символ кожної клітинки за координатами без масивів. Опція --list виводить усі візерунки поспіль із заголовками. Недопустимі комбінації опцій (наприклад, парний розмір ромба) повідомляються в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 26. Популяція бактерій

1. Початковий рівень. Створити консольну програму, яка для колонії з 1 000 бактерій, що кожні 20 хвилин збільшується на 35 % (значення задані в програмі), виводить чисельність щогодини протягом 8 годин та час, коли чисельність уперше перевищить 100 000.

2. Базовий рівень. Створити консольну програму, яка запитує в користувача початкову чисельність, ємність середовища K і коефіцієнт росту r та моделює логістичний ріст N = N + r · N · (1 − N/K) по кроках, доки зміна чисельності не стане меншою за 1, виводячи таблицю кроків і кількість кроків до досягнення 90 % ємності.

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який моделює дві популяції «хижак – жертва» за дискретною моделлю Лотки – Вольтерри з параметрами з опцій та кроком --dt. Програма виводить таблицю станів із заданим інтервалом, знаходить максимуми кожної популяції та період коливань, припиняє моделювання, якщо одна з популяцій вимерла або значення стали некоректними (NaN, нескінченність), і повідомляє причину. Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 27. Паліндромні числа

1. Початковий рівень. Створити консольну програму, яка знаходить усі чотиризначні числа-паліндроми, що діляться на 11, обертаючи число арифметично (операції % і /), та виводить їх кількість.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який для діапазону --from/--to знаходить числа-паліндроми в десятковій і двійковій системах одночасно (--base 2), числа Лішрел-кандидати (процедура «обернути й додати» не дає паліндрома за --steps кроків) і найбільший паліндром, що є добутком двох чисел із діапазону. Результати виводяться окремими таблицями; переповнення long повідомляються в потік помилок. Коди завершення: 0 або 2 (помилка опцій).

Варіант 28. Система двох лінійних рівнянь

1. Початковий рівень. Створити консольну програму, яка розв’язує систему 2 · x + 3 · y = 13, 5 · x − y = 7 (коефіцієнти задані в програмі) методом Крамера та виводить визначники й розв’язок.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який розв’язує систему трьох лінійних рівнянь, коефіцієнти якої передаються аргументами (12 чисел) або вводяться рядками, методом Гаусса з вибором головного елемента в циклах без масивів (змінні a11…a34) або методом Крамера (--method gauss|cramer). Програма визначає випадки виродженої системи, виводить розв’язок і нев’язку кожного рівняння та порівнює результати обох методів з опцією --compare. Помилки виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 29. Кидки кубика

1. Початковий рівень. Створити консольну програму, яка моделює 600 кидків грального кубика за допомогою Random.Shared.Next(1, 7), підраховує в циклі кількість випадінь кожної грані (шість лічильників, вибір виразом switch) і виводить частоти у відсотках.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який моделює гру «хто першим набере 100 очок»: гравець кидає кубик, доки не вирішить зупинитися (стратегія --hold N – зупинитися, набравши за хід N очок) або не випаде 1 (очки ходу згоряють). Опції --games, --seed і --strategies 15,20,25 задають кількість партій та стратегії для порівняння. Програма виводить таблицю «стратегія – виграші – середня кількість ходів – найдовша партія». Помилки опцій виводяться в потік помилок з кодом завершення 2; --help виводить довідку.

Варіант 30. Автозаправка

1. Початковий рівень. Створити консольну програму, яка виводить меню пального (А-92 – 55,49 грн/л, А-95 – 58,99 грн/л, ДП – 54,79 грн/л), запитує номер пального та кількість літрів, визначає ціну виразом switch і виводить суму до сплати.

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

3. Високий рівень. Створити за допомогою dotnet CLI консольний застосунок із методом Main, який моделює АЗС із резервуарами (опція --tanks A92:5000,A95:8000,DP:10000) і журналом заправок, переданим аргументами (A95:40l, DP:1500uah, A92:full, де full – до повного бака ємністю --tank-size). Програма перевіряє залишок пального, частково виконує замовлення, якщо пального не вистачає, і виводить таблицю операцій, виручку та залишки з попередженням, коли резервуар заповнений менше ніж на 10 %. Некоректні записи повідомляються в потік помилок; коди завершення: 0, 1, 2.

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

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