diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp
index 0e4393b..0ff86f9 100644
--- a/task_01/src/main.cpp
+++ b/task_01/src/main.cpp
@@ -1,3 +1,15 @@
+#include "mediana.hpp"
+
 #include <iostream>
 
-int main() { return 0; }
+int main() 
+try
+{
+    setlocale(LC_ALL, "RU");
+
+	return 0;
+}
+catch(const std::exception& e)
+{
+    std::cerr << e.what() << '\n';
+}
diff --git a/task_01/src/mediana.cpp b/task_01/src/mediana.cpp
new file mode 100644
index 0000000..3634074
--- /dev/null
+++ b/task_01/src/mediana.cpp
@@ -0,0 +1,23 @@
+#include "mediana.hpp"
+#include <vector>
+
+int mediana(int a, int b, int c) {
+	int m{-999999999};
+    int n{999999999};
+
+    std::vector<int> vec {a, b, c};
+    for (int i=0; i<3; i++)
+    {
+        if (vec[i]>m)
+            m=vec[i];
+    }
+
+    for (int i=0; i<3; i++)
+    {
+        if (vec[i]<n)
+            n=vec[i];
+    }
+
+    int res = (a + b + c) - (m + n);
+    return res;
+}
\ No newline at end of file
diff --git a/task_01/src/mediana.hpp b/task_01/src/mediana.hpp
new file mode 100644
index 0000000..befc06f
--- /dev/null
+++ b/task_01/src/mediana.hpp
@@ -0,0 +1 @@
+int mediana(int a, int b, int c);
\ No newline at end of file
diff --git a/task_01/src/sum.hpp b/task_01/src/sum.hpp
deleted file mode 100644
index 97cc293..0000000
--- a/task_01/src/sum.hpp
+++ /dev/null
@@ -1 +0,0 @@
-int Sum(int first_number, int second_number, int third_number) { return 6; }
\ No newline at end of file
diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp
index 0c33b55..ccae7a8 100644
--- a/task_01/src/test.cpp
+++ b/task_01/src/test.cpp
@@ -1,5 +1,14 @@
 #include <gtest/gtest.h>
 
-#include <sum.hpp>
+#include "mediana.hpp"
+
+TEST(Mediana, Simple1) { EXPECT_EQ(mediana(1, 2, 3), 2); }
+TEST(Mediana, Simple2) { EXPECT_EQ(mediana(-1, 2, 3), 2); }
+TEST(Mediana, Simple3) { EXPECT_EQ(mediana(123, 22, 32345), 123); }
+TEST(Mediana, Simple4) { EXPECT_EQ(mediana(1, 3, 3), 3); }
+TEST(Mediana, Simple5) { ASSERT_EQ(mediana(1, 2, 3), 2); }
+TEST(Mediana, Simple6) { ASSERT_EQ(mediana(1, 1, 1), 1); }
+TEST(Mediana, Simple7) { ASSERT_EQ(mediana(-10, 0, 10), 0); }
+TEST(Mediana, Simple8) { ASSERT_EQ(mediana(-3, -2, -1), -2); }
+TEST(Mediana, Simple9) { ASSERT_EQ(mediana(2, 2, 3), 2); }
 
-TEST(Test, Simple) { ASSERT_EQ(Sum(1, 2, 3), 6); }
\ No newline at end of file
diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp
index 0e4393b..42090cf 100644
--- a/task_02/src/main.cpp
+++ b/task_02/src/main.cpp
@@ -1,3 +1,17 @@
 #include <iostream>
+#include "max_element.hpp"
 
-int main() { return 0; }
+int main() 
+try
+{
+    setlocale(LC_ALL, "RU");
+    int array[] = {1, 3, 5, 7, 9};
+    int size = sizeof(array) / sizeof(array[0]);
+    int res = get_max_element(array, size);
+    std::cout << res;
+	return 0;
+}
+catch(const std::exception& e)
+{
+    std::cerr << e.what() << '\n';
+}
\ No newline at end of file
diff --git a/task_02/src/max_element.cpp b/task_02/src/max_element.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/task_02/src/max_element.hpp b/task_02/src/max_element.hpp
new file mode 100644
index 0000000..f5f91a3
--- /dev/null
+++ b/task_02/src/max_element.hpp
@@ -0,0 +1,10 @@
+int get_max_element(int* array, int size)
+{
+    int max_element = array[0];
+    for (int i{ 0 }; i < size; i++)
+    {
+        if (max_element < array[i])
+            max_element = array[i];
+    }
+    return max_element;
+};
\ No newline at end of file
diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp
index 87cef73..f2d7499 100644
--- a/task_02/src/test.cpp
+++ b/task_02/src/test.cpp
@@ -1,5 +1,37 @@
 #include <gtest/gtest.h>
