Завдання

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

Програми C# у завданнях невеликі: головне – історія їх розробки в Git. Усі завдання виконуються з локальними репозиторіями, без облікового запису GitHub і доступу до мережі.

Варіанти

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

1. Початковий рівень. Створити консольну програму C# «Список покупок», яка виводить товари з кількістю, і вести її історію в локальному репозиторії Git: створити .gitignore командою dotnet new gitignore, зробити щонайменше чотири коміти зі змістовними повідомленнями (створення проєкту, виведення списку, додавання товару з клавіатури, підрахунок позицій) і показати історію командою git log --oneline.

2. Базовий рівень. Створити консольну програму C# «Список покупок» (товари з кількістю та ціною) у локальному репозиторії Git і розробити в гілках feature/remove (видалення товару) і feature/total (підрахунок вартості) по два коміти; злити першу гілку в main перемотуванням (fast-forward), а другу – тристороннім злиттям після нового коміту в main, видалити злиті гілки, позначити результат анотованим тегом v1.0 і показати git log --oneline --graph --all та git show v1.0.

3. Високий рівень. Створити консольну програму C# «Список покупок» (товари з кількістю) і організувати її командну розробку без хостингу: створити порожній репозиторій D:\Labs\remote\Shopping.git, надіслати в нього main і зробити другий клон від імені іншого учасника (власні user.name і user.email у клоні). Кожен учасник розробляє свою функцію (сортування, збереження списку у файл) в окремій гілці та надсилає її, а інший переглядає гілку командами git log main..origin/<гілка> і git diff main...origin/<гілка> і зливає. Отримати та розв’язати один конфлікт злиття, позначити випуск тегом v1.0 з файлом CHANGELOG.md і показати граф історії в обох клонах та git ls-remote --tags origin.

Варіант 2. Бібліотечний формуляр

1. Початковий рівень. Створити консольну програму C# «Бібліотечний формуляр» (видані читачеві книги та дати їх повернення) і зафіксувати її розробку в локальному репозиторії Git щонайменше десятьма невеликими комітами, кожен з яких залишає проєкт у стані, що збирається; показати історію командами git log --oneline і git log --stat -3.

2. Базовий рівень. Створити консольну програму C# «Бібліотечний формуляр» (видані читачеві книги та дати їх повернення) у репозиторії Git, створити гілку feature/overdue (пошук прострочених книг) з двома комітами, тим часом додати в main коміт з іншою зміною, перебазувати гілку командою git rebase main, злити її перемотуванням і показати, що історія лінійна (git log --oneline --graph), а хеші комітів гілки змінилися.

3. Високий рівень. Створити консольну програму C# «Бібліотечний формуляр» (видані книги та дати повернення) у репозиторії Git і підготувати її випуски за правилами семантичного версіювання: розробити в окремих гілках виправлення помилки, нову функцію та зміну формату виведення, перед злиттям перебазовувати кожну гілку на актуальний main, після кожного злиття доповнювати CHANGELOG.md і ставити анотовані теги v1.0.0, v1.0.1, v1.1.0; створити архів випуску командою git archive --format=zip -o Library-1.1.0.zip v1.1.0 і показати git tag -n, git log --oneline --graph --decorate та git diff --stat v1.0.0 v1.1.0.

Варіант 3. Облік витрат

1. Початковий рівень. Створити консольну програму C# «Облік витрат», яка підсумовує витрати за категоріями, у репозиторії Git; закомітити помилкову зміну (неправильний підсумок), скасувати її командою git revert і показати командами git log --oneline та git show, що історія зберегла обидва коміти.

2. Базовий рівень. Створити консольну програму C# «Облік витрат» (підсумок витрат за категоріями) у репозиторії Git, створити дві гілки, які по-різному змінюють рядок виведення підсумку, злити їх у main, отримати конфлікт і розв’язати його в терміналі (видалити маркери, об’єднати зміни), перевірити збірку й завершити злиття; показати git status під час конфлікту та git log --oneline --graph після злиття.

3. Високий рівень. Створити консольну програму C# «Облік витрат» (підсумок витрат за категоріями) і змоделювати роботу двох учасників з порожнім репозиторієм D:\Labs\remote\Expenses.git і двома клонами: обидва змінюють обчислення підсумку, другий отримує відмову git push (rejected), виконує git pull, розв’язує конфлікт у редакторі злиття Visual Studio 2026 і надсилає результат. Потім знайти опублікований помилковий коміт, скасувати його командою git revert без переписування історії, вести CHANGELOG.md і показати граф історії обох клонів.

Варіант 4. Розклад дзвінків

1. Початковий рівень. Створити консольну програму C# «Розклад дзвінків», яка виводить час початку й кінця пар, у репозиторії Git; почати зміну тривалості перерви, сховати незавершену роботу командою git stash, виправити й закомітити помилку в назві пари, повернути зміни командою git stash pop і завершити їх окремим комітом. Показати git stash list і git log --oneline.

