Завдання

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

Варіанти

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

1. Початковий рівень. Створити консольну програму Kotlin: читати роки a,b у 1–9999, a<=b; вивести високосні за григоріанським правилом 400 або 4 без 100. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати роки a,b у 1–9999, a<=b; вивести високосні за григоріанським правилом 400 або 4 без 100. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати роки a,b у 1–9999, a<=b; вивести високосні за григоріанським правилом 400 або 4 без 100. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 2. Тариф

1. Початковий рівень. Створити консольну програму Kotlin: читати хвилини 0–10000; порівняти навчальні A=100+2*m та B=200+m, за рівності вивести обидва. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати хвилини 0–10000; порівняти навчальні A=100+2*m та B=200+m, за рівності вивести обидва. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати хвилини 0–10000; порівняти навчальні A=100+2*m та B=200+m, за рівності вивести обидва. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 3. Тура

1. Початковий рівень. Створити консольну програму Kotlin: читати координати двох різних клітин 1–8; перевірити хід тури без інших фігур. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати координати двох різних клітин 1–8; перевірити хід тури без інших фігур. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати координати двох різних клітин 1–8; перевірити хід тури без інших фігур. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 4. Прості числа

1. Початковий рівень. Створити консольну програму Kotlin: читати a,b у 0–10000, a<=b; вивести кількість простих у включному діапазоні. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати a,b у 0–10000, a<=b; вивести кількість простих у включному діапазоні. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати a,b у 0–10000, a<=b; вивести кількість простих у включному діапазоні. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 5. Купюри

1. Початковий рівень. Створити консольну програму Kotlin: читати кратну 10 суму 10–100000; розкласти на необмежені купюри 100, 50, 20, 10 і надрукувати кількості. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати кратну 10 суму 10–100000; розкласти на необмежені купюри 100, 50, 20, 10 і надрукувати кількості. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати кратну 10 суму 10–100000; розкласти на необмежені купюри 100, 50, 20, 10 і надрукувати кількості. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 6. Дата

1. Початковий рівень. Створити консольну програму Kotlin: читати місяць 1–12 та день; перевірити дату невисокосного року за фактичною довжиною місяця. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати місяць 1–12 та день; перевірити дату невисокосного року за фактичною довжиною місяця. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати місяць 1–12 та день; перевірити дату невисокосного року за фактичною довжиною місяця. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 7. Вгадування

1. Початковий рівень. Створити консольну програму Kotlin: задати секрет 37; читати до 7 цілих спроб 1–100, друкувати більше/менше/вгадано та число спроб. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: задати секрет 37; читати до 7 цілих спроб 1–100, друкувати більше/менше/вгадано та число спроб. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: задати секрет 37; читати до 7 цілих спроб 1–100, друкувати більше/менше/вгадано та число спроб. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 8. Дільники

1. Початковий рівень. Створити консольну програму Kotlin: читати n 1–10000; обчислити суму власних додатних дільників і класифікувати відносно n. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 1–10000; обчислити суму власних додатних дільників і класифікувати відносно n. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 1–10000; обчислити суму власних додатних дільників і класифікувати відносно n. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 9. Температури

1. Початковий рівень. Створити консольну програму Kotlin: читати n 1–1000 скінченних температур −50..60; підрахувати нижче 0, рівно 0, вище 0. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 1–1000 скінченних температур −50..60; підрахувати нижче 0, рівно 0, вище 0. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 1–1000 скінченних температур −50..60; підрахувати нижче 0, рівно 0, вище 0. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 10. Римські символи

1. Початковий рівень. Створити консольну програму Kotlin: читати ціле 1–10; вивести точний запис I, II, III, IV, V, VI, VII, VIII, IX, X через when. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати ціле 1–10; вивести точний запис I, II, III, IV, V, VI, VII, VIII, IX, X через when. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати ціле 1–10; вивести точний запис I, II, III, IV, V, VI, VII, VIII, IX, X через when. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 11. Трикутник

1. Початковий рівень. Створити консольну програму Kotlin: читати три скінченні сторони 0.1–1000; перевірити нерівності та визначити рівносторонній/рівнобедрений/різносторонній. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати три скінченні сторони 0.1–1000; перевірити нерівності та визначити рівносторонній/рівнобедрений/різносторонній. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати три скінченні сторони 0.1–1000; перевірити нерівності та визначити рівносторонній/рівнобедрений/різносторонній. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 12. НСД

