From 4e17e12ec8f709233251260fb0d1f205810ee023 Mon Sep 17 00:00:00 2001
From: Stanislav Klimovich <stasklimovish@gmail.com>
Date: Mon, 20 Oct 2025 16:13:44 +0300
Subject: [PATCH 1/8] Complete Task 1 (Fibonacci.c)

---
 .../Control-work-No.1/Task_1/Fibonacci.c      | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 Control-works/Control-work-No.1/Task_1/Fibonacci.c

diff --git a/Control-works/Control-work-No.1/Task_1/Fibonacci.c b/Control-works/Control-work-No.1/Task_1/Fibonacci.c
new file mode 100644
index 0000000..4a76fb7
--- /dev/null
+++ b/Control-works/Control-work-No.1/Task_1/Fibonacci.c
@@ -0,0 +1,60 @@
+#include <stdio.h>
+
+
+
+int fibonacci(int count)
+{
+	int a = 1;
+        int b = 1;
+	int c = 0;
+        int n = 3;
+
+	while(n <= count)
+        {
+	        c = a + b;
+        	a = b;
+	        b = c;
+        	n++;
+	}
+
+	return c;
+}
+
+
+int main(void)
+{
+	int number;
+
+	printf("Введите n: ");
+	scanf("%d", &number);
+
+	if (number < 0)
+	{
+		printf("Число n не должно быть отритцательнвм\n");
+	}
+
+	else if (number == 0)
+	{
+		printf("Нулевого числа Фибоначи не существует\n");
+	}
+
+	else if (number == 1 | number == 2)
+	{
+		printf("Число %d: 1\n", number);
+	}
+
+	else
+	{
+		if (number >= 47)
+		{
+			printf("Результат ниже может быть аномальным из-за использования типа int:\n");
+		}
+
+		int result = fibonacci(number);
+		printf("Число %d: %d\n", number, result);
+	}
+
+	return 0;
+}
+
+

From 31763e6a3d1ff75bcab16944b98f268cdfa2d470 Mon Sep 17 00:00:00 2001
From: Stanislav Klimovich <stasklimovish@gmail.com>
Date: Mon, 20 Oct 2025 16:52:48 +0300
Subject: [PATCH 2/8] Complete Task 2(Sorting-by-choice.c)

---
 .../Task_2/Sorting-by-choice.c                | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 Control-works/Control-work-No.1/Task_2/Sorting-by-choice.c

diff --git a/Control-works/Control-work-No.1/Task_2/Sorting-by-choice.c b/Control-works/Control-work-No.1/Task_2/Sorting-by-choice.c
new file mode 100644
index 0000000..ad37b54
--- /dev/null
+++ b/Control-works/Control-work-No.1/Task_2/Sorting-by-choice.c
@@ -0,0 +1,38 @@
+#include <stdio.h>
+
+void selection_sort(int array[], int length)
+{
+    for (int n = 0; n < length - 1; n++)
+    {
+        int min = n;
+        for (int j = n + 1; j < length; j++)
+        {
+            if (array[j] < array[min])
+            {
+                min = j;
+            }
+        }
+
+        int temp = array[n];
+        array[n] = array[min];
+        array[min] = temp;
+    }
+}
+
+int main(void)
+{
+    int arr[10] = {124, 828, 643, 820, 572, 5735, 5902, 55, 90, 12};
+    int l = sizeof(arr) / sizeof(arr[0]);
+
+
+
+    selection_sort(arr, l);
+
+    for (int i = 0; i < l; i++)
+    {
+        printf("%d ", arr[i]);
+    }
+    printf("\n");
+
+    return 0;
+}

From f86bf8f2d0763d1c015b8deeaac8b578ddeb595d Mon Sep 17 00:00:00 2001
From: Stanislav Klimovich <stasklimovish@gmail.com>
Date: Mon, 20 Oct 2025 16:56:35 +0300
Subject: [PATCH 3/8] update Fibonacci.c

---
 .../Control-work-No.1/Task_1/Fibonacci.c      | 92 +++++++++----------
 1 file changed, 46 insertions(+), 46 deletions(-)

diff --git a/Control-works/Control-work-No.1/Task_1/Fibonacci.c b/Control-works/Control-work-No.1/Task_1/Fibonacci.c
index 4a76fb7..369834b 100644
--- a/Control-works/Control-work-No.1/Task_1/Fibonacci.c
+++ b/Control-works/Control-work-No.1/Task_1/Fibonacci.c
@@ -4,57 +4,57 @@
 
 int fibonacci(int count)
 {
-	int a = 1;
-        int b = 1;
-	int c = 0;
-        int n = 3;
-
-	while(n <= count)
-        {
-	        c = a + b;
-        	a = b;
-	        b = c;
-        	n++;
-	}
-
-	return c;
+    int a = 1;
+    int b = 1;
+    int c = 0;
+    int n = 3;
+
+    while(n <= count)
+    {
+        c = a + b;
+       	a = b;
+        b = c;
+       	n++;
+    }
+
+    return c;
 }
 
 
 int main(void)
 {
-	int number;
-
-	printf("Введите n: ");
-	scanf("%d", &number);
-
-	if (number < 0)
-	{
-		printf("Число n не должно быть отритцательнвм\n");
-	}
-
-	else if (number == 0)
-	{
-		printf("Нулевого числа Фибоначи не существует\n");
-	}
-
-	else if (number == 1 | number == 2)
-	{
-		printf("Число %d: 1\n", number);
-	}
-
-	else
-	{
-		if (number >= 47)
-		{
-			printf("Результат ниже может быть аномальным из-за использования типа int:\n");
-		}
-
-		int result = fibonacci(number);
-		printf("Число %d: %d\n", number, result);
-	}
-
-	return 0;
+    int number;
+
+    printf("Введите n: ");
+    scanf("%d", &number);
+
+    if (number < 0)
+    {
+	printf("Число n не должно быть отритцательнвм\n");
+    }
+
+    else if (number == 0)
+    {
+	printf("Нулевого числа Фибоначи не существует\n");
+    }
+
+    else if (number == 1 | number == 2)
+    {
+	printf("Число %d: 1\n", number);
+    }
+
+    else
+    {
+	if (number >= 47)
+        {
+	    printf("Результат ниже может быть аномальным из-за использования типа int:\n");
+        }
+
+	int result = fibonacci(number);
+	printf("Число %d: %d\n", number, result);
+    }
+
+    return 0;
 }
 
 

From f831d884760d32c2d11ca6991d3200d904f1b97e Mon Sep 17 00:00:00 2001
From: Stanislav Klimovich <stasklimovish@gmail.com>
Date: Mon, 1 Dec 2025 15:51:24 +0300
Subject: [PATCH 4/8] The first task

---
 .../Task_1/Functional-queue.c                 | 141 ++++++++++++++++++
 1 file changed, 141 insertions(+)
 create mode 100644 Control-works/Control-work-No.2/Task_1/Functional-queue.c