2. Базовий рівень. Створити консольну програму C# «Розклад дзвінків» (час початку й кінця пар) у репозиторії Git і розробити в гілках feature/short-day (скорочений день) і feature/next-bell (час до наступного дзвінка) дві функції: під час роботи над першою сховати зміни з повідомленням (git stash push -m), завершити другу, повернутися й відновити схованку; злити обидві гілки й поставити анотований тег v1.0. Показати git log --oneline --graph --all і git tag -n.

3. Високий рівень. Створити консольну програму C# «Розклад дзвінків», що читає час пар із файлу, у репозиторії Git і організувати її випуски: гілки функцій, теги v1.0.0 і v1.1.0, дві незалежні незавершені зміни в схованці, застосовані вибірково (git stash apply "stash@{1}"). Після випуску v1.1.0 виправити помилку в гілці hotfix/1.1.1, створеній від тегу (git switch -c hotfix/1.1.1 v1.1.0), злити її в main, поставити тег v1.1.1 і доповнити CHANGELOG.md. Показати граф історії, теги та git diff v1.1.0 v1.1.1.

Варіант 5. Щоденник погоди

1. Початковий рівень. Створити консольну програму C# «Щоденник погоди» (температури за тиждень і середнє значення) у репозиторії Git із файлами .gitignore і .gitattributes, створеними шаблонами dotnet new, зробити кілька комітів і показати командою git ls-files --eol, що текстові файли зберігаються в індексі з кінцями рядків LF.

2. Базовий рівень. Створити консольну програму C# «Щоденник погоди» (температури за тиждень і середнє значення) у репозиторії Git, зробити щонайменше вісім комітів, в одному з яких непомітно внести помилку в обчислення середньої температури; знайти цей коміт командою git bisect, позначаючи версії good і bad після запуску програми, показати його зміни командою git show і скасувати помилку командою git revert.

3. Високий рівень. Створити консольну програму C# «Щоденник погоди» з методом обчислення мінімуму, максимуму й середнього значення температур, створити її історію з 15 і більше комітів із прихованою помилкою, написати сценарій перевірки, який запускає програму з відомими даними й повертає код 0 для правильного результату, і знайти помилковий коміт автоматично командою git bisect run. Показати git bisect log, автора рядка з помилкою (git blame -L), виправити помилку в гілці fix/average і злити її.

Варіант 6. Журнал оцінок

1. Початковий рівень. Створити консольну програму C# «Журнал оцінок» (оцінки студентів і середній бал), закомітити її в локальний репозиторій Git, створити порожній репозиторій командою git init --bare D:\Labs\remote\Grades.git, додати його як origin, надіслати гілку main командою git push -u origin main і показати git remote -v та git status.

2. Базовий рівень. Створити консольну програму C# «Журнал оцінок» (оцінки студентів і середній бал), порожній репозиторій D:\Labs\remote\Grades.git і два клони від імені двох учасників (у кожному клоні свої user.name і user.email); перший додає сортування за середнім балом, другий – пошук студента; кожен надсилає свої коміти й отримує зміни іншого командою git pull. Показати git log --oneline --graph і git shortlog -sn в обох клонах.

3. Високий рівень. Створити консольну програму C# «Журнал оцінок» (оцінки студентів і середній бал) і змоделювати перегляд її коду без хостингу: порожній репозиторій і два клони; автор надсилає гілку feature/report, рецензент переглядає її командами git log main..origin/feature/report і git diff main...origin/feature/report, записує зауваження у файл REVIEW.md окремим комітом у гілці, автор виправляє їх новими комітами, рецензент зливає гілку з ключем --no-ff і видаляє її на сервері й локально (git push origin --delete, git fetch --prune). Показати граф історії та git branch -a в обох клонах.

Варіант 7. Трекер тренувань

1. Початковий рівень. Створити консольну програму C# «Трекер тренувань» (вид тренування, тривалість, сумарний час) у репозиторії Git, поставити анотований тег v1.0, виправити округлення тривалості в гілці hotfix/rounding, злити її в main, поставити тег v1.0.1 і показати git tag -n та git log --oneline --decorate.

2. Базовий рівень. Створити консольну програму C# «Трекер тренувань» (вид тренування, тривалість, сумарний час) у репозиторії Git, зробити в гілці feature/stats три коміти, один з яких виправляє помилку, що є і в main; перенести в main лише це виправлення командою git cherry-pick, поставити тег v1.0.1, а потім перебазувати feature/stats на main і показати, що Git пропустив уже перенесений коміт.

3. Високий рівень. Створити консольну програму C# «Трекер тренувань» (тренування та сумарний час) у репозиторії Git і підтримувати дві лінії її випусків: гілку release/1.x, створену від тегу v1.0.0, і main для версії 2. Виправлення робити в main і переносити в release/1.x командою git cherry-pick -x, розв’язуючи конфлікти, якщо код гілок розійшовся; ставити теги v1.0.1 і v2.0.0 і вести CHANGELOG.md у кожній лінії. Показати git log --oneline --graph --all, повідомлення перенесеного коміту та git branch --contains для виправлення.

Варіант 8. Меню кав’ярні

1. Початковий рівень. Створити консольну програму C# «Меню кав’ярні» (страви та ціни) з класом страви в окремому файлі у репозиторії Git; видалити файл класу й закомітити видалення, потім відновити файл з попереднього коміту командою git restore --source HEAD~1 <файл> і закомітити відновлення. Показати git log --oneline --stat.