1. Початковий рівень. Створити консольну програму Kotlin: читати два числа 1–1000000; знайти НСД алгоритмом Евкліда й надрукувати. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати два числа 1–1000000; знайти НСД алгоритмом Евкліда й надрукувати. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати два числа 1–1000000; знайти НСД алгоритмом Евкліда й надрукувати. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 13. Цифри

1. Початковий рівень. Створити консольну програму Kotlin: читати n 0–1000000000; циклом знайти суму й кількість цифр, для 0 кількість 1. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 0–1000000000; циклом знайти суму й кількість цифр, для 0 кількість 1. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 0–1000000000; циклом знайти суму й кількість цифр, для 0 кількість 1. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

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

1. Початковий рівень. Створити консольну програму Kotlin: читати n 0–1000000000; перевірити збіг із числом у зворотному порядку, обчислення виконати в Long. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 0–1000000000; перевірити збіг із числом у зворотному порядку, обчислення виконати в Long. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 0–1000000000; перевірити збіг із числом у зворотному порядку, обчислення виконати в Long. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 15. Факторіал

1. Початковий рівень. Створити консольну програму Kotlin: читати n 0–20; обчислити факторіал у Long, 0!=1. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 0–20; обчислити факторіал у Long, 0!=1. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 0–20; обчислити факторіал у Long, 0!=1. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 16. Фібоначчі

1. Початковий рівень. Створити консольну програму Kotlin: читати n 0–90; обчислити F0=0,F1=1,F(n)=F(n-1)+F(n-2) у Long. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 0–90; обчислити F0=0,F1=1,F(n)=F(n-1)+F(n-2) у Long. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 0–90; обчислити F0=0,F1=1,F(n)=F(n-1)+F(n-2) у Long. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 17. Оцінки

1. Початковий рівень. Створити консольну програму Kotlin: читати n 1–100 і оцінки 0–100; надрукувати середнє та кількість >=60. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 1–100 і оцінки 0–100; надрукувати середнє та кількість >=60. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 1–100 і оцінки 0–100; надрукувати середнє та кількість >=60. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 18. Знижка

1. Початковий рівень. Створити консольну програму Kotlin: читати суму 0–100000; навчальна знижка 0% до 1000, 5% від 1000 до 5000, 10% від 5000 включно. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати суму 0–100000; навчальна знижка 0% до 1000, 5% від 1000 до 5000, 10% від 5000 включно. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати суму 0–100000; навчальна знижка 0% до 1000, 5% від 1000 до 5000, 10% від 5000 включно. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 19. Квадратне рівняння

1. Початковий рівень. Створити консольну програму Kotlin: читати цілі a,b,c від −100 до 100, a!=0; за дискримінантом вивести 0, 1 або 2 дійсні корені. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати цілі a,b,c від −100 до 100, a!=0; за дискримінантом вивести 0, 1 або 2 дійсні корені. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати цілі a,b,c від −100 до 100, a!=0; за дискримінантом вивести 0, 1 або 2 дійсні корені. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 20. Календар днів

1. Початковий рівень. Створити консольну програму Kotlin: читати рік 1–9999 і місяць 1–12; вивести кількість днів з урахуванням високосності. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати рік 1–9999 і місяць 1–12; вивести кількість днів з урахуванням високосності. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати рік 1–9999 і місяць 1–12; вивести кількість днів з урахуванням високосності. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 21. Парність

1. Початковий рівень. Створити консольну програму Kotlin: читати n 1–1000 цілих −10000..10000; вивести суми парних і непарних окремо. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 1–1000 цілих −10000..10000; вивести суми парних і непарних окремо. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 1–1000 цілих −10000..10000; вивести суми парних і непарних окремо. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 22. Максимум

1. Початковий рівень. Створити консольну програму Kotlin: читати n 1–1000 цілих −10000..10000; вивести максимум і номер його першої появи від 1. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 1–1000 цілих −10000..10000; вивести максимум і номер його першої появи від 1. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 1–1000 цілих −10000..10000; вивести максимум і номер його першої появи від 1. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 23. Меню

