MedianaForInt

task_01/src/main.cpp

@@ -1,3 +1,4 @@
-#include <iostream>
+
+
 
 int main() { return 0; }

task_01/src/mediana.cpp

@@ -0,0 +1,26 @@
+#include "mediana.hpp"
+
+int _max(int first_number, int second_number)
+{
+    return first_number >= second_number ? first_number : second_number;
+}
+
+int _min(int first_number, int second_number)
+{
+    return first_number <= second_number ? first_number : second_number;
+}
+
+
+
+int mediana(int first_number, int second_number, int third_number)
+{
+    int maxx = _max(first_number, second_number);
+    maxx = _max(maxx, third_number);
+
+    int minn = _min(first_number, second_number);
+    minn = _min(minn, third_number);
+
+    int summ = first_number + second_number + third_number;
+
+    return summ - (maxx + minn); 
+}

task_01/src/mediana.hpp

@@ -0,0 +1,6 @@
+int _max(int first_number, int second_number);
+
+int _min(int first_number, int second_number);
+
+int mediana(int first_number, int second_number, int third_number);
+

task_01/src/test.cpp

@@ -1,5 +1,10 @@
 #include <gtest/gtest.h>
 
-#include <sum.hpp>
+#include "mediana.hpp"
 
-TEST(Test, Simple) { ASSERT_EQ(Sum(1, 2, 3), 6); }
+TEST(Mediana, Simple1) { ASSERT_EQ(mediana(1, 2, 3), 2); }
+TEST(Mediana, Simple2) { ASSERT_EQ(mediana(1, 1, 1), 1); }
+TEST(Mediana, Simple3) { ASSERT_EQ(mediana(-10, 0, 10), 0); }
+TEST(Mediana, Simple4) { ASSERT_EQ(mediana(-3, -2, -1), -2); }
+TEST(Mediana, Simple5) { ASSERT_EQ(mediana(2, 2, 3), 2); }
+TEST(Mediana, Simple6) { ASSERT_EQ(mediana(1, 3, 3), 3); }

task_02/src/max_arr.cpp

@@ -0,0 +1,14 @@
+#include "max_arr.hpp"
+
+int max_arr(int* pa, int length)
+{
+    int maxx = *pa;
+
+    for (int i = 0; i < length; ++i)
+    {
+        if (*pa >= maxx) maxx = *pa;
+        pa += 1;
+    }
+
+    return maxx;
+}

task_02/src/max_arr.hpp

@@ -0,0 +1 @@
+int max_arr(int* pa, int length);

task_02/src/test.cpp

@@ -1,5 +1,27 @@
 #include <gtest/gtest.h>
+#include "max_arr.hpp"
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+int arr1[4] {1,2, 3, 4};
+int* pa1 = &arr1[0];
+
+int arr2[10] {1, 3, 7, 1, 15, 2, 9, 10, 10, 3};
+int* pa2 = &arr2[0];
+
+int arr3[6] {-9, -6, -7, -15, -60, -25};
+int* pa3 = &arr3[0];
+
+int arr4[1] {12};
+int* pa4 = &arr4[0];
+
+int arr5[3] {-9999999, -9999999, 1};
+int* pa5 = &arr5[0];
+
+TEST(Max_Arr, Simple1) { ASSERT_EQ(max_arr(pa1, 4), 4); }
+
+TEST(Max_Arr, Simple2) { ASSERT_EQ(max_arr(pa2, 10), 15); }
+
+TEST(Max_Arr, Simple3) { ASSERT_EQ(max_arr(pa3, 5), -6); }
+
+TEST(Max_Arr, Simple4) { ASSERT_EQ(max_arr(pa4, 1), 12); }
+
+TEST(Max_Arr, Simple5) { ASSERT_EQ(max_arr(pa5, 3), 1); }

task_03/src/main.cpp