2. Базовий рівень. Створити консольну програму C# «Меню кав’ярні» (страви та ціни) у репозиторії Git і позначити три її версії анотованими тегами з описом змін (v1.0 – меню, v1.1 – знижки, v1.2 – пошук страви); показати git tag -n, вміст файлу у версії 1.0 (git show v1.0:Program.cs), зміни git diff v1.0 v1.2, тимчасово перейти до версії v1.1 командою git switch --detach і повернутися на main.

3. Високий рівень. Створити консольну програму C# «Меню кав’ярні», що зберігає страви й ціни у файлі menu.json, у репозиторії Git і відновити втрачені дані: після кількох комітів закомітити очищене меню, виконати git reset --hard на кілька комітів назад, знайти втрачені коміти в git reflog, відновити гілку, повернути menu.json з потрібної версії командою git restore --source і описати послідовність дій у файлі RECOVERY.md. Показати git reflog -10 і фінальну історію.

Варіант 9. Парковка

1. Початковий рівень. Створити консольну програму C# «Парковка» (вільні та зайняті місця) у локальному репозиторії Git і розробити три функції (заїзд, виїзд, звіт) у трьох окремих гілках, кожну з яких злити в main командою git merge --no-ff; показати git log --oneline --graph із трьома комітами злиття.

2. Базовий рівень. Створити консольну програму C# «Парковка» (вільні та зайняті місця) у репозиторії Git, надіслати її в порожній репозиторій D:\Labs\remote\Parking.git і захистити в ньому гілку main параметрами receive.denyNonFastForwards і receive.denyDeletes; показати, що звичайне надсилання працює, а git push --force після git commit --amend опублікованого коміту та git push origin --delete main сервер відхиляє.

3. Високий рівень. Створити консольну програму C# «Парковка» (заїзд, виїзд, звіт про вільні місця) і організувати для неї робочий процес за зразком GitHub Flow без хостингу: порожній репозиторій із захищеною гілкою main і серверним хуком pre-receive, який відхиляє надсилання, якщо повідомлення будь-якого нового коміту коротше за 10 символів; три гілки функцій від двох учасників, перегляд кожної гілки перед злиттям (git log, git diff main...), злиття з --no-ff, видалення гілок на сервері. Показати відмову хука, граф історії та git ls-remote origin.

Варіант 10. Словник термінів

1. Початковий рівень. Створити консольну програму C# «Словник термінів» (пошук визначення за терміном) у репозиторії Git, у двох гілках по-різному змінити повідомлення «термін не знайдено», злити гілки в main, розв’язати конфлікт у терміналі й показати маркери конфлікту до виправлення та git log --oneline --graph після нього.

2. Базовий рівень. Створити консольну програму C# «Словник термінів» (клас словника та пошук визначення за терміном у Program.cs) у репозиторії Git, отримати конфлікт злиття одразу у двох файлах (клас словника та Program.cs) і розв’язати його в редакторі злиття Visual Studio 2026 (Git Changes, Unmerged Changes, Accept Merge): в одному файлі прийняти обидві зміни, в іншому – лише вхідні; завершити злиття комітом і показати його командою git show --stat.

3. Високий рівень. Створити консольну програму C# «Словник термінів», що зберігає терміни й визначення у файлі terms.txt, і змоделювати паралельну роботу двох учасників із порожнім репозиторієм і двома клонами: обидва редагують сусідні рядки файлу й отримують конфлікти під час git pull і git rebase; один розв’язує конфлікт злиттям у Visual Studio 2026, інший – перебазуванням у терміналі (git rebase --continue). Увімкнути git config merge.conflictStyle zdiff3, показати маркери зі спільною версією та пояснити їх у файлі CONFLICTS.md.

Варіант 11. Облік автопарку

1. Початковий рівень. Створити консольну програму C# «Облік автопарку» (автомобілі та пробіг) у локальному репозиторії Git, зробити три коміти, скасувати два останні командою git reset --soft HEAD~2, об’єднати їхні зміни в один коміт і показати історію до та після (git log --oneline).

2. Базовий рівень. Створити консольну програму C# «Облік автопарку» (автомобілі та пробіг) у репозиторії Git і продемонструвати режими git reset --soft, --mixed і --hard на однаковій послідовності комітів (у трьох тимчасових гілках), після кожного показати git status --short і git log --oneline -3, а потім відновити коміти, втрачені після --hard, за допомогою git reflog.

3. Високий рівень. Створити консольну програму C# «Облік автопарку» (автомобілі та пробіг), порожній репозиторій D:\Labs\remote\Fleet.git і два клони та показати різницю між локальними й опублікованими комітами: локальні помилкові коміти прибрати командою git reset, опублікований помилковий коміт скасувати командою git revert і надіслати; показати, що git push --force-with-lease відхиляється, якщо інший учасник уже надіслав нові коміти. Записати правила скасування змін для команди у файл NOTES.md і показати історію обох клонів.

Варіант 12. Калькулятор оренди