+#include "max_element.hpp"
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
\ No newline at end of file
+TEST(MaxElementTests, PositiveArray)
+{
+    int array[] = {1, 3, 5, 7, 9};
+    int size = sizeof(array) / sizeof(array[0]);
+    EXPECT_EQ(get_max_element(array, size), 9);
+}
+
+TEST(MaxElementTests, NegativeArray)
+{
+    int array[] = {-1, -3, -5, -7, -9};
+    int size = sizeof(array) / sizeof(array[0]);
+    EXPECT_EQ(get_max_element(array, size), -1);
+}
+
+TEST(MaxElementTests, MixedArray)
+{
+    int array[] = {-1, 2, -3, 4, -5};
+    int size = sizeof(array) / sizeof(array[0]);
+    EXPECT_EQ(get_max_element(array, size), 4);
+}
+
+TEST(MaxElementTests, SingleElementArray)
+{
+    int array[] = {42};
+    int size = sizeof(array) / sizeof(array[0]);
+    EXPECT_EQ(get_max_element(array, size), 42);
+}
+
+TEST(MaxElementTests, SameElementArray)
+{
+    int array[] = {5, 5, 5, 5, 5};
+    int size = sizeof(array) / sizeof(array[0]);
+    EXPECT_EQ(get_max_element(array, size), 5);
+}
diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp
index 76e8197..2046048 100644
--- a/task_03/src/main.cpp
+++ b/task_03/src/main.cpp
@@ -1 +1,24 @@
-int main() { return 0; }
+#include "reverse.hpp"
+#include <iostream>
+
+int main() 
+try
+{
+    setlocale(LC_ALL, "RU");
+
+    int array[4]{ 1, 2, 3, 4 };
+    int len = 4;
+    
+    Reverse(array, len);
+
+    std::cout << "Инвертированный массив:" << std::endl;
+
+    for (int i{ 0 }; i < len; i++)
+        std::cout << array[i] << " ";
+	
+    return 0;
+}
+catch(const std::exception& e)
+{
+    std::cerr << e.what() << '\n';
+}
diff --git a/task_03/src/reverse.cpp b/task_03/src/reverse.cpp
index 3457424..e69de29 100644
--- a/task_03/src/reverse.cpp
+++ b/task_03/src/reverse.cpp
@@ -1,3 +0,0 @@
-#include "reverse.hpp"
-
-void Reverse(int *array, size_t len) {}
\ No newline at end of file
diff --git a/task_03/src/reverse.hpp b/task_03/src/reverse.hpp
index 450a729..bd82fc9 100644
--- a/task_03/src/reverse.hpp
+++ b/task_03/src/reverse.hpp
@@ -1,5 +1,9 @@
 #pragma once
-
 #include <cstddef>
+#include <algorithm>
 
-void Reverse(int *array, size_t len);
+void Reverse(int* array, size_t len)
+{
+    for (int i{ 0 }; i < len / 2; i++)
+        std::swap(array[i], array[(len -i - 1)]);
+}
diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp
index 2d868db..1f336d8 100644
--- a/task_03/src/test.cpp
+++ b/task_03/src/test.cpp
@@ -1,6 +1,77 @@
-
 #include <gtest/gtest.h>
-
 #include "reverse.hpp"
 
-TEST(Reverse, Simple) {}
+TEST(ReverseTests, SimpleArray)
+{
+    int array[] = {1, 2, 3, 4, 5};
+    size_t len = sizeof(array) / sizeof(array[0]);
+    
+    Reverse(array, len);
+    
+    EXPECT_EQ(array[0], 5);
+    EXPECT_EQ(array[1], 4);
+    EXPECT_EQ(array[2], 3);
+    EXPECT_EQ(array[3], 2);
+    EXPECT_EQ(array[4], 1);
+}
+
+TEST(ReverseTests, EmptyArray)
+{
+    int array[] = {};
+    size_t len = sizeof(array) / sizeof(array[0]);
+
+    Reverse(array, len);
+
+    EXPECT_EQ(len, 0);
+}
+
+TEST(ReverseTests, SingleElementArray)
+{
+    int array[] = {42};
+    size_t len = sizeof(array) / sizeof(array[0]);
+
+    Reverse(array, len);
+
+    EXPECT_EQ(array[0], 42);
+}
+
+TEST(ReverseTests, EvenLengthArray)
+{
+    int array[] = {1, 2, 3, 4};
+    size_t len = sizeof(array) / sizeof(array[0]);
+
+    Reverse(array, len);
+
+    EXPECT_EQ(array[0], 4);
+    EXPECT_EQ(array[1], 3);
+    EXPECT_EQ(array[2], 2);
+    EXPECT_EQ(array[3], 1);
+}
+
+TEST(ReverseTests, SameElementArray)
+{
+    int array[] = {5, 5, 5, 5, 5};
+    size_t len = sizeof(array) / sizeof(array[0]);
+
+    Reverse(array, len);
+
+    EXPECT_EQ(array[0], 5);
+    EXPECT_EQ(array[1], 5);
+    EXPECT_EQ(array[2], 5);
+    EXPECT_EQ(array[3], 5);
+    EXPECT_EQ(array[4], 5);
+}
+
+TEST(ReverseTests, NegativeArray)
+{
+    int array[] = {-1, -2, -3, -4, -5};
+    size_t len = sizeof(array) / sizeof(array[0]);
+
+    Reverse(array, len);
+
+    EXPECT_EQ(array[0], -5);
+    EXPECT_EQ(array[1], -4);
+    EXPECT_EQ(array[2], -3);
+    EXPECT_EQ(array[3], -2);
+    EXPECT_EQ(array[4], -1);
+}
diff --git a/task_04/src/main.cpp b/task_04/src/main.cpp
index 0e4393b..c87c81d 100644
--- a/task_04/src/main.cpp
+++ b/task_04/src/main.cpp
@@ -1,3 +1,25 @@
 #include <iostream>
