From 644f198627618239de2998c7ccace297c3e97657 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 19 Apr 2025 18:16:15 +0000 Subject: [PATCH 01/20] KDtree --- sandbox/template/src/main | Bin 0 -> 70504 bytes sandbox/template/src/main.cpp | 40 +++++++++- task_01/src/find.cpp | 23 ++++++ task_01/src/main.cpp | 2 +- task_01/src/test.cpp | 31 +++++++- task_02/src/stack.cpp | 43 +++++++---- task_02/src/stack.hpp | 80 +++++++++++++++++--- task_02/src/test.cpp | 6 +- task_05/src/main.cpp | 64 +++++++++++++++- task_05/src/merge.cpp | 35 +++++++++ task_05/src/sorting.hpp | 3 + task_05/src/test.cpp | 14 +++- task_07/CMakeLists.txt | 3 + task_07/src/KDtree.cpp | 98 +++++++++++++++++++++++++ task_07/src/KDtree.hpp | 64 ++++++++++++++++ task_07/src/SAH.cpp | 55 ++++++++++++++ task_07/src/constants.hpp | 11 +++ task_07/src/main.cpp | 16 +++- task_07/src/min_search.cpp | 59 +++++++++++++++ task_07/src/test.cpp | 133 +++++++++++++++++++++++++++++++++- 20 files changed, 738 insertions(+), 42 deletions(-) create mode 100755 sandbox/template/src/main create mode 100644 task_01/src/find.cpp create mode 100644 task_05/src/merge.cpp create mode 100644 task_05/src/sorting.hpp create mode 100644 task_07/src/KDtree.cpp create mode 100644 task_07/src/KDtree.hpp create mode 100644 task_07/src/SAH.cpp create mode 100644 task_07/src/constants.hpp create mode 100644 task_07/src/min_search.cpp diff --git a/sandbox/template/src/main b/sandbox/template/src/main new file mode 100755 index 0000000000000000000000000000000000000000..c89b0c223f3be679c63e4b177ed58b276c47fa3f GIT binary patch literal 70504 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 XT=Dm};9V;HR$aLGLz>|gJ!by{EZl=N literal 0 HcmV?d00001 diff --git a/sandbox/template/src/main.cpp b/sandbox/template/src/main.cpp index 0e4393b..6ed1c71 100644 --- a/sandbox/template/src/main.cpp +++ b/sandbox/template/src/main.cpp @@ -1,3 +1,41 @@ #include +#include -int main() { return 0; } +void MergeSort(std ::vector& array) { + int i{0}, j{1}; + int slice{1}; + do { + while (j <= array.size() - 1) { + if (array[i] > array[j]) { + iter_swap(array.begin() + i, array.begin() + j); + + ++j; + } else + ++i; + if (j - i > slice) { + i = j; + j = i + slice; + } else if (j == i) { + i += 1; + j = i + slice; + } + } + slice *= 2; + slice > array.size() ? j = array.size() - 1 : j = slice; + i = 0; + if (j == array.size() - 1) { + if (i == 0) { + return; + } + } + } while (true); +} + +int main() { + std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; + MergeSort(unsort); + for (int i = 0; i < unsort.size(); ++i) { + std ::cout << unsort[i] << " "; + } + std ::cout << std ::endl; +} diff --git a/task_01/src/find.cpp b/task_01/src/find.cpp new file mode 100644 index 0000000..1a54654 --- /dev/null +++ b/task_01/src/find.cpp @@ -0,0 +1,23 @@ +#include +#include + +struct no_sum_num { + std ::string s{"no possible way to solve task"}; +}; + +std ::vector find_nums(int k, std ::vector sequence) { + std ::vector ans; + unsigned long left_index{0}; + unsigned long right_index{sequence.size() - 1}; + while (left_index != right_index) { + if ((sequence[left_index] + sequence[right_index]) == k) { + ans.push_back(sequence[left_index]); + ans.push_back(sequence[right_index]); + return ans; + } else if (sequence[left_index] + sequence[right_index] > k) + --right_index; + else + ++left_index; + } + throw no_sum_num{}; +} \ No newline at end of file diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 0e4393b..9ec81e0 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1,3 +1,3 @@ #include -int main() { return 0; } +int main() { return 0; } \ No newline at end of file diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 87cef73..1994774 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,5 +1,28 @@ -#include +// #include -TEST(Test, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} \ No newline at end of file +// #include "find.cpp" + +// TEST(find_nums, simple) { +// std ::vector seq{1, 2, 3, 4, 5}; +// std ::vector ans{find_nums(5, seq)}; +// // ASSERT_EQ(5, ans[0] + ans[1]); +// } + +// TEST(find_nums, negative) { +// std ::vector seq{-100, -10, -9, -8, -1}; +// std ::vector ans{find_nums(-9, seq)}; +// ASSERT_EQ(-9, ans[0] + ans[1]); +// } + +// TEST(find_nums, with_zeros) { +// std ::vector seq{ +// -15, 0, 0, 2, 8, +// }; +// std ::vector ans{find_nums(10, seq)}; +// ASSERT_EQ(10, ans[0] + ans[1]); +// } + +// TEST(find_nums, no_value) { +// std ::vector seq{0, 0, 2, 8, -15}; +// ASSERT_THROW(find_nums(60, seq), no_sum_num); +// } \ No newline at end of file diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp index 8ca8990..8070060 100644 --- a/task_02/src/stack.cpp +++ b/task_02/src/stack.cpp @@ -1,21 +1,36 @@ #include "stack.hpp" -#include +// template +// void Stack::Push(T k) { +// _data.push_back(k); +// } -void Stack::Push(int value) { data_.push(value); } +// template +// T Stack::Pop() { +// int pop_val{_data.back()}; +// _data.pop_back(); +// return pop_val; +// } -int Stack::Pop() { - auto result = data_.top(); - data_.pop(); - return result; -} +// #include "stack.hpp" -void MinStack::Push(int value) { data_.push_back(value); } +// #include -int MinStack::Pop() { - auto result = data_.back(); - data_.pop_back(); - return result; -} +// void Stack::Push(int value) { data_.push(value); } -int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); } \ No newline at end of file +// int Stack::Pop() { +// auto result = data_.top(); +// data_.pop(); +// return result; +// } + +// void MinStack::Push(int value) { data_.push_back(value); } + +// int MinStack::Pop() { +// auto result = data_.back(); +// data_.pop_back(); +// return result; +// } + +// int MinStack::GetMin() { return *std::min_element(data_.begin(), +// data_.end()); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 138ec40..c9282e3 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -1,23 +1,83 @@ -#pragma once - -#include #include +template class Stack { public: - void Push(int value); - int Pop(); + void Push(T k); + T Pop(); private: - std::stack data_; + std ::vector _data; }; +template +void Stack::Push(T k) { + _data.push_back(k); +} + +template +T Stack::Pop() { + T pop_val{_data.back()}; + _data.pop_back(); + return pop_val; +} + +template class MinStack { public: - void Push(int value); - int Pop(); - int GetMin(); + void Push(T k); + T Pop(); + T GetMin(); private: - std::vector data_; + std ::vector _data; + std ::vector _min_data; }; + +template +void MinStack::Push(T k) { + if (_min_data.size() == 0) + _min_data.push_back(k); + else if (_min_data.back() > k) + _min_data.push_back(k); + else + _min_data.push_back(_min_data.back()); + _data.push_back(k); +} + +template +T MinStack::Pop() { + T pop_val{_data.back()}; + _data.pop_back(); + _min_data.pop_back(); + return pop_val; +} + +template +T MinStack::GetMin() { + return _min_data.back(); +} + +// #pragma once + +// #include +// #include + +// class Stack { +// public: +// void Push(int value); +// int Pop(); + +// private: +// std::stack data_; +// }; + +// class MinStack { +// public: +// void Push(int value); +// int Pop(); +// int GetMin(); + +// private: +// std::vector data_; +// }; diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 54e7ce9..1f26b2c 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -1,12 +1,10 @@ #include -#include - #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 +20,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 [] diff --git a/task_05/src/main.cpp b/task_05/src/main.cpp index 0e4393b..c90ace8 100644 --- a/task_05/src/main.cpp +++ b/task_05/src/main.cpp @@ -1,3 +1,65 @@ +#include #include -int main() { return 0; } +#include "sorting.hpp" + +// template +// class Heap { +// public: +// Heap() {} +// void push(T k) { +// _data.push_back(k); +// SiftUp(_data); +// } +// void print() { +// for (int i{0}; i < _data.size(); ++i) std ::cout << _data[i] << " "; +// std ::cout << std ::endl; +// } +// void pop() { +// iter_swap(_data.begin(), _data.begin() + _data.size() - 1); +// _data.pop_back(); +// SiftDown(_data); +// } +// Heap(std ::vector dat) { +// for (int i{0}; i < dat.size(); ++i) { +// push(dat[i]); +// } +// } +// int min() { return _data[0]; } + +// private: +// std ::vector _data; +// void SiftUp(std ::vector& data); +// void SiftDown(std ::vector& data); +// int find_parent(int i) { return ((i - 1) / 2); } +// int find_childL(int i) { return (2 * i + 1); } +// int find_childR(int i) { return (2 * i + 2); } +// }; + +// template +// void Heap::SiftUp(std ::vector& data) { // снизу вверх +// int index{static_cast(data.size() - 1)}; +// int par_index{find_parent(index)}; +// while (data[index] < data[par_index]) { +// iter_swap(data.begin() + index, data.begin() + par_index); +// index = par_index; +// par_index = find_parent(index); +// } +// } + +// template +// void Heap::SiftDown(std ::vector& data) { +// int index{0}; +// int child{std::min(find_childL(index), find_childR(index))}; +// while (data[child] < data[index]) { +// iter_swap(data.begin() + index, data.begin() + child); +// index = child; +// child = std::min(find_childL(index), find_childR(index)); +// } +// } + +int main() { + // std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; + // std ::vector sorted{1, 2, 3, 4, 5, 7, 9}; + // MergeSort(unsort); +} diff --git a/task_05/src/merge.cpp b/task_05/src/merge.cpp new file mode 100644 index 0000000..730fa67 --- /dev/null +++ b/task_05/src/merge.cpp @@ -0,0 +1,35 @@ +#include +#include + +#include "sorting.hpp" + +// std::vector United(std::vector first, std::vector second) { +// std ::vector ans{}; +// if ((first.size() == 1) && (second.size() == 1)) { +// ans.push_back(std::min(first[0], second[0])); +// ans.push_back(std::max(first[0], second[0])); +// } else if (first.size() == 1) +// return ans; +// } + +void MergeSort(std ::vector& array) { + int i{0}, j{1}; + int slice{1}; + while ((j != array.size() - 1) && (i != 0)) { + while (i != j) { + if (array[i] > array[j]) { + iter_swap(array.begin() + i, array.begin() + j); + std ::cout << "SWAP"; + ++j; + } else + ++i; + if ((j - i > slice) || (i == j)) { + i = j; + j = i + slice; + } + } + slice *= 2; + slice > array.size() ? j = array.size() - 1 : j = slice; + i = 0; + } +} \ No newline at end of file diff --git a/task_05/src/sorting.hpp b/task_05/src/sorting.hpp new file mode 100644 index 0000000..f2e9c73 --- /dev/null +++ b/task_05/src/sorting.hpp @@ -0,0 +1,3 @@ +#include + +void MergeSort(std ::vector& array); \ No newline at end of file diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index 5e11617..c3849c8 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -1,6 +1,12 @@ -#include +// #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} +// // #include "sorting.hpp" +// #include "merge.cpp" + +// TEST(MergeSortTEST, Simple) { +// std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; +// std ::vector sorted{1, 2, 3, 4, 5, 7, 9}; +// MergeSort(unsort); +// ASSERT_EQ(unsort, sorted); +// } diff --git a/task_07/CMakeLists.txt b/task_07/CMakeLists.txt index 91b6a60..68f94d9 100644 --- a/task_07/CMakeLists.txt +++ b/task_07/CMakeLists.txt @@ -24,11 +24,14 @@ add_executable(${PROJECT_NAME} ${source_list}) enable_testing() find_package(GTest REQUIRED) + + include_directories(${GTEST_INCLUDE_DIRS}) find_library(Utils ../) target_link_libraries(${PROJECT_NAME} PUBLIC Utils) + # Link runTests with what we want to test and the GTest and pthread library add_executable(${PROJECT_NAME}_tests ${test_source_list}) target_link_libraries( diff --git a/task_07/src/KDtree.cpp b/task_07/src/KDtree.cpp new file mode 100644 index 0000000..74578ce --- /dev/null +++ b/task_07/src/KDtree.cpp @@ -0,0 +1,98 @@ +#include "KDtree.hpp" + +#include + +#include +#include +#include + +#include "constants.hpp" + +void KDTree::prepare_points(std::vector& points) { + std::sort(std::execution::par, points.begin(), points.end(), + [](const Point& a, const Point& b) { + return std::tie(a.x, a.y) < std::tie(b.x, b.y); + }); + + auto equal = [](const Point& a, const Point& b) { + return a.x == b.x && a.y == b.y; + }; + points.erase(std::unique(points.begin(), points.end(), equal), points.end()); +} + +void KDTree::split(std::unique_ptr& node, axis Ax, int depth) { + std ::pair SAH = KDTree::SAH( + node->bounding_box.first, node->bounding_box.second, Ax, node->indices); + + double SAH_parant = Ci * (node->indices.second - node->indices.first); + + if (SAH.first >= SAH_parant) { + node->leaf = true; + return; + } + + node->left_child = std::make_unique(); + node->right_child = std::make_unique(); + + if (Ax == axis::Ox) { + node->left_child->bounding_box.first = node->bounding_box.first; + node->left_child->bounding_box.second = + Point(SAH.second, node->bounding_box.second.y); + node->right_child->bounding_box.first = + Point(SAH.second, node->bounding_box.first.y); + node->right_child->bounding_box.second = node->bounding_box.second; + } else { + node->right_child->bounding_box.first = + Point(node->bounding_box.first.x, SAH.second); + node->right_child->bounding_box.second = node->bounding_box.second; + + node->left_child->bounding_box.first = node->bounding_box.first; + node->left_child->bounding_box.second = + Point(node->bounding_box.second.x, SAH.second); + } + + node->left_child->indices.first = node->indices.first; + + int left_count = std::count_if( + std::execution::par, cloud.begin() + node->indices.first, + cloud.begin() + node->indices.second + 1, + [Ax, split_pos = SAH.second](const Point& p) { + return (Ax == axis::Ox) ? p.x < split_pos : p.y < split_pos; + }); + + node->left_child->indices.second = node->indices.first + left_count - 1; + node->right_child->indices.first = node->indices.first + left_count; + node->right_child->indices.second = node->indices.second; + + Ax == axis::Ox ? Ax = axis::Oy : Ax = axis::Ox; + + if (depth < max_parallel_depth) { +#pragma omp task shared(node) + split(node->left_child, Ax, depth + 1); + +#pragma omp task shared(node) + split(node->right_child, Ax, depth + 1); + +#pragma omp taskwait + } else { + split(node->left_child, Ax, depth + 1); + split(node->right_child, Ax, depth + 1); + } +} + +KDTree::KDTree(std ::vector points) { + if (points.size() == 0) throw std::invalid_argument{"No Points detected"}; + + cloud = std::move(points); + prepare_points(cloud); + + root = std::make_unique(); + root->indices = std::make_pair(0, cloud.size() - 1); + root->bounding_box = std::make_pair(cloud[0], cloud[cloud.size() - 1]); + +#pragma omp parallel + { +#pragma omp single nowait + split(root, axis::Ox, 0); + } +} diff --git a/task_07/src/KDtree.hpp b/task_07/src/KDtree.hpp new file mode 100644 index 0000000..b602efe --- /dev/null +++ b/task_07/src/KDtree.hpp @@ -0,0 +1,64 @@ +#ifndef KDtreeHpp +#define KDtreeHpp + +#include +#include + +#include "constants.hpp" + +struct Point { + double x; + double y; + Point(double xx, double yy) : x{xx}, y{yy} {} + Point() : x{NONE}, y{NONE} {} + + bool operator==(const Point& other) const { + constexpr double epsilon = 1e-9; + return (std::abs(x - other.x) < epsilon) && + (std::abs(y - other.y) < epsilon); + } +}; + +class KDTree { + public: + KDTree(std::vector points); + ~KDTree() = default; + Point nearest_point(Point target); + + private: + std ::vector cloud; + + struct Node { + bool leaf = false; + std::unique_ptr left_child = nullptr; + std::unique_ptr right_child = nullptr; + std::pair bounding_box = + std::make_pair(Point(0, 0), Point(0, 0)); + std ::pair indices; // промежуток точек + // принадлежащих данной bounding_box [от, до] + }; + std::unique_ptr root; + enum class axis { + Ox = 0, + Oy = 1, + }; + + void split(std::unique_ptr& node, axis Ax = axis::Ox, int depth = 0); + std ::pair SAH(Point left_min_point, Point right_max_point, + axis curr_axis, std::pair& range); + std::pair find_minimum(Point target, + std::unique_ptr& node); + void prepare_points(std::vector& points); + double distance(Point first, Point second); + double distanceToBox(Point& point, std::pair& box); + bool into_box(Point target, std::pair box); + + template + auto get_axis(const T& request, axis ax) { + if (ax == axis::Ox) + return request.x; + else + return request.y; + } +}; +#endif \ No newline at end of file diff --git a/task_07/src/SAH.cpp b/task_07/src/SAH.cpp new file mode 100644 index 0000000..2eee71f --- /dev/null +++ b/task_07/src/SAH.cpp @@ -0,0 +1,55 @@ +#include + +#include + +#include "KDtree.hpp" +#include "constants.hpp" + +std::pair KDTree::SAH(Point left_min_point, + Point right_max_point, axis curr_axis, + std::pair& range) { + std::pair SAH_result{NONE, NONE}; + double width = get_axis(right_max_point, curr_axis) - + get_axis(left_min_point, curr_axis); + double width_x = right_max_point.x - left_min_point.x; + double width_y = right_max_point.y - left_min_point.y; + double width_w = curr_axis == axis::Ox ? width_y : width_x; + double SApar = width_x * width_y; + + if (SApar <= 0) return SAH_result; + + const int bins = PARITION; + std::vector binCounts(bins, 0); + + double bin_width = width / bins; + if (bin_width <= 0) return SAH_result; + + for (int index = range.first; index <= range.second; ++index) { + int bin_index = static_cast((get_axis(cloud[index], curr_axis) - + get_axis(left_min_point, curr_axis)) / + bin_width); + bin_index = std::clamp(bin_index, 0, bins - 1); + ++binCounts[bin_index]; + } + + std::vector prefix_sum(bins + 1, 0); + for (int i = 1; i <= bins; ++i) { + prefix_sum[i] = prefix_sum[i - 1] + binCounts[i - 1]; + } + + for (int i = 1; i < bins; ++i) { + double x0 = get_axis(left_min_point, curr_axis) + width * i / bins; + double SAl = (x0 - get_axis(left_min_point, curr_axis)) * width_w; + double SAr = (get_axis(right_max_point, curr_axis) - x0) * width_w; + + int Nl = prefix_sum[i]; + int Nr = (range.second - range.first + 1) - Nl; + + double SAH = Ct + Ci * (SAl * Nl + SAr * Nr) / SApar; + if ((SAH < SAH_result.first) || (SAH_result.first < 0)) { + SAH_result = std::make_pair(SAH, x0); + } + } + + return SAH_result; +} \ No newline at end of file diff --git a/task_07/src/constants.hpp b/task_07/src/constants.hpp new file mode 100644 index 0000000..ca6ee32 --- /dev/null +++ b/task_07/src/constants.hpp @@ -0,0 +1,11 @@ +#ifndef CONSTS +#define CONSTS +#include +// SAH +constexpr double Ct{1}; // стоимость прослеживания луча внутри узла +constexpr double Ci{1}; // стоимость пересечения (плоскостью) лучом +constexpr double PARITION{33}; // разбиение по оси + +constexpr double NONE{std::numeric_limits::max()}; +constexpr int max_parallel_depth{4}; +#endif \ No newline at end of file diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index 0e4393b..31c3358 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -1,3 +1,17 @@ #include +#include -int main() { return 0; } +#include "KDtree.hpp" +#include "vector" + +int main() { + std::vector cloud = { + Point(1.0, 2.0), Point(3.0, 4.0), Point(5.0, 6.0), + Point(7.0, 8.0), Point(9.0, 10.0), + }; + + KDTree tree(cloud); + std ::cout << "compiled\n"; + Point k = tree.nearest_point(Point(4.8, 5.9)); + std ::cout << k.x << " " << k.y << std ::endl; +} diff --git a/task_07/src/min_search.cpp b/task_07/src/min_search.cpp new file mode 100644 index 0000000..9dec686 --- /dev/null +++ b/task_07/src/min_search.cpp @@ -0,0 +1,59 @@ +#include + +#include "KDtree.hpp" + +double KDTree::distance(Point first, Point second) { + return ((first.x - second.x) * (first.x - second.x) + + (first.y - second.y) * (first.y - second.y)); +} + +bool KDTree::into_box(Point target, std::pair box) { + if ((target.x >= box.first.x) && (target.x <= box.second.x)) { + if ((target.y >= box.first.y) && (target.y <= box.second.y)) return true; + } + return false; +} + +double KDTree::distanceToBox(Point& point, std::pair& box) { + double dx = std::max({box.first.x - point.x, 0.0, point.x - box.second.x}); + double dy = std::max({box.first.y - point.y, 0.0, point.y - box.second.y}); + return dx * dx + dy * dy; +} + +std::pair KDTree::find_minimum(Point target, + std::unique_ptr& node) { + if (node->leaf) { + double min_dist = NONE; + Point nearest_point; + for (int i = node->indices.first; i <= node->indices.second; ++i) { + double current_dist = distance(cloud[i], target); + if (current_dist < min_dist) { + min_dist = current_dist; + nearest_point = cloud[i]; + } + } + return {min_dist, nearest_point}; + } + + bool target_in_left = into_box(target, node->left_child->bounding_box); + auto& first_child = target_in_left ? node->left_child : node->right_child; + auto& second_child = target_in_left ? node->right_child : node->left_child; + + auto [min_dist, nearest] = find_minimum(target, first_child); + + double dist_to_second_box = distanceToBox(target, second_child->bounding_box); + if (dist_to_second_box < min_dist) { + auto [second_dist, second_nearest] = find_minimum(target, second_child); + if (second_dist < min_dist) { + min_dist = second_dist; + nearest = second_nearest; + } + } + + return {min_dist, nearest}; +} + +Point KDTree::nearest_point(Point target) { + auto point = find_minimum(target, root); + return point.second; +} \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index 5e11617..0abda05 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -1,6 +1,135 @@ #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include +#include +#include + +#include "KDtree.hpp" + +std::vector generate_random_points(size_t count, double min = 0.0, + double max = 1000.0) { + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_real_distribution dist(min, max); + + std::vector points; + points.reserve(count); + for (size_t i = 0; i < count; ++i) { + points.emplace_back(dist(gen), dist(gen)); + } + return points; +} + +TEST(KD3, Simple) { + std::vector cloud = { + Point(1.0, 2.0), Point(3.0, 4.0), Point(5.0, 6.0), + Point(7.0, 8.0), Point(9.0, 10.0), + }; + + KDTree tree(cloud); + + Point k = tree.nearest_point(Point(4.8, 5.9)); + ASSERT_EQ(k, Point(5.0, 6.0)); +} + +TEST(KD3, SameDistanse) { + std::vector cloud = { + Point(0.0, 0.0), Point(1.0, 0.0), Point(0.0, 1.0), + Point(-1.0, 0.0), Point(0.0, -1.0), + }; + + KDTree tree(cloud); + + Point k = tree.nearest_point(Point(0.0, 0.0)); + ASSERT_EQ(k, Point(0.0, 0.0)); +} + +TEST(KD3, OneLine) { + std::vector cloud = { + Point(1.0, 1.0), Point(1.0, 2.0), Point(1.0, 3.0), + Point(1.0, 4.0), Point(1.0, 5.0), + }; + + KDTree tree(cloud); + + Point k = tree.nearest_point(Point(1.2, 3.1)); + ASSERT_EQ(k, Point(1.0, 3.0)); } + +TEST(KD3, Dublicates) { + std::vector cloud = { + Point(2.0, 2.0), Point(2.0, 2.0), Point(3.0, 3.0), + Point(2.0, 2.0), Point(4.0, 4.0), + }; + + KDTree tree(cloud); + + Point k = tree.nearest_point(Point(2.1, 2.1)); + ASSERT_EQ(k, Point(2.0, 2.0)); +} + +TEST(KD3, Error) { + std::vector cloud(0); + EXPECT_THROW(KDTree tree(cloud), std::invalid_argument); +} + +TEST(KD3, TimeTest_1000) { + auto cloud = generate_random_points(1000); + + auto start = std::chrono::high_resolution_clock::now(); + KDTree tree(cloud); + auto end = std::chrono::high_resolution_clock::now(); + + auto duration = + std::chrono::duration_cast(end - start); + EXPECT_TRUE(duration.count() < 500); +} + +TEST(KD3, TimeTest_10000) { + auto cloud = generate_random_points(10000); + + auto start = std::chrono::high_resolution_clock::now(); + KDTree tree(cloud); + auto end = std::chrono::high_resolution_clock::now(); + + auto duration = + std::chrono::duration_cast(end - start); + EXPECT_TRUE(duration.count() < 500); +} + +TEST(KD3, TimeTest_1M) { + auto cloud = generate_random_points(1000000); + + auto start = std::chrono::high_resolution_clock::now(); + KDTree tree(cloud); + auto end = std::chrono::high_resolution_clock::now(); + + auto duration = + std::chrono::duration_cast(end - start); + EXPECT_TRUE(duration.count() < 4000); +} + +TEST(KD3, TimeTest_10M) { + auto cloud = generate_random_points(10'000'000); + + KDTree tree(cloud); + auto start = std::chrono::high_resolution_clock::now(); + + tree.nearest_point(Point(3.75, 2.1)); + auto end = std::chrono::high_resolution_clock::now(); + auto duration = + std::chrono::duration_cast(end - start); + EXPECT_TRUE(duration.count() < 20000); +} + +TEST(KD3, YandexTest) { + auto cloud = generate_random_points(1'500'000); + + auto start = std::chrono::high_resolution_clock::now(); + KDTree tree(cloud); + auto end = std::chrono::high_resolution_clock::now(); + auto duration = + std::chrono::duration_cast(end - start); + EXPECT_TRUE(duration.count() < 5500); +} \ No newline at end of file From a21446539333b5232f25dd31e585f02b44bda45d Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 19 Apr 2025 18:49:59 +0000 Subject: [PATCH 02/20] task_01 --- task_01/src/find.cpp | 9 +++----- task_01/src/find.hpp | 8 +++++++ task_01/src/test.cpp | 51 ++++++++++++++++++++++++-------------------- 3 files changed, 39 insertions(+), 29 deletions(-) create mode 100644 task_01/src/find.hpp diff --git a/task_01/src/find.cpp b/task_01/src/find.cpp index 1a54654..5d2b5fb 100644 --- a/task_01/src/find.cpp +++ b/task_01/src/find.cpp @@ -1,11 +1,8 @@ -#include -#include - -struct no_sum_num { - std ::string s{"no possible way to solve task"}; -}; +#include "find.hpp" std ::vector find_nums(int k, std ::vector sequence) { + if (sequence.size() == 0) throw no_sum_num{}; + std ::vector ans; unsigned long left_index{0}; unsigned long right_index{sequence.size() - 1}; diff --git a/task_01/src/find.hpp b/task_01/src/find.hpp new file mode 100644 index 0000000..f946e9c --- /dev/null +++ b/task_01/src/find.hpp @@ -0,0 +1,8 @@ +#include +#include + +struct no_sum_num { + std ::string s{"no possible way to solve task"}; +}; + +std ::vector find_nums(int k, std ::vector sequence); \ No newline at end of file diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 1994774..db1f57c 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,28 +1,33 @@ -// #include +#include -// #include "find.cpp" +#include "find.hpp" -// TEST(find_nums, simple) { -// std ::vector seq{1, 2, 3, 4, 5}; -// std ::vector ans{find_nums(5, seq)}; -// // ASSERT_EQ(5, ans[0] + ans[1]); -// } +TEST(find_nums, simple) { + std ::vector seq{1, 2, 3, 4, 5}; + std ::vector ans{find_nums(5, seq)}; + ASSERT_EQ(5, ans[0] + ans[1]); +} -// TEST(find_nums, negative) { -// std ::vector seq{-100, -10, -9, -8, -1}; -// std ::vector ans{find_nums(-9, seq)}; -// ASSERT_EQ(-9, ans[0] + ans[1]); -// } +TEST(find_nums, negative) { + std ::vector seq{-100, -10, -9, -8, -1}; + std ::vector ans{find_nums(-9, seq)}; + ASSERT_EQ(-9, ans[0] + ans[1]); +} -// TEST(find_nums, with_zeros) { -// std ::vector seq{ -// -15, 0, 0, 2, 8, -// }; -// std ::vector ans{find_nums(10, seq)}; -// ASSERT_EQ(10, ans[0] + ans[1]); -// } +TEST(find_nums, with_zeros) { + std ::vector seq{ + -15, 0, 0, 2, 8, + }; + std ::vector ans{find_nums(10, seq)}; + ASSERT_EQ(10, ans[0] + ans[1]); +} -// TEST(find_nums, no_value) { -// std ::vector seq{0, 0, 2, 8, -15}; -// ASSERT_THROW(find_nums(60, seq), no_sum_num); -// } \ No newline at end of file +TEST(find_nums, no_value) { + std ::vector seq{0, 0, 2, 8, -15}; + EXPECT_THROW(find_nums(60, seq), no_sum_num); +} + +TEST(find_nums, empty) { + std ::vector seq(0); + EXPECT_THROW(find_nums(60, seq), no_sum_num); +} \ No newline at end of file From 4aab724841610b9273dd3e0efe739cee5c7a2e2f Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 19 Apr 2025 19:40:21 +0000 Subject: [PATCH 03/20] task_02 --- task_02/src/stack.hpp | 47 ++++++++++++++++--------------------------- task_02/src/test.cpp | 26 ++++++++++++++++++++++++ 2 files changed, 43 insertions(+), 30 deletions(-) diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index c9282e3..989a688 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -1,6 +1,14 @@ +#include +#include +#include #include template +concept Comparable = requires(T a, T b) { + { a < b } -> std::convertible_to; +}; + +template class Stack { public: void Push(T k); @@ -10,19 +18,20 @@ class Stack { std ::vector _data; }; -template +template void Stack::Push(T k) { _data.push_back(k); } -template +template T Stack::Pop() { + if (_data.size() == 0) throw std::runtime_error("No data in stack"); T pop_val{_data.back()}; _data.pop_back(); return pop_val; } -template +template class MinStack { public: void Push(T k); @@ -34,7 +43,7 @@ class MinStack { std ::vector _min_data; }; -template +template void MinStack::Push(T k) { if (_min_data.size() == 0) _min_data.push_back(k); @@ -45,39 +54,17 @@ void MinStack::Push(T k) { _data.push_back(k); } -template +template T MinStack::Pop() { + if ((_data.size() == 0) || (_min_data.size() == 0))throw std::runtime_error("No data in stack"); T pop_val{_data.back()}; _data.pop_back(); _min_data.pop_back(); return pop_val; } -template +template T MinStack::GetMin() { + if (_min_data.size() == 0) throw std::runtime_error("No data in stack"); return _min_data.back(); } - -// #pragma once - -// #include -// #include - -// class Stack { -// public: -// void Push(int value); -// int Pop(); - -// private: -// std::stack data_; -// }; - -// class MinStack { -// public: -// void Push(int value); -// int Pop(); -// int GetMin(); - -// private: -// std::vector data_; -// }; diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 1f26b2c..ee30345 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -37,4 +37,30 @@ TEST(MinStackTest, Simple) { ASSERT_EQ(stack.GetMin(), 1); ASSERT_EQ(stack.Pop(), 3); // Stack [1] ASSERT_EQ(stack.Pop(), 1); // Stack [] +} + +TEST(Stack, Custom) { + Stack stack; + stack.Push(10); + ASSERT_EQ(10, stack.Pop()); + + EXPECT_THROW(stack.Pop(), std::runtime_error); +} + +TEST(MinStack, Custom) { + MinStack stack; + stack.Push(10); + stack.Push(2); + stack.Push(17); + ASSERT_EQ(2, stack.GetMin()); + + stack.Pop(); + stack.Pop(); + stack.Pop(); + EXPECT_THROW(stack.Pop(), std::runtime_error); + + stack.Push(10); + stack.Push(10); + stack.Push(10); + ASSERT_EQ(10, stack.GetMin()); } \ No newline at end of file From c94a85ba036c275e1c29f70a3db3dcc4d9b794bd Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 19 Apr 2025 19:52:19 +0000 Subject: [PATCH 04/20] task_03 --- task_03/src/main.cpp | 12 +++++++++- task_03/src/test.cpp | 44 ++++++++++++++++++++++++++++++++--- task_03/src/topology_sort.cpp | 1 - task_03/src/topology_sort.hpp | 1 - task_03/src/warming_func.cpp | 18 ++++++++++++++ task_03/src/warming_func.hpp | 3 +++ 6 files changed, 73 insertions(+), 6 deletions(-) delete mode 100644 task_03/src/topology_sort.cpp delete mode 100644 task_03/src/topology_sort.hpp create mode 100644 task_03/src/warming_func.cpp create mode 100644 task_03/src/warming_func.hpp diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp index 0e4393b..1c3884a 100644 --- a/task_03/src/main.cpp +++ b/task_03/src/main.cpp @@ -1,3 +1,13 @@ #include -int main() { return 0; } +#include "warming_func.hpp" + +void print(std::vector& v) { + for (auto c : v) std ::cout << c << " "; +} + +int main() { + std ::vector s{5, 7, 9, 3, 4, 0, 2, -1, 3}; + s = warming(s); + print(s); +} diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index ef5a86a..372b14e 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -1,8 +1,46 @@ #include -#include "topology_sort.hpp" +#include "warming_func.hpp" -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +TEST(Warm, Simple) { + std ::vector temperature = {73, 74, 75, 71, 69, 72, 76, 73}; + std ::vector ans = {1, 1, 4, 2, 1, 1, 0, 0}; + ASSERT_EQ(warming(temperature), ans); +} + +TEST(Warm, Stable) { + std ::vector temperature = {30, 20, 10}; + std ::vector ans = {0, 0, 0}; + ASSERT_EQ(warming(temperature), ans); +} + +TEST(Warm, OneDay) { + std ::vector temperature = {50}; + std ::vector ans = {0}; + ASSERT_EQ(warming(temperature), ans); +} + +TEST(Warm, Empty) { + std ::vector temperature = {}; + std ::vector ans = {}; + ASSERT_EQ(warming(temperature), ans); +} + +TEST(Warm, SameTemperature) { + std ::vector temperature = {10, 10, 10, 10}; + std ::vector ans = {0, 0, 0, 0}; + ASSERT_EQ(warming(temperature), ans); +} + +TEST(Warm, Negative) { + std ::vector temperature = {-10, -5, -20}; + std ::vector ans = {1, 0, 0}; + ASSERT_EQ(warming(temperature), ans); +} + +TEST(Warm, BigDiff) { + std ::vector temperature = {0, -10, 100, 5, 1000}; + std ::vector ans = {2, 1, 1, 1, 0}; + ASSERT_EQ(warming(temperature), ans); } diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp deleted file mode 100644 index e53f670..0000000 --- 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 6f70f09..0000000 --- a/task_03/src/topology_sort.hpp +++ /dev/null @@ -1 +0,0 @@ -#pragma once diff --git a/task_03/src/warming_func.cpp b/task_03/src/warming_func.cpp new file mode 100644 index 0000000..1eb45ec --- /dev/null +++ b/task_03/src/warming_func.cpp @@ -0,0 +1,18 @@ +#include "warming_func.hpp" + +#include + +std ::vector warming(std ::vector temperature) { + std::stack index; + std ::vector ans(temperature.size()); + + for (int i = 0; i < temperature.size(); ++i) { + while (!index.empty() && (temperature[i] > temperature[index.top()])) { + int j = index.top(); + index.pop(); + ans[j] = i - j; + } + index.push(i); + } + return ans; +} \ No newline at end of file diff --git a/task_03/src/warming_func.hpp b/task_03/src/warming_func.hpp new file mode 100644 index 0000000..06b76ad --- /dev/null +++ b/task_03/src/warming_func.hpp @@ -0,0 +1,3 @@ +#include + +std ::vector warming(std ::vector temperature); From c5bd9a4bbd7c3184b7da6d903c524627de63d0c3 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 19 Apr 2025 19:59:30 +0000 Subject: [PATCH 05/20] task_03 test_fix --- task_03/src/test.cpp | 2 +- task_03/src/{warming_func.cpp => topology_sort.cpp} | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) rename task_03/src/{warming_func.cpp => topology_sort.cpp} (100%) diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index 372b14e..8f988a8 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -41,6 +41,6 @@ TEST(Warm, Negative) { TEST(Warm, BigDiff) { std ::vector temperature = {0, -10, 100, 5, 1000}; - std ::vector ans = {2, 1, 1, 1, 0}; + std ::vector ans = {2, 1, 2, 1, 0}; ASSERT_EQ(warming(temperature), ans); } diff --git a/task_03/src/warming_func.cpp b/task_03/src/topology_sort.cpp similarity index 100% rename from task_03/src/warming_func.cpp rename to task_03/src/topology_sort.cpp index 1eb45ec..6a936d5 100644 --- a/task_03/src/warming_func.cpp +++ b/task_03/src/topology_sort.cpp @@ -1,7 +1,7 @@ -#include "warming_func.hpp" - #include +#include "warming_func.hpp" + std ::vector warming(std ::vector temperature) { std::stack index; std ::vector ans(temperature.size()); From d11799e990d56e6ee548a490ad86706cee04013e Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 19 Apr 2025 20:45:42 +0000 Subject: [PATCH 06/20] task_06 --- task_06/src/NStatistic.cpp | 12 +++++++++++ task_06/src/NStatistic.hpp | 3 +++ task_06/src/test.cpp | 42 ++++++++++++++++++++++++++++++++++++-- 3 files changed, 55 insertions(+), 2 deletions(-) create mode 100644 task_06/src/NStatistic.cpp create mode 100644 task_06/src/NStatistic.hpp diff --git a/task_06/src/NStatistic.cpp b/task_06/src/NStatistic.cpp new file mode 100644 index 0000000..c5c1a89 --- /dev/null +++ b/task_06/src/NStatistic.cpp @@ -0,0 +1,12 @@ +#include "NStatistic.hpp" + +#include +#include + +int NStatistic(std ::vector data, int n) { + if (data.size() == 0) throw std::invalid_argument(""); + if (n > data.size()) throw std::invalid_argument(""); + + std::sort(data.begin(), data.end()); + return data[n]; +} \ No newline at end of file diff --git a/task_06/src/NStatistic.hpp b/task_06/src/NStatistic.hpp new file mode 100644 index 0000000..336d39f --- /dev/null +++ b/task_06/src/NStatistic.hpp @@ -0,0 +1,3 @@ +#include + +int NStatistic(std ::vector data, int n); \ No newline at end of file diff --git a/task_06/src/test.cpp b/task_06/src/test.cpp index 5e11617..4a3087f 100644 --- a/task_06/src/test.cpp +++ b/task_06/src/test.cpp @@ -1,6 +1,44 @@ #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include "NStatistic.hpp" + +TEST(NStatistic, Simple) { + std ::vector data = {3, 1, 4, 1, 5}; + int n = 2; + int ans = 3; + ASSERT_EQ(NStatistic(data, n), ans); +} + +TEST(NStatistic, OneElem) { + std ::vector data = {100}; + int n = 0; + int ans = 100; + ASSERT_EQ(NStatistic(data, n), ans); +} + +TEST(NStatistic, SameElem) { + std ::vector data = {7, 7, 7, 7}; + int n = 2; + int ans = 7; + ASSERT_EQ(NStatistic(data, n), ans); +} + +TEST(NStatistic, NegativeElem) { + std ::vector data = {-5, 0, -1, 3, -2}; + int n = 2; + int ans = -1; + ASSERT_EQ(NStatistic(data, n), ans); +} + +TEST(NStatistic, BigN) { + std ::vector data = {1, 2, 3, 65, 4}; + int n = 100; + EXPECT_THROW(NStatistic(data, n), std::invalid_argument); +} + +TEST(NStatistic, Empty) { + std ::vector data = {}; + int n = 0; + EXPECT_THROW(NStatistic(data, n), std::invalid_argument); } From 7fe458dccd7028a03d38127b042ab8a4f7df1be9 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 26 Apr 2025 08:08:35 +0000 Subject: [PATCH 07/20] clang-format --- task_02/src/stack.hpp | 3 ++- task_07/src/KDtree.cpp | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 989a688..b3050e3 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -56,7 +56,8 @@ void MinStack::Push(T k) { template T MinStack::Pop() { - if ((_data.size() == 0) || (_min_data.size() == 0))throw std::runtime_error("No data in stack"); + if ((_data.size() == 0) || (_min_data.size() == 0)) + throw std::runtime_error("No data in stack"); T pop_val{_data.back()}; _data.pop_back(); _min_data.pop_back(); diff --git a/task_07/src/KDtree.cpp b/task_07/src/KDtree.cpp index 74578ce..d4cb9fd 100644 --- a/task_07/src/KDtree.cpp +++ b/task_07/src/KDtree.cpp @@ -85,7 +85,7 @@ KDTree::KDTree(std ::vector points) { cloud = std::move(points); prepare_points(cloud); - + root = std::make_unique(); root->indices = std::make_pair(0, cloud.size() - 1); root->bounding_box = std::make_pair(cloud[0], cloud[cloud.size() - 1]); From f3155484c5d18ee0b62372411fe8c7437e6a441e Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 07:47:54 +0000 Subject: [PATCH 08/20] CamelStyle --- task_01/src/find.cpp | 6 +++--- task_01/src/find.hpp | 4 ++-- task_01/src/test.cpp | 20 ++++++++++---------- 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/task_01/src/find.cpp b/task_01/src/find.cpp index 5d2b5fb..401c67c 100644 --- a/task_01/src/find.cpp +++ b/task_01/src/find.cpp @@ -1,7 +1,7 @@ #include "find.hpp" -std ::vector find_nums(int k, std ::vector sequence) { - if (sequence.size() == 0) throw no_sum_num{}; +std ::vector FindNums(int k, std ::vector sequence) { + if (sequence.size() == 0) throw NoSumNum{}; std ::vector ans; unsigned long left_index{0}; @@ -16,5 +16,5 @@ std ::vector find_nums(int k, std ::vector sequence) { else ++left_index; } - throw no_sum_num{}; + throw NoSumNum{}; } \ No newline at end of file diff --git a/task_01/src/find.hpp b/task_01/src/find.hpp index f946e9c..8812e23 100644 --- a/task_01/src/find.hpp +++ b/task_01/src/find.hpp @@ -1,8 +1,8 @@ #include #include -struct no_sum_num { +struct NoSumNum { std ::string s{"no possible way to solve task"}; }; -std ::vector find_nums(int k, std ::vector sequence); \ No newline at end of file +std ::vector FindNums(int k, std ::vector sequence); \ No newline at end of file diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index db1f57c..42dc3c1 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -2,32 +2,32 @@ #include "find.hpp" -TEST(find_nums, simple) { +TEST(FindNums, Simple) { std ::vector seq{1, 2, 3, 4, 5}; - std ::vector ans{find_nums(5, seq)}; + std ::vector ans{FindNums(5, seq)}; ASSERT_EQ(5, ans[0] + ans[1]); } -TEST(find_nums, negative) { +TEST(FindNums, Negative) { std ::vector seq{-100, -10, -9, -8, -1}; - std ::vector ans{find_nums(-9, seq)}; + std ::vector ans{FindNums(-9, seq)}; ASSERT_EQ(-9, ans[0] + ans[1]); } -TEST(find_nums, with_zeros) { +TEST(FindNums, WithZeros) { std ::vector seq{ -15, 0, 0, 2, 8, }; - std ::vector ans{find_nums(10, seq)}; + std ::vector ans{FindNums(10, seq)}; ASSERT_EQ(10, ans[0] + ans[1]); } -TEST(find_nums, no_value) { +TEST(FindNums, NoValue) { std ::vector seq{0, 0, 2, 8, -15}; - EXPECT_THROW(find_nums(60, seq), no_sum_num); + EXPECT_THROW(FindNums(60, seq), NoSumNum); } -TEST(find_nums, empty) { +TEST(FindNums, Empty) { std ::vector seq(0); - EXPECT_THROW(find_nums(60, seq), no_sum_num); + EXPECT_THROW(FindNums(60, seq), NoSumNum); } \ No newline at end of file From b1334be18872c31484270d6ce6183329cec87096 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 07:48:21 +0000 Subject: [PATCH 09/20] Free sandbox --- sandbox/template/src/main.cpp | 76 +++++++++++++++++----------------- sandbox/template/src/test.cpp | 8 ++-- sandbox/template/src/utils.cpp | 2 +- sandbox/template/src/utils.hpp | 2 +- 4 files changed, 44 insertions(+), 44 deletions(-) diff --git a/sandbox/template/src/main.cpp b/sandbox/template/src/main.cpp index 6ed1c71..3023142 100644 --- a/sandbox/template/src/main.cpp +++ b/sandbox/template/src/main.cpp @@ -1,41 +1,41 @@ -#include -#include +// #include +// #include -void MergeSort(std ::vector& array) { - int i{0}, j{1}; - int slice{1}; - do { - while (j <= array.size() - 1) { - if (array[i] > array[j]) { - iter_swap(array.begin() + i, array.begin() + j); +// void MergeSort(std ::vector& array) { +// int i{0}, j{1}; +// int slice{1}; +// do { +// while (j <= array.size() - 1) { +// if (array[i] > array[j]) { +// iter_swap(array.begin() + i, array.begin() + j); - ++j; - } else - ++i; - if (j - i > slice) { - i = j; - j = i + slice; - } else if (j == i) { - i += 1; - j = i + slice; - } - } - slice *= 2; - slice > array.size() ? j = array.size() - 1 : j = slice; - i = 0; - if (j == array.size() - 1) { - if (i == 0) { - return; - } - } - } while (true); -} +// ++j; +// } else +// ++i; +// if (j - i > slice) { +// i = j; +// j = i + slice; +// } else if (j == i) { +// i += 1; +// j = i + slice; +// } +// } +// slice *= 2; +// slice > array.size() ? j = array.size() - 1 : j = slice; +// i = 0; +// if (j == array.size() - 1) { +// if (i == 0) { +// return; +// } +// } +// } while (true); +// } -int main() { - std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; - MergeSort(unsort); - for (int i = 0; i < unsort.size(); ++i) { - std ::cout << unsort[i] << " "; - } - std ::cout << std ::endl; -} +// int main() { +// std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; +// MergeSort(unsort); +// for (int i = 0; i < unsort.size(); ++i) { +// std ::cout << unsort[i] << " "; +// } +// std ::cout << std ::endl; +// } diff --git a/sandbox/template/src/test.cpp b/sandbox/template/src/test.cpp index 31df8b8..7b3eb4a 100644 --- a/sandbox/template/src/test.cpp +++ b/sandbox/template/src/test.cpp @@ -1,8 +1,8 @@ -#include +// #include -#include +// #include -#include "utils.hpp" +// #include "utils.hpp" -TEST(Template, Simple) { ASSERT_EQ(true, true); } +// TEST(Template, Simple) { ASSERT_EQ(true, true); } diff --git a/sandbox/template/src/utils.cpp b/sandbox/template/src/utils.cpp index 0ee624c..03b9030 100644 --- a/sandbox/template/src/utils.cpp +++ b/sandbox/template/src/utils.cpp @@ -1 +1 @@ -#include "utils.hpp" +// #include "utils.hpp" diff --git a/sandbox/template/src/utils.hpp b/sandbox/template/src/utils.hpp index 6f70f09..7dcceab 100644 --- a/sandbox/template/src/utils.hpp +++ b/sandbox/template/src/utils.hpp @@ -1 +1 @@ -#pragma once +// #pragma once From 1bf01e0a58a0ae9dab73dbe3b56d3b7a7b9681c8 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 07:51:50 +0000 Subject: [PATCH 10/20] made it compile --- sandbox/template/src/main.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/sandbox/template/src/main.cpp b/sandbox/template/src/main.cpp index 3023142..f46e229 100644 --- a/sandbox/template/src/main.cpp +++ b/sandbox/template/src/main.cpp @@ -31,11 +31,11 @@ // } while (true); // } -// int main() { -// std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; -// MergeSort(unsort); -// for (int i = 0; i < unsort.size(); ++i) { -// std ::cout << unsort[i] << " "; -// } -// std ::cout << std ::endl; -// } +int main() { + // std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; + // MergeSort(unsort); + // for (int i = 0; i < unsort.size(); ++i) { + // std ::cout << unsort[i] << " "; + // } + // std ::cout << std ::endl; +} From 1380d32bbf783cc8457fed73a76c04a02f6307c1 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 07:52:29 +0000 Subject: [PATCH 11/20] CamelStyle --- task_03/src/main.cpp | 12 ++++++------ task_03/src/test.cpp | 14 +++++++------- task_03/src/topology_sort.cpp | 2 +- task_03/src/warming_func.hpp | 2 +- 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp index 1c3884a..a4fe526 100644 --- a/task_03/src/main.cpp +++ b/task_03/src/main.cpp @@ -2,12 +2,12 @@ #include "warming_func.hpp" -void print(std::vector& v) { - for (auto c : v) std ::cout << c << " "; -} +// void print(std::vector& v) { +// for (auto c : v) std ::cout << c << " "; +// } int main() { - std ::vector s{5, 7, 9, 3, 4, 0, 2, -1, 3}; - s = warming(s); - print(s); + // std ::vector s{5, 7, 9, 3, 4, 0, 2, -1, 3}; + // s = Warming(s); + // print(s); } diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index 8f988a8..9b68bb4 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -6,41 +6,41 @@ TEST(Warm, Simple) { std ::vector temperature = {73, 74, 75, 71, 69, 72, 76, 73}; std ::vector ans = {1, 1, 4, 2, 1, 1, 0, 0}; - ASSERT_EQ(warming(temperature), ans); + ASSERT_EQ(Warming(temperature), ans); } TEST(Warm, Stable) { std ::vector temperature = {30, 20, 10}; std ::vector ans = {0, 0, 0}; - ASSERT_EQ(warming(temperature), ans); + ASSERT_EQ(Warming(temperature), ans); } TEST(Warm, OneDay) { std ::vector temperature = {50}; std ::vector ans = {0}; - ASSERT_EQ(warming(temperature), ans); + ASSERT_EQ(Warming(temperature), ans); } TEST(Warm, Empty) { std ::vector temperature = {}; std ::vector ans = {}; - ASSERT_EQ(warming(temperature), ans); + ASSERT_EQ(Warming(temperature), ans); } TEST(Warm, SameTemperature) { std ::vector temperature = {10, 10, 10, 10}; std ::vector ans = {0, 0, 0, 0}; - ASSERT_EQ(warming(temperature), ans); + ASSERT_EQ(Warming(temperature), ans); } TEST(Warm, Negative) { std ::vector temperature = {-10, -5, -20}; std ::vector ans = {1, 0, 0}; - ASSERT_EQ(warming(temperature), ans); + ASSERT_EQ(Warming(temperature), ans); } TEST(Warm, BigDiff) { std ::vector temperature = {0, -10, 100, 5, 1000}; std ::vector ans = {2, 1, 2, 1, 0}; - ASSERT_EQ(warming(temperature), ans); + ASSERT_EQ(Warming(temperature), ans); } diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp index 6a936d5..b1294ee 100644 --- a/task_03/src/topology_sort.cpp +++ b/task_03/src/topology_sort.cpp @@ -2,7 +2,7 @@ #include "warming_func.hpp" -std ::vector warming(std ::vector temperature) { +std ::vector Warming(std ::vector temperature) { std::stack index; std ::vector ans(temperature.size()); diff --git a/task_03/src/warming_func.hpp b/task_03/src/warming_func.hpp index 06b76ad..a8020ee 100644 --- a/task_03/src/warming_func.hpp +++ b/task_03/src/warming_func.hpp @@ -1,3 +1,3 @@ #include -std ::vector warming(std ::vector temperature); +std ::vector Warming(std ::vector temperature); From 00bef32ce572f22228b48bb15a84a65c3bcef47c Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 08:01:32 +0000 Subject: [PATCH 12/20] CamelStyle --- task_07/src/KDtree.cpp | 4 ++-- task_07/src/KDtree.hpp | 14 +++++++------- task_07/src/SAH.cpp | 14 +++++++------- task_07/src/main.cpp | 2 +- task_07/src/min_search.cpp | 28 ++++++++++++++-------------- task_07/src/test.cpp | 33 +++++++++++---------------------- 6 files changed, 42 insertions(+), 53 deletions(-) diff --git a/task_07/src/KDtree.cpp b/task_07/src/KDtree.cpp index d4cb9fd..64daa85 100644 --- a/task_07/src/KDtree.cpp +++ b/task_07/src/KDtree.cpp @@ -8,7 +8,7 @@ #include "constants.hpp" -void KDTree::prepare_points(std::vector& points) { +void KDTree::PreparePoints(std::vector& points) { std::sort(std::execution::par, points.begin(), points.end(), [](const Point& a, const Point& b) { return std::tie(a.x, a.y) < std::tie(b.x, b.y); @@ -84,7 +84,7 @@ KDTree::KDTree(std ::vector points) { if (points.size() == 0) throw std::invalid_argument{"No Points detected"}; cloud = std::move(points); - prepare_points(cloud); + PreparePoints(cloud); root = std::make_unique(); root->indices = std::make_pair(0, cloud.size() - 1); diff --git a/task_07/src/KDtree.hpp b/task_07/src/KDtree.hpp index b602efe..dea43aa 100644 --- a/task_07/src/KDtree.hpp +++ b/task_07/src/KDtree.hpp @@ -23,7 +23,7 @@ class KDTree { public: KDTree(std::vector points); ~KDTree() = default; - Point nearest_point(Point target); + Point NearestPoint(Point target); private: std ::vector cloud; @@ -46,15 +46,15 @@ class KDTree { void split(std::unique_ptr& node, axis Ax = axis::Ox, int depth = 0); std ::pair SAH(Point left_min_point, Point right_max_point, axis curr_axis, std::pair& range); - std::pair find_minimum(Point target, + std::pair FindMinimum(Point target, std::unique_ptr& node); - void prepare_points(std::vector& points); - double distance(Point first, Point second); - double distanceToBox(Point& point, std::pair& box); - bool into_box(Point target, std::pair box); + void PreparePoints(std::vector& points); + double Distance(Point first, Point second); + double DistanceToBox(Point& point, std::pair& box); + bool IntoBox(Point target, std::pair box); template - auto get_axis(const T& request, axis ax) { + auto GetAxis(const T& request, axis ax) { if (ax == axis::Ox) return request.x; else diff --git a/task_07/src/SAH.cpp b/task_07/src/SAH.cpp index 2eee71f..a355590 100644 --- a/task_07/src/SAH.cpp +++ b/task_07/src/SAH.cpp @@ -9,8 +9,8 @@ std::pair KDTree::SAH(Point left_min_point, Point right_max_point, axis curr_axis, std::pair& range) { std::pair SAH_result{NONE, NONE}; - double width = get_axis(right_max_point, curr_axis) - - get_axis(left_min_point, curr_axis); + double width = GetAxis(right_max_point, curr_axis) - + GetAxis(left_min_point, curr_axis); double width_x = right_max_point.x - left_min_point.x; double width_y = right_max_point.y - left_min_point.y; double width_w = curr_axis == axis::Ox ? width_y : width_x; @@ -25,8 +25,8 @@ std::pair KDTree::SAH(Point left_min_point, if (bin_width <= 0) return SAH_result; for (int index = range.first; index <= range.second; ++index) { - int bin_index = static_cast((get_axis(cloud[index], curr_axis) - - get_axis(left_min_point, curr_axis)) / + int bin_index = static_cast((GetAxis(cloud[index], curr_axis) - + GetAxis(left_min_point, curr_axis)) / bin_width); bin_index = std::clamp(bin_index, 0, bins - 1); ++binCounts[bin_index]; @@ -38,9 +38,9 @@ std::pair KDTree::SAH(Point left_min_point, } for (int i = 1; i < bins; ++i) { - double x0 = get_axis(left_min_point, curr_axis) + width * i / bins; - double SAl = (x0 - get_axis(left_min_point, curr_axis)) * width_w; - double SAr = (get_axis(right_max_point, curr_axis) - x0) * width_w; + double x0 = GetAxis(left_min_point, curr_axis) + width * i / bins; + double SAl = (x0 - GetAxis(left_min_point, curr_axis)) * width_w; + double SAr = (GetAxis(right_max_point, curr_axis) - x0) * width_w; int Nl = prefix_sum[i]; int Nr = (range.second - range.first + 1) - Nl; diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index 31c3358..c06cebc 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -12,6 +12,6 @@ int main() { KDTree tree(cloud); std ::cout << "compiled\n"; - Point k = tree.nearest_point(Point(4.8, 5.9)); + Point k = tree.NearestPoint(Point(4.8, 5.9)); std ::cout << k.x << " " << k.y << std ::endl; } diff --git a/task_07/src/min_search.cpp b/task_07/src/min_search.cpp index 9dec686..eccfa07 100644 --- a/task_07/src/min_search.cpp +++ b/task_07/src/min_search.cpp @@ -2,48 +2,48 @@ #include "KDtree.hpp" -double KDTree::distance(Point first, Point second) { +double KDTree::Distance(Point first, Point second) { return ((first.x - second.x) * (first.x - second.x) + (first.y - second.y) * (first.y - second.y)); } -bool KDTree::into_box(Point target, std::pair box) { +bool KDTree::IntoBox(Point target, std::pair box) { if ((target.x >= box.first.x) && (target.x <= box.second.x)) { if ((target.y >= box.first.y) && (target.y <= box.second.y)) return true; } return false; } -double KDTree::distanceToBox(Point& point, std::pair& box) { +double KDTree::DistanceToBox(Point& point, std::pair& box) { double dx = std::max({box.first.x - point.x, 0.0, point.x - box.second.x}); double dy = std::max({box.first.y - point.y, 0.0, point.y - box.second.y}); return dx * dx + dy * dy; } -std::pair KDTree::find_minimum(Point target, +std::pair KDTree::FindMinimum(Point target, std::unique_ptr& node) { if (node->leaf) { double min_dist = NONE; - Point nearest_point; + Point NearestPoint; for (int i = node->indices.first; i <= node->indices.second; ++i) { - double current_dist = distance(cloud[i], target); + double current_dist = Distance(cloud[i], target); if (current_dist < min_dist) { min_dist = current_dist; - nearest_point = cloud[i]; + NearestPoint = cloud[i]; } } - return {min_dist, nearest_point}; + return {min_dist, NearestPoint}; } - bool target_in_left = into_box(target, node->left_child->bounding_box); + bool target_in_left = IntoBox(target, node->left_child->bounding_box); auto& first_child = target_in_left ? node->left_child : node->right_child; auto& second_child = target_in_left ? node->right_child : node->left_child; - auto [min_dist, nearest] = find_minimum(target, first_child); + auto [min_dist, nearest] = FindMinimum(target, first_child); - double dist_to_second_box = distanceToBox(target, second_child->bounding_box); + double dist_to_second_box = DistanceToBox(target, second_child->bounding_box); if (dist_to_second_box < min_dist) { - auto [second_dist, second_nearest] = find_minimum(target, second_child); + auto [second_dist, second_nearest] = FindMinimum(target, second_child); if (second_dist < min_dist) { min_dist = second_dist; nearest = second_nearest; @@ -53,7 +53,7 @@ std::pair KDTree::find_minimum(Point target, return {min_dist, nearest}; } -Point KDTree::nearest_point(Point target) { - auto point = find_minimum(target, root); +Point KDTree::NearestPoint(Point target) { + auto point = FindMinimum(target, root); return point.second; } \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index 0abda05..89d3cae 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -7,7 +7,7 @@ #include "KDtree.hpp" -std::vector generate_random_points(size_t count, double min = 0.0, +std::vector GenerateRandomPoints(size_t count, double min = 0.0, double max = 1000.0) { std::random_device rd; std::mt19937 gen(rd()); @@ -29,7 +29,7 @@ TEST(KD3, Simple) { KDTree tree(cloud); - Point k = tree.nearest_point(Point(4.8, 5.9)); + Point k = tree.NearestPoint(Point(4.8, 5.9)); ASSERT_EQ(k, Point(5.0, 6.0)); } @@ -41,7 +41,7 @@ TEST(KD3, SameDistanse) { KDTree tree(cloud); - Point k = tree.nearest_point(Point(0.0, 0.0)); + Point k = tree.NearestPoint(Point(0.0, 0.0)); ASSERT_EQ(k, Point(0.0, 0.0)); } @@ -53,7 +53,7 @@ TEST(KD3, OneLine) { KDTree tree(cloud); - Point k = tree.nearest_point(Point(1.2, 3.1)); + Point k = tree.NearestPoint(Point(1.2, 3.1)); ASSERT_EQ(k, Point(1.0, 3.0)); } @@ -65,7 +65,7 @@ TEST(KD3, Dublicates) { KDTree tree(cloud); - Point k = tree.nearest_point(Point(2.1, 2.1)); + Point k = tree.NearestPoint(Point(2.1, 2.1)); ASSERT_EQ(k, Point(2.0, 2.0)); } @@ -75,7 +75,7 @@ TEST(KD3, Error) { } TEST(KD3, TimeTest_1000) { - auto cloud = generate_random_points(1000); + auto cloud = GenerateRandomPoints(1000); auto start = std::chrono::high_resolution_clock::now(); KDTree tree(cloud); @@ -87,7 +87,7 @@ TEST(KD3, TimeTest_1000) { } TEST(KD3, TimeTest_10000) { - auto cloud = generate_random_points(10000); + auto cloud = GenerateRandomPoints(10000); auto start = std::chrono::high_resolution_clock::now(); KDTree tree(cloud); @@ -99,7 +99,7 @@ TEST(KD3, TimeTest_10000) { } TEST(KD3, TimeTest_1M) { - auto cloud = generate_random_points(1000000); + auto cloud = GenerateRandomPoints(1000000); auto start = std::chrono::high_resolution_clock::now(); KDTree tree(cloud); @@ -107,29 +107,18 @@ TEST(KD3, TimeTest_1M) { auto duration = std::chrono::duration_cast(end - start); - EXPECT_TRUE(duration.count() < 4000); + EXPECT_TRUE(duration.count() < 5000); } TEST(KD3, TimeTest_10M) { - auto cloud = generate_random_points(10'000'000); + auto cloud = GenerateRandomPoints(10'000'000); KDTree tree(cloud); auto start = std::chrono::high_resolution_clock::now(); - tree.nearest_point(Point(3.75, 2.1)); + tree.NearestPoint(Point(3.75, 2.1)); auto end = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(end - start); EXPECT_TRUE(duration.count() < 20000); -} - -TEST(KD3, YandexTest) { - auto cloud = generate_random_points(1'500'000); - - auto start = std::chrono::high_resolution_clock::now(); - KDTree tree(cloud); - auto end = std::chrono::high_resolution_clock::now(); - auto duration = - std::chrono::duration_cast(end - start); - EXPECT_TRUE(duration.count() < 5500); } \ No newline at end of file From e2e5c895fd9f2e30ba6fe84741311b5cffc5b62b Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 08:19:12 +0000 Subject: [PATCH 13/20] task05 --- task_05/src/merge.cpp | 42 +++++++++++++------------------ task_05/src/test.cpp | 58 ++++++++++++++++++++++++++++++++++++------- 2 files changed, 66 insertions(+), 34 deletions(-) diff --git a/task_05/src/merge.cpp b/task_05/src/merge.cpp index 730fa67..a7faab9 100644 --- a/task_05/src/merge.cpp +++ b/task_05/src/merge.cpp @@ -3,33 +3,25 @@ #include "sorting.hpp" -// std::vector United(std::vector first, std::vector second) { -// std ::vector ans{}; -// if ((first.size() == 1) && (second.size() == 1)) { -// ans.push_back(std::min(first[0], second[0])); -// ans.push_back(std::max(first[0], second[0])); -// } else if (first.size() == 1) -// return ans; -// } +void MergeSort(std::vector& array) { + int n = array.size(); + std::vector buffer(n); -void MergeSort(std ::vector& array) { - int i{0}, j{1}; - int slice{1}; - while ((j != array.size() - 1) && (i != 0)) { - while (i != j) { - if (array[i] > array[j]) { - iter_swap(array.begin() + i, array.begin() + j); - std ::cout << "SWAP"; - ++j; - } else - ++i; - if ((j - i > slice) || (i == j)) { - i = j; - j = i + slice; + for (int slice = 1; slice < n; slice *= 2) { + for (int left = 0; left < n; left += 2 * slice) { + int mid = std::min(left + slice, n); + int right = std::min(left + 2 * slice, n); + + int i = left, j = mid; + int k = left; + while (i < mid && j < right) { + buffer[k++] = array[i] <= array[j] ? array[i++] : array[j++]; } + while (i < mid) buffer[k++] = array[i++]; + while (j < right) buffer[k++] = array[j++]; + + std::copy(buffer.begin() + left, buffer.begin() + right, + array.begin() + left); } - slice *= 2; - slice > array.size() ? j = array.size() - 1 : j = slice; - i = 0; } } \ No newline at end of file diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index c3849c8..64b6813 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -1,12 +1,52 @@ +#include -// #include +#include "sorting.hpp" -// // #include "sorting.hpp" -// #include "merge.cpp" +TEST(MergeSort, Simple) { + std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; + std ::vector sorted{1, 2, 3, 4, 5, 7, 9}; + MergeSort(unsort); + ASSERT_EQ(unsort, sorted); +} -// TEST(MergeSortTEST, Simple) { -// std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; -// std ::vector sorted{1, 2, 3, 4, 5, 7, 9}; -// MergeSort(unsort); -// ASSERT_EQ(unsort, sorted); -// } +TEST(MergeSort, Simple2) { + std ::vector unsort{5, 7, 2, 3, 1, 6, 4}; + std ::vector sorted{1, 2, 3, 4, 5, 6, 7}; + MergeSort(unsort); + ASSERT_EQ(unsort, sorted); +} + +TEST(MergeSort, Negative) { + std ::vector unsort{-5, -7, -2, -3, -1, -6, -4}; + std ::vector sorted{-7, -6, -5, -4, -3, -2, -1}; + MergeSort(unsort); + ASSERT_EQ(unsort, sorted); +} + +TEST(MergeSort, SameElements) { + std ::vector unsort{3, 3, 3, 3}; + std ::vector sorted{3, 3, 3, 3}; + MergeSort(unsort); + ASSERT_EQ(unsort, sorted); +} + +TEST(MergeSort, NoElements) { + std ::vector unsort{}; + std ::vector sorted{}; + MergeSort(unsort); + ASSERT_EQ(unsort, sorted); +} + +TEST(MergeSort, DiffElements) { + std ::vector unsort{1, -3, 5, 0, 0, -10, 6, 2, 21, -8, 90, -6}; + std ::vector sorted{-10, -8, -6, -3, 0, 0, 1, 2, 5, 6, 21, 90}; + MergeSort(unsort); + ASSERT_EQ(unsort, sorted); +} + +TEST(MergeSort, OneElement) { + std ::vector unsort{10}; + std ::vector sorted{10}; + MergeSort(unsort); + ASSERT_EQ(unsort, sorted); +} \ No newline at end of file From c3598efcbc0bc7e210fd95cabfb483733083c115 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 08:27:35 +0000 Subject: [PATCH 14/20] task06 good --- task_06/src/NStatistic.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/task_06/src/NStatistic.cpp b/task_06/src/NStatistic.cpp index c5c1a89..0c96d68 100644 --- a/task_06/src/NStatistic.cpp +++ b/task_06/src/NStatistic.cpp @@ -1,12 +1,12 @@ #include "NStatistic.hpp" -#include +#include "../../lib/src/util.hpp" #include int NStatistic(std ::vector data, int n) { if (data.size() == 0) throw std::invalid_argument(""); if (n > data.size()) throw std::invalid_argument(""); - std::sort(data.begin(), data.end()); + MergeSort(data); return data[n]; } \ No newline at end of file From ad2f8c2fb64404c33bb684925988f709a1b143ff Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 08:33:32 +0000 Subject: [PATCH 15/20] add sorting --- lib/src/util.cpp | 23 +++++++++++++++++++++++ lib/src/util.hpp | 3 +++ 2 files changed, 26 insertions(+) diff --git a/lib/src/util.cpp b/lib/src/util.cpp index 81e15bd..2f00b78 100644 --- a/lib/src/util.cpp +++ b/lib/src/util.cpp @@ -1 +1,24 @@ #include "util.hpp" + +void MergeSort(std::vector& array) { + int n = array.size(); + std::vector buffer(n); + + for (int slice = 1; slice < n; slice *= 2) { + for (int left = 0; left < n; left += 2 * slice) { + int mid = std::min(left + slice, n); + int right = std::min(left + 2 * slice, n); + + int i = left, j = mid; + int k = left; + while (i < mid && j < right) { + buffer[k++] = array[i] <= array[j] ? array[i++] : array[j++]; + } + while (i < mid) buffer[k++] = array[i++]; + while (j < right) buffer[k++] = array[j++]; + + std::copy(buffer.begin() + left, buffer.begin() + right, + array.begin() + left); + } + } +} \ No newline at end of file diff --git a/lib/src/util.hpp b/lib/src/util.hpp index e69de29..fd0b3e2 100644 --- a/lib/src/util.hpp +++ b/lib/src/util.hpp @@ -0,0 +1,3 @@ +#include + +void MergeSort(std::vector& array); From 411b59f18e5b5734073cb38686a09a5d82494903 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 08:53:57 +0000 Subject: [PATCH 16/20] omp compilation added --- .github/workflows/tests.yaml | 1 + task_08/src/HashTable.cpp | 6 ++++++ task_08/src/HashTable.hpp | 11 +++++++++++ task_08/src/main.cpp | 7 ++++++- task_08/src/test.cpp | 6 +++--- 5 files changed, 27 insertions(+), 4 deletions(-) create mode 100644 task_08/src/HashTable.cpp create mode 100644 task_08/src/HashTable.hpp diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml index 267b2ec..783d168 100644 --- a/.github/workflows/tests.yaml +++ b/.github/workflows/tests.yaml @@ -15,6 +15,7 @@ jobs: steps: - name: Install gtest manually run: sudo apt-get install libgtest-dev + run: sudo apt install libomp-dev - uses: actions/checkout@v3 diff --git a/task_08/src/HashTable.cpp b/task_08/src/HashTable.cpp new file mode 100644 index 0000000..68dc781 --- /dev/null +++ b/task_08/src/HashTable.cpp @@ -0,0 +1,6 @@ +#include "HashTable.hpp" + + +void HashTable::add(int elem) { + +} \ No newline at end of file diff --git a/task_08/src/HashTable.hpp b/task_08/src/HashTable.hpp new file mode 100644 index 0000000..9d44383 --- /dev/null +++ b/task_08/src/HashTable.hpp @@ -0,0 +1,11 @@ +#include + +class HashTable { + public: + HashTable(); + HashTable(std ::vector InputData) : data{InputData} {}; + + void add (int elem); + private: + std ::vector data; +}; \ No newline at end of file diff --git a/task_08/src/main.cpp b/task_08/src/main.cpp index 0e4393b..99e4958 100644 --- a/task_08/src/main.cpp +++ b/task_08/src/main.cpp @@ -1,3 +1,8 @@ #include +#include -int main() { return 0; } +int main() { + int k; + std ::cin >> k; + std ::cout << std ::hash{}(k); +} diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 5e11617..381be64 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -1,6 +1,6 @@ - #include +#include "HashTable.hpp" -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +TEST(HashTable, Simple) { + } From 61e83444cdf056362132fd6478b62dc509392cb3 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sat, 3 May 2025 21:25:50 +0000 Subject: [PATCH 17/20] task08 --- task_08/src/HashTable.cpp | 68 +++++++++++++++++++++++++++++++- task_08/src/HashTable.hpp | 23 +++++++++-- task_08/src/main.cpp | 9 +---- task_08/src/test.cpp | 82 ++++++++++++++++++++++++++++++++++++++- 4 files changed, 169 insertions(+), 13 deletions(-) diff --git a/task_08/src/HashTable.cpp b/task_08/src/HashTable.cpp index 68dc781..e555dfa 100644 --- a/task_08/src/HashTable.cpp +++ b/task_08/src/HashTable.cpp @@ -1,6 +1,70 @@ #include "HashTable.hpp" +#include +#include -void HashTable::add(int elem) { - +size_t HashTable::MyHash(std::string value) { + return std::hash{}(value) * 0xdeadbeef; +} + +HashTable::HashTable() { + std::vector PreparedData(13, ZeroElem); + data = std::move(PreparedData); +} + +void HashTable::Resize() { + std::vector NewData(data.size() * 2, ZeroElem); + std::vector OldData = std::move(data); + data = std::move(NewData); + for (auto elem : OldData) { + if (elem.CurrentLabel == Label::Full) { + add(elem.Key, elem.Value); + } + } +} + +void HashTable::add(std::string key, int value) { + int index = MyHash(key) % data.size(); + int BeginingIndex = index; + while ((data[index].CurrentLabel != Label::Empty) && + (data[index].CurrentLabel != Label::Deleted)) { + if (data[index].CurrentLabel == Label::Full && data[index].Key == key) { + data[index].Value = value; + return; + } + ++index; + if (index >= data.size()) index = 0; + if (index == BeginingIndex) break; + } + data[index].Value = value; + data[index].Key = key; + data[index].CurrentLabel = Label::Full; + ++EngagedSpace; + if (EngagedSpace > (data.size() / 2)) Resize(); +} + +void HashTable::remove(std::string key) { + int index = MyHash(key) % data.size(); + int BeginingIndex = index; + while (data[index].Key != key) { + ++index; + if (index >= data.size()) index = 0; + if (index == BeginingIndex) throw std::runtime_error("ValueError"); + } + data[index].CurrentLabel = Label::Deleted; + --EngagedSpace; +} + +int HashTable::get(std::string key) { + int index = MyHash(key) % data.size(); + while ((data[index].Key != key) && + (data[index].CurrentLabel != Label::Empty)) { + ++index; + if (index >= data.size()) index = 0; + } + if (data[index].CurrentLabel == Label::Empty) { + throw std::runtime_error("ValueError"); + } else { + return data[index].Value; + } } \ No newline at end of file diff --git a/task_08/src/HashTable.hpp b/task_08/src/HashTable.hpp index 9d44383..719fa5f 100644 --- a/task_08/src/HashTable.hpp +++ b/task_08/src/HashTable.hpp @@ -1,11 +1,28 @@ +#include #include class HashTable { public: HashTable(); - HashTable(std ::vector InputData) : data{InputData} {}; - void add (int elem); + void add(std::string key, int value); + void remove(std::string key); + int get(std::string key); + private: - std ::vector data; + enum struct Label { + Empty = 0, + Full = 1, + Deleted = 2, + }; + struct Elem { + Label CurrentLabel; + int Value; + std::string Key; + }; + int EngagedSpace = 0; + std ::vector data; + size_t MyHash(std::string value); + void Resize(); + Elem ZeroElem = {Label::Empty, 0}; }; \ No newline at end of file diff --git a/task_08/src/main.cpp b/task_08/src/main.cpp index 99e4958..3d180c4 100644 --- a/task_08/src/main.cpp +++ b/task_08/src/main.cpp @@ -1,8 +1,3 @@ -#include -#include +#include "HashTable.hpp" -int main() { - int k; - std ::cin >> k; - std ::cout << std ::hash{}(k); -} +int main() {} \ No newline at end of file diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 381be64..2e62a39 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -1,6 +1,86 @@ #include + #include "HashTable.hpp" TEST(HashTable, Simple) { - + HashTable table; + table.add("first", 1); + table.add("second", 2); + ASSERT_EQ(table.get("first"), 1); +} + +TEST(HashTable, DeleteTest) { + HashTable table; + table.add("first", 1); + table.add("second", 2); + table.add("second_full", 3); + table.remove("second"); + ASSERT_EQ(table.get("second_full"), 3); +} + +TEST(HashTable, FalseDelete) { + HashTable table; + table.add("first", 1); + table.add("second", 2); + EXPECT_THROW(table.remove("no_second"), std::runtime_error); +} + +TEST(HashTable, FalseGet) { + HashTable table; + table.add("first", 1); + table.add("second", 2); + EXPECT_THROW(table.get("no_second"), std::runtime_error); +} + +TEST(HashTable, ResizeTest1) { + HashTable table; + table.add("1", -8); + table.add("2", 2); + table.add("3", 1); + table.add("4", 2); + table.add("5", 1); + table.add("5", 2); + table.add("6", 1); + table.add("7", 2); + table.add("8", 1); + table.add("9", 2); + table.add("10", 1); + table.add("11", 2); + table.add("12", 1); + table.add("13", 2); + table.add("14", 1); + table.add("15", 2); + table.add("16", 1); + table.add("17", 2); + ASSERT_EQ(table.get("1"), -8); } + +TEST(HashTable, ResizeTest2) { + HashTable table; + table.add("1", -8); + table.add("2", 2); + table.add("3", 1); + table.add("4", 2); + table.add("5", 1); + table.add("5", 2); + table.add("6", 1); + table.add("7", 2); + table.add("8", 1); + table.add("9", 2); + table.add("10", 1); + table.add("11", 2); + table.add("12", 1); + table.add("13", 2); + table.add("14", 1); + table.add("15", 2); + table.add("16", 1); + table.add("17", 19); + ASSERT_EQ(table.get("17"), 19); +} + +TEST(HashTable, AddSameKey) { + HashTable table; + table.add("first", 1); + table.add("first", 2); + ASSERT_EQ(table.get("first"), 2); +} \ No newline at end of file From d789268cf27cc7607fd1547c10cc742440e105e3 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sun, 4 May 2025 10:11:52 +0000 Subject: [PATCH 18/20] task04 --- task_04/src/EconomicCalculation.cpp | 23 ++++++++++++ task_04/src/EconomicCalculation.hpp | 4 +++ task_04/src/test.cpp | 56 +++++++++++++++++++++++++++-- 3 files changed, 81 insertions(+), 2 deletions(-) create mode 100644 task_04/src/EconomicCalculation.cpp create mode 100644 task_04/src/EconomicCalculation.hpp diff --git a/task_04/src/EconomicCalculation.cpp b/task_04/src/EconomicCalculation.cpp new file mode 100644 index 0000000..4298014 --- /dev/null +++ b/task_04/src/EconomicCalculation.cpp @@ -0,0 +1,23 @@ +#include "EconomicCalculation.hpp" + +#include + +std::vector OptimizeFishPurchases(std::vector& prices, int K, int N) { + std::vector purchases(N, 0); + int CurrentDay = 0; + + while (CurrentDay < N) { + int Border = std::min(CurrentDay + K, N); + int BestDay = CurrentDay; + + for (int day = CurrentDay; day < Border; ++day) { + if (prices[day] < prices[BestDay]) { + BestDay = day; + } + } + int FishNeeded = Border - BestDay; + purchases[BestDay] += FishNeeded; + CurrentDay = BestDay + FishNeeded; + } + return purchases; +} \ No newline at end of file diff --git a/task_04/src/EconomicCalculation.hpp b/task_04/src/EconomicCalculation.hpp new file mode 100644 index 0000000..fcf53f7 --- /dev/null +++ b/task_04/src/EconomicCalculation.hpp @@ -0,0 +1,4 @@ +#include + +std::vector OptimizeFishPurchases(std::vector& prices, int N, + int K); \ No newline at end of file diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 5e11617..1002a34 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -1,6 +1,58 @@ #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include "EconomicCalculation.hpp" + +TEST(FindFish, Simple) { + std::vector prices = {3, 5, 2, 4, 1, 3}; + int K = 3; + int N = prices.size(); + auto result = OptimizeFishPurchases(prices, K, N); + std::vector expected = {0, 0, 1, 0, 2, 0}; + ASSERT_EQ(expected, result); +} + +TEST(FindFish, SamePrice) { + std::vector prices = {2, 2, 2, 2, 2}; + int K = 2; + int N = prices.size(); + auto result = OptimizeFishPurchases(prices, K, N); + std::vector expected = {2, 0, 2, 0, 1}; + ASSERT_EQ(expected, result); +} + +TEST(FindFish, ImmediateConsumption) { + std::vector prices = {5, 4, 3, 2, 1}; + int K = 1; + int N = prices.size(); + auto result = OptimizeFishPurchases(prices, K, N); + std::vector expected = {1, 1, 1, 1, 1}; + ASSERT_EQ(expected, result); } + +TEST(FindFish, OneBuy) { + std::vector prices = {5, 3, 4, 2, 6}; + int K = 10; + int N = prices.size(); + auto result = OptimizeFishPurchases(prices, K, N); + std::vector expected = {0, 0, 0, 2, 0}; + ASSERT_EQ(expected, result); +} + +TEST(FindFish, OneDay) { + std::vector prices = {3}; + int K = 5; + int N = prices.size(); + auto result = OptimizeFishPurchases(prices, K, N); + std::vector expected = {1}; + ASSERT_EQ(expected, result); +} + +TEST(FindFish, OptimizedBuy) { + std::vector prices = {5, 4, 3, 2, 1}; + int K = 3; + int N = prices.size(); + auto result = OptimizeFishPurchases(prices, K, N); + std::vector expected = {0, 0, 1, 0, 1}; + ASSERT_EQ(expected, result); +} \ No newline at end of file From 62eb3b3f4b05092eb2d281f698ccebb15e42fdee Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sun, 4 May 2025 13:54:11 +0000 Subject: [PATCH 19/20] task09 --- task_09/src/TableTask.cpp | 45 +++++++++++++++++++++++++++++ task_09/src/TableTask.hpp | 6 ++++ task_09/src/test.cpp | 61 +++++++++++++++++++++++++++++---------- 3 files changed, 97 insertions(+), 15 deletions(-) create mode 100644 task_09/src/TableTask.cpp create mode 100644 task_09/src/TableTask.hpp diff --git a/task_09/src/TableTask.cpp b/task_09/src/TableTask.cpp new file mode 100644 index 0000000..a38818e --- /dev/null +++ b/task_09/src/TableTask.cpp @@ -0,0 +1,45 @@ +#include "TableTask.hpp" + +std::vector TaskSolve(int n, int m, int k, + std::vector>& table, + std::vector>& queries) { + std::vector answer; + std::vector> IsGood(n - 1, std::vector(m)); + + for (int j = 0; j < m; ++j) { + for (int i = 0; i < n - 1; ++i) { + IsGood[i][j] = (table[i][j] <= table[i + 1][j]); + } + } + + std::vector> prefix(m, std::vector(n)); + for (int j = 0; j < m; ++j) { + prefix[j][0] = 0; + for (int i = 1; i < n; ++i) { + prefix[j][i] = prefix[j][i - 1] + (IsGood[i - 1][j] ? 1 : 0); + } + } + + for (auto& query : queries) { + int l = query.first - 1; + int r = query.second - 1; + + if (l == r) { + answer.push_back("Yes"); + continue; + } + + bool found = false; + for (int j = 0; j < m; ++j) { + int cnt = prefix[j][r] - prefix[j][l]; + if (cnt == r - l) { + found = true; + break; + } + } + + answer.push_back(found ? "Yes" : "No"); + } + + return answer; +} \ No newline at end of file diff --git a/task_09/src/TableTask.hpp b/task_09/src/TableTask.hpp new file mode 100644 index 0000000..932fad5 --- /dev/null +++ b/task_09/src/TableTask.hpp @@ -0,0 +1,6 @@ +#include +#include + +std::vector TaskSolve(int n, int m, int k, + std::vector>& table, + std::vector>& queries); \ No newline at end of file diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp index a42caa4..f9479cd 100644 --- a/task_09/src/test.cpp +++ b/task_09/src/test.cpp @@ -1,23 +1,54 @@ #include -#include +#include "TableTask.hpp" + +TEST(CanReachNonDecreasingSegment, SampleTest) { + std::vector> table = { + {1, 2, 3, 5}, {3, 1, 3, 2}, {4, 5, 2, 3}, {5, 5, 3, 2}, {4, 4, 3, 4}}; + + std::vector> queries = {{1, 1}, {2, 5}, {4, 5}, + {3, 5}, {1, 3}, {1, 5}}; + + auto result = TaskSolve(5, 4, 6, table, queries); + std::vector expected = {"Yes", "No", "Yes", "Yes", "Yes", "No"}; + + ASSERT_EQ(result, expected); +} TEST(CanReachNonDecreasingSegment, 1) { - // ASSERT_EQ(SolveFunction(5, 4, 6, - // std::vector>{{1, 2, 3, 5}, - // {3, 1, 3, 2}, - // {4, 5, 2, 3}, - // {5, 5, 3, 2}, - // {4, 4, 3, 4}}, - // std::vector>{ - // {1, 1}, {2, 5}, {4, 5}, {3, 5}, {1, 3}, {1, - // 5}}), - // (std::vector{"Yes", "No", "Yes", "Yes", "Yes", - // "No"})); + std::vector> table = { + {1, 2, 3, 5}, {3, 1, 3, 2}, {4, 5, 2, 3}, {5, 5, 3, 2}, {4, 4, 3, 4}}; + std::vector> queries{{1, 1}, {2, 5}, {4, 5}, + {3, 5}, {1, 3}, {1, 5}}; + ASSERT_EQ(TaskSolve(5, 4, 6, table, queries), + (std::vector{"Yes", "No", "Yes", "Yes", "Yes", "No"})); } TEST(CanReachNonDecreasingSegment, 2) { - // ASSERT_EQ(SolveFunction(1, 1, 1, std::vector>{{1, 1}}, - // std::vector>{{1, 1}}), - // (std::vector{"Yes"})); + std::vector> table = {{1, 1}}; + std::vector> queries = {{1, 1}}; + ASSERT_EQ(TaskSolve(1, 1, 1, table, queries), + (std::vector{"Yes"})); } + +TEST(CanReachNonDecreasingSegment, SingleElement) { + std::vector> table = {{1}}; + std::vector> queries{{1, 1}}; + ASSERT_EQ(TaskSolve(1, 1, 1, table, queries), + (std::vector{"Yes"})); +} + +TEST(CanReachNonDecreasingSegment, AllColumnsSorted) { + std::vector> table = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}}; + std::vector> queries{{1, 3}, {2, 3}, {1, 2}}; + ASSERT_EQ(TaskSolve(3, 3, 3, table, queries), + (std::vector{"Yes", "Yes", "Yes"})); +} + +TEST(CanReachNonDecreasingSegment, OneColumnSorted) { + std::vector> table = { + {5, 1}, {4, 2}, {3, 3}, {2, 4}, {1, 5}}; + std::vector> queries{{1, 5}, {2, 4}, {3, 5}}; + ASSERT_EQ(TaskSolve(5, 2, 3, table, queries), + (std::vector{"Yes", "Yes", "Yes"})); +} \ No newline at end of file From 762daf43ae182b3661517c05b0881c0bb54ca3e1 Mon Sep 17 00:00:00 2001 From: Half-Head Date: Sun, 4 May 2025 14:20:35 +0000 Subject: [PATCH 20/20] refactoring --- task_01/src/find.cpp | 8 +-- task_02/src/stack.cpp | 36 ----------- task_02/src/stack.hpp | 7 +- task_02/src/test.cpp | 52 +++++++-------- .../{topology_sort.cpp => warming_func.cpp} | 0 task_05/src/main.cpp | 64 +------------------ task_05/src/merge.cpp | 1 - task_07/src/KDtree.cpp | 24 ++++--- task_07/src/KDtree.hpp | 14 ++-- task_07/src/SAH.cpp | 8 +-- task_07/src/main.cpp | 3 +- task_08/src/HashTable.cpp | 10 +-- task_08/src/HashTable.hpp | 8 +-- 13 files changed, 66 insertions(+), 169 deletions(-) delete mode 100644 task_02/src/stack.cpp rename task_03/src/{topology_sort.cpp => warming_func.cpp} (100%) diff --git a/task_01/src/find.cpp b/task_01/src/find.cpp index 401c67c..b5d0413 100644 --- a/task_01/src/find.cpp +++ b/task_01/src/find.cpp @@ -3,14 +3,14 @@ std ::vector FindNums(int k, std ::vector sequence) { if (sequence.size() == 0) throw NoSumNum{}; - std ::vector ans; + std ::vector answer; unsigned long left_index{0}; unsigned long right_index{sequence.size() - 1}; while (left_index != right_index) { if ((sequence[left_index] + sequence[right_index]) == k) { - ans.push_back(sequence[left_index]); - ans.push_back(sequence[right_index]); - return ans; + answer.push_back(sequence[left_index]); + answer.push_back(sequence[right_index]); + return answer; } else if (sequence[left_index] + sequence[right_index] > k) --right_index; else diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp deleted file mode 100644 index 8070060..0000000 --- a/task_02/src/stack.cpp +++ /dev/null @@ -1,36 +0,0 @@ -#include "stack.hpp" - -// template -// void Stack::Push(T k) { -// _data.push_back(k); -// } - -// template -// T Stack::Pop() { -// int pop_val{_data.back()}; -// _data.pop_back(); -// return pop_val; -// } - -// #include "stack.hpp" - -// #include - -// void Stack::Push(int value) { data_.push(value); } - -// int Stack::Pop() { -// auto result = data_.top(); -// data_.pop(); -// return result; -// } - -// void MinStack::Push(int value) { data_.push_back(value); } - -// int MinStack::Pop() { -// auto result = data_.back(); -// data_.pop_back(); -// return result; -// } - -// int MinStack::GetMin() { return *std::min_element(data_.begin(), -// data_.end()); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index b3050e3..fcf5a1b 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -1,5 +1,4 @@ #include -#include #include #include @@ -25,7 +24,7 @@ void Stack::Push(T k) { template T Stack::Pop() { - if (_data.size() == 0) throw std::runtime_error("No data in stack"); + if (_data.size() == 0) throw std::out_of_range("No data in stack"); T pop_val{_data.back()}; _data.pop_back(); return pop_val; @@ -57,7 +56,7 @@ void MinStack::Push(T k) { template T MinStack::Pop() { if ((_data.size() == 0) || (_min_data.size() == 0)) - throw std::runtime_error("No data in stack"); + throw std::out_of_range("No data in stack"); T pop_val{_data.back()}; _data.pop_back(); _min_data.pop_back(); @@ -66,6 +65,6 @@ T MinStack::Pop() { template T MinStack::GetMin() { - if (_min_data.size() == 0) throw std::runtime_error("No data in stack"); + if (_min_data.size() == 0) throw std::out_of_range("No data in stack"); return _min_data.back(); } diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index ee30345..f99f283 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -5,38 +5,38 @@ TEST(StackTest, Simple) { Stack stack; - stack.Push(1); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - stack.Push(3); // Stack [1, 3] - ASSERT_EQ(stack.Pop(), 3); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] + stack.Push(1); + ASSERT_EQ(stack.Pop(), 1); + stack.Push(1); + stack.Push(2); + ASSERT_EQ(stack.Pop(), 2); + ASSERT_EQ(stack.Pop(), 1); + stack.Push(1); + stack.Push(2); + ASSERT_EQ(stack.Pop(), 2); + stack.Push(3); + ASSERT_EQ(stack.Pop(), 3); + ASSERT_EQ(stack.Pop(), 1); } TEST(MinStackTest, Simple) { MinStack stack; - stack.Push(1); // Stack [1] + stack.Push(1); ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] + ASSERT_EQ(stack.Pop(), 1); + stack.Push(1); + stack.Push(2); ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] + ASSERT_EQ(stack.Pop(), 2); + ASSERT_EQ(stack.Pop(), 1); + stack.Push(1); + stack.Push(2); ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - stack.Push(3); // Stack [1, 3] + ASSERT_EQ(stack.Pop(), 2); + stack.Push(3); ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 3); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] + ASSERT_EQ(stack.Pop(), 3); + ASSERT_EQ(stack.Pop(), 1); } TEST(Stack, Custom) { @@ -44,7 +44,7 @@ TEST(Stack, Custom) { stack.Push(10); ASSERT_EQ(10, stack.Pop()); - EXPECT_THROW(stack.Pop(), std::runtime_error); + EXPECT_THROW(stack.Pop(), std::out_of_range); } TEST(MinStack, Custom) { @@ -57,7 +57,7 @@ TEST(MinStack, Custom) { stack.Pop(); stack.Pop(); stack.Pop(); - EXPECT_THROW(stack.Pop(), std::runtime_error); + EXPECT_THROW(stack.Pop(), std::out_of_range); stack.Push(10); stack.Push(10); diff --git a/task_03/src/topology_sort.cpp b/task_03/src/warming_func.cpp similarity index 100% rename from task_03/src/topology_sort.cpp rename to task_03/src/warming_func.cpp diff --git a/task_05/src/main.cpp b/task_05/src/main.cpp index c90ace8..67c383e 100644 --- a/task_05/src/main.cpp +++ b/task_05/src/main.cpp @@ -1,65 +1,3 @@ -#include -#include - #include "sorting.hpp" -// template -// class Heap { -// public: -// Heap() {} -// void push(T k) { -// _data.push_back(k); -// SiftUp(_data); -// } -// void print() { -// for (int i{0}; i < _data.size(); ++i) std ::cout << _data[i] << " "; -// std ::cout << std ::endl; -// } -// void pop() { -// iter_swap(_data.begin(), _data.begin() + _data.size() - 1); -// _data.pop_back(); -// SiftDown(_data); -// } -// Heap(std ::vector dat) { -// for (int i{0}; i < dat.size(); ++i) { -// push(dat[i]); -// } -// } -// int min() { return _data[0]; } - -// private: -// std ::vector _data; -// void SiftUp(std ::vector& data); -// void SiftDown(std ::vector& data); -// int find_parent(int i) { return ((i - 1) / 2); } -// int find_childL(int i) { return (2 * i + 1); } -// int find_childR(int i) { return (2 * i + 2); } -// }; - -// template -// void Heap::SiftUp(std ::vector& data) { // снизу вверх -// int index{static_cast(data.size() - 1)}; -// int par_index{find_parent(index)}; -// while (data[index] < data[par_index]) { -// iter_swap(data.begin() + index, data.begin() + par_index); -// index = par_index; -// par_index = find_parent(index); -// } -// } - -// template -// void Heap::SiftDown(std ::vector& data) { -// int index{0}; -// int child{std::min(find_childL(index), find_childR(index))}; -// while (data[child] < data[index]) { -// iter_swap(data.begin() + index, data.begin() + child); -// index = child; -// child = std::min(find_childL(index), find_childR(index)); -// } -// } - -int main() { - // std ::vector unsort{3, 2, 4, 5, 1, 9, 7}; - // std ::vector sorted{1, 2, 3, 4, 5, 7, 9}; - // MergeSort(unsort); -} +int main() {} diff --git a/task_05/src/merge.cpp b/task_05/src/merge.cpp index a7faab9..7e5b467 100644 --- a/task_05/src/merge.cpp +++ b/task_05/src/merge.cpp @@ -1,5 +1,4 @@ #include -#include #include "sorting.hpp" diff --git a/task_07/src/KDtree.cpp b/task_07/src/KDtree.cpp index 64daa85..fd284f4 100644 --- a/task_07/src/KDtree.cpp +++ b/task_07/src/KDtree.cpp @@ -6,8 +6,6 @@ #include #include -#include "constants.hpp" - void KDTree::PreparePoints(std::vector& points) { std::sort(std::execution::par, points.begin(), points.end(), [](const Point& a, const Point& b) { @@ -20,8 +18,8 @@ void KDTree::PreparePoints(std::vector& points) { points.erase(std::unique(points.begin(), points.end(), equal), points.end()); } -void KDTree::split(std::unique_ptr& node, axis Ax, int depth) { - std ::pair SAH = KDTree::SAH( +void KDTree::Split(std::unique_ptr& node, Axis Ax, int depth) { + std::pair SAH = KDTree::SAH( node->bounding_box.first, node->bounding_box.second, Ax, node->indices); double SAH_parant = Ci * (node->indices.second - node->indices.first); @@ -34,7 +32,7 @@ void KDTree::split(std::unique_ptr& node, axis Ax, int depth) { node->left_child = std::make_unique(); node->right_child = std::make_unique(); - if (Ax == axis::Ox) { + if (Ax == Axis::Ox) { node->left_child->bounding_box.first = node->bounding_box.first; node->left_child->bounding_box.second = Point(SAH.second, node->bounding_box.second.y); @@ -57,31 +55,31 @@ void KDTree::split(std::unique_ptr& node, axis Ax, int depth) { std::execution::par, cloud.begin() + node->indices.first, cloud.begin() + node->indices.second + 1, [Ax, split_pos = SAH.second](const Point& p) { - return (Ax == axis::Ox) ? p.x < split_pos : p.y < split_pos; + return (Ax == Axis::Ox) ? p.x < split_pos : p.y < split_pos; }); node->left_child->indices.second = node->indices.first + left_count - 1; node->right_child->indices.first = node->indices.first + left_count; node->right_child->indices.second = node->indices.second; - Ax == axis::Ox ? Ax = axis::Oy : Ax = axis::Ox; + Ax = (Ax == Axis::Ox) ? Axis::Oy : Axis::Ox; if (depth < max_parallel_depth) { #pragma omp task shared(node) - split(node->left_child, Ax, depth + 1); + Split(node->left_child, Ax, depth + 1); #pragma omp task shared(node) - split(node->right_child, Ax, depth + 1); + Split(node->right_child, Ax, depth + 1); #pragma omp taskwait } else { - split(node->left_child, Ax, depth + 1); - split(node->right_child, Ax, depth + 1); + Split(node->left_child, Ax, depth + 1); + Split(node->right_child, Ax, depth + 1); } } KDTree::KDTree(std ::vector points) { - if (points.size() == 0) throw std::invalid_argument{"No Points detected"}; + if (points.empty()) throw std::invalid_argument{"No Points detected"}; cloud = std::move(points); PreparePoints(cloud); @@ -93,6 +91,6 @@ KDTree::KDTree(std ::vector points) { #pragma omp parallel { #pragma omp single nowait - split(root, axis::Ox, 0); + Split(root, Axis::Ox, 0); } } diff --git a/task_07/src/KDtree.hpp b/task_07/src/KDtree.hpp index dea43aa..4297920 100644 --- a/task_07/src/KDtree.hpp +++ b/task_07/src/KDtree.hpp @@ -9,7 +9,7 @@ struct Point { double x; double y; - Point(double xx, double yy) : x{xx}, y{yy} {} + Point(double x, double y) : x{x}, y{y} {} Point() : x{NONE}, y{NONE} {} bool operator==(const Point& other) const { @@ -38,24 +38,24 @@ class KDTree { // принадлежащих данной bounding_box [от, до] }; std::unique_ptr root; - enum class axis { + enum class Axis { Ox = 0, Oy = 1, }; - void split(std::unique_ptr& node, axis Ax = axis::Ox, int depth = 0); + void Split(std::unique_ptr& node, Axis Ax = Axis::Ox, int depth = 0); std ::pair SAH(Point left_min_point, Point right_max_point, - axis curr_axis, std::pair& range); + Axis curr_Axis, std::pair& range); std::pair FindMinimum(Point target, - std::unique_ptr& node); + std::unique_ptr& node); void PreparePoints(std::vector& points); double Distance(Point first, Point second); double DistanceToBox(Point& point, std::pair& box); bool IntoBox(Point target, std::pair box); template - auto GetAxis(const T& request, axis ax) { - if (ax == axis::Ox) + auto GetAxis(const T& request, Axis ax) { + if (ax == Axis::Ox) return request.x; else return request.y; diff --git a/task_07/src/SAH.cpp b/task_07/src/SAH.cpp index a355590..d661765 100644 --- a/task_07/src/SAH.cpp +++ b/task_07/src/SAH.cpp @@ -6,14 +6,14 @@ #include "constants.hpp" std::pair KDTree::SAH(Point left_min_point, - Point right_max_point, axis curr_axis, + Point right_max_point, Axis curr_axis, std::pair& range) { std::pair SAH_result{NONE, NONE}; - double width = GetAxis(right_max_point, curr_axis) - - GetAxis(left_min_point, curr_axis); + double width = + GetAxis(right_max_point, curr_axis) - GetAxis(left_min_point, curr_axis); double width_x = right_max_point.x - left_min_point.x; double width_y = right_max_point.y - left_min_point.y; - double width_w = curr_axis == axis::Ox ? width_y : width_x; + double width_w = curr_axis == Axis::Ox ? width_y : width_x; double SApar = width_x * width_y; if (SApar <= 0) return SAH_result; diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index c06cebc..87affd0 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -1,5 +1,4 @@ #include -#include #include "KDtree.hpp" #include "vector" @@ -13,5 +12,5 @@ int main() { KDTree tree(cloud); std ::cout << "compiled\n"; Point k = tree.NearestPoint(Point(4.8, 5.9)); - std ::cout << k.x << " " << k.y << std ::endl; + std ::cout << k.x << " " << k.y << '\n'; } diff --git a/task_08/src/HashTable.cpp b/task_08/src/HashTable.cpp index e555dfa..b58109b 100644 --- a/task_08/src/HashTable.cpp +++ b/task_08/src/HashTable.cpp @@ -3,7 +3,7 @@ #include #include -size_t HashTable::MyHash(std::string value) { +size_t HashTable::MyHash(const std::string& value) { return std::hash{}(value) * 0xdeadbeef; } @@ -16,14 +16,14 @@ void HashTable::Resize() { std::vector NewData(data.size() * 2, ZeroElem); std::vector OldData = std::move(data); data = std::move(NewData); - for (auto elem : OldData) { + for (auto& elem : OldData) { if (elem.CurrentLabel == Label::Full) { add(elem.Key, elem.Value); } } } -void HashTable::add(std::string key, int value) { +void HashTable::add(const std::string& key, int value) { int index = MyHash(key) % data.size(); int BeginingIndex = index; while ((data[index].CurrentLabel != Label::Empty) && @@ -43,7 +43,7 @@ void HashTable::add(std::string key, int value) { if (EngagedSpace > (data.size() / 2)) Resize(); } -void HashTable::remove(std::string key) { +void HashTable::remove(const std::string& key) { int index = MyHash(key) % data.size(); int BeginingIndex = index; while (data[index].Key != key) { @@ -55,7 +55,7 @@ void HashTable::remove(std::string key) { --EngagedSpace; } -int HashTable::get(std::string key) { +int HashTable::get(const std::string& key) { int index = MyHash(key) % data.size(); while ((data[index].Key != key) && (data[index].CurrentLabel != Label::Empty)) { diff --git a/task_08/src/HashTable.hpp b/task_08/src/HashTable.hpp index 719fa5f..2934db2 100644 --- a/task_08/src/HashTable.hpp +++ b/task_08/src/HashTable.hpp @@ -5,9 +5,9 @@ class HashTable { public: HashTable(); - void add(std::string key, int value); - void remove(std::string key); - int get(std::string key); + void add(const std::string& key, int value); + void remove(const std::string& key); + int get(const std::string& key); private: enum struct Label { @@ -22,7 +22,7 @@ class HashTable { }; int EngagedSpace = 0; std ::vector data; - size_t MyHash(std::string value); + size_t MyHash(const std::string& value); void Resize(); Elem ZeroElem = {Label::Empty, 0}; }; \ No newline at end of file