Burachek Homework

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';
+}

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;
+}

task_01/src/mediana.hpp

@@ -0,0 +1 @@
+int mediana(int a, int b, int c);

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); }

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';
+}

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;
+};

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 []
-}
+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);
+}

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';
+}

task_03/src/reverse.cpp

@@ -1,3 +0,0 @@
-#include "reverse.hpp"
-
-void Reverse(int *array, size_t len) {}

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)]);
+}

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);
+}

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';
+}

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;
+    }
+}