Завдання

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

Варіанти

Варіант 1. Лічильник слів у книгах

1. Початковий рівень. Створити консольну програму, яка для трьох текстових рядків (фрагменти книг задані в програмі) запускає по одному потоку Thread на кожен рядок; потік рахує кількість слів у своєму рядку й записує результат у свій елемент масиву. Після Join усіх потоків програма виводить кількість слів у кожному фрагменті та загальну кількість.

2. Базовий рівень. Створити консольну програму, яка запитує шлях до каталогу, знаходить у ньому всі файли *.txt і рахує слова в кожному файлі окремим потоком. Якщо каталог не існує або не містить файлів, програма повідомляє про це. Програма виводить таблицю «файл – кількість слів – ідентифікатор потоку», загальну кількість слів і час виконання, а також перевіряє, що сума збігається з послідовним підрахунком.

3. Високий рівень. Створити консольний застосунок, який отримує в аргументах каталог із текстовими файлами та опції --threads N (за замовчуванням кількість логічних процесорів), --top K і --help. Файли розподіляються між N потоками групами з приблизно рівним сумарним розміром. Програма виводить K найчастіших слів (без урахування регістру), а для N = 1, 2, 4, …, --threads вимірює медіану трьох запусків і виводить таблицю «потоки – час – прискорення – ефективність». Результат кожного запуску перевіряється за послідовною версією. Помилки (немає каталогу, некоректне число) виводяться в потік помилок із кодом завершення 1.

Варіант 2. Пошук досконалих чисел

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

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

3. Високий рівень. Створити консольний застосунок, який шукає в кількох потоках досконалі числа (рівні сумі своїх дільників, менших за число) до межі --limit і приймає опції --threads, --split equal|balanced і --help. Режим equal ділить діапазон на рівні частини, режим balanced робить частини з більшими числами коротшими (межі за квадратним коренем). Для обох режимів і N = 1…--threads програма виводить таблицю часу, прискорення та ефективності, час найповільнішого й найшвидшого потоку. Некоректні опції – у потік помилок з кодом 2.

Варіант 3. Середня температура метеостанцій

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

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

3. Високий рівень. Створити консольний застосунок, який читає CSV-файл вимірювань (станція;дата;година; температура), заданий аргументом, разом з опціями --threads N, --out файл і --help. Рядки групуються за станціями, групи розподіляються між потоками, кожен потік обчислює середню, мінімум, максимум і кількість пропусків. Некоректні рядки пропускаються з лічильником. Результат записується у CSV-файл, а в консоль виводиться таблиця часу, прискорення та ефективності для 1…N потоків (медіана трьох запусків); коди завершення: 0 – успіх, 1 – помилка файлу, 2 – помилка аргументів.

Варіант 4. Процеси-обчислювачі інтеграла

1. Початковий рівень. Створити консольну програму, яка обчислює інтеграл функції sin x на відрізку [0; π] методом прямокутників з 10 000 000 кроків, запускаючи себе як дочірній процес для кожної з двох половин відрізка (межі передаються аргументами), і виводить суму результатів дочірніх процесів.

2. Базовий рівень. Створити консольну програму-координатор, яка запитує межі інтегрування, кількість кроків і кількість процесів N (від 1 до 16), запускає N процесів-обчислювачів (та сама програма з аргументом --worker a b steps), читає їхній стандартний вивід, перевіряє коди завершення й виводить значення інтеграла, похибку відносно точного значення для sin x і загальний час.

3. Високий рівень. Створити консольний застосунок, який обчислює інтеграл однієї з функцій (sin, exp, sqrt, опція --f) на відрізку --from/--to у режимах --mode processes|threads з опціями --n і --help. Для N = 1…--n програма виводить таблицю часу для процесів і для потоків та пояснює різницю накладними витратами запуску процесів. Якщо обчислювач завершився з ненульовим кодом або вивів некоректне число, координатор повідомляє PID і діапазон у потік помилок і завершується з кодом 3.

Варіант 5. Контроль якості деталей

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

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