1. Початковий рівень. Створити консольну програму Kotlin: читати команди 1, 2, 0: 1 збільшує лічильник, 2 друкує його, 0 або EOF завершує; невідомі не змінюють стан. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати команди 1, 2, 0: 1 збільшує лічильник, 2 друкує його, 0 або EOF завершує; невідомі не змінюють стан. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати команди 1, 2, 0: 1 збільшує лічильник, 2 друкує його, 0 або EOF завершує; невідомі не змінюють стан. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 24. Пошук пари

1. Початковий рівень. Створити консольну програму Kotlin: читати s 2–20; знайти першу пару a,b 1–10 із сумою s у порядку a, потім b. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати s 2–20; знайти першу пару a,b 1–10 із сумою s у порядку a, потім b. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати s 2–20; знайти першу пару a,b 1–10 із сумою s у порядку a, потім b. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 25. Степінь

1. Початковий рівень. Створити консольну програму Kotlin: читати ціле a −10..10 і n 0–10; циклом обчислити a^n у Long, a^0=1. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати ціле a −10..10 і n 0–10; циклом обчислити a^n у Long, a^0=1. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати ціле a −10..10 і n 0–10; циклом обчислити a^n у Long, a^0=1. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 26. Ряд

1. Початковий рівень. Створити консольну програму Kotlin: читати n 1–10000; обчислити суму 1+1/2+…+1/n у Double. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 1–10000; обчислити суму 1+1/2+…+1/n у Double. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 1–10000; обчислити суму 1+1/2+…+1/n у Double. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 27. Двійкові цифри

1. Початковий рівень. Створити консольну програму Kotlin: читати n 0–1000000; циклом визначити кількість одиничних бітів. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 0–1000000; циклом визначити кількість одиничних бітів. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 0–1000000; циклом визначити кількість одиничних бітів. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 28. Кут

1. Початковий рівень. Створити консольну програму Kotlin: читати цілий кут −1000000..1000000; нормалізувати до 0–359 і вказати головний напрямок для 0, 90, 180, 270. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати цілий кут −1000000..1000000; нормалізувати до 0–359 і вказати головний напрямок для 0, 90, 180, 270. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати цілий кут −1000000..1000000; нормалізувати до 0–359 і вказати головний напрямок для 0, 90, 180, 270. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 29. Таблиця

1. Початковий рівень. Створити консольну програму Kotlin: читати n 1–12; надрукувати таблицю множення n на 1–12. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати n 1–12; надрукувати таблицю множення n на 1–12. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати n 1–12; надрукувати таблицю множення n на 1–12. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

Варіант 30. Потік

1. Початковий рівень. Створити консольну програму Kotlin: читати до stop/EOF не більше 1000 цілих −1000..1000; неправильні пропускати, вивести суму та число прийнятих. Перевірити типи та межі; для неправильного вводу вивести повідомлення й завершити.

2. Базовий рівень. Створити консольну програму Kotlin: читати до stop/EOF не більше 1000 цілих −1000..1000; неправильні пропускати, вивести суму та число прийнятих. Використати nullable-перетворення без !!, перевірити межі та EOF; повторити запит після неправильного рядка. Надрукувати підсумок тільки для коректного набору.

3. Високий рівень. Створити консольну програму Kotlin: читати до stop/EOF не більше 1000 цілих −1000..1000; неправильні пропускати, вивести суму та число прийнятих. Винести весь набір параметрів у повторюване меню: обчислити новий набір або завершити. Без !! перевірити межі, переповнення й EOF; неправильний набір не змінює число успішних обчислень. Показати цей лічильник і таблицю не менше п’яти граничних перевірок. Додати аргументи CLI у форматі ключ=значення та --help; без аргументів читати ті самі поля з клавіатури. Виводити підписаний табличний звіт із підсумком; помилки надсилати у stderr. Коди завершення: 0 – успіх або довідка, 2 – неправильний ввід, 1 – операційний збій.

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

1. Сформулюйте контракт вводу та очікуваний результат.
2. Оберіть типи й перевірте межі проміжних обчислень.
3. Відокремте розбір рядка від перевірки допустимого значення.
4. Для циклу запишіть інваріант і умови завершення.
5. Перевірте кожну гілку, межі, null, текст і порожній потік.
6. Збережіть код і таблицю перевірок у локальному репозиторії.