1. Початковий рівень. Створити консольну програму C# «Калькулятор оренди» (вартість за кількістю днів і тарифом) у репозиторії Git, позначити версію анотованим тегом v1.0.0, створити легкий тег v1.0.0-test, порівняти обидва теги командою git show і видалити легкий тег.

2. Базовий рівень. Створити консольну програму C# «Калькулятор оренди» (вартість за кількістю днів і тарифом) у репозиторії Git і випустити версії v1.0.0, v1.0.1 (виправлення), v1.1.0 (знижка за тиждень) і v2.0.0 (новий формат введення), ведучи файл CHANGELOG.md з розділом для кожної версії; показати git tag -n, git log --oneline --decorate і список змін між версіями git log --oneline v1.0.0..v1.1.0.

3. Високий рівень. Створити консольну програму C# «Калькулятор оренди» (вартість за днями й тарифом) у репозиторії Git і сценарій PowerShell release.ps1 для її випуску, який отримує номер версії в аргументі, перевіряє формат MAJOR.MINOR.PATCH, чистоту робочого каталогу (git status --porcelain) і відсутність такого тегу, збирає проєкт, додає до CHANGELOG.md розділ з повідомленнями комітів після попереднього тегу (git log --pretty=format:"- %s"), створює коміт, анотований тег і архів git archive; у разі помилки виводить повідомлення в потік помилок і завершується з ненульовим кодом.

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

1. Початковий рівень. Створити консольну програму C# «Прокат велосипедів», яка читає тариф і пароль доступу до бази з файлу appsettings.Local.json, у репозиторії Git; додати цей файл до .gitignore, закомітити шаблон appsettings.Example.json без секретів і показати командами git status та git check-ignore -v, що файл із секретом ігнорується.

2. Базовий рівень. Створити консольну програму C# «Прокат велосипедів» (тариф і пароль доступу до бази у файлі secrets.json) у репозиторії Git і виправити ситуацію, коли в коміт потрапили папки bin, obj і файл secrets.json: додати правила до .gitignore, прибрати файли з індексу командою git rm -r --cached, закомітити зміни й показати git ls-files до та після; пояснити у README.md, чому секрет, що потрапив в історію, вважають скомпрометованим.

3. Високий рівень. Створити консольну програму C# «Прокат велосипедів», що читає тариф і пароль доступу до бази з файлу secrets.json, у репозиторії Git і написати хук pre-commit у папці .githooks, підключеній через core.hooksPath, який відхиляє коміт, якщо серед підготовлених файлів (git diff --cached --name-only) є *.pfx, secrets.json чи .env або в їхньому вмісті є рядок Password=; хук пояснює причину в потоці помилок. Показати відмову хука, успішний коміт після виправлення та правила .gitignore, перевірені командою git check-ignore -v.

Варіант 14. Медична картка

1. Початковий рівень. Створити консольну програму C# «Медична картка» (дані пацієнта та список візитів) у репозиторії Git, розробити додавання візиту в гілці feature/visit, перед злиттям перебазувати гілку на оновлений main і злити її перемотуванням; показати граф історії до та після перебазування.

2. Базовий рівень. Створити консольну програму C# «Медична картка» (дані пацієнта, алергії та візити) у репозиторії Git і розробити три функції в гілках feature/allergies, feature/visits і feature/export, між злиттями додаючи коміти в main; кожну гілку перед злиттям перебазувати на main, розв’язати конфлікт перебазування (git rebase --continue) і злити перемотуванням. Показати лінійну історію git log --oneline --graph.

3. Високий рівень. Створити консольну програму C# «Медична картка» (дані пацієнта та візити) у репозиторії Git і впорядкувати історію гілки функції перед злиттям: зробити 6–8 дрібних комітів (зокрема «fix typo», «wip»), об’єднати їх у 2–3 логічні коміти командою git rebase -i (дії squash, reword, зміна порядку), перебазувати гілку на актуальний main, перевірити збірку після кожного коміту командою git rebase --exec "dotnet build" main і злити гілку. Показати історію до та після та знайти в git reflog стан гілки до впорядкування.

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

1. Початковий рівень. Створити консольну програму C# «Турнірна таблиця» (команди, очки, сортування) у репозиторії Git з кількома гілками та злиттями й показати історію різними форматами: git log --oneline --graph --all, git log --stat, git log --since, git log --author і git log --pretty=format:"%h %an %ad %s" --date=short.

2. Базовий рівень. Створити консольну програму C# «Турнірна таблиця» (команди, очки, сортування) у репозиторії Git, змоделювати роботу трьох авторів (різні user.name або параметр --author), зробити не менше 12 комітів і вивести: кількість комітів кожного автора (git shortlog -sn), коміти одного автора за період, змінені файли кожного коміту (git log --name-only) та історію одного файлу (git log --follow).

3. Високий рівень. Створити консольну програму C# GitStats, яка отримує в аргументі шлях до репозиторію, запускає git log з параметром --pretty=format: через System.Diagnostics.Process і виводить таблицю авторів із кількістю комітів, першою та останньою датою, а також кількість комітів за днями тижня; перевірити її на репозиторії з комітами щонайменше трьох авторів, повідомляти про помилки (папка не є репозиторієм, Git не встановлено) у потік помилок з ненульовим кодом завершення. Вести розробку GitStats у власному репозиторії з тегом v1.0.