3. Високий рівень. Створити консольний застосунок для Windows або Linux, який генерує --count розмірів деталей (нормальний розподіл, фіксоване зерно) і в --threads потоках рахує браковані (відхилення від номіналу 50 мм більше за 0,2 мм). Опція --affinity маска (наприклад, 0x5) встановлює спорідненість процесу (Process.ProcessorAffinity); програма виводить таблицю часу для масок «усі процесори», «один процесор», «два логічні процесори одного ядра», «два різні ядра». Непідтримувана ОС або некоректна маска – повідомлення в потік помилок і код 1; --help.

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

1. Початковий рівень. Створити консольну програму, яка знаходить усі числа Армстронга (сума цифр у степені кількості цифр дорівнює числу) до 10 000 000, ставлячи в пул потоків (ThreadPool.QueueUserWorkItem) десять робіт по одному мільйону чисел, і виводить знайдені числа в порядку зростання.

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

3. Високий рівень. Створити консольний застосунок з опціями --limit, --jobs, --mode threads|pool|both і --help, який порівнює пошук чисел Армстронга окремими потоками Thread (один потік на роботу) і пулом потоків. Програма виводить таблицю «кількість робіт (4, 16, 64, 256) – час потоків – час пулу – відношення» та перевіряє однаковість результатів. Некоректні опції виводяться в потік помилок із кодом 2.

Варіант 7. Пікселі зображення в пам’яті

1. Початковий рівень. Створити консольну програму, яка створює в пам’яті зображення 4000×3000 пікселів (масив байтів яскравості, фіксоване зерно) і в чотирьох потоках горизонтальними смугами обчислює середню яскравість, після чого виводить результат і середню яскравість кожної смуги.

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

3. Високий рівень. Створити консольний застосунок, який генерує в пам’яті зображення --width × --height (масив байтів яскравості, фіксоване зерно) і застосовує фільтр --filter invert|threshold|blur смугами для 1, 2, 4, …, 2·ProcessorCount потоків; для blur смуги враховують сусідні рядки. Програма вимірює медіану п’яти запусків і виводить таблицю часу, прискорення та ефективності. Результат кожного запуску порівнюється з послідовним; розбіжність – повідомлення в потік помилок і код 1; --help.

Варіант 8. Перевірка паролів на складність

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

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

3. Високий рівень. Створити консольний застосунок, який отримує файл паролів і опції --min-length, --report файл і --help. Кожна робота пулу потоків обчислює оцінку складності пароля від 0 до 5 (по балу за довжину, великі й малі літери, цифри, спецсимволи) і причину слабкості. Програма записує звіт у файл (пароль замінено на маску з першим і останнім символом), виводить гістограму оцінок, ThreadPool.ThreadCount, кількість виконаних робіт і час. Порожній або відсутній файл – повідомлення в потік помилок і код 1.

Варіант 9. Статистика оцінок школи

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

2. Базовий рівень. Створити консольну програму, яка генерує оцінки для заданої кількості класів і учнів, обробляє класи потоками, в яких кількість оброблених оцінок рахує лічильник ThreadLocal<int>, і виводить середні бали класів, значення лічильників усіх потоків (Values) і перевірку, що їх сума дорівнює кількості оцінок.

3. Високий рівень. Створити консольний застосунок, який читає CSV-файл клас;учень;предмет;оцінка (аргумент) з опціями --threads, --subject і --help. Потоки обробляють частини рядків і накопичують проміжну статистику в ThreadLocal-словниках, які після завершення потоків об’єднуються. Програма виводить таблицю класів із середнім балом і рівнями, найкращий клас із предмета та час для 1…N потоків. Некоректні рядки рахуються та виводяться в потік помилок.

Варіант 10. Імітація касирів супермаркету

1. Початковий рівень. Створити консольну програму, яка імітує трьох касирів окремими іменованими потоками: кожен обслуговує 5 покупців (обслуговування – Thread.Sleep випадкової тривалості від 50 до 200 мс, фіксоване зерно) і виводить ім’я потоку та номер покупця. Програма чекає всіх касирів і виводить загальний час.

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