@@ -1 +1,23 @@
-int main() { return 0; }
+#include <iostream>
+#include "reverse.hpp"
+
+// Тестирование функции _arrays_equality
+
+int main()
+{
+    int arr_1[4] {1, 2, 3, 4};
+    int arr_2[4] {1, 2, 3, 4};
+    int arr_error [4] {4, 2, 3, 4};
+
+    int arr4[5] {1, 4, 9, 16, 25};
+    int right_answer4[5] {25, 16, 9, 4, 1};
+    int* answer4 = return_re_array(arr4, 5);
+
+    std::cout << "True: " << true << std::endl;
+    std::cout << _arrays_equality(arr_1, arr_2, 4) << std::endl;
+    std::cout << _arrays_equality(answer4, right_answer4, 5) << std::endl;
+
+    std::cout << "False: " << false << std::endl;
+    std::cout << _arrays_equality(arr_1, arr_error, 4) << std::endl;
+
+}

task_03/src/reverse.cpp

@@ -1,3 +1,46 @@
 #include "reverse.hpp"
 
-void Reverse(int *array, size_t len) {}
+
+bool _arrays_equality(int* array1, int* array2, const size_t& len)
+{
+    // Функция для проверки равенства массивов
+
+    int* pa1 = array1;
+    int* pa2 = array2;
+
+    size_t it{0};
+
+    while (it < len)
+    {
+
+        if (pa1[it] == pa2[it]) ++it;
+
+        else return false;
+    }
+
+    return true;
+}
+
+void Reverse(int* array, const size_t& len) 
+{
+    int* _array = new int[len];
+
+    for (size_t i{0}; i < len; ++i)
+        _array[i] = array[len - i - 1];
+
+    for (size_t i{0}; i < len; ++i)
+        array[i] = _array[i];
+
+    delete[] _array;
+
+}
+
+int* return_re_array(int* array, const size_t& len)
+{
+    // Дополнительную функцию для того, чтобы написать тесты
+    // для функции Reverse, которая возвращает void
+
+    Reverse(array, len);
+
+    return array;
+}

task_03/src/reverse.hpp

@@ -2,4 +2,9 @@
 
 #include <cstddef>
 
-void Reverse(int *array, size_t len);
+bool _arrays_equality(int* array1, int* array2, const size_t& len);
+
+void Reverse(int* array, const size_t& len);
+
+int* return_re_array(int* array, const size_t& len);
+

task_03/src/test.cpp

@@ -3,4 +3,37 @@
 
 #include "reverse.hpp"
 
-TEST(Reverse, Simple) {}
+
+int arr1[4] {1,2, 3, 4};
+int right_answer1[4] {4, 3, 2, 1};
+int* answer1 = return_re_array(arr1, 4);
+
+TEST(Revese, Simple1) { ASSERT_EQ(_arrays_equality(answer1, right_answer1, 4), true); }
+
+
+int arr2[5] {5, 5, 5, 5, 5};
+int right_answer2[5] {5, 5, 5, 5, 5};
+int* answer2 = return_re_array(arr2, 5);
+
+TEST(Revese, Simple2) { ASSERT_EQ(_arrays_equality(answer2, right_answer2, 5), true); }
+
+int arr3[6] {0, 1, 0, 1, 0, 1};
+int right_answer3[6] {1, 0, 1, 0, 1, 0};
+int* answer3 = return_re_array(arr3, 6);
+
+TEST(Revese, Simple3) { ASSERT_EQ(_arrays_equality(answer3, right_answer3, 6), true); }
+
+int arr4[5] {1, 4, 9, 16, 25};
+int bad_answer1[5] {25, 16, 9, 4, 10000};
+int* answer4 = return_re_array(arr4, 5);
+
+TEST(Revese, SimpleError1) { ASSERT_EQ(_arrays_equality(answer4, bad_answer1, 5), false); }
+
+int arr5[5] {1, 4, 9, 16, 25};
+int bad_answer5[5] {1, 4, 9, 16, 25};
+int* answer5 = return_re_array(arr5, 5);
+
+TEST(Revese, SimpleError2) { ASSERT_EQ(_arrays_equality(answer4, bad_answer1, 5), false); }
+
+
+// TEST(Revese, WHAT) { ASSERT_EQ(answer3, right_answer3); } У одинаковых массивов разные адреса