Варіант 16. Рецепти

1. Початковий рівень. Створити консольну програму C# «Рецепти» (інгредієнти та кроки приготування) у репозиторії Git, злити гілку з новою функцією тристороннім злиттям і скасувати це злиття командою git revert -m 1 <коміт злиття>; показати git log --oneline --graph і пояснити значення ключа -m 1.

2. Базовий рівень. Створити консольну програму C# «Рецепти» (інгредієнти та кроки приготування) у репозиторії Git, злити гілку feature/scale (перерахунок інгредієнтів на кількість порцій) з конфліктом, розв’язати його, потім скасувати злиття командою git revert -m 1; виправити гілку й повторно злити її, попередньо скасувавши коміт відміни (git revert цього коміту). Показати граф історії.

3. Високий рівень. Створити консольну програму C# «Рецепти», що зберігає рецепти (інгредієнти та кроки) у файлі recipes.json, і змоделювати паралельне редагування тих самих рецептів двома учасниками з порожнім репозиторієм і двома клонами; розв’язувати конфлікти так, щоб файл залишався коректним JSON (перевірка програмою після злиття), скасувати помилкове злиття командою git revert -m 1, надіслати відміну й повторно злити виправлену гілку. Налаштувати .gitattributes для *.json і показати граф історії обох клонів.

Варіант 17. Розклад поїздів

1. Початковий рівень. Створити консольну програму C# «Розклад поїздів» (номер, пункт призначення, час відправлення) у репозиторії Git з комітами двох авторів (різні user.name або параметр --author), знайти автора й коміт рядка з неправильним форматом часу командою git blame -L і виправити рядок у гілці fix/time-format.

2. Базовий рівень. Створити консольну програму C# «Розклад поїздів» (номер, пункт призначення, час відправлення, сортування за часом) у репозиторії Git з кількома комітами, в одному з яких з’являється помилка сортування; знайти цей коміт командами git log -S, git log -G і git blame, переглянути його зміни (git show), виправити помилку в гілці fix/sort, злити її й переглянути у Visual Studio 2026 анотації Git → Blame (Annotate) для виправленого рядка.

3. Високий рівень. Створити консольну програму C# «Розклад поїздів» (номер, пункт призначення, час) у репозиторії Git з комітами кількох авторів і звіт про походження її коду: консольна програма C# або сценарій PowerShell отримує шлях до репозиторію в аргументі, для кожного файлу .cs обчислює за даними git blame --line-porcelain кількість рядків кожного автора й виводить таблицю «файл – автор – рядки – %». Також знайти коміт, що вніс помилку в програму, командою git bisect run, виправити помилку в гілці та злити її. Показати звіт і git bisect log.

Варіант 18. Облік комунальних платежів

1. Початковий рівень. Створити консольну програму C# «Облік комунальних платежів» (послуги, покази, сума) у репозиторії Git; почати дві незалежні зміни, сховати кожну окремо з повідомленням (git stash push -m), показати git stash list і git stash show -p, застосувати одну схованку, а іншу видалити.

2. Базовий рівень. Створити консольну програму C# «Облік комунальних платежів» (послуги, покази, сума) у репозиторії Git, сховати незавершені зміни разом із новим невідстежуваним файлом (git stash push -u -m), виправити помилку в іншій гілці, повернутися й відновити схованку; окремо створити зі схованки нову гілку командою git stash branch і завершити в ній роботу. Показати git status --short на кожному кроці.

3. Високий рівень. Створити консольну програму C# «Облік комунальних платежів» (послуги, покази, сума) у репозиторії Git і змоделювати конфлікт під час git stash pop (файл змінено в гілці після створення схованки): розв’язати конфлікт, переконатися, що схованку не видалено, і видалити її вручну; сховати зміни лише одного файлу (git stash push -- <файл>) і лише частину змін (git stash push -p). Описати дії та результати у файлі STASH.md і показати історію.

Варіант 19. Шкільна бібліотека

1. Початковий рівень. Створити консольну програму C# «Шкільна бібліотека» (пошук книги за автором) у репозиторії Git і файл TASKS.md з трьома пронумерованими завданнями; виконати кожне завдання окремим комітом із номером завдання в повідомленні (наприклад, Add search by author (#1)) і знайти коміти завдання командою git log --grep.

2. Базовий рівень. Створити консольну програму C# «Шкільна бібліотека» (книги, пошук за автором) у репозиторії Git і вести список завдань у файлі TASKS.md (номер, опис, стан): для кожного завдання створювати гілку task/<номер>-<назва>, у повідомленні завершального коміту писати Closes #<номер>, після злиття з --no-ff позначати завдання виконаним. Показати git log --oneline --graph і git log --grep "Closes".