3. Високий рівень. Створити консольний застосунок, який імітує касирів супермаркету потоками з різними пріоритетами (обслуговування покупця – обчислювальний цикл) з опціями --cashiers, --customers, --affinity 1 і --help та порівнює час обслуговування без обмеження й з обмеженням процесу одним логічним процесором. Програма виводить таблицю «касир – пріоритет – час без обмеження – час на одному процесорі» і попереджає, якщо ОС не підтримує спорідненість (код 1).

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

1. Початковий рівень. Створити консольну програму, яка знаходить у діапазоні від 1 до 1 000 000 число з найдовшою послідовністю Коллатца, розбиваючи діапазон на чотири потоки, і виводить число та довжину послідовності.

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

3. Високий рівень. Створити консольний застосунок, який шукає в діапазоні до --limit число з найдовшою послідовністю Коллатца в N потоках і для N = 1…--max-threads (до 16) вимірює медіану трьох запусків. Програма виводить таблицю часу, прискорення й ефективності, кількість потоків із найменшим часом і кількість, за якої ефективність стає меншою за 0,5, і зберігає таблицю у CSV-файл (--csv); опція --help.

Варіант 12. Таймер резервного копіювання

1. Початковий рівень. Створити консольну програму, яка за допомогою System.Threading.Timer кожні 500 мс виводить повідомлення «резервна копія N» з часом і номером потоку пулу, працює 3 секунди, а потім зупиняє таймер і виводить кількість спрацювань.

2. Базовий рівень. Створити консольну програму, яка запитує шлях до файлу, період таймера в мілісекундах і тривалість роботи в секундах, перевіряє введення, а потім за допомогою System.Threading.Timer при кожному спрацюванні копіює файл у каталог backup з міткою часу в імені та записує рядок у журнал. Після завершення таймер зупиняється методом Dispose, і програма виводить журнал.

3. Високий рівень. Створити консольний застосунок з опціями --source, --target, --period, --keep N і --help, який періодично копіює файл таймером, зберігає лише N останніх копій, не запускає нове копіювання, якщо попереднє ще триває (прапорець зайнятості), і коректно зупиняється після натискання Enter. Програма виводить журнал спрацювань із тривалістю копіювання та кількістю пропущених спрацювань. Помилки копіювання записуються в журнал і потік помилок без аварійного завершення.

Варіант 13. Сортування файлів частинами

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

2. Базовий рівень. Створити консольну програму, яка запитує розмір масиву та кількість потоків (степінь двійки), генерує масив випадкових цілих чисел (фіксоване зерно), сортує його частини в окремих потоках, зливає їх попарно й перевіряє впорядкованість. Програма виводить час сортування частин, час злиття, загальний час і час Array.Sort для всього масиву.

3. Високий рівень. Створити консольний застосунок, який сортує текстовий файл із числами (по одному в рядку) з опціями --input, --output, --threads і --help. Потоки сортують блоки, основний потік виконує k-шляхове злиття, результат записується у файл. Програма виводить таблицю часу етапів (читання, сортування, злиття, запис) для 1…N потоків і частку паралельної частини. Некоректні рядки файлу спричиняють повідомлення з номером рядка та код 1.

Варіант 14. Моніторинг процесів

1. Початковий рівень. Створити консольну програму, яка отримує список процесів Process.GetProcesses() і виводить 10 процесів із найбільшою кількістю потоків: ім’я, PID і кількість потоків.

2. Базовий рівень. Створити консольну програму, яка запитує критерій сортування (threads, memory) і кількість рядків, виводить таблицю процесів (ім’я, PID, потоки, робоча пам’ять у МБ) і пропускає процеси, до яких немає доступу, підраховуючи їх кількість.

3. Високий рівень. Створити консольний застосунок з опціями --interval, --count, --top, --name і --help, який робить знімки процесів через заданий інтервал, для кожного процесу обчислює завантаження процесора між знімками (TotalProcessorTime) і зміну кількості потоків, виводить оновлювану таблицю найактивніших процесів і записує всі знімки у CSV-файл. Процеси, що завершилися між знімками, коректно пропускаються.

Варіант 15. Шифр Цезаря для текстів

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