+#include "shift.hpp"
 
-int main() { return 0; }
+int main() 
+try
+{
+    setlocale(LC_ALL, "RU");
+
+    int array[5]{ 1, 2, 3, 4, 5};
+    size_t len = 5;
+    unsigned int N = 2;
+    
+    shift(array, len, N);
+
+    std::cout << "Сдвинутый  массив:" << std::endl;
+
+    for (int i{ 0 }; i < len; i++)
+        std::cout << array[i] << " ";
+	
+    return 0;
+}
+catch(const std::exception& e)
+{
+    std::cerr << e.what() << '\n';
+}
diff --git a/task_04/src/shift.cpp b/task_04/src/shift.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/task_04/src/shift.hpp b/task_04/src/shift.hpp
new file mode 100644
index 0000000..756c347
--- /dev/null
+++ b/task_04/src/shift.hpp
@@ -0,0 +1,19 @@
+#include <cstddef>
+
+void shift(int* array, size_t& len, unsigned int& N)
+{
+    if (len == 0) return;
+
+    N = N % len; 
+    if (N == 0) return;
+
+    for (size_t i = 0; i < N; ++i)
+    {
+        int temp = array[len - 1];
+        for (size_t j = len - 1; j > 0; --j)
+        {
+            array[j] = array[j - 1];
+        }
+        array[0] = temp;
+    }
+}
diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp
index 5e11617..814f98b 100644
--- a/task_04/src/test.cpp
+++ b/task_04/src/test.cpp
@@ -1,6 +1,88 @@
-
+#include "shift.hpp"
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+// Тестовый случай для обычного массива с N < len
+TEST(ShiftTests, NormalShift)
+{
+    int array[] = {1, 2, 3, 4, 5};
+    size_t len = sizeof(array) / sizeof(array[0]);
+    unsigned int N = 2;
+
+    shift(array, len, N);
+
+    EXPECT_EQ(array[0], 4);
+    EXPECT_EQ(array[1], 5);
+    EXPECT_EQ(array[2], 1);
+    EXPECT_EQ(array[3], 2);
+    EXPECT_EQ(array[4], 3);
+}
+
+// Тестовый случай для сдвига на 0
+TEST(ShiftTests, ZeroShift)
+{
+    int array[] = {1, 2, 3, 4, 5};
+    size_t len = sizeof(array) / sizeof(array[0]);
+    unsigned int N = 0;
+
+    shift(array, len, N);
+
+    EXPECT_EQ(array[0], 1);
+    EXPECT_EQ(array[1], 2);
+    EXPECT_EQ(array[2], 3);
+    EXPECT_EQ(array[3], 4);
+    EXPECT_EQ(array[4], 5);
+}
+
+// Тестовый случай для сдвига на длину массива
+TEST(ShiftTests, LengthShift)
+{
+    int array[] = {1, 2, 3, 4, 5};
+    size_t len = sizeof(array) / sizeof(array[0]);
+    unsigned int N = len; // Сдвиг на длину массива
+
+    shift(array, len, N);
+
+    EXPECT_EQ(array[0], 1);
+    EXPECT_EQ(array[1], 2);
+    EXPECT_EQ(array[2], 3);
+    EXPECT_EQ(array[3], 4);
+    EXPECT_EQ(array[4], 5);
 }
+
+// Тестовый случай для сдвига больше длины массива
+TEST(ShiftTests, LargeShift)
+{
+    int array[] = {1, 2, 3, 4, 5};
+    size_t len = sizeof(array) / sizeof(array[0]);
+    unsigned int N = 7; // Сдвиг больше длины массива
+
+    shift(array, len, N);
+
+    EXPECT_EQ(array[0], 4);
+    EXPECT_EQ(array[1], 5);
+    EXPECT_EQ(array[2], 1);
+    EXPECT_EQ(array[3], 2);
+    EXPECT_EQ(array[4], 3);
+}
+
+// Тестовый случай для пустого массива
+TEST(ShiftTests, EmptyArray)
+{
+    int array[] = {};
+    size_t len = sizeof(array) / sizeof(array[0]);
+    unsigned int N = 2;
+
+    shift(array, len, N);
+
+    EXPECT_EQ(len, 0); // Допускаем, что пустой массив остается пустым
+}
+
+// Тестовый случай для массива с одним элементом
+TEST(ShiftTests, SingleElementArray)
+{
+    int array[] = {42};
+    size_t len = sizeof(array) / sizeof(array[0]);
+    unsigned int N = 3;
+
+    shift(array, len, N);
+}
\ No newline at end of file