diff --git a/Control-works/Control-work-No.2/Task_1/Functional-queue.c b/Control-works/Control-work-No.2/Task_1/Functional-queue.c
new file mode 100644
index 0000000..0328191
--- /dev/null
+++ b/Control-works/Control-work-No.2/Task_1/Functional-queue.c
@@ -0,0 +1,141 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+typedef struct Node {
+    int value;
+    struct Node* next;
+} Node;
+
+typedef struct List {
+    Node* head;
+} List;
+
+typedef struct Queue {
+    List* f;  // Прямой порядок
+    List* r;   // Обратный порядок
+} Queue;
+
+// Создать пустой список
+List* list_create() {
+    List* list = (List*)malloc(sizeof(List));
+    list->head = NULL;
+
+    return list;
+}
+
+// Проверить, пуст ли список
+int list_is_empty(List* list) {
+
+    return list->head == NULL;
+}
+
+// Добавить элемент в начало
+List* list_cons(int value, List* list) {
+    Node* node = (Node*)malloc(sizeof(Node));
+    node->value = value;
+    node->next = list->head;
+
+    List* new_list = (List*)malloc(sizeof(List));
+    new_list->head = node;
+
+    return new_list;
+}
+
+// Получить первый элемент
+int list_head(List* list) {
+
+    return list->head->value;
+}
+
+// Получить хвост списка
+List* list_tail(List* list) {
+    List* new_list = (List*)malloc(sizeof(List));
+    new_list->head = list->head->next;
+
+    return new_list;
+}
+
+// Перевернуть список
+List* list_reverse(List* list) {
+    List* reversed = list_create();
+    Node* current = list->head;
+
+    while (current != NULL) {
+        reversed = list_cons(current->value, reversed);
+        current = current->next;
+    }
+
+    return reversed;
+}
+
+// Создать пустую очередь
+Queue* queue_create() {
+    Queue* queue = (Queue*)malloc(sizeof(Queue));
+    queue->f = list_create();
+    queue->r = list_create();
+
+    return queue;
+}
+
+// Проверить, пуста ли очередь
+int queue_is_empty(Queue* queue) {
+
+    return list_is_empty(queue->f) && list_is_empty(queue->r);
+}
+
+// Добавить элемент в конец очереди
+Queue* queue_enqueue(Queue* queue, int value) {
+    Queue* new_queue = (Queue*)malloc(sizeof(Queue));
+    new_queue->f = queue->f;
+    new_queue->r = list_cons(value, queue->r);
+
+    return new_queue;
+}
+
+// Удалить элемент из начала очереди
+Queue* queue_dequeue(Queue* queue, int* value) {
+    if (list_is_empty(queue->f)) {
+        List* new_front = list_reverse(queue->r);
+        *value = list_head(new_front);
+
+        Queue* new_queue = (Queue*)malloc(sizeof(Queue));
+        new_queue->f = list_tail(new_front);
+        new_queue->r = list_create();
+
+        return new_queue;
+    }
+
+    // Если front не пуст, просто берем из него
+    *value = list_head(queue->f);
+
+    Queue* new_queue = (Queue*)malloc(sizeof(Queue));
+    new_queue->f = list_tail(queue->f);
+    new_queue->r = queue->r;
+
+    return new_queue;
+}
+
+// Базовые операции со списком
+void test_list_basic() {
+    printf("Test: Базовые операции со списком\n");
+
+    // Создание пустого списка
+    List* empty = list_create();
+    assert(list_is_empty(empty));
+
+    // Добавление элемента
+    List* one = list_cons(42, empty);
+    assert(!list_is_empty(one));
+    assert(list_head(one) == 42);
+
+    printf("Test: Пройден\n");
+}
+
+// Главная функция
+int main() {
+    // Запуск тестов
+    test_list_basic();
+
+    return 0;
+}

From 1bd59d3df7271614f7d151f8df8f9bb62a19b1c2 Mon Sep 17 00:00:00 2001
From: Stanislav Klimovich <stasklimovish@gmail.com>
Date: Mon, 1 Dec 2025 16:13:00 +0300
Subject: [PATCH 5/8] The second task is completed

---
 .../Control-work-No.2/Task_2/Comparison.c     | 99 +++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 Control-works/Control-work-No.2/Task_2/Comparison.c

diff --git a/Control-works/Control-work-No.2/Task_2/Comparison.c b/Control-works/Control-work-No.2/Task_2/Comparison.c
new file mode 100644
index 0000000..154ffde
--- /dev/null
+++ b/Control-works/Control-work-No.2/Task_2/Comparison.c
@@ -0,0 +1,99 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+
+// Функция для сравнения двух двоичных чисел
+int compare_binary_numbers(bool* num1, int len1, bool* num2, int len2) {
+    // Находим первую 1 для каждого числа
+    int start1 = 0;
+    while (start1 < len1 && !num1[start1]) {
+        start1++;
+    }
+
+    int start2 = 0;
+    while (start2 < len2 && !num2[start2]) {
+        start2++;
+    }
+
+    // Вычисляем реальную длину числа (без ведущих нулей)
+    int real_len1 = len1 - start1;
+    int real_len2 = len2 - start2;
+
+    if (real_len1 == 0 && real_len2 == 0) {
+        return 0; // 0 == 0
+    }
+
+    if (real_len1 == 0) {
+        return -1; // num 1 < num2
+    }
+
+    if (real_len2 == 0) {
+        return 1; // num1 > num2
+    }
+
+    if (real_len1 > real_len2) {
+        return 1; // num1 > num2
+    }
+
+    if (real_len1 < real_len2) {
+        return -1; // num1 < num2
+    }
+
+    // Если длины равны, сравниваем побитово
+    for (int i = 0; i < real_len1; i++) {
+        bool bit1 = num1[start1 + i];
+        bool bit2 = num2[start2 + i];
+
+        if (bit1 && !bit2) {
+            return 1; // num1 > num2
+        }
+
+        if (!bit1 && bit2) {
+            return -1; // num1 < num2
+        }
+    }
+
+    return 0; // числа равны
+}
+
+// Функция для печати двоичного числа
+void print_binary(bool* num, int len) {
+    int start = 0;
+
+    while (start < len && !num[start]) {
+        start++;
+    }
+
+    if (start == len) {
+        printf("0");
+        return;
+    }
+
+    for (int i = start; i < len; i++) {
+        printf("%d", num[i]);
+    }
+}
+
+int main() {
+
+    {
+        bool num1[] = {1, 0, 1, 1};  // 1011 = 11
+        bool num2[] = {1, 1, 0, 0};  // 1100 = 12
+
+        int result = compare_binary_numbers(num1, 4, num2, 4);
+
+        print_binary(num1, 4);
+        printf("\n");
+        print_binary(num2, 4);
+        printf("\n");
+        if (result > 0) {
+            printf("Первое больше\n");
+        }
+
+        else if (result < 0) {
+            printf("Второе больше\n");
+        }
+
+        else printf("Равны\n");
+    }
+}

From c27eeb4bf1072e48786dd80c128111be40002714 Mon Sep 17 00:00:00 2001
From: Stanislav Klimovich <stasklimovish@gmail.com>
Date: Fri, 19 Dec 2025 12:07:49 +0300
Subject: [PATCH 6/8] Complete Task_1 | Rewrite

---
 .../Rewrite/Task_1/.gitignore                 |  25 +++
 .../Rewrite/Task_1/CMakeLists.txt             |  38 ++++
 .../Rewrite/Task_1/README.md                  |  27 +++
 .../Rewrite/Task_1/include/palindrome.h       |  64 +++++++
 .../Rewrite/Task_1/src/main.c                 |  60 +++++++
 .../Rewrite/Task_1/src/palindrome.c           | 123 +++++++++++++
 .../Rewrite/Task_1/tests/test_palindrome.c    | 166 ++++++++++++++++++
 7 files changed, 503 insertions(+)
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_1/.gitignore
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_1/CMakeLists.txt
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_1/README.md
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_1/include/palindrome.h
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_1/src/main.c
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_1/src/palindrome.c
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_1/tests/test_palindrome.c

diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/.gitignore b/Control-works/Control-work-No.2/Rewrite/Task_1/.gitignore
new file mode 100644
index 0000000..80d92b8
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/.gitignore
@@ -0,0 +1,25 @@
+# Build
+build/
+*.exe
+*.out
+
+# Object files
+*.o
+*.obj
+
+# Libraries
+*.a
+*.so
+*.dylib
+
+# CMake
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+Makefile
+compile_commands.json
+
+# IDE
+.vscode/
+.idea/
+*.swp
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/CMakeLists.txt b/Control-works/Control-work-No.2/Rewrite/Task_1/CMakeLists.txt
new file mode 100644
index 0000000..400f6eb
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/CMakeLists.txt
@@ -0,0 +1,38 @@
+cmake_minimum_required(VERSION 3.10)
+project(palindrome_check C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Werror")
+
+add_executable(palindrome_check
+    src/main.c
+    src/palindrome.c
+)
+
+target_include_directories(palindrome_check
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+add_executable(test_palindrome
+    tests/test_palindrome.c
+    src/palindrome.c
+)
+
+target_include_directories(test_palindrome
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+target_compile_definitions(test_palindrome
+    PRIVATE TEST_MAIN
+)
+
+enable_testing()
+add_test(NAME palindrome_tests COMMAND test_palindrome)
+
+message(STATUS "=== Проект 'Проверка палиндрома' ===")
+message(STATUS "Доступные цели:")
+message(STATUS "  - palindrome_check (основная программа)")
+message(STATUS "  - test_palindrome (тесты)")
+message(STATUS "Для сборки: mkdir build && cd build && cmake .. && make")
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/README.md b/Control-works/Control-work-No.2/Rewrite/Task_1/README.md
new file mode 100644
index 0000000..0033fbc
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/README.md
@@ -0,0 +1,27 @@
+# "Опять палиндром"
+
+## Описание
+Программа для проверки симметричности списка.
+С клавиатуры вводятся натуральные числ.  по ним строится список и определяется, симметричен ли он.
+
+## Структура проекта
+Task_1/
+| .gitignore                    Игнорируемые файлы
+| CMakeLists.txt                Главный файл CMake
+| README.md                     Документация
+| include/                      Заголовочные файлы
+| - palindrome.h                Объявление структур и функций
+|
+| src/                          Исходный код
+| - main.c                      Основная программа с вводом/выводом
+| - palindrome.c                Реализация алгоритмов работы со списком
+|
+| tests/                        Модульные тесты
+| - test_palindrome.c           Тесты для проверки корректности
+
+## Сборка
+```bash
+mkdir build
+cd build
+cmake ..
+make
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/include/palindrome.h b/Control-works/Control-work-No.2/Rewrite/Task_1/include/palindrome.h
new file mode 100644
index 0000000..6c3efce
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/include/palindrome.h
@@ -0,0 +1,64 @@
+#ifndef PALINDROME_H
+#define PALINDROME_H
+
+#include <stdbool.h>
+
+typedef struct Node {
+    int data;
+    struct Node* next;
+} Node;
+
+// Функции для работы со списком
+
+/**
+ * Создает новый узел списка
+ * - param: data Значение для узла
+ * - return: Указатель на созданный узел или NULL при ошибке
+ */
+Node* create_node(int data);
+
+/**
+ * Добавляет элемент в конец списка
+ * - param: head Указатель на начало списка
+ *          data Значение для добавления
+ * - return: Указатель на начало списка
+ */
+Node* append_node(Node* head, int data);
+
+/**
+ * Освобождает память, занятую списком
+ * - param: head Указатель на начало списка
+ */
+void free_list(Node* head);
+
+/**
+ * Печатает элементы списка
+ * - param: head Указатель на начало списка
+ */
+void print_list(Node* head);
+
+/**
+ * Проверяет, является ли список палиндромом
+ * - param: head Указатель на начало списка
+ * - return: true если список палиндром
+ *           false в противном случае
+ */
+bool is_palindrome(Node* head);
+
+/**
+ * Реверсирует список
+ * - param: head Указатель на начало списка
+ * - return: Указатель на начало реверсированного списка
+ */
+Node* reverse_list(Node* head);
+
+/**
+ * Сравнивает два списка на равенство
+ * - param: list1 - первый список
+ *          list2 - второй список
+ * - return: true если списки равны
+ *           false в противном случае
+ */
+bool compare_lists(Node* list1, Node* list2);
+
+#endif // PALINDROME_H
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/src/main.c b/Control-works/Control-work-No.2/Rewrite/Task_1/src/main.c
new file mode 100644
index 0000000..dd58df6
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/src/main.c
@@ -0,0 +1,60 @@
+#include "../include/palindrome.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+    Node* head = NULL;
+    int number;
+
+    printf("=== \"Опять палиндром\"  ===\n");
+    printf("Вводите натуральные числа по одному через пробел\n");
+    printf("(0 для окончания ввода):\n");
+
+    while (1) {
+        printf("> ");
+        if (scanf("%d", &number) != 1) {
+            printf("Ошибка ввода. Пожалуйста, введите число.\n");
+
+            // Очищаем буфер ввода
+            while (getchar() != '\n');
+            continue;
+        }
+
+        if (number == 0) {
+            break;
+        }
+
+        if (number < 0) {
+            printf("Пожалуйста, вводите только натуральные числа (положительные).\n");
+            continue;
+        }
+
+        head = append_node(head, number);
+
+        if (head == NULL) {
+            printf("Ошибка: не удалось добавить элемент в список.\n");
+            return 1;
+        }
+    }
+
+    if (head == NULL) {
+        printf("Список пуст.\n");
+        return 0;
+    }
+
+    printf("\nПолученный список: ");
+    print_list(head);
+
+    if (is_palindrome(head)) {
+        printf("Список является палиндромом.\n");
+    }
+
+    else {
+        printf("Список не является палиндромом.\n");
+    }
+
+    // Освобождаем память
+    free_list(head);
+
+    return 0;
+}
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/src/palindrome.c b/Control-works/Control-work-No.2/Rewrite/Task_1/src/palindrome.c
new file mode 100644
index 0000000..95caaa9
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/src/palindrome.c
@@ -0,0 +1,123 @@
+#include "../include/palindrome.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+Node* create_node(int data) {
+    Node* new_node = (Node*)malloc(sizeof(Node));
+    if (new_node == NULL) {
+        fprintf(stderr, "Ошибка выделения памяти\n");
+        return NULL;
+    }
+
+    new_node->data = data;
+    new_node->next = NULL;
+    return new_node;
+}
+
+Node* append_node(Node* head, int data) {
+    Node* new_node = create_node(data);
+    if (new_node == NULL) {
+        return head;
+    }
+
+    if (head == NULL) {
+        return new_node;
+    }
+
+    Node* current = head;
+    while (current->next != NULL) {
+        current = current->next;
+    }
+
+    current->next = new_node;
+    return head;
+}
+
+void free_list(Node* head) {
+    Node* current = head;
+    while (current != NULL) {
+        Node* next = current->next;
+        free(current);
+        current = next;
+    }
+}
+
+void print_list(Node* head) {
+    Node* current = head;
+    while (current != NULL) {
+        printf("%d ", current->data);
+        current = current->next;
+    }
+    printf("\n");
+}
+
+Node* reverse_list(Node* head) {
+    Node* prev = NULL;
+    Node* current = head;
+    Node* next = NULL;
+
+    while (current != NULL) {
+        next = current->next;
+        current->next = prev;
+        prev = current;
+        current = next;
+    }
+
+    return prev;
+}
+
+bool compare_lists(Node* list1, Node* list2) {
+    while (list1 != NULL && list2 != NULL) {
+        if (list1->data != list2->data) {
+            return false;
+        }
+        list1 = list1->next;
+        list2 = list2->next;
+    }
+
+    // Оба списка должны быть пустыми одновременно
+    return (list1 == NULL && list2 == NULL);
+}
+
+bool is_palindrome(Node* head) {
+    if (head == NULL || head->next == NULL) {
+        return true; // Пустой список или один элемент - палиндром
+    }
+
+    // Находим середину списка
+    Node* slow = head;
+    Node* fast = head;
+    Node* prev_slow = NULL;
+
+    while (fast != NULL && fast->next != NULL) {
+        fast = fast->next->next;
+        prev_slow = slow;
+        slow = slow->next;
+    }
+
+    // Если количество элементов нечетное, пропускаем средний элемент
+    Node* second_half = slow;
+    if (fast != NULL) {
+        second_half = slow->next;
+    }
+
+    // Разделяем список на две части
+    if (prev_slow != NULL) {
+        prev_slow->next = NULL;
+    }
+
+    // Реверсируем вторую половину
+    Node* reversed_second_half = reverse_list(second_half);
+
+    // Сравниваем две половины
+    bool result = compare_lists(head, reversed_second_half);
+
+    // Восстанавливаем оригинальный список
+    Node* original_second_half = reverse_list(reversed_second_half);
+    if (prev_slow != NULL) {
+        prev_slow->next = original_second_half;
+    }
+
+    return result;
+}
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/tests/test_palindrome.c b/Control-works/Control-work-No.2/Rewrite/Task_1/tests/test_palindrome.c
new file mode 100644
index 0000000..d155fd1
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/tests/test_palindrome.c
@@ -0,0 +1,166 @@
+#include "../include/palindrome.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+// Вспомогательная функция для создания списка из массива
+Node* create_list_from_array(int arr[], int size) {
+    Node* head = NULL;
+    for (int i = 0; i < size; i++) {
+        head = append_node(head, arr[i]);
+    }
+    return head;
+}
+
+void test_empty_list() {
+    printf("1. Тест пустого списка: ");
+    Node* head = NULL;
+    bool result = is_palindrome(head);
+
+    if (result == true) {
+        printf("Пройдено.\n");
+    }
+
+    else {
+        printf("Не пройдено (ожидалось true, получено %s)\n", result ? "true" : "false");
+    }
+
+    free_list(head);
+}
+
+void test_single_element() {
+    printf("2. Тест одного элемента: ");
+    Node* head = create_node(42);
+    bool result = is_palindrome(head);
+
+    if (result == true) {
+        printf("Пройдено.\n");
+    }
+
+    else {
+        printf("Не пройдено.\n");
+    }
+
+    free_list(head);
+}
+
+void test_even_palindrome() {
+    printf("3. Тест четного палиндрома (1 2 2 1): ");
+    int arr[] = {1, 2, 2, 1};
+    Node* head = create_list_from_array(arr, 4);
+    bool result = is_palindrome(head);
+
+    if (result == true) {
+        printf("Пройдено.\n");
+    }
+
+    else {
+        printf("Не пройдено.\n");
+    }
+
+    free_list(head);
+}
+
+void test_odd_palindrome() {
+    printf("4. Тест нечетного палиндрома (1 2 3 2 1): ");
+    int arr[] = {1, 2, 3, 2, 1};
+    Node* head = create_list_from_array(arr, 5);
+    bool result = is_palindrome(head);
+
+    if (result == true) {
+        printf("Пройдено.\n");
+    }
+
+    else {
+        printf("Не пройдено.\n");
+    }
+
+    free_list(head);
+}
+
+void test_not_palindrome() {
+    printf("5. Тест не палиндрома (1 2 3 4): ");
+    int arr[] = {1, 2, 3, 4};
+    Node* head = create_list_from_array(arr, 4);
+    bool result = is_palindrome(head);
+
+    if (result == false) {
+        printf("Пройдено.\n");
+    }
+
+    else {
+        printf("Не прлйдено.\n");
+    }
+
+    free_list(head);
+}
+
+void test_long_palindrome() {
+    printf("6. Тест длинного палиндрома: ");
+    int arr[] = {10, 20, 30, 40, 50, 40, 30, 20, 10};
+    Node* head = create_list_from_array(arr, 9);
+    bool result = is_palindrome(head);
+
+    if (result == true) {
+        printf("Прлйдено.\n");
+    }
+
+    else {
+        printf("Не пройдено.\n");
+    }
+
+    free_list(head);
+}
+
+void test_not_palindrome2() {
+    printf("7. Тест из задания (10 20 30 40 20 10): ");
+    int arr[] = {10, 20, 30, 40, 20, 10};
+    Node* head = create_list_from_array(arr, 6);
+    bool result = is_palindrome(head);
+
+    if (result == false) {
+        printf("Пройдено.\n");
+    }
+
+    else {
+        printf("Не прлйдно.\n");
+    }
+
+    free_list(head);
+}
+
+void test_all_identical() {
+    printf("8. Тест всех одинаковых элементов (5 5 5 5): ");
+    int arr[] = {5, 5, 5, 5};
+    Node* head = create_list_from_array(arr, 4);
+    bool result = is_palindrome(head);
+
+    if (result == true) {
+        printf("Пройдено.\n");
+    }
+
+    else {
+        printf("Не пройдено.\n");
+    }
+
+    free_list(head);
+}
+
+#ifdef TEST_MAIN
+int main() {
+    printf("=== Запуск тестов ===\n\n");
+
+    test_empty_list();
+    test_single_element();
+    test_even_palindrome();
+    test_odd_palindrome();
+    test_not_palindrome();
+    test_long_palindrome();
+    test_not_palindrome2();
+    test_all_identical();
+
+    printf("\n=== Все тесты завершены ===\n");
+    return 0;
+}
+
+#endif

From 22dd2a28b698390d51d3981fa213f082712c2678 Mon Sep 17 00:00:00 2001
From: Stanislav Klimovich <stasklimovish@gmail.com>
Date: Fri, 19 Dec 2025 12:10:45 +0300
Subject: [PATCH 7/8] Task_1 to clang format | Rewrite

---
 .../Rewrite/Task_1/include/palindrome.h       |  18 +-
 .../Rewrite/Task_1/src/main.c                 |  91 ++++----
 .../Rewrite/Task_1/src/palindrome.c           | 196 ++++++++--------
 .../Rewrite/Task_1/tests/test_palindrome.c    | 213 +++++++++---------
 4 files changed, 260 insertions(+), 258 deletions(-)

diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/include/palindrome.h b/Control-works/Control-work-No.2/Rewrite/Task_1/include/palindrome.h
index 6c3efce..73862dc 100644
--- a/Control-works/Control-work-No.2/Rewrite/Task_1/include/palindrome.h
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/include/palindrome.h
@@ -4,8 +4,8 @@
 #include <stdbool.h>
 
 typedef struct Node {
-    int data;
-    struct Node* next;
+  int data;
+  struct Node *next;
 } Node;
 
 // Функции для работы со списком
@@ -15,7 +15,7 @@ typedef struct Node {
  * - param: data Значение для узла
  * - return: Указатель на созданный узел или NULL при ошибке
  */
-Node* create_node(int data);
+Node *create_node(int data);
 
 /**
  * Добавляет элемент в конец списка
@@ -23,19 +23,19 @@ Node* create_node(int data);
  *          data Значение для добавления
  * - return: Указатель на начало списка
  */
-Node* append_node(Node* head, int data);
+Node *append_node(Node *head, int data);
 
 /**
  * Освобождает память, занятую списком
  * - param: head Указатель на начало списка
  */
-void free_list(Node* head);
+void free_list(Node *head);
 
 /**
  * Печатает элементы списка
  * - param: head Указатель на начало списка
  */
-void print_list(Node* head);
+void print_list(Node *head);
 
 /**
  * Проверяет, является ли список палиндромом
@@ -43,14 +43,14 @@ void print_list(Node* head);
  * - return: true если список палиндром
  *           false в противном случае
  */
-bool is_palindrome(Node* head);
+bool is_palindrome(Node *head);
 
 /**
  * Реверсирует список
  * - param: head Указатель на начало списка
  * - return: Указатель на начало реверсированного списка
  */
-Node* reverse_list(Node* head);
+Node *reverse_list(Node *head);
 
 /**
  * Сравнивает два списка на равенство
@@ -59,6 +59,6 @@ Node* reverse_list(Node* head);
  * - return: true если списки равны
  *           false в противном случае
  */
-bool compare_lists(Node* list1, Node* list2);
+bool compare_lists(Node *list1, Node *list2);
 
 #endif // PALINDROME_H
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/src/main.c b/Control-works/Control-work-No.2/Rewrite/Task_1/src/main.c
index dd58df6..80f9a43 100644
--- a/Control-works/Control-work-No.2/Rewrite/Task_1/src/main.c
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/src/main.c
@@ -3,58 +3,59 @@
 #include <stdlib.h>
 
 int main() {
-    Node* head = NULL;
-    int number;
-
-    printf("=== \"Опять палиндром\"  ===\n");
-    printf("Вводите натуральные числа по одному через пробел\n");
-    printf("(0 для окончания ввода):\n");
-
-    while (1) {
-        printf("> ");
-        if (scanf("%d", &number) != 1) {
-            printf("Ошибка ввода. Пожалуйста, введите число.\n");
-
-            // Очищаем буфер ввода
-            while (getchar() != '\n');
-            continue;
-        }
-
-        if (number == 0) {
-            break;
-        }
-
-        if (number < 0) {
-            printf("Пожалуйста, вводите только натуральные числа (положительные).\n");
-            continue;
-        }
-
-        head = append_node(head, number);
-
-        if (head == NULL) {
-            printf("Ошибка: не удалось добавить элемент в список.\n");
-            return 1;
-        }
+  Node *head = NULL;
+  int number;
+
+  printf("=== \"Опять палиндром\"  ===\n");
+  printf("Вводите натуральные числа по одному через пробел\n");
+  printf("(0 для окончания ввода):\n");
+
+  while (1) {
+    printf("> ");
+    if (scanf("%d", &number) != 1) {
+      printf("Ошибка ввода. Пожалуйста, введите число.\n");
+
+      // Очищаем буфер ввода
+      while (getchar() != '\n')
+        ;
+      continue;
     }
 
-    if (head == NULL) {
-        printf("Список пуст.\n");
-        return 0;
+    if (number == 0) {
+      break;
     }
 
-    printf("\nПолученный список: ");
-    print_list(head);
-
-    if (is_palindrome(head)) {
-        printf("Список является палиндромом.\n");
+    if (number < 0) {
+      printf("Пожалуйста, вводите только натуральные числа (положительные).\n");
+      continue;
     }
 
-    else {
-        printf("Список не является палиндромом.\n");
-    }
+    head = append_node(head, number);
 
-    // Освобождаем память
-    free_list(head);
+    if (head == NULL) {
+      printf("Ошибка: не удалось добавить элемент в список.\n");
+      return 1;
+    }
+  }
 
+  if (head == NULL) {
+    printf("Список пуст.\n");
     return 0;
+  }
+
+  printf("\nПолученный список: ");
+  print_list(head);
+
+  if (is_palindrome(head)) {
+    printf("Список является палиндромом.\n");
+  }
+
+  else {
+    printf("Список не является палиндромом.\n");
+  }
+
+  // Освобождаем память
+  free_list(head);
+
+  return 0;
 }
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/src/palindrome.c b/Control-works/Control-work-No.2/Rewrite/Task_1/src/palindrome.c
index 95caaa9..014bdaf 100644
--- a/Control-works/Control-work-No.2/Rewrite/Task_1/src/palindrome.c
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/src/palindrome.c
@@ -1,123 +1,123 @@
 #include "../include/palindrome.h"
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdbool.h>
 
-Node* create_node(int data) {
-    Node* new_node = (Node*)malloc(sizeof(Node));
-    if (new_node == NULL) {
-        fprintf(stderr, "Ошибка выделения памяти\n");
-        return NULL;
-    }
+Node *create_node(int data) {
+  Node *new_node = (Node *)malloc(sizeof(Node));
+  if (new_node == NULL) {
+    fprintf(stderr, "Ошибка выделения памяти\n");
+    return NULL;
+  }
 
-    new_node->data = data;
-    new_node->next = NULL;
-    return new_node;
+  new_node->data = data;
+  new_node->next = NULL;
+  return new_node;
 }
 
-Node* append_node(Node* head, int data) {
-    Node* new_node = create_node(data);
-    if (new_node == NULL) {
-        return head;
-    }
+Node *append_node(Node *head, int data) {
+  Node *new_node = create_node(data);
+  if (new_node == NULL) {
+    return head;
+  }
 
-    if (head == NULL) {
-        return new_node;
-    }
+  if (head == NULL) {
+    return new_node;
+  }
 
-    Node* current = head;
-    while (current->next != NULL) {
-        current = current->next;
-    }
+  Node *current = head;
+  while (current->next != NULL) {
+    current = current->next;
+  }
 
-    current->next = new_node;
-    return head;
+  current->next = new_node;
+  return head;
 }
 
-void free_list(Node* head) {
-    Node* current = head;
-    while (current != NULL) {
-        Node* next = current->next;
-        free(current);
-        current = next;
-    }
+void free_list(Node *head) {
+  Node *current = head;
+  while (current != NULL) {
+    Node *next = current->next;
+    free(current);
+    current = next;
+  }
 }
 
-void print_list(Node* head) {
-    Node* current = head;
-    while (current != NULL) {
-        printf("%d ", current->data);
-        current = current->next;
-    }
-    printf("\n");
+void print_list(Node *head) {
+  Node *current = head;
+  while (current != NULL) {
+    printf("%d ", current->data);
+    current = current->next;
+  }
+  printf("\n");
 }
 
-Node* reverse_list(Node* head) {
-    Node* prev = NULL;
-    Node* current = head;
-    Node* next = NULL;
+Node *reverse_list(Node *head) {
+  Node *prev = NULL;
+  Node *current = head;
+  Node *next = NULL;
 
-    while (current != NULL) {
-        next = current->next;
-        current->next = prev;
-        prev = current;
-        current = next;
-    }
+  while (current != NULL) {
+    next = current->next;
+    current->next = prev;
+    prev = current;
+    current = next;
+  }
 
-    return prev;
+  return prev;
 }
 
-bool compare_lists(Node* list1, Node* list2) {
-    while (list1 != NULL && list2 != NULL) {
-        if (list1->data != list2->data) {
-            return false;
-        }
-        list1 = list1->next;
-        list2 = list2->next;
+bool compare_lists(Node *list1, Node *list2) {
+  while (list1 != NULL && list2 != NULL) {
+    if (list1->data != list2->data) {
+      return false;
     }
+    list1 = list1->next;
+    list2 = list2->next;
+  }
 
-    // Оба списка должны быть пустыми одновременно
-    return (list1 == NULL && list2 == NULL);
+  // Оба списка должны быть пустыми одновременно
+  return (list1 == NULL && list2 == NULL);
 }
 
-bool is_palindrome(Node* head) {
-    if (head == NULL || head->next == NULL) {
-        return true; // Пустой список или один элемент - палиндром
-    }
-
-    // Находим середину списка
-    Node* slow = head;
-    Node* fast = head;
-    Node* prev_slow = NULL;
-
-    while (fast != NULL && fast->next != NULL) {
-        fast = fast->next->next;
-        prev_slow = slow;
-        slow = slow->next;
-    }
-
-    // Если количество элементов нечетное, пропускаем средний элемент
-    Node* second_half = slow;
-    if (fast != NULL) {
-        second_half = slow->next;
-    }
-
-    // Разделяем список на две части
-    if (prev_slow != NULL) {
-        prev_slow->next = NULL;
-    }
-
-    // Реверсируем вторую половину
-    Node* reversed_second_half = reverse_list(second_half);
-
-    // Сравниваем две половины
-    bool result = compare_lists(head, reversed_second_half);
-
-    // Восстанавливаем оригинальный список
-    Node* original_second_half = reverse_list(reversed_second_half);
-    if (prev_slow != NULL) {
-        prev_slow->next = original_second_half;
-    }
-
-    return result;
+bool is_palindrome(Node *head) {
+  if (head == NULL || head->next == NULL) {
+    return true; // Пустой список или один элемент - палиндром
+  }
+
+  // Находим середину списка
+  Node *slow = head;
+  Node *fast = head;
+  Node *prev_slow = NULL;
+
+  while (fast != NULL && fast->next != NULL) {
+    fast = fast->next->next;
+    prev_slow = slow;
+    slow = slow->next;
+  }
+
+  // Если количество элементов нечетное, пропускаем средний элемент
+  Node *second_half = slow;
+  if (fast != NULL) {
+    second_half = slow->next;
+  }
+
+  // Разделяем список на две части
+  if (prev_slow != NULL) {
+    prev_slow->next = NULL;
+  }
+
+  // Реверсируем вторую половину
+  Node *reversed_second_half = reverse_list(second_half);
+
+  // Сравниваем две половины
+  bool result = compare_lists(head, reversed_second_half);
+
+  // Восстанавливаем оригинальный список
+  Node *original_second_half = reverse_list(reversed_second_half);
+  if (prev_slow != NULL) {
+    prev_slow->next = original_second_half;
+  }
+
+  return result;
 }
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_1/tests/test_palindrome.c b/Control-works/Control-work-No.2/Rewrite/Task_1/tests/test_palindrome.c
index d155fd1..033f1b2 100644
--- a/Control-works/Control-work-No.2/Rewrite/Task_1/tests/test_palindrome.c
+++ b/Control-works/Control-work-No.2/Rewrite/Task_1/tests/test_palindrome.c
@@ -1,166 +1,167 @@
 #include "../include/palindrome.h"
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdbool.h>
 
 // Вспомогательная функция для создания списка из массива
-Node* create_list_from_array(int arr[], int size) {
-    Node* head = NULL;
-    for (int i = 0; i < size; i++) {
-        head = append_node(head, arr[i]);
-    }
-    return head;
+Node *create_list_from_array(int arr[], int size) {
+  Node *head = NULL;
+  for (int i = 0; i < size; i++) {
+    head = append_node(head, arr[i]);
+  }
+  return head;
 }
 
 void test_empty_list() {
-    printf("1. Тест пустого списка: ");
-    Node* head = NULL;
-    bool result = is_palindrome(head);
+  printf("1. Тест пустого списка: ");
+  Node *head = NULL;
+  bool result = is_palindrome(head);
 
-    if (result == true) {
-        printf("Пройдено.\n");
-    }
+  if (result == true) {
+    printf("Пройдено.\n");
+  }
 
-    else {
-        printf("Не пройдено (ожидалось true, получено %s)\n", result ? "true" : "false");
-    }
+  else {
+    printf("Не пройдено (ожидалось true, получено %s)\n",
+           result ? "true" : "false");
+  }
 
-    free_list(head);
+  free_list(head);
 }
 
 void test_single_element() {
-    printf("2. Тест одного элемента: ");
-    Node* head = create_node(42);
-    bool result = is_palindrome(head);
+  printf("2. Тест одного элемента: ");
+  Node *head = create_node(42);
+  bool result = is_palindrome(head);
 
-    if (result == true) {
-        printf("Пройдено.\n");
-    }
+  if (result == true) {
+    printf("Пройдено.\n");
+  }
 
-    else {
-        printf("Не пройдено.\n");
-    }
+  else {
+    printf("Не пройдено.\n");
+  }
 
-    free_list(head);
+  free_list(head);
 }
 
 void test_even_palindrome() {
-    printf("3. Тест четного палиндрома (1 2 2 1): ");
-    int arr[] = {1, 2, 2, 1};
-    Node* head = create_list_from_array(arr, 4);
-    bool result = is_palindrome(head);
+  printf("3. Тест четного палиндрома (1 2 2 1): ");
+  int arr[] = {1, 2, 2, 1};
+  Node *head = create_list_from_array(arr, 4);
+  bool result = is_palindrome(head);
 
-    if (result == true) {
-        printf("Пройдено.\n");
-    }
+  if (result == true) {
+    printf("Пройдено.\n");
+  }
 
-    else {
-        printf("Не пройдено.\n");
-    }
+  else {
+    printf("Не пройдено.\n");
+  }
 
-    free_list(head);
+  free_list(head);
 }
 
 void test_odd_palindrome() {
-    printf("4. Тест нечетного палиндрома (1 2 3 2 1): ");
-    int arr[] = {1, 2, 3, 2, 1};
-    Node* head = create_list_from_array(arr, 5);
-    bool result = is_palindrome(head);
+  printf("4. Тест нечетного палиндрома (1 2 3 2 1): ");
+  int arr[] = {1, 2, 3, 2, 1};
+  Node *head = create_list_from_array(arr, 5);
+  bool result = is_palindrome(head);
 
-    if (result == true) {
-        printf("Пройдено.\n");
-    }
+  if (result == true) {
+    printf("Пройдено.\n");
+  }
 
-    else {
-        printf("Не пройдено.\n");
-    }
+  else {
+    printf("Не пройдено.\n");
+  }
 
-    free_list(head);
+  free_list(head);
 }
 
 void test_not_palindrome() {
-    printf("5. Тест не палиндрома (1 2 3 4): ");
-    int arr[] = {1, 2, 3, 4};
-    Node* head = create_list_from_array(arr, 4);
-    bool result = is_palindrome(head);
+  printf("5. Тест не палиндрома (1 2 3 4): ");
+  int arr[] = {1, 2, 3, 4};
+  Node *head = create_list_from_array(arr, 4);
+  bool result = is_palindrome(head);
 
-    if (result == false) {
-        printf("Пройдено.\n");
-    }
+  if (result == false) {
+    printf("Пройдено.\n");
+  }
 
-    else {
-        printf("Не прлйдено.\n");
-    }
+  else {
+    printf("Не прлйдено.\n");
+  }
 
-    free_list(head);
+  free_list(head);
 }
 
 void test_long_palindrome() {
-    printf("6. Тест длинного палиндрома: ");
-    int arr[] = {10, 20, 30, 40, 50, 40, 30, 20, 10};
-    Node* head = create_list_from_array(arr, 9);
-    bool result = is_palindrome(head);
+  printf("6. Тест длинного палиндрома: ");
+  int arr[] = {10, 20, 30, 40, 50, 40, 30, 20, 10};
+  Node *head = create_list_from_array(arr, 9);
+  bool result = is_palindrome(head);
 
-    if (result == true) {
-        printf("Прлйдено.\n");
-    }
+  if (result == true) {
+    printf("Прлйдено.\n");
+  }
 
-    else {
-        printf("Не пройдено.\n");
-    }
+  else {
+    printf("Не пройдено.\n");
+  }
 
-    free_list(head);
+  free_list(head);
 }
 
 void test_not_palindrome2() {
-    printf("7. Тест из задания (10 20 30 40 20 10): ");
-    int arr[] = {10, 20, 30, 40, 20, 10};
-    Node* head = create_list_from_array(arr, 6);
-    bool result = is_palindrome(head);
+  printf("7. Тест из задания (10 20 30 40 20 10): ");
+  int arr[] = {10, 20, 30, 40, 20, 10};
+  Node *head = create_list_from_array(arr, 6);
+  bool result = is_palindrome(head);
 
-    if (result == false) {
-        printf("Пройдено.\n");
-    }
+  if (result == false) {
+    printf("Пройдено.\n");
+  }
 
-    else {
-        printf("Не прлйдно.\n");
-    }
+  else {
+    printf("Не прлйдно.\n");
+  }
 
-    free_list(head);
+  free_list(head);
 }
 
 void test_all_identical() {
-    printf("8. Тест всех одинаковых элементов (5 5 5 5): ");
-    int arr[] = {5, 5, 5, 5};
-    Node* head = create_list_from_array(arr, 4);
-    bool result = is_palindrome(head);
+  printf("8. Тест всех одинаковых элементов (5 5 5 5): ");
+  int arr[] = {5, 5, 5, 5};
+  Node *head = create_list_from_array(arr, 4);
+  bool result = is_palindrome(head);
 
-    if (result == true) {
-        printf("Пройдено.\n");
-    }
+  if (result == true) {
+    printf("Пройдено.\n");
+  }
 
-    else {
-        printf("Не пройдено.\n");
-    }
+  else {
+    printf("Не пройдено.\n");
+  }
 
-    free_list(head);
+  free_list(head);
 }
 
 #ifdef TEST_MAIN
 int main() {
-    printf("=== Запуск тестов ===\n\n");
-
-    test_empty_list();
-    test_single_element();
-    test_even_palindrome();
-    test_odd_palindrome();
-    test_not_palindrome();
-    test_long_palindrome();
-    test_not_palindrome2();
-    test_all_identical();
-
-    printf("\n=== Все тесты завершены ===\n");
-    return 0;
+  printf("=== Запуск тестов ===\n\n");
+
+  test_empty_list();
+  test_single_element();
+  test_even_palindrome();
+  test_odd_palindrome();
+  test_not_palindrome();
+  test_long_palindrome();
+  test_not_palindrome2();
+  test_all_identical();
+
+  printf("\n=== Все тесты завершены ===\n");
+  return 0;
 }
 
 #endif

From 779b4cd227fd415bb4239e2c23453089e02ac1e4 Mon Sep 17 00:00:00 2001
From: Stanislav Klimovich <stasklimovish@gmail.com>
Date: Fri, 19 Dec 2025 12:54:11 +0300
Subject: [PATCH 8/8] Complete Task_2 | Rewrite

---
 .../Rewrite/Task_2/.gitignore                 |  25 ++++
 .../Rewrite/Task_2/CMakeLists.txt             |  38 +++++
 .../Rewrite/Task_2/README.md                  |  34 +++++
 .../Rewrite/Task_2/include/cyclic_shift.h     |  48 +++++++
 .../Rewrite/Task_2/src/cyclic_shift.c         |  80 +++++++++++
 .../Rewrite/Task_2/src/main.c                 |  84 +++++++++++
 .../Rewrite/Task_2/tests/test_cyclic_shift.c  | 132 ++++++++++++++++++
 7 files changed, 441 insertions(+)
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_2/.gitignore
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_2/CMakeLists.txt
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_2/README.md
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_2/include/cyclic_shift.h
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_2/src/cyclic_shift.c
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_2/src/main.c
 create mode 100644 Control-works/Control-work-No.2/Rewrite/Task_2/tests/test_cyclic_shift.c

diff --git a/Control-works/Control-work-No.2/Rewrite/Task_2/.gitignore b/Control-works/Control-work-No.2/Rewrite/Task_2/.gitignore
new file mode 100644
index 0000000..80d92b8
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_2/.gitignore
@@ -0,0 +1,25 @@
+# Build
+build/
+*.exe
+*.out
+
+# Object files
+*.o
+*.obj
+
+# Libraries
+*.a
+*.so
+*.dylib
+
+# CMake
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+Makefile
+compile_commands.json
+
+# IDE
+.vscode/
+.idea/
+*.swp
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_2/CMakeLists.txt b/Control-works/Control-work-No.2/Rewrite/Task_2/CMakeLists.txt
new file mode 100644
index 0000000..1802fbd
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_2/CMakeLists.txt
@@ -0,0 +1,38 @@
+cmake_minimum_required(VERSION 3.10)
+project(cyclic_shift C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Werror")
+
+add_executable(cyclic_shift
+    src/main.c
+    src/cyclic_shift.c
+)
+
+target_include_directories(cyclic_shift
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+add_executable(test_cyclic_shift
+    tests/test_cyclic_shift.c
+    src/cyclic_shift.c
+)
+
+target_include_directories(test_cyclic_shift
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+target_compile_definitions(test_cyclic_shift
+    PRIVATE TEST_MAIN
+)
+
+enable_testing()
+add_test(NAME cyclic_shift_tests COMMAND test_cyclic_shift)
+
+message(STATUS "=== 'Циклический сдвиг' ===")
+message(STATUS "Доступные цели:")
+message(STATUS "  - cyclic_shift (основная программа)")
+message(STATUS "  - test_cyclic_shift (тесты)")
+message(STATUS "Для сборки: mkdir build && cd build && cmake .. && make")
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_2/README.md b/Control-works/Control-work-No.2/Rewrite/Task_2/README.md
new file mode 100644
index 0000000..deeb187
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_2/README.md
@@ -0,0 +1,34 @@
+# "Циклический сдвиг"
+
+## Описание
+Программа для нахождения наибольшего числа, получаемого циклическим сдвигом двоичного представления числа.
+
+Дано целое число больше нуля, представленное в двоичной форме в массиве длины N <= 32. 
+Элементы массивов — булевые (0 или 1). 
+Найти наибольшее число, получающееся из него циклическим сдвигом. 
+Ответ должен быть числом в десятичной форме.
+
+## Структура проекта
+Task_2/
+| .gitignore                    # Игнорируемые файлы
+| CMakeLists.txt                # Главный файл CMake
+| README.md                     # Документация
+|
+| include/                      # Заголовочные файлы
+| - cyclic_shift.h              # Объявление функций
+|
+| src/                          # Исходный код
+| - main.c                      # Основная программа
+| - cyclic_shift.c              # Реализация алгоритмов
+|
+| tests/                        # Модульные тесты
+| - test_cyclic_shift.c         # Тесты для проверки
+
+## Сборка
+```bash
+mkdir build
+cd build
+cmake ..
+make
+```
+
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_2/include/cyclic_shift.h b/Control-works/Control-work-No.2/Rewrite/Task_2/include/cyclic_shift.h
new file mode 100644
index 0000000..bb8cb6d
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_2/include/cyclic_shift.h
@@ -0,0 +1,48 @@
+#ifndef CYCLIC_SHIFT_H
+#define CYCLIC_SHIFT_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+/**
+ * Находит максимальное число циклического сдвига (версия с массивом)
+ * - param: arr Массив битов (младший бит - arr[0])
+ *          n Длина массива (1 <= n <= 32)
+ *          max_value Указатель для записи максимального значения
+ * - return: Количество позиций сдвига для получения максимума
+ */
+int max_cyclic_shift_array(const bool arr[], int n, uint32_t *max_value);
+
+/**
+ * Преобразует массив битов в целое число
+ * - param: arr Массив битов (младший бит - arr[0])
+ *          n Длина массива
+ * - return: Число в десятичной системе
+ */
+uint32_t binary_array_to_uint(const bool arr[], int n);
+
+/**
+ * Преобразует число в массив битов
+ * - param: value Число для преобразования
+ *          arr Массив для записи битов (должен быть достаточно большим)
+ *          n Количество битов для преобразования
+ */
+void uint_to_binary_array(uint32_t value, bool arr[], int n);
+
+/**
+ * Выполняет циклический сдвиг массива влево на k позиций
+ * - param: src Исходный массив
+ *          dst Результирующий массив
+ *          n Длина массива
+ *          k Количество позиций сдвига
+ */
+void cyclic_shift_array(const bool src[], bool dst[], int n, int k);
+
+/**
+ * Печатает массив битов
+ * - param: arr Массив битов
+ *          n Длина массива
+ */
+void print_binary_array(const bool arr[], int n);
+
+#endif // CYCLIC_SHIFT_H
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_2/src/cyclic_shift.c b/Control-works/Control-work-No.2/Rewrite/Task_2/src/cyclic_shift.c
new file mode 100644
index 0000000..e22cb17
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_2/src/cyclic_shift.c
@@ -0,0 +1,80 @@
+#include "../include/cyclic_shift.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+
+uint32_t binary_array_to_uint(const bool arr[], int n) {
+    uint32_t result = 0;
+
+    for (int i = 0; i < n; i++) {
+        if (arr[i]) {
+            result |= (1u << i);  // Устанавливаем i-й бит
+        }
+    }
+
+    return result;
+}
+
+void uint_to_binary_array(uint32_t value, bool arr[], int n) {
+    for (int i = 0; i < n; i++) {
+        arr[i] = (value >> i) & 1u;
+    }
+}
+
+uint32_t cyclic_shift_left(uint32_t value, int n, int k) {
+    if (n == 0) return 0;
+
+    k = k % n;  // Нормализуем сдвиг
+
+    // Маска для n битов
+    uint32_t mask = (1u << n) - 1;
+
+    // Циклический сдвиг влево
+    uint32_t left_part = (value << k) & mask;
+    uint32_t right_part = value >> (n - k);
+
+    return left_part | right_part;
+}
+
+void cyclic_shift_array(const bool src[], bool dst[], int n, int k) {
+    if (n == 0) return;
+
+    k = k % n;  // Нормализуем сдвиг
+
+    for (int i = 0; i < n; i++) {
+        dst[(i + k) % n] = src[i];
+    }
+}
+
+int max_cyclic_shift_array(const bool arr[], int n, uint32_t *max_value) {
+    if (n <= 0 || arr == NULL || max_value == NULL) {
+        return -1;
+    }
+
+    // Временный массив для хранения сдвинутого значения
+    bool *shifted = (bool*)malloc(n * sizeof(bool));
+    if (shifted == NULL) {
+        fprintf(stderr, "Ошибка выделения памяти\n");
+        return -1;
+    }
+
+    uint32_t max_val = 0;
+    int best_shift = 0;
+
+    // Проверяем все возможные сдвиги
+    for (int k = 0; k < n; k++) {
+        cyclic_shift_array(arr, shifted, n, k);
+        uint32_t current = binary_array_to_uint(shifted, n);
+
+        if (current > max_val) {
+            max_val = current;
+            best_shift = k;
+        }
+    }
+
+    *max_value = max_val;
+    free(shifted);
+    return best_shift;
+}
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_2/src/main.c b/Control-works/Control-work-No.2/Rewrite/Task_2/src/main.c
new file mode 100644
index 0000000..2f205d7
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_2/src/main.c
@@ -0,0 +1,84 @@
+#include "../include/cyclic_shift.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#define MAX_BITS 32
+
+int main() {
+    int n;
+    bool arr[MAX_BITS];
+
+    printf("=== \"Циклический сдвиг\"  ===\n\n");
+
+    // Ввод длины числа
+    while (1) {
+        printf("Введите длину двоичного числа (1-%d): ", MAX_BITS);
+        if (scanf("%d", &n) != 1) {
+            printf("Ошибка ввода. Пожалуйста, введите число.\n");
+            while (getchar() != '\n');  // Очистка буфера
+            continue;
+        }
+
+        if (n >= 1 && n <= MAX_BITS) {
+            break;
+        }
+        printf("Длина должна быть от 1 до %d.\n", MAX_BITS);
+    }
+
+    // Ввод битов
+    printf("Введите %d битов (через пробел, 0 или 1): ", n);
+    for (int i = n - 1; i >= 0; i--) {
+        int bit;
+        if (scanf("%d", &bit) != 1) {
+            printf("Ошибка ввода бита.\n");
+            return 1;
+        }
+
+        if (bit != 0 && bit != 1) {
+            printf("Биты должны быть 0 или 1.\n");
+            return 1;
+        }
+
+        arr[i] = (bit == 1);
+    }
+
+    printf("\nИсходное двоичное число: ");
+    print_binary_array(arr, n);
+
+    uint32_t original_value = binary_array_to_uint(arr, n);
+    printf(" (%u в десятичной)\n\n", original_value);
+
+    // Алгоритм с массивом
+    uint32_t max_array_value;
+    int array_shift = max_cyclic_shift_array(arr, n, &max_array_value);
+
+    // Алгоритм с битами
+    printf("Результаты:\n");
+    printf("1. Алгоритм с массивом: \n");
+    printf("   Максимальное число: ");
+
+    bool max_arr[MAX_BITS];
+    cyclic_shift_array(arr, max_arr, n, array_shift);
+    print_binary_array(max_arr, n);
+    printf(" (%u)\n", max_array_value);
+    printf("   Сдвиг: %d позиции(й)\n\n", array_shift);
+
+    // Дополнительная информация
+    printf("\nВсе циклические сдвиги:\n");
+    for (int k = 0; k < n; k++) {
+        uint32_t shifted = cyclic_shift_left(original_value, n, k);
+        printf("  Сдвиг %2d: ", k);
+        uint_to_binary_array(shifted, max_arr, n);
+        print_binary_array(max_arr, n);
+        printf(" = %u", shifted);
+
+        if (k == array_shift) {
+            printf(" ← МАКСИМУМ");
+        }
+        printf("\n");
+    }
+
+    return 0;
+}
diff --git a/Control-works/Control-work-No.2/Rewrite/Task_2/tests/test_cyclic_shift.c b/Control-works/Control-work-No.2/Rewrite/Task_2/tests/test_cyclic_shift.c
new file mode 100644
index 0000000..a130e44
--- /dev/null
+++ b/Control-works/Control-work-No.2/Rewrite/Task_2/tests/test_cyclic_shift.c
@@ -0,0 +1,132 @@
+#include "../include/cyclic_shift.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+void test_binary_conversion() {
+    printf("1. Тест преобразований число↔массив: ");
+
+    bool arr1[] = {0, 0, 1, 0, 1};  // 10100 в правильном порядке
+    uint32_t val = binary_array_to_uint(arr1, 5);
+
+    if (val != 20) {
+        printf("Не пройдено: ожидалось 20, получено %u.\n", val);
+        return;
+    }
+
+    bool arr2[5];
+    uint_to_binary_array(val, arr2, 5);
+
+    if (memcmp(arr1, arr2, 5) == 0) {
+        printf("Пройдено\n");
+    } else {
+        printf("Не процдено: массивы не совпадают\n");
+    }
+}
+
+void test_single_bit() {
+    printf("2. Тест одного бита (1): ");
+
+    bool arr[] = {1};
+    uint32_t max_val;
+    int shift = max_cyclic_shift(arr, 1, &max_val);
+
+    if (max_val == 1 && shift == 0) {
+        printf("Пройдено.\n");
+    } else {
+        printf("Не пройдено.\n");
+    }
+}
+
+void test_example_1() {
+    printf("3. Тест примера 1 (110): ");
+
+    bool arr[] = {0, 1, 1};  // 110
+    uint32_t max_val;
+    max_cyclic_shift(arr, 3, &max_val);
+
+    if (max_val == 6) {  // 110 в десятичной = 6
+        printf("Процдено.\n");
+    } else {
+        printf("Не пройдено.: ожидалось 6, получено %u.\n", max_val);
+    }
+}
+
+void test_example_2() {
+    printf("4. Тест примера 2 (1011): ");
+
+    bool arr[] = {1, 1, 0, 1};  // 1011
+    uint32_t max_val;
+    max_cyclic_shift(arr, 4, &max_val);
+
+    if (max_val == 14) {  // 1110 в десятичной = 14
+        printf("Пройдено.\n");
+    } else {
+        printf("Не процдено: ожидалось 14, получено %u.\n", max_val);
+    }
+}
+
+void test_all_ones() {
+    printf("5. Тест всех единиц (1111): ");
+
+    bool arr[] = {1, 1, 1, 1};
+    uint32_t max_val;
+    max_cyclic_shift(arr, 4, &max_val);
+
+    if (max_val == 15) {
+        printf("Процдено.\n");
+    } else {
+        printf("Не пройдено.\n");
+    }
+}
+
+void test_all_zeros() {
+    printf("6. Тест всех нулей (0000): ");
+
+    bool arr[] = {0, 0, 0, 0};
+    uint32_t max_val;
+    max_cyclic_shift(arr, 4, &max_val);
+
+    if (max_val == 0) {
+        printf("Пройдено.\n");
+    } else {
+        printf("Не пройдено.\n");
+    }
+}
+
+void test_cyclic_shift_array() {
+    printf("7. Тест функции циклического сдвига массива: ");
+
+    bool src[] = {1, 1, 0, 1};  // 1011
+    bool dst[4];
+
+    cyclic_shift_array(src, dst, 4, 2);  // Сдвиг на 2
+
+    // Ожидаемый результат после сдвига на 2: 1110 (младший бит справа)
+    bool expected[] = {0, 1, 1, 1};  // 1110
+
+    if (memcmp(dst, expected, 4) == 0) {
+        printf("Пройдено.\n");
+    } else {
+        printf("Не пройдено.\n");
+    }
+}
+
+#ifdef TEST_MAIN
+int main() {
+    printf("=== Запуск тестов ===\n\n");
+
+    test_binary_conversion();
+    test_single_bit();
+    test_example_1();
+    test_example_2();
+    test_all_ones();
+    test_all_zeros();
+    test_cyclic_shift_array();
+
+    printf("\n=== Все тесты пройдены ===\n");
+    return 0;
+}
+#endif