2. Базовий рівень. Створити консольну програму, яка запитує шлях до текстового файлу, зсув і кількість потоків, шифрує текст шифром Цезаря для українського алфавіту частинами в потоках, записує результат у файл із суфіксом .enc і виводить час паралельного та послідовного шифрування та прискорення.

3. Високий рівень. Створити консольний застосунок, який шифрує або розшифровує текстовий файл шифром Цезаря в кількох потоках з опціями --encrypt|--decrypt, --shift, --input, --output, --threads і --help і підтримує український та англійський алфавіти з великими й малими літерами. Для великих файлів програма виводить таблицю часу для 1…N потоків і перевіряє, що шифрування й розшифрування повертають початковий текст. Відсутній файл або некоректний зсув – повідомлення в потік помилок і коди завершення 1 або 2.

Варіант 16. Факторизація чисел

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

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

3. Високий рівень. Створити консольний застосунок з опціями --input, --min-threads і --help, який факторизує числа роботами пулу потоків, вимірює для кожної роботи затримку від постановки в чергу до старту і час виконання, а також виводить середню й максимальну затримку, ThreadPool.ThreadCount і CompletedWorkItemCount. Порівняння запусків зі стандартним мінімумом потоків і зі значенням --min-threads виводиться таблицею. Некоректні числа пропускаються з повідомленням у потік помилок.

Варіант 17. Спорідненість ядер

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

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

3. Високий рівень. Створити консольний застосунок з опціями --threads, --work і --help, який вимірює час однакового обчислення з масками: один логічний процесор, два логічні процесори одного фізичного ядра, два різні фізичні ядра, половина процесорів, усі процесори. Програма виводить таблицю «маска – кількість процесорів – час – прискорення відносно одного процесора» і висновок, чи дає SMT додаткове прискорення. На ОС без підтримки спорідненості програма завершується з кодом 1.

Варіант 18. Парковка торгового центру

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

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

3. Високий рівень. Створити консольний застосунок з опціями --floors, --places, --duration і --help, у якому потоки-датчики імітують в’їзд і виїзд автомобілів, фоновий потік-табло виводить заповненість поверхів, а за командою stop або після --duration секунд виконується кооперативна зупинка з тайм-аутом Join. Потоки, що не зупинилися вчасно, виводяться в потік помилок; програма повертає код 0 або 1 і виводить статистику в’їздів і виїздів кожного поверху.

Варіант 19. Матриця відстаней міст

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

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

3. Високий рівень. Створити консольний застосунок, який читає міста з CSV-файлу назва;широта;довгота з опціями --threads, --nearest K і --help, обчислює матрицю відстаней за формулою гаверсинуса рядками в потоках і для кожного міста виводить K найближчих. Програма виводить таблицю часу, прискорення та ефективності для 1…N потоків (медіана трьох запусків). Некоректні координати спричиняють повідомлення з номером рядка.

Варіант 20. Паліндроми в словнику

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

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

3. Високий рівень. Створити консольний застосунок, який рахує паліндроми в словнику (файл --dictionary, одне слово в рядку) у кількох потоках з опціями --split letters|equal, --threads і --help та порівнює розбиття словника за першими літерами (групи різного розміру) і на рівні частини. Для обох розбиттів програма виводить кількість паліндромів, час, розміри найбільшої й найменшої частини, прискорення і висновок, яке розбиття ефективніше. Порожній словник – код завершення 1.

Варіант 21. Контрольні суми файлів

1. Початковий рівень. Створити консольну програму, яка обчислює контрольну суму SHA-256 для всіх файлів заданого в програмі каталогу, використовуючи окремий потік на кожен файл, і виводить ім’я файлу та суму в шістнадцятковому вигляді.

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

3. Високий рівень. Створити консольний застосунок, який обчислює контрольні суми SHA-256 файлів каталогу --dir з опціями --mode threads|processes, --n і --help. У режимі processes координатор запускає себе дочірнім процесом на кожну групу файлів (--worker файл…) і збирає суми зі стандартного виводу. Програма записує суми у файл SHA256SUMS, виводить порівняльну таблицю часу потоків і процесів і повідомляє про файли, які не вдалося прочитати (код завершення 1).

