From ebb96063dd53f6a64f242874e5b8d1e80c73b82e Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sat, 24 Feb 2024 17:40:33 +0000 Subject: [PATCH 01/23] task_01 1st take --- task_01/src/main.cpp | 22 +++++++++++++++++++++- task_01/src/searching_sum.cpp | 15 +++++++++++++++ task_01/src/searching_sum.hpp | 9 +++++++++ task_01/src/test.cpp | 29 ++++++++++++++++++++++++++--- 4 files changed, 71 insertions(+), 4 deletions(-) create mode 100644 task_01/src/searching_sum.cpp create mode 100644 task_01/src/searching_sum.hpp diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 0e4393ba..bebfe295 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1,3 +1,23 @@ #include -int main() { return 0; } +#include "searching_sum.hpp" + +/* +Формат ввода: + В первой строке ввода через пробел подаётся 2 целых числа: + sum - заданное число, n - длина массива чисел + В следующей строке подаются n целых чисел - элемента массива + +Формат вывода: + В одной строке через пробел выводятся два числа - индексы элементов данного + массива, дающие в сумме sum +*/ +int main() { + int sum = 0, n = 0; + std::cin >> sum >> n; + std::vector arr(n); + for (int i = 0; i < n; ++i) std::cin >> arr[i]; + std::pair answer = SearchingSum(sum, arr); + std::cout << answer.first << " " << answer.second << std::endl; + return 0; +} diff --git a/task_01/src/searching_sum.cpp b/task_01/src/searching_sum.cpp new file mode 100644 index 00000000..a1de8c21 --- /dev/null +++ b/task_01/src/searching_sum.cpp @@ -0,0 +1,15 @@ +#include "searching_sum.hpp" + +/* +Алгоритм для нахождения в массиве чисел, дающих в сумме заданное число +Ассимптотика алгоритма - O(n), затраты по памяти - O(n) +*/ +std::pair SearchingSum(int sum, std::vector arr) { + std::pair ans = {0, arr.size() - 1}; + while (ans.first < ans.second) { + if (arr[ans.first] + arr[ans.second] == sum) return ans; + if (arr[ans.first] + arr[ans.second] < sum) ++ans.first; + if (arr[ans.first] + arr[ans.second] > sum) --ans.second; + } + return {-1, -1}; +} \ No newline at end of file diff --git a/task_01/src/searching_sum.hpp b/task_01/src/searching_sum.hpp new file mode 100644 index 00000000..34338f20 --- /dev/null +++ b/task_01/src/searching_sum.hpp @@ -0,0 +1,9 @@ +#ifndef SEARCHING_SUM +#define SEARCHING_SUM + +#include +#include + +std::pair SearchingSum(int sum, std::vector arr); + +#endif // SEARCHING_SUM \ No newline at end of file diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index ef5a86ae..3434cfc4 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,8 +1,31 @@ #include -#include "topology_sort.hpp" +#include "searching_sum.hpp" -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +TEST(SearchingSum, Simple) { + int sum1 = 10; + std::vector arr1 = {1, 3, 4, 7, 14}; + std::pair ans1 = {1, 3}; + ASSERT_EQ(ans1, SearchingSum(sum1, arr1)); + + int sum2 = 19; + std::vector arr2 = {1, 2, 5, 5, 6, 7, 8, 9, 14}; + std::pair ans2 = {2, 8}; + ASSERT_EQ(ans2, SearchingSum(sum2, arr2)); + + int sum3 = 8; + std::vector arr3 = {}; + std::pair ans3 = {-1, -1}; + ASSERT_EQ(ans3, SearchingSum(sum3, arr3)); + + int sum4 = -1; + std::vector arr4 = {-7, -5, 0, 1, 3, 4, 6}; + std::pair ans4 = {0, 6}; + ASSERT_EQ(ans4, SearchingSum(sum4, arr4)); + + int sum5 = 0; + std::vector arr5 = {1, 2, 5, 5, 6, 7, 8, 9, 14}; + std::pair ans5 = {-1, -1}; + ASSERT_EQ(ans2, SearchingSum(sum5, arr5)); } From 13d4454385604b4e24be583fb8ba9625a6df2d9a Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sat, 24 Feb 2024 17:54:27 +0000 Subject: [PATCH 02/23] test fix --- task_01/src/test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 3434cfc4..394cf30d 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -27,5 +27,5 @@ TEST(SearchingSum, Simple) { int sum5 = 0; std::vector arr5 = {1, 2, 5, 5, 6, 7, 8, 9, 14}; std::pair ans5 = {-1, -1}; - ASSERT_EQ(ans2, SearchingSum(sum5, arr5)); + ASSERT_EQ(ans5, SearchingSum(sum5, arr5)); } From 5d39f6fe103da8a6870df185bd2ccea3fdd0944d Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sat, 2 Mar 2024 12:45:16 +0000 Subject: [PATCH 03/23] add one-element vector test --- task_01/src/test.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 394cf30d..689364eb 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -28,4 +28,9 @@ TEST(SearchingSum, Simple) { std::vector arr5 = {1, 2, 5, 5, 6, 7, 8, 9, 14}; std::pair ans5 = {-1, -1}; ASSERT_EQ(ans5, SearchingSum(sum5, arr5)); + + int sum6 = 2; + std::vector arr6 = {2}; + std::pair ans6 = {-1, -1}; + ASSERT_EQ(ans6, SearchingSum(sum6, arr6)); } From c7dd0a5f4b0e2625006d282d5ced592dffef6003 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Tue, 16 Apr 2024 12:51:32 +0000 Subject: [PATCH 04/23] task_02 --- task_02/src/main | Bin 0 -> 30920 bytes task_02/src/stack.cpp | 52 +++++++++++++++++++++++++++++++---------- task_02/src/stack.hpp | 53 ++++++++++++++++++++++++++++++------------ task_02/src/test.cpp | 4 ++-- 4 files changed, 80 insertions(+), 29 deletions(-) create mode 100755 task_02/src/main diff --git a/task_02/src/main b/task_02/src/main new file mode 100755 index 0000000000000000000000000000000000000000..fa671f7597be0384fbdd7a91d29822e3839e978d GIT binary patch literal 30920 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 literal 0 HcmV?d00001 diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp index 8ca89902..eb75d009 100644 --- a/task_02/src/stack.cpp +++ b/task_02/src/stack.cpp @@ -1,21 +1,49 @@ #include "stack.hpp" -#include +template size_t Stack::Size() const { return size_; } -void Stack::Push(int value) { data_.push(value); } +template void Stack::Push(T data) +{ + top_ = std::make_shared(data, top_); + size_++; +} + +template T Stack::Pop() +{ + if (size_ == 0) + throw std::runtime_error("Stack is empty"); + T removed_value = top_->data_; + top_ = std::move(top_->next_); + size_--; + return removed_value; +} -int Stack::Pop() { - auto result = data_.top(); - data_.pop(); - return result; +template T Stack::Top() const +{ + if (size_ == 0) + throw std::runtime_error("Stack is empty"); + return top_->data_; } -void MinStack::Push(int value) { data_.push_back(value); } +template void MinStack::Push(T data) +{ + top_ = std::make_shared(data, top_); + size_++; + if (minimums_stack_.Size() > 0 && data > minimums_stack_.Top()) + minimums_stack_.Push(minimums_stack_.Top()); + else + minimums_stack_.Push(data); +} -int MinStack::Pop() { - auto result = data_.back(); - data_.pop_back(); - return result; +template T MinStack::Pop() +{ + if (size_ == 0) + throw std::runtime_error("Stack is empty"); + T removed_value = top_->data_; + top_ = std::move(top_->next_); + size_--; + minimums_stack_.Pop(); + return removed_value; } -int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); } \ No newline at end of file +template T MinStack::GetMin() const { return minimums_stack_.Top(); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 138ec40f..52d730a7 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -1,23 +1,46 @@ #pragma once -#include -#include +#include -class Stack { - public: - void Push(int value); - int Pop(); +/// @brief Элемент стека +template struct Element +{ + explicit Element(T data, const std::shared_ptr& next) : data_(data), next_(next) {} - private: - std::stack data_; + T data_; + std::shared_ptr next_; }; -class MinStack { - public: - void Push(int value); - int Pop(); - int GetMin(); +/// @brief Cтек +/// @tparam Т Тип данных +template class Stack +{ +public: + explicit Stack() : top_(nullptr), size_{0} {} - private: - std::vector data_; + size_t Size () const; + virtual void Push (T data); + virtual T Pop (); + virtual T Top () const; + +private: + size_t size_; + std::shared_ptr> top_; +}; + +/// @brief Стек с минимумом +/// @tparam T Тип данных +template class MinStack : public Stack +{ +public: + explicit MinStack() : Stack(), minimums_stack_() {} + + void Push (T data) override; + T Pop () override; + T GetMin () const; + +private: + Stack minimums_stack_; + size_t size_; + std::shared_ptr> top_; }; diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 54e7ce90..9960b93c 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -6,7 +6,7 @@ #include "stack.hpp" TEST(StackTest, Simple) { - Stack stack; + Stack stack; stack.Push(1); // Stack [1] ASSERT_EQ(stack.Pop(), 1); // Stack [] stack.Push(1); // Stack [1] @@ -22,7 +22,7 @@ TEST(StackTest, Simple) { } TEST(MinStackTest, Simple) { - MinStack stack; + MinStack stack; stack.Push(1); // Stack [1] ASSERT_EQ(stack.GetMin(), 1); ASSERT_EQ(stack.Pop(), 1); // Stack [] From a1046dfefb650cda9baad9f007da85ee208fd839 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Tue, 16 Apr 2024 13:01:28 +0000 Subject: [PATCH 05/23] small fix --- task_02/src/stack.cpp | 21 ++++++++++++++------- task_02/src/stack.hpp | 9 ++++++--- 2 files changed, 20 insertions(+), 10 deletions(-) diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp index eb75d009..f1f4455c 100644 --- a/task_02/src/stack.cpp +++ b/task_02/src/stack.cpp @@ -1,14 +1,17 @@ #include "stack.hpp" -template size_t Stack::Size() const { return size_; } +template +size_t Stack::Size() const { return size_; } -template void Stack::Push(T data) +template +void Stack::Push(T data) { top_ = std::make_shared(data, top_); size_++; } -template T Stack::Pop() +template +T Stack::Pop() { if (size_ == 0) throw std::runtime_error("Stack is empty"); @@ -18,14 +21,16 @@ template T Stack::Pop() return removed_value; } -template T Stack::Top() const +template +T Stack::Top() const { if (size_ == 0) throw std::runtime_error("Stack is empty"); return top_->data_; } -template void MinStack::Push(T data) +template +void MinStack::Push(T data) { top_ = std::make_shared(data, top_); size_++; @@ -35,7 +40,8 @@ template void MinStack::Push(T data) minimums_stack_.Push(data); } -template T MinStack::Pop() +template +T MinStack::Pop() { if (size_ == 0) throw std::runtime_error("Stack is empty"); @@ -46,4 +52,5 @@ template T MinStack::Pop() return removed_value; } -template T MinStack::GetMin() const { return minimums_stack_.Top(); } \ No newline at end of file +template +T MinStack::GetMin() const { return minimums_stack_.Top(); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 52d730a7..51eaf162 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -3,7 +3,8 @@ #include /// @brief Элемент стека -template struct Element +template +struct Element { explicit Element(T data, const std::shared_ptr& next) : data_(data), next_(next) {} @@ -13,7 +14,8 @@ template struct Element /// @brief Cтек /// @tparam Т Тип данных -template class Stack +template +class Stack { public: explicit Stack() : top_(nullptr), size_{0} {} @@ -30,7 +32,8 @@ template class Stack /// @brief Стек с минимумом /// @tparam T Тип данных -template class MinStack : public Stack +template +class MinStack : public Stack { public: explicit MinStack() : Stack(), minimums_stack_() {} From 4520d885da9c9af443022f80d4ec59366a009e81 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 15:50:21 +0000 Subject: [PATCH 06/23] task_02 --- task_02/src/main | Bin 30920 -> 0 bytes task_02/src/stack.cpp | 56 ------------------------------------------ task_02/src/stack.hpp | 56 ++++++++++++++++++++++++++++++++++++++++++ task_02/src/test.cpp | 1 - 4 files changed, 56 insertions(+), 57 deletions(-) delete mode 100755 task_02/src/main delete mode 100644 task_02/src/stack.cpp diff --git a/task_02/src/main b/task_02/src/main deleted file mode 100755 index fa671f7597be0384fbdd7a91d29822e3839e978d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 30920 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 diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp deleted file mode 100644 index f1f4455c..00000000 --- a/task_02/src/stack.cpp +++ /dev/null @@ -1,56 +0,0 @@ -#include "stack.hpp" - -template -size_t Stack::Size() const { return size_; } - -template -void Stack::Push(T data) -{ - top_ = std::make_shared(data, top_); - size_++; -} - -template -T Stack::Pop() -{ - if (size_ == 0) - throw std::runtime_error("Stack is empty"); - T removed_value = top_->data_; - top_ = std::move(top_->next_); - size_--; - return removed_value; -} - -template -T Stack::Top() const -{ - if (size_ == 0) - throw std::runtime_error("Stack is empty"); - return top_->data_; -} - -template -void MinStack::Push(T data) -{ - top_ = std::make_shared(data, top_); - size_++; - if (minimums_stack_.Size() > 0 && data > minimums_stack_.Top()) - minimums_stack_.Push(minimums_stack_.Top()); - else - minimums_stack_.Push(data); -} - -template -T MinStack::Pop() -{ - if (size_ == 0) - throw std::runtime_error("Stack is empty"); - T removed_value = top_->data_; - top_ = std::move(top_->next_); - size_--; - minimums_stack_.Pop(); - return removed_value; -} - -template -T MinStack::GetMin() const { return minimums_stack_.Top(); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 51eaf162..89f83637 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -47,3 +47,59 @@ class MinStack : public Stack size_t size_; std::shared_ptr> top_; }; + + +template +size_t Stack::Size() const { return size_; } + +template +void Stack::Push(T data) +{ + top_ = std::make_shared>(data, top_); + size_++; +} + +template +T Stack::Pop() +{ + if (size_ == 0) + throw std::runtime_error("Stack is empty"); + T removed_value = top_->data_; + top_ = std::move(top_->next_); + size_--; + return removed_value; +} + +template +T Stack::Top() const +{ + if (size_ == 0) + throw std::runtime_error("Stack is empty"); + return top_->data_; +} + +template +void MinStack::Push(T data) +{ + top_ = std::make_shared>(data, top_); + size_++; + if (minimums_stack_.Size() > 0 && data > minimums_stack_.Top()) + minimums_stack_.Push(minimums_stack_.Top()); + else + minimums_stack_.Push(data); +} + +template +T MinStack::Pop() +{ + if (size_ == 0) + throw std::runtime_error("Stack is empty"); + T removed_value = top_->data_; + top_ = std::move(top_->next_); + size_--; + minimums_stack_.Pop(); + return removed_value; +} + +template +T MinStack::GetMin() const { return minimums_stack_.Top(); } \ No newline at end of file diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 9960b93c..cb838fd1 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -1,4 +1,3 @@ - #include #include From d6a2a92dfb163c7971f8a87274cb2ff346ec7e9f Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 16:09:13 +0000 Subject: [PATCH 07/23] task 3 --- task_03/src/days_amount_before_warming.cpp | 18 ++++++++++++++++++ task_03/src/days_amount_before_warming.h | 5 +++++ task_03/src/topology_sort.cpp | 1 - task_03/src/topology_sort.hpp | 1 - 4 files changed, 23 insertions(+), 2 deletions(-) create mode 100644 task_03/src/days_amount_before_warming.cpp create mode 100644 task_03/src/days_amount_before_warming.h delete mode 100644 task_03/src/topology_sort.cpp delete mode 100644 task_03/src/topology_sort.hpp diff --git a/task_03/src/days_amount_before_warming.cpp b/task_03/src/days_amount_before_warming.cpp new file mode 100644 index 00000000..71108c1e --- /dev/null +++ b/task_03/src/days_amount_before_warming.cpp @@ -0,0 +1,18 @@ +#include "days_amount_before_warming.h" + +#include + +std::vector DaysAmountBeforeWarming(std::vector temperatures) { + std::vector result(temperatures.size()); + std::stack remaining_days; + for (size_t i = 0; i < temperatures.size(); ++i) { + result[i] = 0; + while (!remaining_days.empty() && + temperatures[i] > temperatures[remaining_days.top()]) { + result[remaining_days.top()] = i - remaining_days.top(); + remaining_days.pop(); + } + remaining_days.push(i); + } + return result; +} \ No newline at end of file diff --git a/task_03/src/days_amount_before_warming.h b/task_03/src/days_amount_before_warming.h new file mode 100644 index 00000000..d745eda6 --- /dev/null +++ b/task_03/src/days_amount_before_warming.h @@ -0,0 +1,5 @@ +#pragma once + +#include + +std::vector DaysAmountBeforeWarming(std::vector temperatures); \ No newline at end of file diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp deleted file mode 100644 index e53f670c..00000000 --- a/task_03/src/topology_sort.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "topology_sort.hpp" diff --git a/task_03/src/topology_sort.hpp b/task_03/src/topology_sort.hpp deleted file mode 100644 index 6f70f09b..00000000 --- a/task_03/src/topology_sort.hpp +++ /dev/null @@ -1 +0,0 @@ -#pragma once From 8400f7cc2d8e6339f003b2cd0457f87f2264802d Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 16:14:21 +0000 Subject: [PATCH 08/23] test task_03 --- task_03/src/test.cpp | 31 +++++++++++++++++++++++++++---- 1 file changed, 27 insertions(+), 4 deletions(-) diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index ef5a86ae..9319c07e 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -1,8 +1,31 @@ - #include -#include "topology_sort.hpp" +#include "days_amount_before_warming.h" + +TEST(Temperature, Simple) { + std::vector days_data_1 = DaysAmountBeforeWarming({1, 2, 3, 4, 5}); + std::vector answer_1 = {1, 1, 1, 1, 0}; + + ASSERT_EQ(days_data_1, answer_1); + + std::vector days_data_2 = DaysAmountBeforeWarming({5}); + std::vector answer_2 = {0}; + + ASSERT_EQ(days_data_2, answer_2); + + std::vector days_data_3 = DaysAmountBeforeWarming({}); + std::vector answer_3 = {}; + + ASSERT_EQ(days_data_3, answer_3); + + std::vector days_data_4 = + DaysAmountBeforeWarming({-1, -1, 2, 2, -5, 3, 4, 1}); + std::vector answer_4 = {2, 1, 3, 2, 1, 1, 0, 0}; + + ASSERT_EQ(days_data_4, answer_4); + + std::vector days_data_5 = DaysAmountBeforeWarming({6, 5, 4, 3, 2, 1}); + std::vector answer_5 = {0, 0, 0, 0, 0, 0}; -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] + ASSERT_EQ(days_data_3, answer_5); } From 5280acc77a69955044d9e6251ff3cd15782e7ec9 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 16:52:28 +0000 Subject: [PATCH 09/23] task_04 --- task_04/src/heap.hpp | 153 +++++++++++++++++++++++++++++++++++++++++ task_04/src/test.cpp | 160 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 310 insertions(+), 3 deletions(-) create mode 100644 task_04/src/heap.hpp diff --git a/task_04/src/heap.hpp b/task_04/src/heap.hpp new file mode 100644 index 00000000..aa85afed --- /dev/null +++ b/task_04/src/heap.hpp @@ -0,0 +1,153 @@ +#include +#include +#include +#include +#include + +/** + * @brief Двоичная куча на std::vector с доступом к минимальному элементу + * @tparam T: Тип данных в двоичной кучи + */ +template +class BinaryMinHeap { + public: + BinaryMinHeap() = default; + BinaryMinHeap(const std::vector& data) { + for (const auto& elem : data) Add(elem); + } + + BinaryMinHeap(const std::initializer_list& data) { + for (const auto& elem : data) Add(elem); + } + + /** + * @brief Индексация элементов кучи + * @param index + * @return T: Значение элемента + * @throw std::out_of_range: Индекс больше размера кучи + */ + T operator[](size_t index) const { + if (index > Size()) throw std::out_of_range("invalid index"); + + return data_[index]; + } + + /** + * @brief Доступ к данным кучи (const &) + * @return const std::vector&: все элементов + */ + const std::vector& Data() const { return data_; } + + /** + * @brief Доступ к данным кучи (const &) + * @return const std::vector&: вектор всех элементов + */ + explicit operator const std::vector&() const { return Data(); } + + /** + * @brief Добавление элемента в кучу + * @param elem: Значение нового элемента + */ + void Add(T elem) { + data_.push_back(elem); + SiftUp(); + } + + /** + * @brief Вырезает корень кучи + * @return T: Значение корня + * @throw std::out_of_range: Куча пуста + */ + T ExtractMin() { + if (Empty()) throw std::out_of_range("empty heap"); + + auto res = Data()[0]; + + // меняем местами минимум с последним + std::swap(data_[0], data_[Size() - 1]); + data_.pop_back(); + SiftDown(); + + return res; + } + + /** + * @brief Возвращает значение корня + * @return T: Значение корня + * @throw std::out_of_range: Куча пуста + */ + T GetMin() const { + if (Empty()) throw std::out_of_range("empty heap"); + + return Data()[0]; + } + + size_t Size() const { return data_.size(); } + + bool Empty() const { return Size() == 0; } + + private: + /** + * @brief Возвращает индекс родителя + * @param index: Индекс элемента + * @return size_t: Индекс родителя + */ + size_t ParentIndex(size_t index) const { return (index - 1) / 2; } + + /** + * @brief Возвращает индекс левого ребенка + * @param index: Индекс элемента + * @return size_t: Индекс левого ребенка + */ + size_t LeftChildIndex(size_t index) const { return (2 * index + 1); } + + /** + * @brief Возвращает индекс правого ребенка + * @param index: Индекс элемента + * @return size_t: Индекс правого ребенка + */ + size_t RightChildIndex(size_t index) const { return (2 * index + 2); } + + /// @brief Корректирует кучу после добавления элемента + void SiftUp() { + // начинаем с конца + size_t index = Size() - 1; + + // меняем элемент с родителям местами, пока последний больше + while (index > 0 && data_[ParentIndex(index)] > data_[index]) { + std::swap(data_[index], data_[ParentIndex(index)]); + index = ParentIndex(index); + } + } + + /// @brief Корректирует кучу после удаления элемента + void SiftDown(size_t index = 0) { + while (index < Size()) { + size_t smallest = index; // индекс кореня поддерева + + // если левый ребенок существует и меньше текущего наименьшего элемента + if (LeftChildIndex(index) < Size() && + data_[LeftChildIndex(index)] < data_[smallest]) { + smallest = LeftChildIndex(index); + } + + // если правый ребенок существует и меньше текущего наименьшего элемента + if (RightChildIndex(index) < Size() && + data_[RightChildIndex(index)] < data_[smallest]) { + smallest = RightChildIndex(index); + } + + // если текущий элемент не меньше своих детей, завершаем итерацию + if (smallest == index) break; + + // меняем местами текущий элемент с наименьшим из детей + std::swap(data_[index], data_[smallest]); + + // переходим вниз по дереву к ребенку, с которым произвели обмен + index = smallest; + } + } + + /// @brief Элементы кучи + std::vector data_; +}; diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 5e11617e..031688df 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -1,6 +1,160 @@ - #include +#include "heap.hpp" +#include + +TEST(BinaryMinHeap_test, Empty) { + BinaryMinHeap heap; + ASSERT_EQ(heap.Empty(), true); + ASSERT_EQ(heap.Size(), 0); + heap.Add(1); + ASSERT_EQ(heap.Empty(), false); + ASSERT_EQ(heap.Size(), 1); + ASSERT_EQ(heap.ExtractMin(), 1); + EXPECT_THROW(heap.GetMin(), std::out_of_range); + EXPECT_THROW(heap.ExtractMin(), std::out_of_range); +} + +TEST(BinaryMinHeap_test, WithoutDuplicates) { + BinaryMinHeap heap{}; + for (int value : {3, 1, 2, 4, 5}) heap.Add(value); + ASSERT_EQ(heap.ExtractMin(), 1); + ASSERT_EQ(heap.ExtractMin(), 2); + ASSERT_EQ(heap.ExtractMin(), 3); + ASSERT_EQ(heap.ExtractMin(), 4); + ASSERT_EQ(heap.ExtractMin(), 5); +} + +TEST(BinaryMinHeap_test, WithDuplicates) { + BinaryMinHeap heap{}; + for (int value : {6, 7, 7, 3, 3, 3, 1, 2}) heap.Add(value); + ASSERT_EQ(heap.ExtractMin(), 1); + ASSERT_EQ(heap.ExtractMin(), 2); + ASSERT_EQ(heap.ExtractMin(), 3); + ASSERT_EQ(heap.ExtractMin(), 3); + ASSERT_EQ(heap.ExtractMin(), 3); + ASSERT_EQ(heap.ExtractMin(), 6); + ASSERT_EQ(heap.ExtractMin(), 7); + ASSERT_EQ(heap.ExtractMin(), 7); +} + +TEST(BinaryMinHeap_test, InitListConstructor) { + BinaryMinHeap heap{1, 2, 3}; + ASSERT_EQ(heap.ExtractMin(), 1); + ASSERT_EQ(heap.ExtractMin(), 2); + ASSERT_EQ(heap.ExtractMin(), 3); +} + +TEST(BinaryMinHeap_test, EmptyHeapDataTest) { + BinaryMinHeap heap; + EXPECT_TRUE(heap.Data().empty()); + ASSERT_EQ(heap.Data().empty(), heap.Empty()); +} + +TEST(BinaryMinHeap_test, AddElementTest) { + BinaryMinHeap heap; + heap.Add(5); + EXPECT_EQ(heap.Data().size(), 1); + EXPECT_EQ(heap.GetMin(), 5); +} + +TEST(BinaryMinHeap_test, ExtractMinTest) { + BinaryMinHeap heap; + heap.Add(5); + heap.Add(3); + heap.Add(7); + EXPECT_EQ(heap.ExtractMin(), 3); + EXPECT_EQ(heap.Data().size(), 2); +} + +TEST(BinaryMinHeap_test, GetMinTest) { + BinaryMinHeap heap; + heap.Add(5); + heap.Add(3); + heap.Add(7); + EXPECT_EQ(heap.GetMin(), 3); +} -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +TEST(BinaryMinHeap_test, MaintainHeapPropertyAfterAdd) { + BinaryMinHeap heap; + heap.Add(5); + heap.Add(3); + heap.Add(7); + heap.Add(2); + heap.Add(6); + EXPECT_EQ(heap.Data()[0], 2); // Минимальный элемент должен быть 2 } + +TEST(BinaryMinHeap_test, MaintainHeapPropertyAfterExtractMin) { + BinaryMinHeap heap; + heap.Add(5); + heap.Add(3); + heap.Add(7); + heap.Add(2); + heap.Add(6); + heap.ExtractMin(); + EXPECT_EQ(heap.GetMin(), + 3); // После извлечения минимальный элемент должен быть 3 +} + +TEST(BinaryMinHeap_test, AddDuplicateElements) { + BinaryMinHeap heap; + heap.Add(5); + heap.Add(3); + heap.Add(5); + EXPECT_EQ(heap.GetMin(), 3); // Минимальный элемент должен быть 3 +} + +TEST(BinaryMinHeap_test, AddAndRemoveNegativeElements) { + BinaryMinHeap heap; + heap.Add(-5); + heap.Add(3); + heap.Add(-7); + heap.ExtractMin(); + EXPECT_EQ(heap.GetMin(), -5); // Минимальный элемент должен быть -5 +} + +TEST(BinaryMinHeap_test, ExtractMinFromEmptyHeap) { + BinaryMinHeap heap; + ASSERT_THROW(heap.ExtractMin(), std::out_of_range); +} + +TEST(BinaryMinHeap_test, AddAndExtractMinLargeData) { + BinaryMinHeap heap; + for (int i = 1000; i > 0; --i) { + heap.Add(i); + } + for (int i = 1; i <= 500; ++i) { + EXPECT_EQ(heap.ExtractMin(), i); + } +} + +TEST(BinaryMinHeap_test, ExtractMinWithDuplicates) { + BinaryMinHeap heap; + heap.Add(5); + heap.Add(3); + heap.Add(3); + heap.Add(7); + heap.Add(2); + EXPECT_EQ(heap.ExtractMin(), 2); + EXPECT_EQ(heap.ExtractMin(), 3); + EXPECT_EQ(heap.ExtractMin(), 3); +} + +TEST(BinaryMinHeap_test, ExtractMinAfterInitializationWithVector) { + std::vector data = {8, 2, 10, 3, 5}; + BinaryMinHeap heap(data); + EXPECT_EQ(heap.ExtractMin(), 2); +} + +TEST(BinaryMinHeap_test, ExtractMinAfterInitializationWithInitializerList) { + BinaryMinHeap heap = {15, 7, 9, 4, 11}; + EXPECT_EQ(heap.ExtractMin(), 4); +} + +TEST(BinaryMinHeap_test, ExtractMinAfterInitializationAndAdd) { + std::vector data = {8, 2, 10, 3, 5}; + BinaryMinHeap heap(data); + heap.Add(4); + heap.Add(1); + EXPECT_EQ(heap.ExtractMin(), 1); +} \ No newline at end of file From 54e881a0a03897ffc00443c73eed28b5bda63f14 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 17:05:06 +0000 Subject: [PATCH 10/23] task_05 --- task_05/src/merge_sort.hpp | 65 +++++++++++++++ task_05/src/test.cpp | 157 ++++++++++++++++++++++++++++++++++++- 2 files changed, 219 insertions(+), 3 deletions(-) create mode 100644 task_05/src/merge_sort.hpp diff --git a/task_05/src/merge_sort.hpp b/task_05/src/merge_sort.hpp new file mode 100644 index 00000000..d4ed80e3 --- /dev/null +++ b/task_05/src/merge_sort.hpp @@ -0,0 +1,65 @@ +#include + +/** + * @brief Сливает две отсортированные части вектора в один + * @tparam T: Тип элементов вектора + * @param data: Данные двух векторов + * @param left: Индекс начала первого вектора + * @param mid: Индекс конца первого вектора и начала второго вектора + * @param right: Индекс конца второго вектора + */ +template +static void Merge(std::vector& data, std::size_t left, std::size_t mid, + std::size_t right) { + std::size_t index_1 = 0; // индекс для первой части + std::size_t index_2 = 0; // индекс для второй части + + /// @brief Вспомогательный вектор для слияния + std::vector res(right - left); + + // Сливаем два вектора, пока не достигнем конца одного из них + while (left + index_1 < mid && mid + index_2 < right) { + if (data[left + index_1] < data[mid + index_2]) { + // берем элемент из первой части + res[index_1 + index_2] = data[left + index_1]; + index_1++; + + } else { + // берем элемент из второй части + res[index_1 + index_2] = data[mid + index_2]; + index_2++; + } + } + + // Копируем остаток первого вектора, если он не кончился + while (left + index_1 < mid) { + res[index_1 + index_2] = data[left + index_1]; + index_1++; + } + + // Копируем остаток первого вектора, если он не кончился + while (mid + index_2 < right) { + res[index_1 + index_2] = data[mid + index_2]; + index_2++; + } + + // Копируем результат слияния в исходный вектор + for (std::size_t i = 0; i < index_1 + index_2; i++) data[left + i] = res[i]; +} + +/** + * @brief Сортировка слиянием — алгоритм сортировки, использующий O(n) + * дополнительной памяти и работающий за O(nlog(n)) времени + * @tparam T: Тип данных + * @param data: Данные + */ +template +void MergeSort(std::vector& data) { + if (data.empty()) return; + + auto n = data.size(); + + for (std::size_t i = 1; i < n; i *= 2) + for (std::size_t j = 0; j < n - i; j += 2 * i) + Merge(data, j, j + i, std::min(j + 2 * i, n)); +} \ No newline at end of file diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index 5e11617e..df387619 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -1,6 +1,157 @@ - +#include +#include +#include #include +#include + +TEST(Sort, Simple) { + std::vector b{5, 3, 4, 1, 2}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +TEST(Sort, Empty) { + std::vector b; + MergeSort(b); + EXPECT_TRUE(b.empty()); +} + +TEST(Sort, Sorted) { + std::vector b{1, 2, 3, 4, 5}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +TEST(Sort, Double) { + std::vector b{5.3, 3.1, 4.7, 1.2, 2.8}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +TEST(Sort, Strings) { + std::vector b{"apple", "banana", "cherry", "date", "elderberry"}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +TEST(Sort, Duplicates) { + std::vector b{5, 3, 4, 1, 2, 3, 1, 4}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +TEST(Sort, NegativeNumbers) { + std::vector b{-5, -3, -4, -1, -2}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +TEST(Sort, Characters) { + std::vector b{'e', 'a', 'c', 'b', 'd'}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +struct TestType { + int value; + auto operator<=>(const TestType& other) const = default; +}; + +TEST(Sort, CustomTestType) { + std::vector b{{5}, {3}, {4}, {1}, {2}}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +struct NegativeTestType { + int value; + auto operator<=>(const NegativeTestType& other) const = default; +}; + +TEST(Sort, CustomNegativeTestType) { + std::vector b{{-5}, {-3}, {-4}, {-1}, {-2}}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +struct FloatTestType { + float value; + auto operator<=>(const FloatTestType& other) const = default; +}; + +TEST(Sort, CustomFloatTestType) { + std::vector b{{5.3f}, {3.1f}, {4.7f}, {1.2f}, {2.8f}}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +struct PairTestType { + int first; + double second; + auto operator<=>(const PairTestType& other) const = default; +}; + +TEST(Sort, CustomPairTestType) { + std::vector b{ + {5, 3.14}, {3, 2.71}, {4, 1.62}, {1, 0.57}, {2, 6.28}}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +struct BoolTestType { + bool value; + auto operator<=>(const BoolTestType& other) const = default; +}; + +TEST(Sort, CustomBoolTestType) { + std::vector b{{true}, {false}, {true}, {false}, {true}}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +struct CharTestType { + char value; + auto operator<=>(const CharTestType& other) const = default; +}; + +TEST(Sort, CustomCharTestType) { + std::vector b{{'e'}, {'a'}, {'c'}, {'b'}, {'d'}}; + MergeSort(b); + EXPECT_TRUE(std::is_sorted(b.begin(), b.end())); +} + +TEST(Sort, VeryLargeNumbers_MergeSort) { + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution dis( + std::numeric_limits::min(), std::numeric_limits::max()); + + std::vector a; + + for (int i = 0; i < 1000000; ++i) { + int64_t num = dis(gen); + a.push_back(num); + } + + MergeSort(a); + EXPECT_TRUE(std::is_sorted(a.begin(), a.end())); +} + +TEST(Sort, VeryLongStrings_MergeSort) { + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution dis('a', 'z'); + + std::vector a; + + for (int i = 0; i < 10000; ++i) { + std::string str(1000, 'a'); + for (char& c : str) { + c = dis(gen); + } + a.push_back(str); + } -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] + MergeSort(a); + EXPECT_TRUE(std::is_sorted(a.begin(), a.end())); } From 99ce99564002cbed1f24cf89a9ff75bdd8cf88e8 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 17:20:10 +0000 Subject: [PATCH 11/23] some fixes --- .gitignore | 4 ++- task_02/src/stack.hpp | 67 +++++++++++++++++++------------------------ task_03/src/test.cpp | 2 +- task_04/src/test.cpp | 4 ++- task_05/src/test.cpp | 5 ++-- 5 files changed, 40 insertions(+), 42 deletions(-) diff --git a/.gitignore b/.gitignore index 41f1b1bd..1189e2d1 100644 --- a/.gitignore +++ b/.gitignore @@ -12,4 +12,6 @@ _deps .cache/* .vscode/* -build/* \ No newline at end of file +build/* +.clang-format +.gitignore diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 89f83637..2aac9f83 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -4,9 +4,9 @@ /// @brief Элемент стека template -struct Element -{ - explicit Element(T data, const std::shared_ptr& next) : data_(data), next_(next) {} +struct Element { + explicit Element(T data, const std::shared_ptr& next) + : data_(data), next_(next) {} T data_; std::shared_ptr next_; @@ -15,17 +15,16 @@ struct Element /// @brief Cтек /// @tparam Т Тип данных template -class Stack -{ -public: +class Stack { + public: explicit Stack() : top_(nullptr), size_{0} {} - size_t Size () const; - virtual void Push (T data); - virtual T Pop (); - virtual T Top () const; + size_t Size() const; + virtual void Push(T data); + virtual T Pop(); + virtual T Top() const; -private: + private: size_t size_; std::shared_ptr> top_; }; @@ -33,37 +32,34 @@ class Stack /// @brief Стек с минимумом /// @tparam T Тип данных template -class MinStack : public Stack -{ -public: +class MinStack : public Stack { + public: explicit MinStack() : Stack(), minimums_stack_() {} - void Push (T data) override; - T Pop () override; - T GetMin () const; + void Push(T data) override; + T Pop() override; + T GetMin() const; -private: + private: Stack minimums_stack_; size_t size_; std::shared_ptr> top_; }; - template -size_t Stack::Size() const { return size_; } +size_t Stack::Size() const { + return size_; +} template -void Stack::Push(T data) -{ +void Stack::Push(T data) { top_ = std::make_shared>(data, top_); size_++; } template -T Stack::Pop() -{ - if (size_ == 0) - throw std::runtime_error("Stack is empty"); +T Stack::Pop() { + if (size_ == 0) throw std::runtime_error("Stack is empty"); T removed_value = top_->data_; top_ = std::move(top_->next_); size_--; @@ -71,16 +67,13 @@ T Stack::Pop() } template -T Stack::Top() const -{ - if (size_ == 0) - throw std::runtime_error("Stack is empty"); +T Stack::Top() const { + if (size_ == 0) throw std::runtime_error("Stack is empty"); return top_->data_; } template -void MinStack::Push(T data) -{ +void MinStack::Push(T data) { top_ = std::make_shared>(data, top_); size_++; if (minimums_stack_.Size() > 0 && data > minimums_stack_.Top()) @@ -90,10 +83,8 @@ void MinStack::Push(T data) } template -T MinStack::Pop() -{ - if (size_ == 0) - throw std::runtime_error("Stack is empty"); +T MinStack::Pop() { + if (size_ == 0) throw std::runtime_error("Stack is empty"); T removed_value = top_->data_; top_ = std::move(top_->next_); size_--; @@ -102,4 +93,6 @@ T MinStack::Pop() } template -T MinStack::GetMin() const { return minimums_stack_.Top(); } \ No newline at end of file +T MinStack::GetMin() const { + return minimums_stack_.Top(); +} \ No newline at end of file diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index 9319c07e..05229f2a 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -27,5 +27,5 @@ TEST(Temperature, Simple) { std::vector days_data_5 = DaysAmountBeforeWarming({6, 5, 4, 3, 2, 1}); std::vector answer_5 = {0, 0, 0, 0, 0, 0}; - ASSERT_EQ(days_data_3, answer_5); + ASSERT_EQ(days_data_5, answer_5); } diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 031688df..93c54fd5 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -1,7 +1,9 @@ #include -#include "heap.hpp" + #include +#include "heap.hpp" + TEST(BinaryMinHeap_test, Empty) { BinaryMinHeap heap; ASSERT_EQ(heap.Empty(), true); diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index df387619..815b9c1b 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -1,8 +1,9 @@ +#include + #include +#include #include #include -#include -#include TEST(Sort, Simple) { std::vector b{5, 3, 4, 1, 2}; From 893ac57178d78dd6299c8833bb8feff43dfbf9c7 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 19:32:23 +0000 Subject: [PATCH 12/23] task_09 --- task_09/src/min_amount_of_coins.cpp | 11 +++++++++++ task_09/src/min_amount_of_coins.h | 8 ++++++++ task_09/src/test.cpp | 14 ++++++++++++-- 3 files changed, 31 insertions(+), 2 deletions(-) create mode 100644 task_09/src/min_amount_of_coins.cpp create mode 100644 task_09/src/min_amount_of_coins.h diff --git a/task_09/src/min_amount_of_coins.cpp b/task_09/src/min_amount_of_coins.cpp new file mode 100644 index 00000000..85c35ebf --- /dev/null +++ b/task_09/src/min_amount_of_coins.cpp @@ -0,0 +1,11 @@ +#include "min_amount_of_coins.h" + +size_t MinAmountOfCoins(size_t sum, std::vector coins) { + if (coins.empty()) throw std::runtime_error("there is no coins"); + std::vector table(sum + 1, std::numeric_limits::max()); + table[0] = 0; + for (size_t i = 1; i <= sum; ++i) + for (size_t j : coins) + if (j <= i) table[i] = std::min(table[i], table[i - j] + 1); + return table[sum]; +} \ No newline at end of file diff --git a/task_09/src/min_amount_of_coins.h b/task_09/src/min_amount_of_coins.h new file mode 100644 index 00000000..12120269 --- /dev/null +++ b/task_09/src/min_amount_of_coins.h @@ -0,0 +1,8 @@ +#pragma once + +#include +#include +#include + +/// @brief Определяет наименьшее количество монет из coins, чтобы набрать sum +size_t MinAmountOfCoins(size_t sum, std::vector coins); \ No newline at end of file diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp index 869094dd..7774c877 100644 --- a/task_09/src/test.cpp +++ b/task_09/src/test.cpp @@ -1,4 +1,14 @@ - #include -TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); } +#include "min_amount_of_coins.h" + +TEST(MinAmountOfCoins, Simple) { + ASSERT_EQ(MinAmountOfCoins(14, std::vector{1, 2, 5, 10}), 3); + ASSERT_EQ(MinAmountOfCoins(19, std::vector{1, 2, 5, 10}), 4); + ASSERT_EQ(MinAmountOfCoins(15, std::vector{1, 7, 10}), 3); + ASSERT_EQ(MinAmountOfCoins(14, std::vector{1, 7, 10}), 2); + ASSERT_EQ(MinAmountOfCoins(21, std::vector{1, 7, 10}), 3); + ASSERT_EQ(MinAmountOfCoins(34, std::vector{1, 7, 10}), 4); + ASSERT_THROW(MinAmountOfCoins(14, std::vector{}), std::runtime_error); + ASSERT_EQ(MinAmountOfCoins(0, std::vector{1, 2, 5, 10}), 0); +} \ No newline at end of file From 7ecdbf3679f04c507c7dff6e0d14d004f1433061 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 19:55:46 +0000 Subject: [PATCH 13/23] beautify --- task_09/src/test.cpp | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp index 7774c877..63948e9b 100644 --- a/task_09/src/test.cpp +++ b/task_09/src/test.cpp @@ -3,12 +3,14 @@ #include "min_amount_of_coins.h" TEST(MinAmountOfCoins, Simple) { - ASSERT_EQ(MinAmountOfCoins(14, std::vector{1, 2, 5, 10}), 3); - ASSERT_EQ(MinAmountOfCoins(19, std::vector{1, 2, 5, 10}), 4); - ASSERT_EQ(MinAmountOfCoins(15, std::vector{1, 7, 10}), 3); - ASSERT_EQ(MinAmountOfCoins(14, std::vector{1, 7, 10}), 2); - ASSERT_EQ(MinAmountOfCoins(21, std::vector{1, 7, 10}), 3); - ASSERT_EQ(MinAmountOfCoins(34, std::vector{1, 7, 10}), 4); + std::vector coins_1{1, 2, 5, 10}; + std::vector coins_2{1, 7, 10}; + ASSERT_EQ(MinAmountOfCoins(14, coins_1), 3); + ASSERT_EQ(MinAmountOfCoins(19, coins_1), 4); + ASSERT_EQ(MinAmountOfCoins(15, coins_2), 3); + ASSERT_EQ(MinAmountOfCoins(14, coins_2), 2); + ASSERT_EQ(MinAmountOfCoins(21, coins_2), 3); + ASSERT_EQ(MinAmountOfCoins(34, coins_2), 4); ASSERT_THROW(MinAmountOfCoins(14, std::vector{}), std::runtime_error); - ASSERT_EQ(MinAmountOfCoins(0, std::vector{1, 2, 5, 10}), 0); + ASSERT_EQ(MinAmountOfCoins(0, coins_1), 0); } \ No newline at end of file From 805306679732bd9cc4ad20564d6bbf0973825e3b Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 20:13:16 +0000 Subject: [PATCH 14/23] task_08 --- task_08/src/hashtable.cpp | 82 +++++++++++++++++++++++++++++++++++++++ task_08/src/hashtable.h | 50 ++++++++++++++++++++++++ task_08/src/test.cpp | 43 ++++++++++++++++++-- 3 files changed, 171 insertions(+), 4 deletions(-) create mode 100644 task_08/src/hashtable.cpp create mode 100644 task_08/src/hashtable.h diff --git a/task_08/src/hashtable.cpp b/task_08/src/hashtable.cpp new file mode 100644 index 00000000..8a1d8274 --- /dev/null +++ b/task_08/src/hashtable.cpp @@ -0,0 +1,82 @@ +#include "hashtable.h" + +#include + +#include +#include + +size_t HashTable::FirstHashFunc(std::size_t key) { + return floor(buf_size * ((key * hash_coef) - floor(key * hash_coef))); +} + +size_t HashTable::SecondHashFunc(std::size_t key) { + return (key * buf_size - 1) % buf_size; +} + +void HashTable::Clear() { + cells = 0; + size = 0; + for (auto &cell : cell_states) cell = State::Vacant; +} + +void HashTable::Resize() { + buf_size *= 2; + data.resize(buf_size); + cell_states.resize(buf_size); +} + +void HashTable::Rehash() { + std::vector subdata; + for (std::size_t i{0}; i < buf_size; i++) + if (cell_states[i] == State::Occupied) subdata.push_back(data[i]); + + Resize(); + Clear(); + for (auto &elem : subdata) Insert(elem); +} + +bool HashTable::Contains(std::size_t value) { + size_t hash = FirstHashFunc(value) % buf_size; + std::size_t count = 0; + while (cell_states[hash] != State::Vacant) { + if (data[hash] == value && cell_states[hash] == State::Occupied) + return true; + count++; + hash = (FirstHashFunc(value) + count * SecondHashFunc(value)) % buf_size; + } + return false; +} + +void HashTable::Insert(std::size_t value) { + size_t hash = FirstHashFunc(value) % buf_size; + std::size_t count = 0; + while (cell_states[hash] == State::Occupied) { + if (data[hash] == value) return; + count++; + hash = (FirstHashFunc(value) + count * SecondHashFunc(value)) % buf_size; + } + + data[hash] = value; + cell_states[hash] = State::Occupied; + cells++; + size++; + + double cells_coefficient = double(cells) / buf_size; + if (cells_coefficient >= rehash_coef) Rehash(); +} + +void HashTable::Remove(std::size_t value) { + size_t hash = FirstHashFunc(value) % buf_size; + std::size_t count = 0; + while (cell_states[hash] != State::Vacant) { + if (data[hash] == value && cell_states[hash] == State::Occupied) { + cell_states[hash] = State::Deleted; + size--; + break; + } + if (data[hash] == value && cell_states[hash] == State::Deleted) break; + + count++; + hash = (FirstHashFunc(value) + SecondHashFunc(value) * count) % buf_size; + } +} \ No newline at end of file diff --git a/task_08/src/hashtable.h b/task_08/src/hashtable.h new file mode 100644 index 00000000..6446037c --- /dev/null +++ b/task_08/src/hashtable.h @@ -0,0 +1,50 @@ +#pragma once +#include + +class HashTable { + public: + HashTable() : size{0}, cells{0}, buf_size{8} { + data = std::vector(buf_size); + cell_states = std::vector(buf_size, State::Vacant); + } + + /// @brief Проверяет наличие значение в хэш-таблице + /// @param value: Значение + /// @return Результат проверки + bool Contains(size_t value); + + /// @brief Добавляет значение в хэш-таблицу + /// @param value: Значение + void Insert(size_t value); + + /// @brief Удаляет значение из хэш-таблицы + /// @param value: Значение + void Remove(size_t value); + + /// @brief Очищает хэш-таблицу + void Clear(); + + size_t Size() { return size; } + + private: + constexpr static const double hash_coef = 0.618033989; + constexpr static const double rehash_coef = 0.7; + + enum class State { Occupied, Deleted, Vacant }; + + size_t buf_size; + size_t size; + size_t cells; + + std::vector data; + std::vector cell_states; + + size_t FirstHashFunc(size_t key); + size_t SecondHashFunc(size_t key); + + /// @brief Меняет размер + void Resize(); + + /// @brief Рехэш + void Rehash(); +}; \ No newline at end of file diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 5e11617e..73f97ae3 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -1,6 +1,41 @@ - #include +#include + +#include + +TEST(HashTableTest, Simple) { + HashTable table; + table.Insert(5); + ASSERT_TRUE(table.Contains(5)); + + table.Insert(14); + ASSERT_TRUE(table.Contains(14)); + + table.Insert(45); + table.Remove(45); + ASSERT_FALSE(table.Contains(45)); + + table.Insert(41420); + table.Clear(); + ASSERT_EQ(table.Size(), 0); + + table.Insert(245); + table.Insert(301); + ASSERT_EQ(table.Size(), 2); + + for (int i = 0; i < 1000; ++i) { + table.Insert(i); + } + table.Clear(); + ASSERT_EQ(table.Size(), 0); + + table.Insert(5); + table.Insert(15); + ASSERT_TRUE(table.Contains(5)); + ASSERT_TRUE(table.Contains(15)); -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} + for (int i = 0; i < 100; i++) table.Insert(i); + for (int i = 0; i <= 50; i++) table.Remove(100 - i); + for (int i = 0; i < 38; i++) table.Insert(i); + ASSERT_EQ(table.Size(), 50); +} \ No newline at end of file From 4c4b8ee5f4d48df2403d85687674c7c40ad623ee Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 20:24:26 +0000 Subject: [PATCH 15/23] fixes --- task_08/src/hashtable.cpp | 15 ++++++++------- task_09/src/min_amount_of_coins.cpp | 2 +- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/task_08/src/hashtable.cpp b/task_08/src/hashtable.cpp index 8a1d8274..c0df7545 100644 --- a/task_08/src/hashtable.cpp +++ b/task_08/src/hashtable.cpp @@ -5,11 +5,12 @@ #include #include -size_t HashTable::FirstHashFunc(std::size_t key) { - return floor(buf_size * ((key * hash_coef) - floor(key * hash_coef))); +std::size_t HashTable::FirstHashFunc(std::size_t key) { + return floor(buf_size * + ((double(key) * hash_coef) - floor(double(key) * hash_coef))); } -size_t HashTable::SecondHashFunc(std::size_t key) { +std::size_t HashTable::SecondHashFunc(std::size_t key) { return (key * buf_size - 1) % buf_size; } @@ -36,7 +37,7 @@ void HashTable::Rehash() { } bool HashTable::Contains(std::size_t value) { - size_t hash = FirstHashFunc(value) % buf_size; + std::size_t hash = FirstHashFunc(value) % buf_size; std::size_t count = 0; while (cell_states[hash] != State::Vacant) { if (data[hash] == value && cell_states[hash] == State::Occupied) @@ -48,7 +49,7 @@ bool HashTable::Contains(std::size_t value) { } void HashTable::Insert(std::size_t value) { - size_t hash = FirstHashFunc(value) % buf_size; + std::size_t hash = FirstHashFunc(value) % buf_size; std::size_t count = 0; while (cell_states[hash] == State::Occupied) { if (data[hash] == value) return; @@ -61,12 +62,12 @@ void HashTable::Insert(std::size_t value) { cells++; size++; - double cells_coefficient = double(cells) / buf_size; + double cells_coefficient = double(cells) / double(buf_size); if (cells_coefficient >= rehash_coef) Rehash(); } void HashTable::Remove(std::size_t value) { - size_t hash = FirstHashFunc(value) % buf_size; + std::size_t hash = FirstHashFunc(value) % buf_size; std::size_t count = 0; while (cell_states[hash] != State::Vacant) { if (data[hash] == value && cell_states[hash] == State::Occupied) { diff --git a/task_09/src/min_amount_of_coins.cpp b/task_09/src/min_amount_of_coins.cpp index 85c35ebf..246ecd69 100644 --- a/task_09/src/min_amount_of_coins.cpp +++ b/task_09/src/min_amount_of_coins.cpp @@ -5,7 +5,7 @@ size_t MinAmountOfCoins(size_t sum, std::vector coins) { std::vector table(sum + 1, std::numeric_limits::max()); table[0] = 0; for (size_t i = 1; i <= sum; ++i) - for (size_t j : coins) + for (const size_t j : coins) if (j <= i) table[i] = std::min(table[i], table[i - j] + 1); return table[sum]; } \ No newline at end of file From b15636707b20813b02fe2cc15e9adb7d83e851a2 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 20:33:22 +0000 Subject: [PATCH 16/23] fixes --- task_02/src/stack.hpp | 9 +++++---- task_03/src/days_amount_before_warming.cpp | 8 ++++---- task_03/src/days_amount_before_warming.h | 2 +- task_04/src/heap.hpp | 22 +++++++++++----------- task_08/src/hashtable.h | 22 +++++++++++----------- 5 files changed, 32 insertions(+), 31 deletions(-) diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 2aac9f83..2b481331 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include /// @brief Элемент стека template @@ -19,13 +20,13 @@ class Stack { public: explicit Stack() : top_(nullptr), size_{0} {} - size_t Size() const; + std::size_t Size() const; virtual void Push(T data); virtual T Pop(); virtual T Top() const; private: - size_t size_; + std::size_t size_; std::shared_ptr> top_; }; @@ -42,12 +43,12 @@ class MinStack : public Stack { private: Stack minimums_stack_; - size_t size_; + std::size_t size_; std::shared_ptr> top_; }; template -size_t Stack::Size() const { +std::size_t Stack::Size() const { return size_; } diff --git a/task_03/src/days_amount_before_warming.cpp b/task_03/src/days_amount_before_warming.cpp index 71108c1e..6d9e03f5 100644 --- a/task_03/src/days_amount_before_warming.cpp +++ b/task_03/src/days_amount_before_warming.cpp @@ -2,10 +2,10 @@ #include -std::vector DaysAmountBeforeWarming(std::vector temperatures) { - std::vector result(temperatures.size()); - std::stack remaining_days; - for (size_t i = 0; i < temperatures.size(); ++i) { +std::vector DaysAmountBeforeWarming(std::vector temperatures) { + std::vector result(temperatures.size()); + std::stack remaining_days; + for (std::size_t i = 0; i < temperatures.size(); ++i) { result[i] = 0; while (!remaining_days.empty() && temperatures[i] > temperatures[remaining_days.top()]) { diff --git a/task_03/src/days_amount_before_warming.h b/task_03/src/days_amount_before_warming.h index d745eda6..6860187b 100644 --- a/task_03/src/days_amount_before_warming.h +++ b/task_03/src/days_amount_before_warming.h @@ -2,4 +2,4 @@ #include -std::vector DaysAmountBeforeWarming(std::vector temperatures); \ No newline at end of file +std::vector DaysAmountBeforeWarming(std::vector temperatures); \ No newline at end of file diff --git a/task_04/src/heap.hpp b/task_04/src/heap.hpp index aa85afed..454ba6df 100644 --- a/task_04/src/heap.hpp +++ b/task_04/src/heap.hpp @@ -26,7 +26,7 @@ class BinaryMinHeap { * @return T: Значение элемента * @throw std::out_of_range: Индекс больше размера кучи */ - T operator[](size_t index) const { + T operator[](std::size_t index) const { if (index > Size()) throw std::out_of_range("invalid index"); return data_[index]; @@ -82,7 +82,7 @@ class BinaryMinHeap { return Data()[0]; } - size_t Size() const { return data_.size(); } + std::size_t Size() const { return data_.size(); } bool Empty() const { return Size() == 0; } @@ -90,28 +90,28 @@ class BinaryMinHeap { /** * @brief Возвращает индекс родителя * @param index: Индекс элемента - * @return size_t: Индекс родителя + * @return std::size_t: Индекс родителя */ - size_t ParentIndex(size_t index) const { return (index - 1) / 2; } + std::size_t ParentIndex(std::size_t index) const { return (index - 1) / 2; } /** * @brief Возвращает индекс левого ребенка * @param index: Индекс элемента - * @return size_t: Индекс левого ребенка + * @return std::size_t: Индекс левого ребенка */ - size_t LeftChildIndex(size_t index) const { return (2 * index + 1); } + std::size_t LeftChildIndex(std::size_t index) const { return (2 * index + 1); } /** * @brief Возвращает индекс правого ребенка * @param index: Индекс элемента - * @return size_t: Индекс правого ребенка + * @return std::size_t: Индекс правого ребенка */ - size_t RightChildIndex(size_t index) const { return (2 * index + 2); } + std::size_t RightChildIndex(std::size_t index) const { return (2 * index + 2); } /// @brief Корректирует кучу после добавления элемента void SiftUp() { // начинаем с конца - size_t index = Size() - 1; + std::size_t index = Size() - 1; // меняем элемент с родителям местами, пока последний больше while (index > 0 && data_[ParentIndex(index)] > data_[index]) { @@ -121,9 +121,9 @@ class BinaryMinHeap { } /// @brief Корректирует кучу после удаления элемента - void SiftDown(size_t index = 0) { + void SiftDown(std::size_t index = 0) { while (index < Size()) { - size_t smallest = index; // индекс кореня поддерева + std::size_t smallest = index; // индекс кореня поддерева // если левый ребенок существует и меньше текущего наименьшего элемента if (LeftChildIndex(index) < Size() && diff --git a/task_08/src/hashtable.h b/task_08/src/hashtable.h index 6446037c..a9e1c240 100644 --- a/task_08/src/hashtable.h +++ b/task_08/src/hashtable.h @@ -4,27 +4,27 @@ class HashTable { public: HashTable() : size{0}, cells{0}, buf_size{8} { - data = std::vector(buf_size); + data = std::vector(buf_size); cell_states = std::vector(buf_size, State::Vacant); } /// @brief Проверяет наличие значение в хэш-таблице /// @param value: Значение /// @return Результат проверки - bool Contains(size_t value); + bool Contains(std::size_t value); /// @brief Добавляет значение в хэш-таблицу /// @param value: Значение - void Insert(size_t value); + void Insert(std::size_t value); /// @brief Удаляет значение из хэш-таблицы /// @param value: Значение - void Remove(size_t value); + void Remove(std::size_t value); /// @brief Очищает хэш-таблицу void Clear(); - size_t Size() { return size; } + std::size_t Size() { return size; } private: constexpr static const double hash_coef = 0.618033989; @@ -32,15 +32,15 @@ class HashTable { enum class State { Occupied, Deleted, Vacant }; - size_t buf_size; - size_t size; - size_t cells; + std::size_t buf_size; + std::size_t size; + std::size_t cells; - std::vector data; + std::vector data; std::vector cell_states; - size_t FirstHashFunc(size_t key); - size_t SecondHashFunc(size_t key); + std::size_t FirstHashFunc(std::size_t key); + std::size_t SecondHashFunc(std::size_t key); /// @brief Меняет размер void Resize(); From ddb6e21e8a7ad4f6eb4e9991125553a135fae21d Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 20:37:17 +0000 Subject: [PATCH 17/23] format --- task_03/src/days_amount_before_warming.cpp | 3 ++- task_04/src/heap.hpp | 8 ++++++-- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/task_03/src/days_amount_before_warming.cpp b/task_03/src/days_amount_before_warming.cpp index 6d9e03f5..5838728e 100644 --- a/task_03/src/days_amount_before_warming.cpp +++ b/task_03/src/days_amount_before_warming.cpp @@ -2,7 +2,8 @@ #include -std::vector DaysAmountBeforeWarming(std::vector temperatures) { +std::vector DaysAmountBeforeWarming( + std::vector temperatures) { std::vector result(temperatures.size()); std::stack remaining_days; for (std::size_t i = 0; i < temperatures.size(); ++i) { diff --git a/task_04/src/heap.hpp b/task_04/src/heap.hpp index 454ba6df..c0bdcac8 100644 --- a/task_04/src/heap.hpp +++ b/task_04/src/heap.hpp @@ -99,14 +99,18 @@ class BinaryMinHeap { * @param index: Индекс элемента * @return std::size_t: Индекс левого ребенка */ - std::size_t LeftChildIndex(std::size_t index) const { return (2 * index + 1); } + std::size_t LeftChildIndex(std::size_t index) const { + return (2 * index + 1); + } /** * @brief Возвращает индекс правого ребенка * @param index: Индекс элемента * @return std::size_t: Индекс правого ребенка */ - std::size_t RightChildIndex(std::size_t index) const { return (2 * index + 2); } + std::size_t RightChildIndex(std::size_t index) const { + return (2 * index + 2); + } /// @brief Корректирует кучу после добавления элемента void SiftUp() { From 9179c3a15edb3216f1f0b257cebc66c4a497677c Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 21:25:49 +0000 Subject: [PATCH 18/23] task_06 --- task_06/src/nth_element.h | 37 +++++++++++++++++++++ task_06/src/test.cpp | 68 +++++++++++++++++++++++++++++++++++++-- 2 files changed, 102 insertions(+), 3 deletions(-) create mode 100644 task_06/src/nth_element.h diff --git a/task_06/src/nth_element.h b/task_06/src/nth_element.h new file mode 100644 index 00000000..b3bf371b --- /dev/null +++ b/task_06/src/nth_element.h @@ -0,0 +1,37 @@ +#include +#include +#include + +template +size_t Division(std::vector& data, size_t left, size_t right) { + T pivot = data[(left + right) / 2]; + while (left <= right) { + while (data[left] < pivot) ++left; + while (data[right] > pivot) --right; + if (left >= right) break; + std::swap(data[left], data[right]); + if (data[left] != pivot) ++left; + if (data[right] != pivot) --right; + } + return right; +} + +template +T NthElement(std::vector data, size_t n) { + if (n >= data.size()) + throw std::runtime_error("N is greater then array size"); + + size_t left = 0; + size_t right = data.size() - 1; + while (true) { + size_t mid_index = Division(data, left, right); + + if (mid_index == n) { + return data[mid_index]; + } else if (n < mid_index) { + right = mid_index; + } else { + left = mid_index + 1; + } + } +} \ No newline at end of file diff --git a/task_06/src/test.cpp b/task_06/src/test.cpp index 5e11617e..6ca4b25b 100644 --- a/task_06/src/test.cpp +++ b/task_06/src/test.cpp @@ -1,6 +1,68 @@ - #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include + +#include "nth_element.h" + +TEST(NthElement, Sorted) { + std::vector v{1, 2, 3, 4, 5, 6}; + ASSERT_EQ(NthElement(v, 0), 1); + ASSERT_EQ(NthElement(v, 1), 2); + ASSERT_EQ(NthElement(v, 2), 3); + ASSERT_EQ(NthElement(v, 3), 4); + ASSERT_EQ(NthElement(v, 4), 5); + ASSERT_EQ(NthElement(v, 5), 6); +} +TEST(NthElement, InverseSorted) { + std::vector v{6, 5, 4, 3, 2, 1}; + ASSERT_EQ(NthElement(v, 0), 1); + ASSERT_EQ(NthElement(v, 1), 2); + ASSERT_EQ(NthElement(v, 2), 3); + ASSERT_EQ(NthElement(v, 3), 4); + ASSERT_EQ(NthElement(v, 4), 5); + ASSERT_EQ(NthElement(v, 5), 6); +} +//[8, 22, 37, 40, 60, 61, 63, 84, 97, 99] + +TEST(NthElement, Integers) { + std::vector v{1, 10, 2, 9, 3, 8, 4, 7, 5, 6}; + ASSERT_EQ(NthElement(v, 0), 1); + ASSERT_EQ(NthElement(v, 1), 2); + ASSERT_EQ(NthElement(v, 2), 3); + ASSERT_EQ(NthElement(v, 3), 4); + ASSERT_EQ(NthElement(v, 4), 5); + ASSERT_EQ(NthElement(v, 5), 6); + ASSERT_EQ(NthElement(v, 6), 7); + ASSERT_EQ(NthElement(v, 7), 8); + ASSERT_EQ(NthElement(v, 8), 9); + ASSERT_EQ(NthElement(v, 9), 10); +} +TEST(NthElement, Doubles) { + std::vector v{37.75, 99.53, 63.24, 22.56, 37.74, + 60.32, 61.48, 8.15, 84.52, 97.93}; + ASSERT_EQ(NthElement(v, 0), 8.15); + ASSERT_EQ(NthElement(v, 1), 22.56); + ASSERT_EQ(NthElement(v, 2), 37.74); + ASSERT_EQ(NthElement(v, 3), 37.75); + ASSERT_EQ(NthElement(v, 4), 60.32); + ASSERT_EQ(NthElement(v, 5), 61.48); + ASSERT_EQ(NthElement(v, 6), 63.24); + ASSERT_EQ(NthElement(v, 7), 84.52); + ASSERT_EQ(NthElement(v, 8), 97.93); + ASSERT_EQ(NthElement(v, 9), 99.53); } + +TEST(NthElement, Characters) { + std::vector v{'d', 's', 'a', 'b'}; + ASSERT_EQ(NthElement(v, 1), 'b'); +} + +TEST(NthElement, Duplicates) { + std::vector v{2, 2, 2, 2, 2, 2}; + ASSERT_EQ(NthElement(v, 0), 2); + ASSERT_EQ(NthElement(v, 1), 2); + ASSERT_EQ(NthElement(v, 2), 2); + ASSERT_EQ(NthElement(v, 3), 2); + ASSERT_EQ(NthElement(v, 4), 2); + ASSERT_EQ(NthElement(v, 5), 2); +} \ No newline at end of file From c1e563d7ac1870969eeaa8ff84a5c3dfdda7df59 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 21:58:39 +0000 Subject: [PATCH 19/23] task_06 redone --- task_06/src/nth_element.h | 82 ++++++++++++++++++++++++++------------- 1 file changed, 56 insertions(+), 26 deletions(-) diff --git a/task_06/src/nth_element.h b/task_06/src/nth_element.h index b3bf371b..0fa5635d 100644 --- a/task_06/src/nth_element.h +++ b/task_06/src/nth_element.h @@ -1,37 +1,67 @@ -#include -#include #include -template -size_t Division(std::vector& data, size_t left, size_t right) { - T pivot = data[(left + right) / 2]; - while (left <= right) { - while (data[left] < pivot) ++left; - while (data[right] > pivot) --right; - if (left >= right) break; - std::swap(data[left], data[right]); - if (data[left] != pivot) ++left; - if (data[right] != pivot) --right; +template +std::size_t Division(std::vector data, std::size_t left, std::size_t right) { + std::size_t half = (left + right - 1) / 2; // середина списка + + if (data[left] < data[half]) { + if (data[right] < data[left]) + return left; + else if (data[right] < data[half]) + return right; + return half; + } else { + if (data[right] < data[half]) + return half; + else if (data[right] < data[left]) + return right; + return left; } - return right; } -template -T NthElement(std::vector data, size_t n) { - if (n >= data.size()) - throw std::runtime_error("N is greater then array size"); +template +std::size_t Partition(std::vector data, std::size_t left, + std::size_t right) { + std::size_t pivotPos = Division(data, left, right); + + if (pivotPos != right - 1) { // меняем местами опорный элемент с последним + std::swap(data[right - 1], data[pivotPos]); + } + + std::size_t i = left; + std::size_t j = left; + T pivot = data[right - 1]; + while (j < right - 1) { + if (data[j] <= pivot) { + // текущий элемент не больше опорного + // меняем его с первым из больших + std::swap(data[i++], data[j]); + } + ++j; + } + if (i != right - 1) { // ставим опорный элемент на место + std::swap(data[i], data[right - 1]); + } + return i; +} - size_t left = 0; - size_t right = data.size() - 1; - while (true) { - size_t mid_index = Division(data, left, right); +// поиск к-ой порядковой статистики +template +T NthElement(std::vector data, std::size_t k) { + std::size_t lastPivotPos = 0; + std::size_t left = 0; + std::size_t right = data.size() - 1; - if (mid_index == n) { - return data[mid_index]; - } else if (n < mid_index) { - right = mid_index; + while (left < right) { + if ((lastPivotPos = Partition(data, left, right)) == k) + return data[lastPivotPos]; + else if (lastPivotPos > k) { + // опорный элемент оказался правее искомого + right = lastPivotPos; } else { - left = mid_index + 1; + // опорный элемент не дошел до искомого + left = lastPivotPos + 1; } } + return data[lastPivotPos]; } \ No newline at end of file From bb8b321bc9902339730d8615c37ea6ac0b756ca5 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 22:02:22 +0000 Subject: [PATCH 20/23] fix_mistake --- task_06/src/nth_element.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/task_06/src/nth_element.h b/task_06/src/nth_element.h index 0fa5635d..f85d9fd8 100644 --- a/task_06/src/nth_element.h +++ b/task_06/src/nth_element.h @@ -50,7 +50,7 @@ template T NthElement(std::vector data, std::size_t k) { std::size_t lastPivotPos = 0; std::size_t left = 0; - std::size_t right = data.size() - 1; + std::size_t right = data.size(); while (left < right) { if ((lastPivotPos = Partition(data, left, right)) == k) From 4c1ce793524ba0d9b26c47af83b79105e0d61efa Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 22:07:07 +0000 Subject: [PATCH 21/23] fix --- task_06/src/nth_element.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/task_06/src/nth_element.h b/task_06/src/nth_element.h index f85d9fd8..5d6534a9 100644 --- a/task_06/src/nth_element.h +++ b/task_06/src/nth_element.h @@ -20,7 +20,7 @@ std::size_t Division(std::vector data, std::size_t left, std::size_t right) { } template -std::size_t Partition(std::vector data, std::size_t left, +std::size_t Partition(std::vector& data, std::size_t left, std::size_t right) { std::size_t pivotPos = Division(data, left, right); @@ -47,7 +47,7 @@ std::size_t Partition(std::vector data, std::size_t left, // поиск к-ой порядковой статистики template -T NthElement(std::vector data, std::size_t k) { +T NthElement(std::vector& data, std::size_t k) { std::size_t lastPivotPos = 0; std::size_t left = 0; std::size_t right = data.size(); From 6d1fb25f561bf424c1d30a0c30d03c8644f1c3d3 Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 22:45:01 +0000 Subject: [PATCH 22/23] task_07 --- task_07/src/AVLTree.cpp | 98 +++++++++++++++++++++++++++++++++++++++++ task_07/src/AVLTree.h | 37 ++++++++++++++++ task_07/src/test.cpp | 86 ++++++++++++++++++++++++++++++++++-- 3 files changed, 218 insertions(+), 3 deletions(-) create mode 100644 task_07/src/AVLTree.cpp create mode 100644 task_07/src/AVLTree.h diff --git a/task_07/src/AVLTree.cpp b/task_07/src/AVLTree.cpp new file mode 100644 index 00000000..acaf1b40 --- /dev/null +++ b/task_07/src/AVLTree.cpp @@ -0,0 +1,98 @@ +#include "AVLTree.h" + +#include +#include + +void AVLTree::Insert(int value) { root_ = Insert(root_, value); } +void AVLTree::Remove(int value) { root_ = Remove(root_, value); } +bool AVLTree::Contains(int value) const { return Contains(root_, value); } + +Node* AVLTree::Insert(Node* root, int value) { + if (!root) return new Node(value); + if (value < root->key) + root->left = Insert(root->left, value); + else + root->right = Insert(root->right, value); + return Balance(root); +} + +Node* AVLTree::Remove(Node* root, int value) { + if (!root) return 0; + if (value < root->key) + root->left = Remove(root->left, value); + else if (value > root->key) + root->right = Remove(root->right, value); + else if (value == root->key) { + Node* new_node_1 = root->left; + Node* new_node_2 = root->right; + delete root; + if (!new_node_2) return new_node_1; + Node* min = FindMin(new_node_2); + min->right = RemoveMin(new_node_2); + min->left = new_node_1; + return Balance(min); + } else { + throw std::runtime_error("AVLTree does not contain this element"); + } + return Balance(root); +} + +bool AVLTree::Contains(Node* node, int value) const { + if (!node) return false; + if (value < node->key) return Contains(node->left, value); + if (value > node->key) return Contains(node->right, value); + return true; +} + +Node* AVLTree::FindMin(Node* root) const { + return root->left ? FindMin(root->left) : root; +} + +Node* AVLTree::RemoveMin(Node* root) { + if (!root->left) return root->right; + root->left = RemoveMin(root->left); + return Balance(root); +} + +Node* AVLTree::Balance(Node* node) { + FixHeight(node); + if (Difference(node) == 2) { + if (Difference(node->right) < 0) node->right = RightRotate(node->right); + return LeftRotate(node); + } + if (Difference(node) == -2) { + if (Difference(node->left) > 0) node->left = LeftRotate(node->left); + return RightRotate(node); + } + return node; +} + +Node* AVLTree::RightRotate(Node* node) { + Node* new_node = node->left; + node->left = new_node->right; + new_node->right = node; + FixHeight(node); + FixHeight(new_node); + return new_node; +} + +Node* AVLTree::LeftRotate(Node* node) { + Node* new_node = node->right; + node->right = new_node->left; + new_node->left = node; + FixHeight(node); + FixHeight(new_node); + return new_node; +} + +unsigned AVLTree::Height(Node* node) const { return node ? node->height : 0; } + +int AVLTree::Difference(Node* node) const { + return Height(node->right) - Height(node->left); +} + +void AVLTree::FixHeight(Node* node) { + unsigned left_height = Height(node->left); + unsigned right_height = Height(node->right); + node->height = std::max(left_height, right_height) + 1; +} \ No newline at end of file diff --git a/task_07/src/AVLTree.h b/task_07/src/AVLTree.h new file mode 100644 index 00000000..36567436 --- /dev/null +++ b/task_07/src/AVLTree.h @@ -0,0 +1,37 @@ +#pragma once + +#include + +struct Node { + Node(int k) : key{k} {} + int key; + unsigned height = 1; + Node* left = nullptr; + Node* right = nullptr; +}; + +class AVLTree { + public: + void Insert(int value); + void Remove(int value); + bool Contains(int value) const; + + private: + Node* root_ = nullptr; + + Node* Insert(Node* root, int value); + Node* Remove(Node* root, int value); + bool Contains(Node* node, int value) const; + + Node* FindMin(Node* root) const; + Node* RemoveMin(Node* root); + + Node* Balance(Node* node); + + Node* RightRotate(Node* node); + Node* LeftRotate(Node* node); + + unsigned Height(Node* node) const; + int Difference(Node* node) const; + void FixHeight(Node* node); +}; \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index 5e11617e..736b0a2f 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -1,6 +1,86 @@ - +#include #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include "AVLTree.h" + +TEST(AVLTreeTest, InsertAndContains) { + AVL_Tree tree; + + tree.Insert(10); + tree.Insert(5); + tree.Insert(15); + + ASSERT_EQ(tree.Contains(10), true); + tree.Remove(10); + ASSERT_EQ(tree.Contains(5), true); + ASSERT_EQ(tree.Contains(15), true); + ASSERT_EQ(tree.Contains(20), false); + ASSERT_EQ(tree.Contains(10), false); +} + +TEST(AVLTreeTest, DuplicateInsert) { + AVL_Tree tree; + tree.Insert(5); + tree.Insert(5); + tree.Insert(5); + ASSERT_EQ(tree.Contains(5), true); +} + +TEST(AVLTreeTest, RemoveNonExisting) { + AVL_Tree tree; + tree.Insert(5); + tree.Remove(10); + ASSERT_EQ(tree.Contains(5), true); + ASSERT_EQ(tree.Contains(10), false); +} + +TEST(AVLTreeTest, LeftRotation) { + AVL_Tree tree; + tree.Insert(30); + tree.Insert(20); + tree.Insert(10); + ASSERT_EQ(tree.Contains(10), true); + ASSERT_EQ(tree.Contains(20), true); + ASSERT_EQ(tree.Contains(30), true); } + +TEST(AVLTreeTest, RightRotation) { + AVL_Tree tree; + tree.Insert(10); + tree.Insert(20); + tree.Insert(30); + ASSERT_EQ(tree.Contains(10), true); + ASSERT_EQ(tree.Contains(20), true); + ASSERT_EQ(tree.Contains(30), true); +} + +TEST(AVLTreeTest, RandomData) { + AVL_Tree tree; + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution<> dist(1, 1000); + + std::vector data(100); + for (int i = 0; i < 100; ++i) { + data[i] = dist(gen); + } + + std::shuffle(data.begin(), data.end(), gen); + + for (int value : data) { + tree.Insert(value); + } + + for (int value : data) { + ASSERT_EQ(tree.Contains(value), true); + } + + std::shuffle(data.begin(), data.end(), gen); + for (int i = 0; i < 50; ++i) { + tree.Remove(data[i]); + } + + for (int i = 50; i < 100; ++i) { + ASSERT_EQ(tree.Contains(data[i]), true); + } +} \ No newline at end of file From afc5e061820bd523727674db339e2c9b634ad6dd Mon Sep 17 00:00:00 2001 From: Ilya_Rybalkin Date: Sun, 16 Jun 2024 22:46:51 +0000 Subject: [PATCH 23/23] fix tests --- task_07/src/test.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index 736b0a2f..ac943673 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -4,7 +4,7 @@ #include "AVLTree.h" TEST(AVLTreeTest, InsertAndContains) { - AVL_Tree tree; + AVLTree tree; tree.Insert(10); tree.Insert(5); @@ -19,7 +19,7 @@ TEST(AVLTreeTest, InsertAndContains) { } TEST(AVLTreeTest, DuplicateInsert) { - AVL_Tree tree; + AVLTree tree; tree.Insert(5); tree.Insert(5); tree.Insert(5); @@ -27,7 +27,7 @@ TEST(AVLTreeTest, DuplicateInsert) { } TEST(AVLTreeTest, RemoveNonExisting) { - AVL_Tree tree; + AVLTree tree; tree.Insert(5); tree.Remove(10); ASSERT_EQ(tree.Contains(5), true); @@ -35,7 +35,7 @@ TEST(AVLTreeTest, RemoveNonExisting) { } TEST(AVLTreeTest, LeftRotation) { - AVL_Tree tree; + AVLTree tree; tree.Insert(30); tree.Insert(20); tree.Insert(10); @@ -45,7 +45,7 @@ TEST(AVLTreeTest, LeftRotation) { } TEST(AVLTreeTest, RightRotation) { - AVL_Tree tree; + AVLTree tree; tree.Insert(10); tree.Insert(20); tree.Insert(30); @@ -55,7 +55,7 @@ TEST(AVLTreeTest, RightRotation) { } TEST(AVLTreeTest, RandomData) { - AVL_Tree tree; + AVLTree tree; std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> dist(1, 1000);