3. Високий рівень. Створити консольну програму C# «Шкільна бібліотека» (книги, пошук за автором) у репозиторії Git з файлом завдань TASKS.md і локальний аналог запитів на злиття: хук commit-msg, який вимагає в повідомленні посилання на завдання у форматі (#N) і перевіряє, що таке завдання є у TASKS.md, та сценарій PowerShell review.ps1, який для гілки з аргументу виводить її коміти (git log main..<гілка>), статистику змін (git diff --stat main...<гілка>) і номери згаданих завдань. Показати відмову хука, звіт сценарію для двох гілок і граф історії після злиття.

Варіант 20. Будильник

1. Початковий рівень. Створити консольну програму C# «Будильник» (час сигналу та залишок часу до нього) у репозиторії Git; зробити коміт з помилкою в повідомленні та без одного файлу й виправити його командою git commit --amend, а випадково доданий в індекс файл прибрати командою git restore --staged. Показати git status і git log --oneline після кожної дії.

2. Базовий рівень. Створити консольну програму C# «Будильник» (час сигналу та залишок часу до нього) у репозиторії Git, змінити в одному файлі два незалежні фрагменти й закомітити їх окремими комітами за допомогою часткового додавання git add -p, додати забуті зміни до останнього коміту командою git commit --amend --no-edit; показати git diff --staged перед кожним комітом і git log --stat.

3. Високий рівень. Створити консольну програму C# «Будильник» (час сигналу та залишок часу) у репозиторії Git і впорядкувати гілку з 8–10 безладних комітів перед злиттям: виправлення як git commit --fixup і git rebase -i --autosquash, перейменування комітів (reword), розділення одного коміту на два (edit, git reset HEAD~1, часткове додавання). Налаштувати хук commit-msg, який перевіряє, що перший рядок повідомлення не довший за 72 символи й не закінчується крапкою. Показати історію до та після та відмову хука.

Варіант 21. Каталог фільмів

1. Початковий рівень. Створити консольну програму C# «Каталог фільмів» (назва, рік, рейтинг) у локальному репозиторії Git, створити порожній репозиторій D:\Labs\remote\Movies.git, надіслати в нього main, клонувати його в іншу папку, зробити й надіслати коміт із клону, а в першому репозиторії отримати його командою git pull; показати git log --oneline в обох репозиторіях.

2. Базовий рівень. Створити консольну програму C# «Каталог фільмів» (назва, рік, рейтинг), порожній репозиторій і два клони та показати різницю між git fetch і git pull: після надсилання комітів із другого клону виконати в першому git fetch, порівняти main і origin/main (git status, git log main..origin/main, git diff main origin/main) і злити зміни git merge origin/main; повторити для розбіжних гілок з git pull --rebase.

3. Високий рівень. Створити консольну програму C# «Каталог фільмів» (назва, рік, рейтинг) у репозиторії Git і налаштувати два віддалені репозиторії: origin (порожній репозиторій на диску) і backup (другий порожній репозиторій в іншій папці або на флешці), надсилати гілки й теги в обидва (git push --all, git push --tags), видалити робочий клон і відновити проєкт із backup командою git clone; перевірити збіг історії й тегів (git log, git tag, git ls-remote) і описати процедуру резервного копіювання у файлі BACKUP.md.

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

1. Початковий рівень. Створити консольну програму C# «Банкомат» (баланс, зняття, поповнення) у локальному репозиторії Git, позначити дві версії анотованими тегами v1.0 і v1.1 та показати зміни між ними командами git diff v1.0 v1.1 і git log --oneline v1.0..v1.1.

2. Базовий рівень. Створити консольну програму C# «Банкомат» (баланс, зняття, поповнення) у репозиторії Git, створити теги v1.0, v1.1 (ліміт зняття готівки) і v1.2, зібрати й запустити кожну версію після git switch --detach <тег>, порівняти один файл у двох версіях (git diff v1.0 v1.2 -- Program.cs) і знайти першу версію з лімітом зняття (git log -S, git tag --contains).

3. Високий рівень. Створити консольну програму C# «Банкомат» (баланс, зняття, поповнення) з кількома версіями, позначеними тегами, і сценарій PowerShell compare.ps1, який приймає два теги, перевіряє їх наявність (git rev-parse --verify), виводить коміти між ними й статистику змін за файлами, збирає обидві версії в тимчасових робочих каталогах git worktree add і запускає їх з однаковими вхідними даними для порівняння результатів, а потім видаляє ці каталоги (git worktree remove); помилки виводить у потік помилок з ненульовим кодом завершення.

Варіант 23. Облік книг автора

1. Початковий рівень. Створити консольну програму C# «Облік книг автора» (книги та роки видання) у локальному репозиторії Git, зробити два коміти в гілці experiment/json, повернутися на main, переконатися, що git branch -d не видаляє незлиту гілку, і видалити її командою git branch -D.

2. Базовий рівень. Створити консольну програму C# «Облік книг автора» (книги та роки видання) у репозиторії Git, створити три експериментальні гілки, вивести злиті й незлиті гілки (git branch --merged, git branch --no-merged), злити одну, видалити решту, а потім відновити помилково видалену незлиту гілку за хешем із git reflog.

3. Високий рівень. Створити консольну програму C# «Облік книг автора» (книги та роки видання) у репозиторії Git і порівняти два варіанти збереження її даних у гілках experiment/json і experiment/csv, використовуючи git worktree для одночасної збірки й запуску обох варіантів у різних папках; обраний варіант злити в main з --no-ff, інший зберегти як тег archive/csv і видалити гілку. Показати git worktree list, git branch -a, git tag і граф історії.

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