Варіант 22. Сплайн-інтерполяція сигналу

1. Початковий рівень. Створити консольну програму, яка для сигналу з 1 000 відліків функції sin(x) обчислює значення лінійної інтерполяції в 10 точках між кожною парою відліків, розбиваючи ділянки на два потоки, і виводить максимальну похибку відносно sin(x).

2. Базовий рівень. Створити консольну програму, яка запитує кількість відліків і потоків, будує інтерполяцію кубічним сплайном Катмулла–Рома ділянками в потоках, порівнює результат із послідовним варіантом (максимальна різниця менша за 1e-12) і виводить час.

3. Високий рівень. Створити консольний застосунок, який читає сигнал (відліки) з CSV-файлу й виконує інтерполяцію кубічним сплайном Катмулла–Рома ділянками в потоках з урахуванням сусідніх відліків на межах частин. Опції: --factor (кількість нових точок на інтервал), --threads, --output, --help. Програма записує результат у файл і виводить таблицю часу, прискорення та ефективності для 1…N потоків із перевіркою за послідовною версією.

Варіант 23. Відеоспостереження (імітація кадрів)

1. Початковий рівень. Створити консольну програму, у якій чотири потоки-обробники імітують обробку 20 кадрів кожен (Thread.Sleep(10)), при цьому один потік на 7-му кадрі генерує виняток; обробник перехоплює виняток, зберігає повідомлення, а основний потік після Join виводить звіт для кожної камери.

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

3. Високий рівень. Створити консольний застосунок, який імітує обробку --frames кадрів з --cameras камер (потік на камеру; пошкоджений кадр з імовірністю --error-rate генерує виняток) з опціями --fail-fast і --help. Потоки записують винятки в масив результатів; у режимі --fail-fast перший виняток встановлює прапорець зупинки для всіх потоків. Режим --crash показує, що необроблений виняток завершує процес (журналювання через AppDomain.UnhandledException). Програма виводить підсумкову таблицю камер і код завершення 1, якщо були помилки.

Варіант 24. Прогрес завантаження ігрових рівнів

1. Початковий рівень. Створити консольну програму, у якій три потоки «завантажують» рівні гри (цикл із 100 кроків по 20 мс) і записують відсоток прогресу у свій елемент масиву, а основний потік кожні 200 мс виводить прогрес усіх рівнів, доки всі потоки не завершаться.