task_04/src/main.cpp

@@ -1,3 +1,21 @@
 #include <iostream>
+#include "shift_right.hpp"
 
-int main() { return 0; }
+
+int main()
+{
+    int arr1[5] {1,2, 3, 4, 5};
+    int right_answer1[5] {4, 1, 2, 3};
+    int* answer1 = return_sh_array(arr1, 5, 1);
+
+    std::cout << "Array: {";
+
+    for (size_t i = 0; i < 5; i++)
+    {
+
+        std::cout << answer1[i] << ", ";
+    }
+
+    std::cout << "}";
+
+}

task_04/src/shift.cpp

@@ -0,0 +1,52 @@
+#include "shift_right.hpp"
+
+bool _arrays_equality(int* array1, int* array2, const size_t& len)
+{
+    // Функция для проверки равенства массивов
+
+    int* pa1 = array1;
+    int* pa2 = array2;
+
+    size_t it{0};
+
+    while (it < len)
+    {
+
+        if (pa1[it] == pa2[it]) ++it;
+
+        else return false;
+    }
+
+    return true;
+}
+
+void Shift_right(int* array, const size_t& len, const unsigned int& N)
+{
+    int* _array = new int[len];
+
+    size_t max_it = len - 1;
+
+    for (size_t it{0}; it < len; ++it)
+    {
+        if (it < N)
+            _array[it] = array[len - N + it];
+        else
+            _array[it] = array[it - N]; 
+    }
+
+    for (size_t i{0}; i < len; ++i)
+        array[i] = _array[i];
+
+    delete[] _array;
+
+}
+
+int* return_sh_array(int* array, const size_t& len, const size_t& N)
+{
+    // Дополнительную функцию для того, чтобы написать тесты
+    // для функции Shift_right, которая возвращает void
+
+    Shift_right(array, len, N);
+
+    return array;
+}

task_04/src/shift_right.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstddef>
+
+bool _arrays_equality(int* array1, int* array2, const size_t& len);
+
+void Shift_right(int* array, const size_t& len, const unsigned int& N);
+
+int* return_sh_array(int* array, const size_t& len, const size_t& N);
+
+
+
+

task_04/src/test.cpp

@@ -1,6 +1,35 @@
-
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+#include "shift_right.hpp"
+
+int arr1[4] {1,2, 3, 4};
+int right_answer1[4] {4, 1, 2, 3};
+int* answer1 = return_sh_array(arr1, 4, 1);
+
+TEST(Shift, Simple1) { ASSERT_EQ(_arrays_equality(answer1, right_answer1, 4), true); }
+
+
+int arr2[4] {1,2, 3, 4};
+int right_answer2[4] {3, 4, 1, 2};
+int* answer2 = return_sh_array(arr2, 4, 2);
+
+TEST(Shift, Simple2) { ASSERT_EQ(_arrays_equality(answer2, right_answer2, 4), true); }
+
+
+int arr3[4] {1,2, 3, 4};
+int right_answer3[4] {1, 2, 3, 4};
+int* answer3 = return_sh_array(arr3, 4, 0);
+
+TEST(Shift, Simple3) { ASSERT_EQ(_arrays_equality(answer3, right_answer3, 4), true); }
+
+int arr4[5] {1, 2, 3, 4, 5};
+int bad_answer4[5] {1, 2, 3, 4, 5};
+int* answer4 = return_sh_array(arr4, 5, 2);
+
+TEST(Shift, SimpleError1) { ASSERT_EQ(_arrays_equality(answer4, bad_answer4, 5), false); }
+
+int arr5[5] {1, 2, 3, 4, 5};
+int right_answer5[5] {1, 2, 3, 4, 5};
+int* answer5 = return_sh_array(arr5, 5, 5);
+
+TEST(Shift, Simple5) { ASSERT_EQ(_arrays_equality(answer5, right_answer5, 5), true); }