1. Початковий рівень. Створити консольну програму C# «Метеостанція» (показання датчиків) у локальному репозиторії Git, надіслати її в порожній репозиторій D:\Labs\remote\Weather.git, створити його копію-«форк» командою git clone --bare D:\Labs\remote\Weather.git D:\Labs\remote\Weather-fork.git, клонувати форк у робочу папку, додати вихідний репозиторій як upstream і показати git remote -v.

2. Базовий рівень. Створити консольну програму C# «Метеостанція» (показання датчиків), надіслати її у вихідний порожній репозиторій upstream, створити його копію origin командою git clone --bare і синхронізувати форк: після нових комітів в upstream виконати git fetch upstream, злити або перебазувати main на upstream/main і надіслати в origin; показати git log --oneline --graph --all і git status.

3. Високий рівень. Створити консольну програму C# «Метеостанція» (показання датчиків) і змоделювати внесок у чужий проєкт без хостингу: власник працює з репозиторієм upstream, учасник – з копією origin і надсилає зміни файлами латок (git format-patch main..feature), власник перевіряє та застосовує їх командою git am, розв’язавши конфлікт, а учасник синхронізує форк з upstream. Показати латки, авторство комітів після git am і граф історії обох репозиторіїв.

Варіант 25. Квітковий магазин

1. Початковий рівень. Створити консольну програму C# «Квітковий магазин» (букети та ціни) у локальному репозиторії Git, зробити три коміти в гілці experiment/delivery і перенести в main два з них командою git cherry-pick <хеш1> <хеш2>; показати git log --oneline --graph --all.

2. Базовий рівень. Створити консольну програму C# «Квітковий магазин» (букети та ціни) у репозиторії Git і перенести з гілки experiment/discounts у main діапазон комітів (git cherry-pick A^..B), розв’язати конфлікт, що виник під час перенесення (git cherry-pick --continue), а ще один коміт перенести без створення коміту (--no-commit) і доповнити змінами; показати історію та git log --cherry-pick --oneline main...experiment/discounts.

3. Високий рівень. Створити консольну програму C# «Квітковий магазин» (букети та ціни) у репозиторії Git з гілками main і release/1.x: виправлення з main переносити в release/1.x командою git cherry-pick -x, а для контролю написати сценарій PowerShell, який виводить коміти main, ще не перенесені в release/1.x (git cherry -v release/1.x main), і коміти з позначкою «cherry picked from» (git log --grep). Показати результат сценарію до та після перенесення, теги випусків і граф історії.

Варіант 26. Гуртожиток

1. Початковий рівень. Створити консольну програму C# «Гуртожиток» (кімнати та мешканці у файлі rooms.json) у репозиторії Git; у двох гілках змінити дані різних кімнат і злити гілки без конфлікту, потім по-різному змінити одну кімнату, отримати конфлікт у rooms.json і розв’язати його вручну так, щоб файл залишився коректним JSON.

2. Базовий рівень. Створити консольну програму C# «Гуртожиток» (кімнати та мешканці у файлі rooms.json) у репозиторії Git, отримати під час злиття двох гілок конфлікт у rooms.json з трьома конфліктними фрагментами й розв’язати його: для першого залишити версію поточної гілки, для другого – вхідну, для третього – об’єднати обидві; перевірити файл програмою перед комітом злиття й показати git diff під час конфлікту та git show коміту злиття.

3. Високий рівень. Створити консольну програму C# «Гуртожиток» (кімнати та мешканці), яка для зменшення конфліктів зберігає кожну кімнату в окремому файлі rooms/<номер>.json; змоделювати паралельну роботу двох учасників із порожнім репозиторієм і показати, що зміни різних кімнат зливаються автоматично; для конфлікту в одному файлі використати git checkout --theirs <файл> або --ours; додати в програму перевірку коректності всіх файлів даних і запускати її хуком pre-commit. Показати відмову хука для некоректного JSON і граф історії.

Варіант 27. Спортивний інвентар

1. Початковий рівень. Створити консольну програму C# «Спортивний інвентар» (предмети та їх кількість) у репозиторії Git, перейти до версії двома комітами раніше командою git switch --detach HEAD~2, запустити програму, повернутися на main і пояснити повідомлення про стан detached HEAD.

2. Базовий рівень. Створити консольну програму C# «Спортивний інвентар» (предмети та їх кількість) у репозиторії Git з тегом v1.0, перейти в стан detached HEAD на цьому тезі, зробити там два коміти з виправленням, повернутися на main, знайти ці коміти в git reflog, зберегти їх у гілці hotfix/1.0.1 і злити її в main; показати граф історії.

3. Високий рівень. Створити консольну програму C# «Спортивний інвентар» (предмети та їх кількість) з кількома версіями, позначеними тегами v*, і сценарій PowerShell для перевірки старих версій: для кожного тегу створити робочий каталог git worktree add (або перейти в стан detached HEAD), зібрати й запустити програму з тестовими даними, записати таблицю «тег – збірка – результат» і гарантовано повернутися до початкового стану (try/finally); виправлення для найстарішої версії зробити в гілці від її тегу й позначити новим тегом.