2. Базовий рівень. Створити консольну програму, яка запитує кількість рівнів і їхні розміри в умовних одиницях, запускає потоки завантаження та виводить в одному рядку текстові смуги прогресу ([#####-----] 50 %) для кожного рівня й загальний прогрес.

3. Високий рівень. Створити консольний застосунок з опціями --levels файл, --threads, --refresh і --help, у якому рівні з файлу розподіляються між обмеженою кількістю потоків, основний потік оновлює таблицю прогресу на місці (Console.SetCursorPosition), показує оцінку часу до завершення, а Esc кооперативно скасовує завантаження. Після завершення виводиться час кожного рівня та ідентифікатор потоку.

Варіант 25. Гістограма зросту призовників

1. Початковий рівень. Створити консольну програму, яка генерує 1 000 000 значень зросту (нормальний розподіл із середнім 176 см, фіксоване зерно) і будує гістограму за інтервалами по 5 см у чотирьох потоках, кожен з яких рахує свою частину в локальний масив; потім локальні гістограми об’єднуються й виводяться.

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

3. Високий рівень. Створити консольний застосунок з опціями --input (файл зі значеннями), --bin, --threads і --help, який будує гістограму, обчислює середнє, медіану й стандартне відхилення, відкидає значення поза межами 100…250 см з лічильником і виводить таблицю часу, прискорення та ефективності для 1…N потоків. Гістограма зберігається у CSV-файл.

Варіант 26. Банківські відсотки за вкладами

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

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

3. Високий рівень. Створити консольний застосунок, який читає CSV-файл вкладів відділення;рахунок;сума; ставка;місяці з опціями --threads, --report і --help, групує вклади за відділеннями, обчислює відсотки в потоках і записує звіт відділень у файл. Програма виводить таблицю часу для 1…N потоків і перевіряє точний збіг сум decimal з послідовною версією. Рядки з від’ємними сумами відхиляються з повідомленням.

Варіант 27. Мінімальний пул потоків

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

2. Базовий рівень. Створити консольну програму з класом SimplePool, що має N іменованих фонових робочих потоків і чергу BlockingCollection<Action> (як готовий засіб), методи Enqueue і Shutdown (очікує завершення робіт). Виконати 100 робіт і вивести кількість робіт, виконаних кожним потоком.

3. Високий рівень. Створити консольний застосунок із власним пулом потоків з опціями --workers, --jobs і --help, який обробляє винятки робіт (збирає їх у список, не зупиняючи потоки), підтримує Shutdown з тайм-аутом і виводить порівняльну таблицю часу виконання робіт власним пулом, ThreadPool і окремими потоками для 100, 1 000 і 10 000 робіт.

Варіант 28. Пріоритети рендерингу

1. Початковий рівень. Створити консольну програму, яка запускає два потоки «рендерингу» з однаковою обчислювальною роботою та пріоритетами ThreadPriority.Lowest і Highest і виводить час виконання кожного потоку.

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

3. Високий рівень. Створити консольний застосунок з опціями --frames, --affinity, --class Normal|BelowNormal|High і --help, який вимірює час рендерингу кадрів потоками з різними пріоритетами за різних масок спорідненості та класів пріоритету процесу, виводить таблицю результатів і попереджає, що на Linux пріоритети потоків можуть не діяти. Некоректні опції повертають код 2.

Варіант 29. Решето Ератосфена сегментами

1. Початковий рівень. Створити консольну програму, яка знаходить прості числа до 10 000 000 сегментованим решетом: базові прості до кореня знаходить основний потік, а чотири сегменти діапазону обробляють чотири потоки; вивести кількість простих чисел.

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

3. Високий рівень. Створити консольний застосунок з опціями --limit, --segment (розмір сегмента в КБ), --max-threads і --help, який виконує сегментоване решето для 1…N потоків і різних розмірів сегмента (32 КБ, 256 КБ, 4 МБ), виводить таблицю часу, прискорення та ефективності і найкращу конфігурацію. Кількість простих перевіряється за послідовною версією.

Варіант 30. Голодування пулу потоків

1. Початковий рівень. Створити консольну програму, яка ставить у пул потоків 40 робіт із Thread.Sleep(2000) і кожні 250 мс виводить ThreadPool.ThreadCount і ThreadPool.PendingWorkItemCount протягом 3 секунд.

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

3. Високий рівень. Створити консольний застосунок з опціями --jobs, --block-ms, --min-threads список (наприклад, default,16,64) і --help, який для кожного значення мінімуму запускає окремий дочірній процес (щоб налаштування пулу не впливали одне на одне), збирає статистику затримок старту робіт і виводить таблицю «мінімум – середня затримка – максимальна затримка – загальний час». Програма також виводить команду dotnet-counters для спостереження за процесом.

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

1. Опрацювати теоретичні відомості та приклади розв’язання завдань; з’ясувати в диспетчері завдань або командою lscpu кількість фізичних ядер і логічних процесорів свого комп’ютера.
2. Для свого варіанта визначити, як розбити задачу на частини (потоки, роботи пулу або процеси), куди кожен потік записує результат і як перевірити результат за послідовною версією.
3. Створити в JetBrains Rider консольне рішення .NET 10 і реалізувати завдання обраного рівня складності; потокам дати імена.
4. Перевірити роботу в налагоджувачі: зупинитися в методі потоку й переглянути список потоків у вікні Debug; для завдань із пулом переглянути лічильники dotnet-counters.
5. Виміряти час у конфігурації Release з прогріванням і медіаною кількох запусків; побудувати таблицю часу, прискорення та ефективності й пояснити отримані значення.
6. Продемонструвати роботу програми викладачеві, пояснити програмний код і відповісти на контрольні питання.