diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 0e4393b..758d8b6 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1,3 +1,4 @@ -#include + + int main() { return 0; } diff --git a/task_01/src/mediana.cpp b/task_01/src/mediana.cpp new file mode 100644 index 0000000..f764155 --- /dev/null +++ b/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); +} \ 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..60e6f10 --- /dev/null +++ b/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); + 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..c9a9948 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,5 +1,10 @@ #include -#include +#include "mediana.hpp" -TEST(Test, Simple) { ASSERT_EQ(Sum(1, 2, 3), 6); } \ No newline at end of file +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); } diff --git a/task_02/src/max_arr.cpp b/task_02/src/max_arr.cpp new file mode 100644 index 0000000..dcd10c8 --- /dev/null +++ b/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; +} \ No newline at end of file diff --git a/task_02/src/max_arr.hpp b/task_02/src/max_arr.hpp new file mode 100644 index 0000000..06ed249 --- /dev/null +++ b/task_02/src/max_arr.hpp @@ -0,0 +1 @@ +int max_arr(int* pa, int length); \ No newline at end of file diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 87cef73..3e86202 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -1,5 +1,27 @@ #include +#include "max_arr.hpp" -TEST(Test, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} \ No newline at end of file +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); } \ No newline at end of file diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp index 76e8197..9b3316c 100644 --- a/task_03/src/main.cpp +++ b/task_03/src/main.cpp @@ -1 +1,23 @@ -int main() { return 0; } +#include +#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; + +} diff --git a/task_03/src/reverse.cpp b/task_03/src/reverse.cpp index 3457424..d4b23eb 100644 --- a/task_03/src/reverse.cpp +++ b/task_03/src/reverse.cpp @@ -1,3 +1,46 @@ #include "reverse.hpp" -void Reverse(int *array, size_t len) {} \ No newline at end of file + +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; +} \ No newline at end of file diff --git a/task_03/src/reverse.hpp b/task_03/src/reverse.hpp index 450a729..794f32d 100644 --- a/task_03/src/reverse.hpp +++ b/task_03/src/reverse.hpp @@ -2,4 +2,9 @@ #include -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); + diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index 2d868db..fd412fa 100644 --- a/task_03/src/test.cpp +++ b/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); } У одинаковых массивов разные адреса diff --git a/task_04/src/main.cpp b/task_04/src/main.cpp index 0e4393b..cbd5d98 100644 --- a/task_04/src/main.cpp +++ b/task_04/src/main.cpp @@ -1,3 +1,21 @@ #include +#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 << "}"; + +} diff --git a/task_04/src/shift.cpp b/task_04/src/shift.cpp new file mode 100644 index 0000000..8893b5e --- /dev/null +++ b/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; +} \ No newline at end of file diff --git a/task_04/src/shift_right.hpp b/task_04/src/shift_right.hpp new file mode 100644 index 0000000..39ef502 --- /dev/null +++ b/task_04/src/shift_right.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include + +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); + + + + diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 5e11617..2a68b84 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -1,6 +1,35 @@ - #include -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); } \ No newline at end of file