Варіант 28. Стоматологічний запис

1. Початковий рівень. Створити консольну програму C# «Стоматологічний запис» (пацієнт, лікар, час прийому) у репозиторії Git з кількома комітами, знайти командою git log -S коміт, у якому з’явилася тривалість прийому 30 хв, і переглянути його зміни командою git show.

2. Базовий рівень. Створити консольну програму C# «Стоматологічний запис» (пацієнт, лікар, час прийому) у репозиторії Git з кількома комітами й дослідити історію її коду: зміни одного методу (git log -L :<метод>:<файл>), коміти, що додавали або видаляли рядок (git log -S), змінювали рядки за регулярним виразом (git log -G), і коміти з певним словом у повідомленні (git log -i --grep); пояснити результати у файлі HISTORY.md.

3. Високий рівень. Створити консольну програму C# WhoChanged, яка отримує в аргументах шлях до репозиторію та рядок пошуку, викликає git log -S і git blame через System.Diagnostics.Process і виводить таблицю комітів (хеш, дата, автор, повідомлення), що додавали або видаляли цей рядок, і поточних авторів рядків, де він є; перевірити її на власному репозиторії з кількома комітами, повідомляти про помилки в потік помилок з ненульовим кодом завершення.

Варіант 29. Туристичні маршрути

1. Початковий рівень. Створити консольну програму C# «Туристичні маршрути» (маршрути та їх довжина) у репозиторії Git і хук pre-commit, який виконує dotnet build і скасовує коміт, якщо збірка не вдалася; показати відмову коміту з помилкою компіляції та успішний коміт після виправлення.

2. Базовий рівень. Створити консольну програму C# «Туристичні маршрути» (маршрути та їх довжина) у репозиторії Git і зберігати хуки в папці .githooks (git config core.hooksPath .githooks): pre-commit перевіряє форматування командою dotnet format --verify-no-changes, а commit-msg – що повідомлення починається з великої літери й має щонайменше 10 символів; показати відмову кожного хука, виправлення та пропуск перевірок ключем --no-verify.

3. Високий рівень. Створити консольну програму C# «Туристичні маршрути» (маршрути та їх довжина) з проєктом тестів xUnit і організувати локальну безперервну інтеграцію: хук pre-push збирає рішення й запускає dotnet test, скасовуючи надсилання в порожній репозиторій, якщо тести не пройшли, а серверний хук post-receive порожнього репозиторію дописує у файл ci.log час, гілку та хеш отриманих комітів. Показати відмову git push через тест, що не проходить, успішне надсилання після виправлення і вміст ci.log.

Варіант 30. Нотатник студента

1. Початковий рівень. Створити консольну програму C# «Нотатник студента» (нотатки з датою та пошук) у репозиторії Git і виконати мінімальний повний цикл: .gitignore, перший коміт, гілка feature/search з комітами, злиття в main, анотований тег v1.0.0; показати git log --oneline --graph --decorate.

2. Базовий рівень. Створити консольну програму C# «Нотатник студента» (нотатки з датою та пошук) у репозиторії Git і виконати цикл розробки з файлом завдань TASKS.md: для двох завдань створити гілки, переглянути кожну перед злиттям (git log main..<гілка>, git diff main...<гілка>), злити з --no-ff, оновити CHANGELOG.md і позначити випуск тегом v1.1.0; надіслати main і теги в порожній репозиторій D:\Labs\remote\Notes.git і показати git ls-remote origin.

3. Високий рівень. Створити консольну програму C# «Нотатник студента» (нотатки з датою та пошук) і провести повний цикл її командної розробки без хостингу: порожній репозиторій із захищеною гілкою main, два клони, файл TASKS.md, гілки завдань із переглядом перед злиттям, конфлікт і його розв’язання у Visual Studio 2026, хук pre-commit зі збіркою, перебазування гілки на оновлений main, CHANGELOG.md, теги v1.0.0 і v1.1.0 та архів випуску git archive. Показати граф історії обох клонів, git tag -n і git shortlog -sn.

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

1. Опрацювати теоретичні відомості та приклади розв’язання завдань.
2. Установити або оновити Git for Windows, налаштувати user.name, user.email, init.defaultBranch, core.autocrlf, core.editor і pull.rebase, перевірити їх командою git config --global --list.
3. Створити в папці D:\Labs консольний проєкт свого варіанта, файли .gitignore і .gitattributes та локальний репозиторій; для завдань з кількома учасниками створити порожній репозиторій і другий клон з іншим іменем автора.
4. Виконати завдання обраного рівня, фіксуючи кожну логічну зміну окремим комітом зі змістовним повідомленням і перевіряючи збірку перед комітом; хоча б одне злиття гілок виконати у Visual Studio 2026 (вікна Git Changes і Git Repository).
5. Захистити роботу на власному комп’ютері: показати git log --oneline --graph --all, git status, теги, гілки та інші результати, указані в завданні, пояснити кожну команду й відповісти на контрольні питання.