From fdf029e0cf8136b7db2b4b2ba1635bd789d9b6c5 Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 28 Feb 2026 09:33:07 +0000 Subject: [PATCH 01/11] task01 --- task_01/src/get_terms.hpp | 29 ++++++++++++++++++++++ task_01/src/main.cpp | 52 ++++++++++++++++++++++++++++++++++++++- task_01/src/test.cpp | 22 ++++++++++++++++- 3 files changed, 101 insertions(+), 2 deletions(-) create mode 100644 task_01/src/get_terms.hpp diff --git a/task_01/src/get_terms.hpp b/task_01/src/get_terms.hpp new file mode 100644 index 0000000..1df5c12 --- /dev/null +++ b/task_01/src/get_terms.hpp @@ -0,0 +1,29 @@ +#include +#include +#include +#include + +using namespace std; + +pair get_terms(vector v, int S) { + int N = v.size(); + + if (N == 0 || N == 1) return pair(-1, -1); + + int l{0}, r{N - 1}; + + int s; + while (l != r) { + s = v[l] + v[r]; + if (s == S) { + return pair(v[l], v[r]); + } else { + if (s > S) + --r; + else + ++l; + } + } + + if (l == r) return pair(-1, -1); +} \ No newline at end of file diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 0e4393b..3e78f87 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1,3 +1,53 @@ +#include #include +#include +#include +#include -int main() { return 0; } +using namespace std; + +int main() { + int S, N; + vector v; + string line3, line1, line2; + + getline(cin, line1); + getline(cin, line2); + getline(cin, line3); + + S = stoi(line1); + N = stoi(line2); + + istringstream is(line3); + + int x; + while (is >> x) v.push_back(x); + pair result = get_terms(v, S); + if (result == pair(-1, -1)) + cout << -1 << endl; + else + cout << result.first << " " << result.second << endl; + /* + python3 ./scripts/run_cases.py --tasks task_01 + int l{0}, r{N-1}; + + int s; + while (l != r) + { + s = v[l] + v[r]; + if (s == S) + { + cout << v[l] << " " << v[r] << endl; + break; + } + else + { + if (s > S) --r; + else ++l; + } + } + + if (l == r) cout << -1 << endl; + */ + return 0; +} diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 87cef73..36e9a91 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,5 +1,25 @@ #include +#include +#include + TEST(Test, Simple) { - ASSERT_EQ(1, 1); // Stack [] + std::vector v = {1, 2, 4}; + ASSERT_EQ(get_terms(v, 52), std::make_pair(-1, -1)); + ASSERT_EQ(get_terms(v, -52), std::make_pair(-1, -1)); + ASSERT_EQ(get_terms(v, 0), std::make_pair(-1, -1)); +} + +TEST(Test, Empty) { + std::vector v_empty = {}; + ASSERT_EQ(get_terms(v_empty, 52), std::make_pair(-1, -1)); + ASSERT_EQ(get_terms(v_empty, -52), std::make_pair(-1, -1)); + ASSERT_EQ(get_terms(v_empty, 0), std::make_pair(-1, -1)); +} + +TEST(Test, Single) { + std::vector v_single = {0}; + ASSERT_EQ(get_terms(v_single, 52), std::make_pair(-1, -1)); + ASSERT_EQ(get_terms(v_single, -52), std::make_pair(-1, -1)); + ASSERT_EQ(get_terms(v_single, 0), std::make_pair(-1, -1)); } \ No newline at end of file From 33dbbe6ef0f6fff1d5f206d6dca34dd32f7d67a5 Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 11 Apr 2026 07:52:20 +0000 Subject: [PATCH 02/11] tasks 1, 4, 7, 9 --- task_01/src/get_terms.hpp | 2 +- task_01/src/main.cpp | 19 ---- task_01/src/test.cpp | 10 ++ task_02/src/get_border_index.hpp | 22 +++++ task_02/src/main.cpp | 52 +++++++++- task_02/src/test.cpp | 31 +++++- task_03/src/get_combinations.hpp | 40 ++++++++ task_03/src/main.cpp | 14 ++- task_03/src/test.cpp | 12 ++- task_04/src/stack.cpp | 23 +++-- task_04/src/stack.hpp | 5 +- task_05/src/main.cpp | 19 +++- task_05/src/test.cpp | 30 +++++- task_05/src/topology_sort.cpp | 1 - task_05/src/topology_sort.hpp | 23 ++++- task_06/src/get_min_cost.hpp | 15 +++ task_06/src/main.cpp | 9 +- task_07/src/MergeSort.hpp | 42 ++++++++ task_07/src/main.cpp | 19 +++- task_07/src/test.cpp | 32 +++++- task_08/src/get_k_element.hpp | 28 ++++++ task_08/src/main.cpp | 21 +++- task_08/src/test.cpp | 80 ++++++++++++++- task_09/src/splay_tree.cpp | 164 +++++++++++++++++++++++++++++++ task_09/src/splay_tree.hpp | 24 +++++ 25 files changed, 690 insertions(+), 47 deletions(-) create mode 100644 task_02/src/get_border_index.hpp create mode 100644 task_03/src/get_combinations.hpp delete mode 100644 task_05/src/topology_sort.cpp create mode 100644 task_06/src/get_min_cost.hpp create mode 100644 task_07/src/MergeSort.hpp create mode 100644 task_08/src/get_k_element.hpp create mode 100644 task_09/src/splay_tree.cpp create mode 100644 task_09/src/splay_tree.hpp diff --git a/task_01/src/get_terms.hpp b/task_01/src/get_terms.hpp index 1df5c12..f55a6ee 100644 --- a/task_01/src/get_terms.hpp +++ b/task_01/src/get_terms.hpp @@ -25,5 +25,5 @@ pair get_terms(vector v, int S) { } } - if (l == r) return pair(-1, -1); + return pair(-1, -1); } \ No newline at end of file diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 3e78f87..d9302c5 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -29,25 +29,6 @@ int main() { cout << result.first << " " << result.second << endl; /* python3 ./scripts/run_cases.py --tasks task_01 - int l{0}, r{N-1}; - - int s; - while (l != r) - { - s = v[l] + v[r]; - if (s == S) - { - cout << v[l] << " " << v[r] << endl; - break; - } - else - { - if (s > S) --r; - else ++l; - } - } - - if (l == r) cout << -1 << endl; */ return 0; } diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 36e9a91..e0d92f2 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -2,12 +2,22 @@ #include #include +#include TEST(Test, Simple) { std::vector v = {1, 2, 4}; + std::vector v1 = {2, 7, 11, 15}; + std::vector v2 = {3, 7, 12}; + std::vector v3 = {-67, -42, 0, 52, 108, 252}; + std::vector v4 = {2, 4}; ASSERT_EQ(get_terms(v, 52), std::make_pair(-1, -1)); ASSERT_EQ(get_terms(v, -52), std::make_pair(-1, -1)); ASSERT_EQ(get_terms(v, 0), std::make_pair(-1, -1)); + ASSERT_EQ(get_terms(v1, 9), std::make_pair(2, 7)); + ASSERT_EQ(get_terms(v2, 19), std::make_pair(7, 12)); + ASSERT_EQ(get_terms(v3, 10), std::make_pair(-42, 52)); + ASSERT_EQ(get_terms(v3, 1), std::make_pair(-1, -1)); + ASSERT_EQ(get_terms(v4, 6), std::make_pair(2, 4)); } TEST(Test, Empty) { diff --git a/task_02/src/get_border_index.hpp b/task_02/src/get_border_index.hpp new file mode 100644 index 0000000..ea0bb0e --- /dev/null +++ b/task_02/src/get_border_index.hpp @@ -0,0 +1,22 @@ +#include + +using namespace std; + +int get_border_index(vector v) { + int N = v.size(); + + if (v[1] == 1) return 0; + if (v[N - 2] == 0) return N - 2; + + int left = 0, right = N - 1; + + while (left + 1 < right) { + int mid = (left + right) / 2; + + if (v[mid] == 1) + right = mid; + else + left = mid; + } + return left; +} \ No newline at end of file diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp index 0e4393b..d78999d 100644 --- a/task_02/src/main.cpp +++ b/task_02/src/main.cpp @@ -1,3 +1,53 @@ +#include #include +#include +#include +#include -int main() { return 0; } +using namespace std; + +int main() { + int N; + vector v; + string line1, line2; + + getline(cin, line1); + getline(cin, line2); + + N = stoi(line1); + + istringstream is(line2); + int x; + while (is >> x) v.push_back(x); + + cout << get_border_index(v) << endl; + /* + if (v[1] == 1) cout << 0 << endl; + else if (v[N-2] == 0) cout << N-2 << endl; + else + { + int i{(N-1)/2}; + while (v[i] != 0 && v[i+1] != 1) + { + if (v[i] == 0) + { + if (i+1 < v.size() && v[i+1] == 1) + { + cout << i << endl; + break; + } + i = (N-1 - i)/2; + } else + { + if (i-1 >= 0 && v[i-1] == 0) + { + cout << i-1 << endl; + break; + } + i /= 2; + } + } + }; + */ + return 0; +} diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index ee23770..01c0d20 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -1,5 +1,34 @@ #include +#include + TEST(Test, Simple) { - ASSERT_EQ(1, 1); // placeholder + vector v1{0, 1}; + vector v2{0, 0, 0, 1, 1}; + vector v3{0, 0, 0, 0, 0, 1}; + vector v4{0, 1, 1, 1, 1}; + vector v5{0, 0, 1, 1, 1, 1}; + vector v6{0, 0, 0, 1}; + vector v7{0, 0, 1}; + vector v8{0, 1, 1}; + vector v9{0, 0, 0, 0, 1, 1, 1}; + vector v10{0, 0, 0, 0, 0, 0, 0, 0, 1}; + vector v11{0, 0, 0, 0, 1}; + vector v12{0, 0, 1, 1}; + vector v13{0, 1, 1, 1}; + vector v14{0, 1, 0, 1, 0, 1, 0, 1}; + + ASSERT_EQ(get_border_index(v1), 0); + ASSERT_EQ(get_border_index(v2), 2); + ASSERT_EQ(get_border_index(v3), 4); + ASSERT_EQ(get_border_index(v4), 0); + ASSERT_EQ(get_border_index(v5), 1); + ASSERT_EQ(get_border_index(v6), 2); + ASSERT_EQ(get_border_index(v7), 1); + ASSERT_EQ(get_border_index(v8), 0); + ASSERT_EQ(get_border_index(v9), 3); + ASSERT_EQ(get_border_index(v10), 7); + ASSERT_EQ(get_border_index(v11), 3); + ASSERT_EQ(get_border_index(v12), 1); + ASSERT_EQ(get_border_index(v13), 0); } diff --git a/task_03/src/get_combinations.hpp b/task_03/src/get_combinations.hpp new file mode 100644 index 0000000..0db3b5a --- /dev/null +++ b/task_03/src/get_combinations.hpp @@ -0,0 +1,40 @@ +#include +#include + +using namespace std; + +const vector v_s{"abc", "def", "ghi", "jkl", + "mno", "pqrs", "tuv", "wxyz"}; +constexpr int shift = 2; + +void get_small_combination(vector nums, int i, string s, + vector &result) { + if (i == nums.size()) { + result.push_back(s); + return; + } + + string s_new; + for (char c : v_s[nums[i] - shift]) { + s_new = s + c; + get_small_combination(nums, i + 1, s_new, result); + } +} + +vector get_combinations(string digits) { + vector nums; + for (char c : digits) { + if (c >= '2' && c <= '9') { + nums.push_back(c - '0'); + } + } + vector result; + + if (nums.empty()) return result; + + string s; + int i = 0; + + get_small_combination(nums, i, s, result); + return result; +} \ No newline at end of file diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp index 0e4393b..f94d169 100644 --- a/task_03/src/main.cpp +++ b/task_03/src/main.cpp @@ -1,3 +1,15 @@ +#include #include +#include +#include -int main() { return 0; } +using namespace std; + +int main() { + string digits; + getline(cin, digits); + + vector result = get_combinations(digits); + + for (string str : result) cout << str << " "; +} diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index 869094d..9bda217 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -1,4 +1,14 @@ - #include +#include + +#include "get_combinations.hpp" + +using namespace std; + TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); } + +TEST(TopologySort, Single) { + ASSERT_EQ(get_combinations("2"), 1); + ASSERT_EQ(get_combinations("1"), ""); +} diff --git a/task_04/src/stack.cpp b/task_04/src/stack.cpp index 8ca8990..fd732b6 100644 --- a/task_04/src/stack.cpp +++ b/task_04/src/stack.cpp @@ -1,21 +1,26 @@ #include "stack.hpp" -#include - -void Stack::Push(int value) { data_.push(value); } +void Stack::Push(int value) { stack_.push_back(value); } int Stack::Pop() { - auto result = data_.top(); - data_.pop(); + auto result = stack_.back(); + stack_.pop_back(); return result; } -void MinStack::Push(int value) { data_.push_back(value); } +void MinStack::Push(int value) { + stack_.push_back(value); + if (min_stack_.size() == 0 || value < min_stack_.back()) + min_stack_.push_back(value); + else + min_stack_.push_back(min_stack_.back()); +} int MinStack::Pop() { - auto result = data_.back(); - data_.pop_back(); + auto result = stack_.back(); + stack_.pop_back(); + min_stack_.pop_back(); return result; } -int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); } \ No newline at end of file +int MinStack::GetMin() { return min_stack_.back(); } \ No newline at end of file diff --git a/task_04/src/stack.hpp b/task_04/src/stack.hpp index 138ec40..cbcdf7f 100644 --- a/task_04/src/stack.hpp +++ b/task_04/src/stack.hpp @@ -9,7 +9,7 @@ class Stack { int Pop(); private: - std::stack data_; + std::vector stack_; }; class MinStack { @@ -19,5 +19,6 @@ class MinStack { int GetMin(); private: - std::vector data_; + std::vector stack_; + std::vector min_stack_; }; diff --git a/task_05/src/main.cpp b/task_05/src/main.cpp index 0e4393b..5d8399e 100644 --- a/task_05/src/main.cpp +++ b/task_05/src/main.cpp @@ -1,3 +1,20 @@ #include +#include -int main() { return 0; } +#include "topology_sort.hpp" + +using namespace std; + +int main() { + int N; + cin >> N; + vector v; + + for (int i = 0; i < N; ++i) { + int n; + cin >> n; + v.push_back(n); + } + vector v2 = temperature_rise(v); + for (int t : v2) cout << t << " "; +} diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index ef5a86a..44fb6c7 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -1,8 +1,36 @@ #include +#include + #include "topology_sort.hpp" TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] + vector v1{1, 2, 3, 4, 5, 6}; + vector v01{1, 1, 1, 1, 1, 0}; + vector v2{67, 52, 42, 13, 2}; + vector v02{0, 0, 0, 0, 0}; + vector v3{52, 52, 52, 52, 52}; + vector v4{23, 24, 25, 21, 29, 22, 26, 23}; + vector v04{1, 1, 4, 2, 1, 1, 0, 0}; + vector v5{-13, -5, 10, 10, 0, -3, -2, 4, -10}; + vector v05{1, 1, 0, 0, 3, 1, 1, 0}; + + ASSERT_EQ(temperature_rise(v1), v01); // по возрастанию + ASSERT_EQ(temperature_rise(v2), v02); // по убыванию + ASSERT_EQ(temperature_rise(v3), v02); // одинаковые числа + ASSERT_EQ(temperature_rise(v4), v04); // обычный + ASSERT_EQ(temperature_rise(v5), v05); // с отрицательными числами +} + +TEST(TopologySort, Single) { + vector v{52}; + vector v0{0}; + ASSERT_EQ(temperature_rise(v), v0); +} + +TEST(TopologySort, Empty) { + vector v{}; + vector v0{}; + ASSERT_EQ(temperature_rise(v), v0); } diff --git a/task_05/src/topology_sort.cpp b/task_05/src/topology_sort.cpp deleted file mode 100644 index e53f670..0000000 --- a/task_05/src/topology_sort.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "topology_sort.hpp" diff --git a/task_05/src/topology_sort.hpp b/task_05/src/topology_sort.hpp index 6f70f09..6e8b37f 100644 --- a/task_05/src/topology_sort.hpp +++ b/task_05/src/topology_sort.hpp @@ -1 +1,22 @@ -#pragma once +#include + +using namespace std; + +vector temperature_rise(vector v1) { + vector stack, v2(v1.size(), 0); + + size_t i = 0; + while (i < v1.size()) { + if (stack.size() == 0) { + stack.push_back(i); + ++i; + } else if (v1[i] > v1[stack.back()]) { + v2[stack.back()] = i - stack.back(); + stack.pop_back(); + } else { + stack.push_back(i); + ++i; + } + } + return v2; +} \ No newline at end of file diff --git a/task_06/src/get_min_cost.hpp b/task_06/src/get_min_cost.hpp new file mode 100644 index 0000000..bd25ae2 --- /dev/null +++ b/task_06/src/get_min_cost.hpp @@ -0,0 +1,15 @@ +#include + +using namespace std; + +double get_min_cost(int K, vector fish_cost) { + vector min_costs; + int left = 0; + for (int i = 0; i < fish_cost.size(); ++i) { + if (i == 0) continue; // min_costs.push_back(fish_cost[0]); + + if (fish_cost[i] <= fish_cost[i - 1]) // min_costs.back()) + // min_costs.push_back(fish_cost[i]); + else min_costs.push_back(min_costs.back()); + } +} \ No newline at end of file diff --git a/task_06/src/main.cpp b/task_06/src/main.cpp index 0e4393b..9a0f219 100644 --- a/task_06/src/main.cpp +++ b/task_06/src/main.cpp @@ -1,3 +1,10 @@ #include +#include +#include "get_min_cost.hpp -int main() { return 0; } +using namespace std; + +int main() { + int N, K; + cin >> N >> K; +} diff --git a/task_07/src/MergeSort.hpp b/task_07/src/MergeSort.hpp new file mode 100644 index 0000000..67914d3 --- /dev/null +++ b/task_07/src/MergeSort.hpp @@ -0,0 +1,42 @@ +#include + +using namespace std; + +vector MergeSort(vector v) { + int n = v.size(); + if (n == 1 || n == 0) return v; + + vector v_sorted; + + // Деление на две части + vector v1(v.begin(), v.begin() + n / 2); + vector v2(v.begin() + n / 2, v.end()); + + vector v1_sorted = MergeSort(v1); + vector v2_sorted = MergeSort(v2); + + // Слияние + size_t ptr1 = 0, ptr2 = 0; + + while (ptr1 < v1.size() && ptr2 < v2.size()) { + if (v1_sorted[ptr1] > v2_sorted[ptr2]) { + v_sorted.push_back(v2_sorted[ptr2]); + ++ptr2; + } else { + v_sorted.push_back(v1_sorted[ptr1]); + ++ptr1; + } + } + + // Добавление оставшихся элементов + while (ptr1 < v1_sorted.size()) { + v_sorted.push_back(v1_sorted[ptr1]); + ++ptr1; + } + + while (ptr2 < v2_sorted.size()) { + v_sorted.push_back(v2_sorted[ptr2]); + ++ptr2; + } + return v_sorted; +} \ No newline at end of file diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index 0e4393b..db72c41 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -1,3 +1,20 @@ +#include #include +#include -int main() { return 0; } +using namespace std; + +int main() { + int N; + cin >> N; + vector v; + + for (int i = 0; i < N; ++i) { + int n; + cin >> n; + v.push_back(n); + } + vector v_sorted = MergeSort(v); + + for (int i = 0; i < N; ++i) cout << v_sorted[i] << " "; +} diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index 5e11617..ca94fc0 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -1,6 +1,32 @@ - #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include +#include + +TEST(MergeSort, Simple) { + vector v1{1, 2, 3, 4, 5}; + vector v2{5, 3, 1, 4, 2}; + vector v3{5, 3, -7, 4, -2, 0}; + vector v03{-7, -2, 0, 3, 4, 5}; + vector v4{1, 1, 42, 0, 42, 42, 52, 42, 67, 52, -52, -52, -52}; + vector v04{-52, -52, -52, 0, 1, 1, 42, 42, 42, 42, 52, 52, 67}; + vector v5{15000, 20, 17, 13, 10, 8, 5, 2, -1, -52}; + vector v05{-52, -1, 2, 5, 8, 10, 13, 17, 20, 15000}; + + ASSERT_EQ(MergeSort(v1), v1); // уже отсортированный + ASSERT_EQ(MergeSort(v2), v1); // нечетное количество элементов + ASSERT_EQ(MergeSort(v3), + v03); // четное количество элементов + отрицательные числа + ASSERT_EQ(MergeSort(v4), v04); // c повторяющимися числами + ASSERT_EQ(MergeSort(v5), v05); // обратный } + +TEST(MergeSort, Empty) { + std::vector v_empty = {}; + ASSERT_EQ(MergeSort(v_empty), v_empty); +} + +TEST(Test, Single) { + std::vector v_single = {52}; + ASSERT_EQ(MergeSort(v_single), v_single); +} \ No newline at end of file diff --git a/task_08/src/get_k_element.hpp b/task_08/src/get_k_element.hpp new file mode 100644 index 0000000..3b06ba8 --- /dev/null +++ b/task_08/src/get_k_element.hpp @@ -0,0 +1,28 @@ +#include +#include + +using namespace std; + +int get_k_element(vector v, int K, int left, int right) { + int pivot = right; + + for (int i = left; i < right; ++i) { + if (pivot > i) { + if (v[i] > v[pivot]) { + swap(v[i], v[pivot]); + pivot = i; + } + } else { + if (v[i] < v[pivot]) { + swap(v[i], v[pivot]); + pivot = i; + } + } + } + + if (pivot + 1 == K) return v[pivot]; + if (pivot + 1 > K) + return get_k_element(v, K, left, pivot - 1); + else + return get_k_element(v, K, pivot + 1, right); +} \ No newline at end of file diff --git a/task_08/src/main.cpp b/task_08/src/main.cpp index 0e4393b..9534489 100644 --- a/task_08/src/main.cpp +++ b/task_08/src/main.cpp @@ -1,3 +1,22 @@ #include +#include -int main() { return 0; } +#include "get_k_element.hpp" + +using namespace std; + +int main() { + int N, K; + cin >> N >> K; + + vector v; + + for (int i = 0; i < N; ++i) { + int n; + cin >> n; + v.push_back(n); + } + + int left{0}, right(N - 1); + cout << get_k_element(v, K, left, right) << endl; +} diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 5e11617..2854e00 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -1,6 +1,82 @@ - #include +#include +#include + +using namespace std; + TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] + vector v1{0, 1}; + vector v2{0, 0, 0, 1, 1}; + vector v3{0, 0, 0, 0, 0, 1}; + vector v4{0, 1, 1, 1, 1}; + vector v5{0, 0, 1, 1, 1, 1}; + + ASSERT_EQ(get_k_element(v1, 1, 0, v1.size() - 1), 0); + ASSERT_EQ(get_k_element(v2, 1, 0, v2.size() - 1), 0); + ASSERT_EQ(get_k_element(v3, 1, 0, v3.size() - 1), 0); + ASSERT_EQ(get_k_element(v4, 1, 0, v4.size() - 1), 0); + ASSERT_EQ(get_k_element(v5, 1, 0, v5.size() - 1), 0); + + ASSERT_EQ(get_k_element(v1, 2, 0, v1.size() - 1), 1); + ASSERT_EQ(get_k_element(v2, 5, 0, v2.size() - 1), 1); + ASSERT_EQ(get_k_element(v3, 6, 0, v3.size() - 1), 1); + + ASSERT_EQ(get_k_element(v2, 3, 0, v2.size() - 1), 0); + ASSERT_EQ(get_k_element(v4, 3, 0, v4.size() - 1), 1); + ASSERT_EQ(get_k_element(v5, 4, 0, v5.size() - 1), 1); +} + +TEST(Test, DifferentNumbers) { + // положительные числа + vector v1{7, 10, 4, 3, 20}; + ASSERT_EQ(get_k_element(v1, 1, 0, v1.size() - 1), 3); + ASSERT_EQ(get_k_element(v1, 3, 0, v1.size() - 1), 7); + ASSERT_EQ(get_k_element(v1, 5, 0, v1.size() - 1), 20); + + // отрицательные числа + vector v2{-5, -2, -8, -1, -3}; + ASSERT_EQ(get_k_element(v2, 1, 0, v2.size() - 1), -8); + ASSERT_EQ(get_k_element(v2, 3, 0, v2.size() - 1), -3); + ASSERT_EQ(get_k_element(v2, 5, 0, v2.size() - 1), -1); + + // положительные и отрицательные + vector v3{-10, 5, -3, 8, 0, -7, 2}; + ASSERT_EQ(get_k_element(v3, 1, 0, v3.size() - 1), -10); + ASSERT_EQ(get_k_element(v3, 4, 0, v3.size() - 1), 0); + ASSERT_EQ(get_k_element(v3, 7, 0, v3.size() - 1), 8); + + // повторяющиеся элементы + vector v4{5, 5, 5, 1, 1, 9, 9, 9, 9}; + ASSERT_EQ(get_k_element(v4, 1, 0, v4.size() - 1), 1); + ASSERT_EQ(get_k_element(v4, 3, 0, v4.size() - 1), 5); + ASSERT_EQ(get_k_element(v4, 6, 0, v4.size() - 1), 9); + ASSERT_EQ(get_k_element(v4, 9, 0, v4.size() - 1), 9); } + +TEST(Test, TooSimple) { + // один элемент + vector v1{42}; + ASSERT_EQ(get_k_element(v1, 1, 0, 0), 42); + + // два элемента + vector v2{100, 200}; + ASSERT_EQ(get_k_element(v2, 1, 0, 1), 100); + ASSERT_EQ(get_k_element(v2, 2, 0, 1), 200); + + // два одинаковых элемента + vector v3{7, 7}; + ASSERT_EQ(get_k_element(v3, 1, 0, 1), 7); + ASSERT_EQ(get_k_element(v3, 2, 0, 1), 7); + + // одинаковые + vector v4{3, 3, 3, 3, 3}; + for (int k = 1; k <= 5; k++) { + ASSERT_EQ(get_k_element(v4, k, 0, v4.size() - 1), 3); + } + + vector v5{-1, 0, -1, 0, -2}; + ASSERT_EQ(get_k_element(v5, 1, 0, v5.size() - 1), -2); + ASSERT_EQ(get_k_element(v5, 3, 0, v5.size() - 1), -1); + ASSERT_EQ(get_k_element(v5, 5, 0, v5.size() - 1), 0); +} \ No newline at end of file diff --git a/task_09/src/splay_tree.cpp b/task_09/src/splay_tree.cpp new file mode 100644 index 0000000..3563ac2 --- /dev/null +++ b/task_09/src/splay_tree.cpp @@ -0,0 +1,164 @@ +#include "splay_tree.hpp" + +#include + +void SplayTree::rotateLeft(Node* n) { + Node* m = n->right; + if (!m) return; + + Node* parent = n->parent; + n->right = m->left; + if (m->left) m->left->parent = n; + + m->left = n; + n->parent = m; + m->parent = parent; + + if (parent) { + if (parent->left == n) + parent->left = m; + else + parent->right = m; + } else + root = m; +} + +void SplayTree::rotateRight(Node* n) { + Node* m = n->left; + if (!m) return; + + Node* parent = n->parent; + n->left = m->right; + if (m->right) m->right->parent = n; + + m->right = n; + n->parent = m; + m->parent = parent; + + if (parent) { + if (parent->left == n) + parent->left = m; + else + parent->right = m; + } else + root = m; +} + +void SplayTree::Splay(Node* n) { + if (!n->parent) return; + + if (!n->parent->parent) { + if (n->parent->left == n) + rotateRight(n->parent); + else + rotateLeft(n->parent); + return; + } + if (n->parent->right == n) { + if (n->parent->parent->right == n->parent) { + rotateLeft(n->parent->parent); + rotateLeft(n->parent); + } else { + rotateLeft(n->parent); + rotateRight(n->parent); + } + } else { + if (n->parent->parent->left == n->parent) { + rotateRight(n->parent->parent); + rotateRight(n->parent); + } else { + rotateRight(n->parent); + rotateLeft(n->parent); + } + } + Splay(n); +} + +void SplayTree::Insert(int key) { + if (!root) { + root = new Node(key); + return; + } + + Node* current = root; + Node* parent = nullptr; + + while (current) { + parent = current; + if (key <= current->key) + current = current->left; + else + current = current->right; + } + + Node* new_n = new Node(key); + new_n->parent = parent; + + if (key <= parent->key) + parent->left = new_n; + else + parent->right = new_n; + + Splay(new_n); +} + +bool SplayTree::Find(int key) { + if (!root) return false; + + Node* current = root; + Node* last = nullptr; + + while (current) { + last = current; + if (key == current->key) { + Splay(current); + return true; + } else if (key < current->key) + current = current->left; + else + current = current->right; + } + if (last) Splay(last); + return false; +} + +void SplayTree::Remove(int key) { + if (Find(key)) { + Node* n = root; + + Node* left_tree = root->left; + Node* right_tree = root->right; + + if (!left_tree) { + root = right_tree; + if (right_tree) right_tree->parent = nullptr; + delete n; + return; + } + if (!right_tree) { + root = left_tree; + if (left_tree) left_tree->parent = nullptr; + delete n; + return; + } + + Node* current = right_tree; + Node* last = nullptr; + + while (current) { + last = current; + current = current->left; + } + + Splay(last); + + if (last->left) last->left->parent = nullptr; + last->left = nullptr; + + root = last; + last->left = left_tree; + left_tree->parent = last; + + delete n; + } +} \ No newline at end of file diff --git a/task_09/src/splay_tree.hpp b/task_09/src/splay_tree.hpp new file mode 100644 index 0000000..057fbc4 --- /dev/null +++ b/task_09/src/splay_tree.hpp @@ -0,0 +1,24 @@ +#pragma once + +struct Node { + Node(const int& key) + : key(key), left(nullptr), right(nullptr), parent(nullptr){}; + + Node* left; + Node* right; + Node* parent; + int key; +}; + +struct SplayTree { + Node* root{nullptr}; + + void Splay(Node* n); + void Insert(int key); // вставка ключа + bool Find(int key); // поиск ключа + void Remove(int key); // удаление ключа + + private: + void rotateRight(Node* n); + void rotateLeft(Node* n); +}; \ No newline at end of file From 373f6272b7c39cffd221c6451c6292c79960e549 Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 11 Apr 2026 08:34:49 +0000 Subject: [PATCH 03/11] task 2 --- task_02/src/test.cpp | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 01c0d20..3bfb653 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -32,3 +32,24 @@ TEST(Test, Simple) { ASSERT_EQ(get_border_index(v12), 1); ASSERT_EQ(get_border_index(v13), 0); } + +void f(int i, vector v) { + ASSERT_EQ(v[i], 0); + ASSERT_EQ(v[i] + 1, 1); +} + +TEST(Test, OutOfSync) { + vector v1{0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1}; + vector v2{0, 1, 0, 1, 0, 1, 0, 1}; + vector v3{0, 0, 0, 1, 0, 0, 0, 1}; + vector v4{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1}; + vector v5{0, 1, 0, 1}; + vector v6{0, 1, 1, 1, 1, 0, 1}; + + f(get_border_index(v1), v1); + f(get_border_index(v2), v2); + f(get_border_index(v3), v3); + f(get_border_index(v4), v4); + f(get_border_index(v5), v5); + f(get_border_index(v6), v6); +} \ No newline at end of file From 84175e7a5458bcd0895b38a15ec7a6afad190524 Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 11 Apr 2026 08:36:09 +0000 Subject: [PATCH 04/11] task_02 --- task_02/src/main.cpp | 28 ---------------------------- 1 file changed, 28 deletions(-) diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp index d78999d..7423885 100644 --- a/task_02/src/main.cpp +++ b/task_02/src/main.cpp @@ -21,33 +21,5 @@ int main() { while (is >> x) v.push_back(x); cout << get_border_index(v) << endl; - /* - if (v[1] == 1) cout << 0 << endl; - else if (v[N-2] == 0) cout << N-2 << endl; - else - { - int i{(N-1)/2}; - while (v[i] != 0 && v[i+1] != 1) - { - if (v[i] == 0) - { - if (i+1 < v.size() && v[i+1] == 1) - { - cout << i << endl; - break; - } - i = (N-1 - i)/2; - } else - { - if (i-1 >= 0 && v[i-1] == 0) - { - cout << i-1 << endl; - break; - } - i /= 2; - } - } - }; - */ return 0; } From 93284fabc8084dd85c7dae8a35d14eede8e4cc1f Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 11 Apr 2026 08:51:40 +0000 Subject: [PATCH 05/11] task_05 --- task_05/src/test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index 44fb6c7..49d869b 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -12,9 +12,9 @@ TEST(TopologySort, Simple) { vector v02{0, 0, 0, 0, 0}; vector v3{52, 52, 52, 52, 52}; vector v4{23, 24, 25, 21, 29, 22, 26, 23}; - vector v04{1, 1, 4, 2, 1, 1, 0, 0}; + vector v04{1, 1, 2, 1, 0, 1, 0, 0}; vector v5{-13, -5, 10, 10, 0, -3, -2, 4, -10}; - vector v05{1, 1, 0, 0, 3, 1, 1, 0}; + vector v05{1, 1, 0, 0, 3, 1, 1, 0, 0}; ASSERT_EQ(temperature_rise(v1), v01); // по возрастанию ASSERT_EQ(temperature_rise(v2), v02); // по убыванию From 3a3c7f8d13d56f49150c45a3ef530b19eef55a14 Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 18 Apr 2026 16:37:25 +0000 Subject: [PATCH 06/11] new tasks added --- task_01/src/get_terms.hpp | 22 ++--- task_01/src/main.cpp | 25 +++-- task_01/src/test.cpp | 28 +++--- task_02/src/get_border_index.hpp | 4 +- task_02/src/main.cpp | 10 +- task_02/src/test.cpp | 81 ++++++++-------- task_03/src/get_combinations.hpp | 34 ++++--- task_03/src/main.cpp | 10 +- task_03/src/test.cpp | 50 +++++++++- task_05/src/main.cpp | 14 ++- ...topology_sort.hpp => temperature_rise.hpp} | 7 +- task_05/src/test.cpp | 48 +++++----- task_06/src/get_min_cost.hpp | 30 +++++- task_06/src/main.cpp | 13 ++- task_06/src/test.cpp | 4 +- task_07/src/main.cpp | 2 +- task_07/src/{MergeSort.hpp => merge_sort.hpp} | 32 ++++--- task_07/src/test.cpp | 4 +- task_09/src/splay_tree.hpp | 11 ++- task_09/src/test.cpp | 96 ++++++++++++++++++- task_10/src/hash_table.cpp | 52 ++++++++++ task_10/src/hash_table.hpp | 21 ++++ task_10/src/test.cpp | 81 +++++++++++++++- task_12/src/exchange_of_coins.hpp | 25 +++++ task_12/src/main.cpp | 16 +++- task_12/src/test.cpp | 51 +++++++++- 26 files changed, 578 insertions(+), 193 deletions(-) rename task_05/src/{topology_sort.hpp => temperature_rise.hpp} (72%) rename task_07/src/{MergeSort.hpp => merge_sort.hpp} (79%) create mode 100644 task_10/src/hash_table.cpp create mode 100644 task_10/src/hash_table.hpp create mode 100644 task_12/src/exchange_of_coins.hpp diff --git a/task_01/src/get_terms.hpp b/task_01/src/get_terms.hpp index f55a6ee..959bbe6 100644 --- a/task_01/src/get_terms.hpp +++ b/task_01/src/get_terms.hpp @@ -3,27 +3,25 @@ #include #include -using namespace std; +std::pair GetTerms(const std::vector& array, int sum) { + int n = array.size(); -pair get_terms(vector v, int S) { - int N = v.size(); + if (n == 0 || n == 1) return std::pair(-1, -1); - if (N == 0 || N == 1) return pair(-1, -1); + int l{0}, r{n - 1}; - int l{0}, r{N - 1}; - - int s; + int current_sum; while (l != r) { - s = v[l] + v[r]; - if (s == S) { - return pair(v[l], v[r]); + current_sum = array[l] + array[r]; + if (current_sum == sum) { + return std::pair(array[l], array[r]); } else { - if (s > S) + if (current_sum > sum) --r; else ++l; } } - return pair(-1, -1); + return std::pair(-1, -1); } \ No newline at end of file diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index d9302c5..1216923 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -4,31 +4,28 @@ #include #include -using namespace std; +// python3 ./scripts/run_cases.py --tasks task_01 int main() { int S, N; - vector v; - string line3, line1, line2; + std::vector v; + std::string line3, line1, line2; - getline(cin, line1); - getline(cin, line2); - getline(cin, line3); + getline(std::cin, line1); + getline(std::cin, line2); + getline(std::cin, line3); S = stoi(line1); N = stoi(line2); - istringstream is(line3); + std::istringstream is(line3); int x; while (is >> x) v.push_back(x); - pair result = get_terms(v, S); - if (result == pair(-1, -1)) - cout << -1 << endl; + std::pair result = GetTerms(v, S); + if (result == std::pair(-1, -1)) + std::cout << -1 << std::endl; else - cout << result.first << " " << result.second << endl; - /* - python3 ./scripts/run_cases.py --tasks task_01 - */ + std::cout << result.first << " " << result.second << std::endl; return 0; } diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index e0d92f2..a80da52 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -10,26 +10,26 @@ TEST(Test, Simple) { std::vector v2 = {3, 7, 12}; std::vector v3 = {-67, -42, 0, 52, 108, 252}; std::vector v4 = {2, 4}; - ASSERT_EQ(get_terms(v, 52), std::make_pair(-1, -1)); - ASSERT_EQ(get_terms(v, -52), std::make_pair(-1, -1)); - ASSERT_EQ(get_terms(v, 0), std::make_pair(-1, -1)); - ASSERT_EQ(get_terms(v1, 9), std::make_pair(2, 7)); - ASSERT_EQ(get_terms(v2, 19), std::make_pair(7, 12)); - ASSERT_EQ(get_terms(v3, 10), std::make_pair(-42, 52)); - ASSERT_EQ(get_terms(v3, 1), std::make_pair(-1, -1)); - ASSERT_EQ(get_terms(v4, 6), std::make_pair(2, 4)); + ASSERT_EQ(GetTerms(v, 52), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v, -52), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v, 0), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v1, 9), std::make_pair(2, 7)); + ASSERT_EQ(GetTerms(v2, 19), std::make_pair(7, 12)); + ASSERT_EQ(GetTerms(v3, 10), std::make_pair(-42, 52)); + ASSERT_EQ(GetTerms(v3, 1), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v4, 6), std::make_pair(2, 4)); } TEST(Test, Empty) { std::vector v_empty = {}; - ASSERT_EQ(get_terms(v_empty, 52), std::make_pair(-1, -1)); - ASSERT_EQ(get_terms(v_empty, -52), std::make_pair(-1, -1)); - ASSERT_EQ(get_terms(v_empty, 0), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v_empty, 52), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v_empty, -52), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v_empty, 0), std::make_pair(-1, -1)); } TEST(Test, Single) { std::vector v_single = {0}; - ASSERT_EQ(get_terms(v_single, 52), std::make_pair(-1, -1)); - ASSERT_EQ(get_terms(v_single, -52), std::make_pair(-1, -1)); - ASSERT_EQ(get_terms(v_single, 0), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v_single, 52), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v_single, -52), std::make_pair(-1, -1)); + ASSERT_EQ(GetTerms(v_single, 0), std::make_pair(-1, -1)); } \ No newline at end of file diff --git a/task_02/src/get_border_index.hpp b/task_02/src/get_border_index.hpp index ea0bb0e..343c1d0 100644 --- a/task_02/src/get_border_index.hpp +++ b/task_02/src/get_border_index.hpp @@ -1,8 +1,6 @@ #include -using namespace std; - -int get_border_index(vector v) { +int GetBorderIndex(std::vector v) { int N = v.size(); if (v[1] == 1) return 0; diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp index 7423885..c0c3ea6 100644 --- a/task_02/src/main.cpp +++ b/task_02/src/main.cpp @@ -4,22 +4,20 @@ #include #include -using namespace std; - int main() { int N; - vector v; - string line1, line2; + std::vector v; + std::string line1, line2; getline(cin, line1); getline(cin, line2); N = stoi(line1); - istringstream is(line2); + std::istringstream is(line2); int x; while (is >> x) v.push_back(x); - cout << get_border_index(v) << endl; + std::cout << GetBorderIndex(v) << endl; return 0; } diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 3bfb653..2cf98e3 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -1,55 +1,56 @@ #include #include +#include TEST(Test, Simple) { - vector v1{0, 1}; - vector v2{0, 0, 0, 1, 1}; - vector v3{0, 0, 0, 0, 0, 1}; - vector v4{0, 1, 1, 1, 1}; - vector v5{0, 0, 1, 1, 1, 1}; - vector v6{0, 0, 0, 1}; - vector v7{0, 0, 1}; - vector v8{0, 1, 1}; - vector v9{0, 0, 0, 0, 1, 1, 1}; - vector v10{0, 0, 0, 0, 0, 0, 0, 0, 1}; - vector v11{0, 0, 0, 0, 1}; - vector v12{0, 0, 1, 1}; - vector v13{0, 1, 1, 1}; - vector v14{0, 1, 0, 1, 0, 1, 0, 1}; + std::vector v1{0, 1}; + std::vector v2{0, 0, 0, 1, 1}; + std::vector v3{0, 0, 0, 0, 0, 1}; + std::vector v4{0, 1, 1, 1, 1}; + std::vector v5{0, 0, 1, 1, 1, 1}; + std::vector v6{0, 0, 0, 1}; + std::vector v7{0, 0, 1}; + std::vector v8{0, 1, 1}; + std::vector v9{0, 0, 0, 0, 1, 1, 1}; + std::vector v10{0, 0, 0, 0, 0, 0, 0, 0, 1}; + std::vector v11{0, 0, 0, 0, 1}; + std::vector v12{0, 0, 1, 1}; + std::vector v13{0, 1, 1, 1}; + std::vector v14{0, 1, 0, 1, 0, 1, 0, 1}; - ASSERT_EQ(get_border_index(v1), 0); - ASSERT_EQ(get_border_index(v2), 2); - ASSERT_EQ(get_border_index(v3), 4); - ASSERT_EQ(get_border_index(v4), 0); - ASSERT_EQ(get_border_index(v5), 1); - ASSERT_EQ(get_border_index(v6), 2); - ASSERT_EQ(get_border_index(v7), 1); - ASSERT_EQ(get_border_index(v8), 0); - ASSERT_EQ(get_border_index(v9), 3); - ASSERT_EQ(get_border_index(v10), 7); - ASSERT_EQ(get_border_index(v11), 3); - ASSERT_EQ(get_border_index(v12), 1); - ASSERT_EQ(get_border_index(v13), 0); + ASSERT_EQ(GetBorderIndex(v1), 0); + ASSERT_EQ(GetBorderIndex(v2), 2); + ASSERT_EQ(GetBorderIndex(v3), 4); + ASSERT_EQ(GetBorderIndex(v4), 0); + ASSERT_EQ(GetBorderIndex(v5), 1); + ASSERT_EQ(GetBorderIndex(v6), 2); + ASSERT_EQ(GetBorderIndex(v7), 1); + ASSERT_EQ(GetBorderIndex(v8), 0); + ASSERT_EQ(GetBorderIndex(v9), 3); + ASSERT_EQ(GetBorderIndex(v10), 7); + ASSERT_EQ(GetBorderIndex(v11), 3); + ASSERT_EQ(GetBorderIndex(v12), 1); + ASSERT_EQ(GetBorderIndex(v13), 0); } -void f(int i, vector v) { +void CheckAnswer(int i, std::vector v) { ASSERT_EQ(v[i], 0); ASSERT_EQ(v[i] + 1, 1); } TEST(Test, OutOfSync) { - vector v1{0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1}; - vector v2{0, 1, 0, 1, 0, 1, 0, 1}; - vector v3{0, 0, 0, 1, 0, 0, 0, 1}; - vector v4{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1}; - vector v5{0, 1, 0, 1}; - vector v6{0, 1, 1, 1, 1, 0, 1}; + std::vector v1{0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1}; + std::vector v2{0, 1, 0, 1, 0, 1, 0, 1}; + std::vector v3{0, 0, 0, 1, 0, 0, 0, 1}; + std::vector v4{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1}; + std::vector v5{0, 1, 0, 1}; + std::vector v6{0, 1, 1, 1, 1, 0, 1}; - f(get_border_index(v1), v1); - f(get_border_index(v2), v2); - f(get_border_index(v3), v3); - f(get_border_index(v4), v4); - f(get_border_index(v5), v5); - f(get_border_index(v6), v6); + CheckAnswer(GetBorderIndex(v1), v1); + CheckAnswer(GetBorderIndex(v2), v2); + CheckAnswer(GetBorderIndex(v3), v3); + CheckAnswer(GetBorderIndex(v4), v4); + CheckAnswer(GetBorderIndex(v5), v5); + CheckAnswer(GetBorderIndex(v6), v6); } \ No newline at end of file diff --git a/task_03/src/get_combinations.hpp b/task_03/src/get_combinations.hpp index 0db3b5a..5da8965 100644 --- a/task_03/src/get_combinations.hpp +++ b/task_03/src/get_combinations.hpp @@ -1,40 +1,38 @@ #include #include -using namespace std; - -const vector v_s{"abc", "def", "ghi", "jkl", - "mno", "pqrs", "tuv", "wxyz"}; +const std::vector num_to_let{"abc", "def", "ghi", "jkl", + "mno", "pqrs", "tuv", "wxyz"}; constexpr int shift = 2; -void get_small_combination(vector nums, int i, string s, - vector &result) { - if (i == nums.size()) { - result.push_back(s); +void FillingArray(std::vector nums, int index, std::string combination, + std::vector &result) { + if (index == nums.size()) { + result.push_back(combination); return; } - string s_new; - for (char c : v_s[nums[i] - shift]) { - s_new = s + c; - get_small_combination(nums, i + 1, s_new, result); + std::string new_combination; + for (char c : num_to_let[nums[index] - shift]) { + new_combination = combination + c; + FillingArray(nums, index + 1, new_combination, result); } } -vector get_combinations(string digits) { - vector nums; +std::vector GetCombinations(std::string digits) { + std::vector nums; for (char c : digits) { if (c >= '2' && c <= '9') { nums.push_back(c - '0'); } } - vector result; + std::vector result; if (nums.empty()) return result; - string s; - int i = 0; + std::string combination; + int index = 0; - get_small_combination(nums, i, s, result); + FillingArray(nums, index, combination, result); return result; } \ No newline at end of file diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp index f94d169..85f536c 100644 --- a/task_03/src/main.cpp +++ b/task_03/src/main.cpp @@ -3,13 +3,11 @@ #include #include -using namespace std; - int main() { - string digits; - getline(cin, digits); + std::string digits; + getline(std::cin, digits); - vector result = get_combinations(digits); + std::vector result = GetCombinations(digits); - for (string str : result) cout << str << " "; + for (std::string str : result) std::cout << str << " "; } diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index 9bda217..477635c 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -4,11 +4,51 @@ #include "get_combinations.hpp" -using namespace std; +TEST(Test, Single) { + // Одна цифра + std::vector empty{}; + std::vector v2{"a", "b", "c"}; + std::vector v3{"d", "e", "f"}; + std::vector v4{"g", "h", "i"}; + std::vector v5{"j", "k", "l"}; + std::vector v6{"m", "n", "o"}; + std::vector v7{"p", "q", "r", "s"}; + std::vector v8{"t", "u", "v"}; + std::vector v9{"w", "x", "y", "z"}; -TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); } + ASSERT_EQ(GetCombinations("0"), empty); + ASSERT_EQ(GetCombinations("1"), empty); + ASSERT_EQ(GetCombinations("2"), v2); + ASSERT_EQ(GetCombinations("3"), v3); + ASSERT_EQ(GetCombinations("4"), v4); + ASSERT_EQ(GetCombinations("5"), v5); + ASSERT_EQ(GetCombinations("6"), v6); + ASSERT_EQ(GetCombinations("7"), v7); + ASSERT_EQ(GetCombinations("8"), v8); + ASSERT_EQ(GetCombinations("9"), v9); +} + +TEST(Test, TwoDigits) { + // Две цифры + std::vector v1{"ad", "ae", "af", "bd", "be", + "bf", "cd", "ce", "cf"}; + std::vector v2{"pw", "px", "py", "pz", "qw", "qx", "qy", "qz", + "rw", "rx", "ry", "rz", "sw", "sx", "sy", "sz"}; + ASSERT_EQ(GetCombinations("23"), v1); + ASSERT_EQ(GetCombinations("79"), v2); +} -TEST(TopologySort, Single) { - ASSERT_EQ(get_combinations("2"), 1); - ASSERT_EQ(get_combinations("1"), ""); +TEST(Test, ThreeDigits) { + // Три цифры + std::vector v1{"adg", "adh", "adi", "aeg", "aeh", "aei", "afg", + "afh", "afi", "bdg", "bdh", "bdi", "beg", "beh", + "bei", "bfg", "bfh", "bfi", "cdg", "cdh", "cdi", + "ceg", "ceh", "cei", "cfg", "cfh", "cfi"}; + ASSERT_EQ(GetCombinations("234"), v1); } + +TEST(Test, Empty) { + // Пустая строка + std::vector empty{}; + ASSERT_EQ(GetCombinations(""), empty); +} \ No newline at end of file diff --git a/task_05/src/main.cpp b/task_05/src/main.cpp index 5d8399e..b4f8de6 100644 --- a/task_05/src/main.cpp +++ b/task_05/src/main.cpp @@ -1,20 +1,18 @@ #include #include -#include "topology_sort.hpp" - -using namespace std; +#include "temperature_rise.hpp" int main() { int N; - cin >> N; - vector v; + std::cin >> N; + std::vector v; for (int i = 0; i < N; ++i) { int n; - cin >> n; + std::cin >> n; v.push_back(n); } - vector v2 = temperature_rise(v); - for (int t : v2) cout << t << " "; + std::vector v2 = TemperatureRise(v); + for (int t : v2) std::cout << t << " "; } diff --git a/task_05/src/topology_sort.hpp b/task_05/src/temperature_rise.hpp similarity index 72% rename from task_05/src/topology_sort.hpp rename to task_05/src/temperature_rise.hpp index 6e8b37f..f01cc78 100644 --- a/task_05/src/topology_sort.hpp +++ b/task_05/src/temperature_rise.hpp @@ -1,9 +1,8 @@ #include -using namespace std; - -vector temperature_rise(vector v1) { - vector stack, v2(v1.size(), 0); +std::vector TemperatureRise(std::vector v1) { + std::vector stack; + std::vector v2(v1.size(), 0); size_t i = 0; while (i < v1.size()) { diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index 49d869b..0ae6b41 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -3,34 +3,34 @@ #include -#include "topology_sort.hpp" +#include "temperature_rise.hpp" -TEST(TopologySort, Simple) { - vector v1{1, 2, 3, 4, 5, 6}; - vector v01{1, 1, 1, 1, 1, 0}; - vector v2{67, 52, 42, 13, 2}; - vector v02{0, 0, 0, 0, 0}; - vector v3{52, 52, 52, 52, 52}; - vector v4{23, 24, 25, 21, 29, 22, 26, 23}; - vector v04{1, 1, 2, 1, 0, 1, 0, 0}; - vector v5{-13, -5, 10, 10, 0, -3, -2, 4, -10}; - vector v05{1, 1, 0, 0, 3, 1, 1, 0, 0}; +TEST(Test, Simple) { + std::vector v1{1, 2, 3, 4, 5, 6}; + std::vector v01{1, 1, 1, 1, 1, 0}; + std::vector v2{67, 52, 42, 13, 2}; + std::vector v02{0, 0, 0, 0, 0}; + std::vector v3{52, 52, 52, 52, 52}; + std::vector v4{23, 24, 25, 21, 29, 22, 26, 23}; + std::vector v04{1, 1, 2, 1, 0, 1, 0, 0}; + std::vector v5{-13, -5, 10, 10, 0, -3, -2, 4, -10}; + std::vector v05{1, 1, 0, 0, 3, 1, 1, 0, 0}; - ASSERT_EQ(temperature_rise(v1), v01); // по возрастанию - ASSERT_EQ(temperature_rise(v2), v02); // по убыванию - ASSERT_EQ(temperature_rise(v3), v02); // одинаковые числа - ASSERT_EQ(temperature_rise(v4), v04); // обычный - ASSERT_EQ(temperature_rise(v5), v05); // с отрицательными числами + ASSERT_EQ(TemperatureRise(v1), v01); // по возрастанию + ASSERT_EQ(TemperatureRise(v2), v02); // по убыванию + ASSERT_EQ(TemperatureRise(v3), v02); // одинаковые числа + ASSERT_EQ(TemperatureRise(v4), v04); // обычный + ASSERT_EQ(TemperatureRise(v5), v05); // с отрицательными числами } -TEST(TopologySort, Single) { - vector v{52}; - vector v0{0}; - ASSERT_EQ(temperature_rise(v), v0); +TEST(Test, Single) { + std::vector v{52}; + std::vector v0{0}; + ASSERT_EQ(TemperatureRise(v), v0); } -TEST(TopologySort, Empty) { - vector v{}; - vector v0{}; - ASSERT_EQ(temperature_rise(v), v0); +TEST(Test, Empty) { + std::vector v{}; + std::vector v0{}; + ASSERT_EQ(TemperatureRise(v), v0); } diff --git a/task_06/src/get_min_cost.hpp b/task_06/src/get_min_cost.hpp index bd25ae2..e6faa9a 100644 --- a/task_06/src/get_min_cost.hpp +++ b/task_06/src/get_min_cost.hpp @@ -1,9 +1,30 @@ +#include +#include +#include #include -using namespace std; +double GetMinCost(int K, std::vector fish_cost) { + std::deque min_costs; + double min_sum = 0; + for (int i = 0; i < fish_cost.size(); ++i) { + if (min_costs.size() >= K) { + min_costs.pop_front(); + } + if (min_costs.empty()) { + min_costs.push_back(fish_cost[i]); + min_sum += fish_cost[i]; + continue; + } + min_costs.push_back(std::min(fish_cost[i], min_costs.back())); + min_sum += min_costs.back(); + // std::cout << min_sum << " "; + } + return min_sum; +} -double get_min_cost(int K, vector fish_cost) { - vector min_costs; +/* +double GetMinCost(int K, std::vector fish_cost) { + std::vector min_costs; int left = 0; for (int i = 0; i < fish_cost.size(); ++i) { if (i == 0) continue; // min_costs.push_back(fish_cost[0]); @@ -12,4 +33,5 @@ double get_min_cost(int K, vector fish_cost) { // min_costs.push_back(fish_cost[i]); else min_costs.push_back(min_costs.back()); } -} \ No newline at end of file +} + */ \ No newline at end of file diff --git a/task_06/src/main.cpp b/task_06/src/main.cpp index 9a0f219..2275419 100644 --- a/task_06/src/main.cpp +++ b/task_06/src/main.cpp @@ -1,10 +1,15 @@ #include #include -#include "get_min_cost.hpp -using namespace std; +#include "get_min_cost.hpp" int main() { - int N, K; - cin >> N >> K; + int n; + double K; + std::cin >> n >> K; + + std::vector costs(n); + for (int i = 0; i < n; ++i) std::cin >> costs[i]; + + std::cout << GetMinCost(K, costs) << "\n"; } diff --git a/task_06/src/test.cpp b/task_06/src/test.cpp index 5e11617..97fce0c 100644 --- a/task_06/src/test.cpp +++ b/task_06/src/test.cpp @@ -1,6 +1,8 @@ #include -TEST(TopologySort, Simple) { +#include + +TEST(Test, Simple) { ASSERT_EQ(1, 1); // Stack [] } diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index db72c41..65c08b6 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -1,5 +1,5 @@ -#include #include +#include #include using namespace std; diff --git a/task_07/src/MergeSort.hpp b/task_07/src/merge_sort.hpp similarity index 79% rename from task_07/src/MergeSort.hpp rename to task_07/src/merge_sort.hpp index 67914d3..c4e63a4 100644 --- a/task_07/src/MergeSort.hpp +++ b/task_07/src/merge_sort.hpp @@ -2,23 +2,13 @@ using namespace std; -vector MergeSort(vector v) { - int n = v.size(); - if (n == 1 || n == 0) return v; - - vector v_sorted; - - // Деление на две части - vector v1(v.begin(), v.begin() + n / 2); - vector v2(v.begin() + n / 2, v.end()); - - vector v1_sorted = MergeSort(v1); - vector v2_sorted = MergeSort(v2); - +vector MergingArrays(const std::vector& v1_sorted, + const std::vector& v2_sorted) { // Слияние + vector v_sorted; size_t ptr1 = 0, ptr2 = 0; - while (ptr1 < v1.size() && ptr2 < v2.size()) { + while (ptr1 < v1_sorted.size() && ptr2 < v2_sorted.size()) { if (v1_sorted[ptr1] > v2_sorted[ptr2]) { v_sorted.push_back(v2_sorted[ptr2]); ++ptr2; @@ -39,4 +29,18 @@ vector MergeSort(vector v) { ++ptr2; } return v_sorted; +} + +vector MergeSort(vector v) { + int n = v.size(); + if (n == 1 || n == 0) return v; + + // Деление на две части + vector v1(v.begin(), v.begin() + n / 2); + vector v2(v.begin() + n / 2, v.end()); + + vector v1_sorted = MergeSort(v1); + vector v2_sorted = MergeSort(v2); + + return MergingArrays(v1_sorted, v2_sorted); } \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index ca94fc0..158aa1c 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -1,6 +1,6 @@ #include -#include +#include #include TEST(MergeSort, Simple) { @@ -26,7 +26,7 @@ TEST(MergeSort, Empty) { ASSERT_EQ(MergeSort(v_empty), v_empty); } -TEST(Test, Single) { +TEST(MergeSort, Single) { std::vector v_single = {52}; ASSERT_EQ(MergeSort(v_single), v_single); } \ No newline at end of file diff --git a/task_09/src/splay_tree.hpp b/task_09/src/splay_tree.hpp index 057fbc4..b0cd735 100644 --- a/task_09/src/splay_tree.hpp +++ b/task_09/src/splay_tree.hpp @@ -11,14 +11,15 @@ struct Node { }; struct SplayTree { - Node* root{nullptr}; - - void Splay(Node* n); void Insert(int key); // вставка ключа bool Find(int key); // поиск ключа void Remove(int key); // удаление ключа private: - void rotateRight(Node* n); - void rotateLeft(Node* n); + Node* root{nullptr}; + + void RotateRight(Node* n); + void RotateLeft(Node* n); + + void Splay(Node* n); }; \ No newline at end of file diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp index 5e11617..7132d82 100644 --- a/task_09/src/test.cpp +++ b/task_09/src/test.cpp @@ -1,6 +1,98 @@ #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include "splay_tree.hpp" + +TEST(Test, Simple) { + SplayTree tree; + + // Поиск ключа в пустом дереве + ASSERT_EQ(tree.Find(52), false); + ASSERT_EQ(tree.Find(0), false); + ASSERT_EQ(tree.Find(-42), false); + + tree.Remove(67); + ASSERT_EQ(tree.Find(67), false); // tree [] + + tree.Insert(52); + ASSERT_EQ(tree.Find(52), true); // tree [52] + tree.Remove(52); + ASSERT_EQ(tree.Find(52), false); // tree [] + + tree.Insert(52); + tree.Insert(0); + tree.Insert(67); + tree.Insert(42); + tree.Insert(-67); + tree.Insert(69); + // tree [52, 0, 67, 42, -67, 69] + + // Значения, которые есть в дереве + ASSERT_EQ(tree.Find(52), true); + ASSERT_EQ(tree.Find(-67), true); + ASSERT_EQ(tree.Find(0), true); + ASSERT_EQ(tree.Find(67), true); + ASSERT_EQ(tree.Find(42), true); + ASSERT_EQ(tree.Find(69), true); + + // Значения, которых нет в дереве + ASSERT_EQ(tree.Find(4), false); + ASSERT_EQ(tree.Find(17), false); + ASSERT_EQ(tree.Find(-34), false); + ASSERT_EQ(tree.Find(55), false); + ASSERT_EQ(tree.Find(95), false); + ASSERT_EQ(tree.Find(-56), false); + + tree.Remove(52); + + // tree [0, 67, 42, -67, 69] + ASSERT_EQ(tree.Find(52), false); + ASSERT_EQ(tree.Find(-67), true); + ASSERT_EQ(tree.Find(0), true); + ASSERT_EQ(tree.Find(67), true); + + tree.Remove(42); + tree.Remove(-67); + tree.Remove(69); + tree.Remove(42); + tree.Remove(0); + tree.Remove(67); + + // tree [] + ASSERT_EQ(tree.Find(-67), false); + ASSERT_EQ(tree.Find(0), false); + ASSERT_EQ(tree.Find(67), false); +} + +TEST(Test, ReapitingKeys) { + SplayTree tree; + + tree.Insert(0); + tree.Insert(67); + tree.Insert(42); + tree.Insert(-67); + tree.Insert(69); + tree.Insert(8); + tree.Insert(8); + tree.Insert(8); + + // tree [0, 67, 42, -67, 69, 8, 8] + + ASSERT_EQ(tree.Find(8), true); + ASSERT_EQ(tree.Find(-67), true); + + tree.Remove(8); + + // tree [0, 67, 42, -67, 69, 8, 8] + ASSERT_EQ(tree.Find(8), true); + + tree.Remove(8); + + // tree [0, 67, 42, -67, 69, 8] + ASSERT_EQ(tree.Find(8), true); + + tree.Remove(8); + + // tree [0, 67, 42, -67, 69] + ASSERT_EQ(tree.Find(8), false); } diff --git a/task_10/src/hash_table.cpp b/task_10/src/hash_table.cpp new file mode 100644 index 0000000..8448515 --- /dev/null +++ b/task_10/src/hash_table.cpp @@ -0,0 +1,52 @@ +#include "hash_table.hpp" + +#include + +HashTable::HashTable(size_t size) : data(size) {} + +void HashTable::Insert(int key, int value) { + int hash = std::hash{}(key) % data.size(); + Node n{key, value}; + + auto& values = data[hash]; + for (auto it = values.begin(); it != values.end(); ++it) { + if (it->key == key) { + it->value = value; + return; + } + } + values.push_front(n); +} + +void HashTable::Remove(int key) { + int hash = std::hash{}(key) % data.size(); + auto& values = data[hash]; + + auto previous = values.before_begin(); + + for (auto current = values.begin(); current != values.end(); ++current) { + if (current->key == key) { + values.erase_after(previous); + return; + } + previous = current; + } +} + +std::optional HashTable::Get(int key) { + int hash = std::hash{}(key) % data.size(); + auto& values = data[hash]; + for (const auto& node : values) { + if (node.key == key) return node.value; + } + return {}; +} + +bool HashTable::Contains(int key) { + int hash = std::hash{}(key) % data.size(); + auto& values = data[hash]; + for (const auto& node : values) { + if (node.key == key) return true; + } + return false; +} \ No newline at end of file diff --git a/task_10/src/hash_table.hpp b/task_10/src/hash_table.hpp new file mode 100644 index 0000000..77d2f58 --- /dev/null +++ b/task_10/src/hash_table.hpp @@ -0,0 +1,21 @@ +#include +#include +#include + +class HashTable { + public: + HashTable(size_t size = 10); + + void Insert(int key, int value); // вставка пары ключ-значение + std::optional Get(int key); // получение значения по ключу + void Remove(int key); // удаление по ключу + bool Contains(int key); // проверка наличия ключа + + private: + struct Node { + int key; + int value; + }; + + std::vector> data; +}; diff --git a/task_10/src/test.cpp b/task_10/src/test.cpp index 5e11617..b6be342 100644 --- a/task_10/src/test.cpp +++ b/task_10/src/test.cpp @@ -1,6 +1,81 @@ - #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include "hash_table.hpp" + +TEST(Test, Simple) { + HashTable table; + + ASSERT_EQ(table.Get(52), std::nullopt); + ASSERT_EQ(table.Contains(52), false); + + table.Remove(52); + table.Insert(0, 52); + ASSERT_EQ(table.Get(0), 52); + ASSERT_EQ(table.Contains(0), true); +} + +TEST(Test, UpdateValue) { + HashTable table; + + table.Insert(1, 42); + ASSERT_EQ(table.Get(1), 42); + + table.Insert(1, 52); // обновляем значение + ASSERT_EQ(table.Get(1), 52); + ASSERT_EQ(table.Contains(1), true); } + +TEST(Test, RemoveKey) { + HashTable table; + + table.Insert(1, 67); + table.Insert(2, 200); + table.Insert(3, 0); + + ASSERT_EQ(table.Contains(2), true); + table.Remove(2); + ASSERT_EQ(table.Contains(2), false); + ASSERT_EQ(table.Get(2), std::nullopt); + + ASSERT_EQ(table.Get(1), 67); + ASSERT_EQ(table.Get(3), 0); +} + +TEST(Test, Collisions) { + HashTable table(5); // маленький размер для коллизий + + // 1 % 5 = 1, 6 % 5 = 1, 11 % 5 = 1 + table.Insert(1, 52); + table.Insert(6, 42); + table.Insert(11, 67); + + ASSERT_EQ(table.Get(1), 52); + ASSERT_EQ(table.Get(6), 42); + ASSERT_EQ(table.Get(11), 67); + ASSERT_EQ(table.Contains(1), true); + ASSERT_EQ(table.Contains(6), true); + ASSERT_EQ(table.Contains(11), true); + + table.Remove(6); + + ASSERT_EQ(table.Contains(6), false); + ASSERT_EQ(table.Get(6), std::nullopt); + ASSERT_EQ(table.Get(1), 52); + ASSERT_EQ(table.Get(11), 67); +} + +TEST(Test, NegativeKeys) { + HashTable table; + + table.Insert(-5, 42); + table.Insert(-10, 52); + + ASSERT_EQ(table.Get(-5), 42); + ASSERT_EQ(table.Get(-10), 52); + ASSERT_EQ(table.Contains(-5), true); + + table.Remove(-10); + ASSERT_EQ(table.Contains(-10), false); + ASSERT_EQ(table.Get(-10), std::nullopt); + ASSERT_EQ(table.Get(-5), 42); +} \ No newline at end of file diff --git a/task_12/src/exchange_of_coins.hpp b/task_12/src/exchange_of_coins.hpp new file mode 100644 index 0000000..9f34075 --- /dev/null +++ b/task_12/src/exchange_of_coins.hpp @@ -0,0 +1,25 @@ +#include +#include + +int MinNumberOfCoins(int sum, std::vector denominations) { + int n = denominations.size(); + + if (sum < 0) return -1; + + std::vector dp( + sum + + 1); // i-ый элемент - минимальное количество монет, нужное для суммы i + dp[0] = 0; + + for (int i = 1; i < sum + 1; ++i) { + dp[i] = 2e9; + for (int coin : denominations) { + if (coin <= 0) continue; // берем только положительные номиналы + if (i - coin >= 0) { + dp[i] = std::min(dp[i], dp[i - coin] + 1); + } + } + } + if (dp[sum] < 2e9) return dp[sum]; + return -1; +} \ No newline at end of file diff --git a/task_12/src/main.cpp b/task_12/src/main.cpp index 0e4393b..94a3e72 100644 --- a/task_12/src/main.cpp +++ b/task_12/src/main.cpp @@ -1,3 +1,17 @@ #include +#include -int main() { return 0; } +#include "exchange_of_coins.hpp" + +int main() { + int sum; + std::cin >> sum; + + int n; + std::cin >> n; + + std::vector denominations(n); + for (int i = 0; i < n; ++i) std::cin >> denominations[i]; + + std::cout << MinNumberOfCoins(sum, denominations) << "\n"; +} diff --git a/task_12/src/test.cpp b/task_12/src/test.cpp index 869094d..63f1e32 100644 --- a/task_12/src/test.cpp +++ b/task_12/src/test.cpp @@ -1,4 +1,51 @@ - #include -TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); } +#include "exchange_of_coins.hpp" + +TEST(Test, Simple) { + ASSERT_EQ(MinNumberOfCoins(15, {1, 5, 10}), 2); // 10+5 + ASSERT_EQ(MinNumberOfCoins(0, {1, 2, 3}), 0); // нулевая сумма + ASSERT_EQ(MinNumberOfCoins(7, {2, 4, 6}), -1); // нет + ASSERT_EQ(MinNumberOfCoins(30, {10, 20, 30}), 1); // 30 + ASSERT_EQ(MinNumberOfCoins(12, {1, 3, 5}), 4); // 5+5+1+1 + ASSERT_EQ(MinNumberOfCoins(100, {25, 10, 5, 1}), 4); // 25+25+25+25 + ASSERT_EQ(MinNumberOfCoins(999999, {1}), 999999); +} + +TEST(Test, SingleCoin) { + // Одна монета + ASSERT_EQ(MinNumberOfCoins(5, {5}), 1); // 5 + ASSERT_EQ(MinNumberOfCoins(10, {5}), 2); // 5+5 + ASSERT_EQ(MinNumberOfCoins(3, {5}), -1); // нет +} + +TEST(Test, NegativesAndZero) { + // С отрицательными номиналами и нулём + std::vector v = {-42, -52, 10, 10, 0, -3, -2, 4, -10}; + ASSERT_EQ(MinNumberOfCoins(20, v), 2); // 10+10 + ASSERT_EQ(MinNumberOfCoins(4, v), 1); // 4 + ASSERT_EQ(MinNumberOfCoins(3, v), -1); // нет +} + +TEST(Test, Empty) { + // Пустой вектор номиналов + std::vector empty; + ASSERT_EQ(MinNumberOfCoins(52, empty), -1); + ASSERT_EQ(MinNumberOfCoins(0, empty), 0); +} + +TEST(Test, AllSame) { + // Все номиналы одинаковые + std::vector v = {52, 52, 52, 52, 52}; + ASSERT_EQ(MinNumberOfCoins(104, v), 2); // 52+52 + ASSERT_EQ(MinNumberOfCoins(53, v), -1); // нет + ASSERT_EQ(MinNumberOfCoins(0, v), 0); +} + +TEST(Test, EdgeCases) { + // Граничные случаи + ASSERT_EQ(MinNumberOfCoins(1, {2, 3, 5}), + -1); // минимальная монета больше суммы + ASSERT_EQ(MinNumberOfCoins(1000000, {999983}), -1); + ASSERT_EQ(MinNumberOfCoins(1, {1}), 1); +} From 19ffb61349092827dea1b9aef38ed9094f7d877c Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 18 Apr 2026 16:41:06 +0000 Subject: [PATCH 07/11] fixed --- task_09/src/splay_tree.cpp | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/task_09/src/splay_tree.cpp b/task_09/src/splay_tree.cpp index 3563ac2..c7889c6 100644 --- a/task_09/src/splay_tree.cpp +++ b/task_09/src/splay_tree.cpp @@ -2,7 +2,7 @@ #include -void SplayTree::rotateLeft(Node* n) { +void SplayTree::RotateLeft(Node* n) { Node* m = n->right; if (!m) return; @@ -23,7 +23,7 @@ void SplayTree::rotateLeft(Node* n) { root = m; } -void SplayTree::rotateRight(Node* n) { +void SplayTree::RotateRight(Node* n) { Node* m = n->left; if (!m) return; @@ -49,26 +49,26 @@ void SplayTree::Splay(Node* n) { if (!n->parent->parent) { if (n->parent->left == n) - rotateRight(n->parent); + RotateRight(n->parent); else - rotateLeft(n->parent); + RotateLeft(n->parent); return; } if (n->parent->right == n) { if (n->parent->parent->right == n->parent) { - rotateLeft(n->parent->parent); - rotateLeft(n->parent); + RotateLeft(n->parent->parent); + RotateLeft(n->parent); } else { - rotateLeft(n->parent); - rotateRight(n->parent); + RotateLeft(n->parent); + RotateRight(n->parent); } } else { if (n->parent->parent->left == n->parent) { - rotateRight(n->parent->parent); - rotateRight(n->parent); + RotateRight(n->parent->parent); + RotateRight(n->parent); } else { - rotateRight(n->parent); - rotateLeft(n->parent); + RotateRight(n->parent); + RotateLeft(n->parent); } } Splay(n); From b384502c02213637538905b614e95a8386e8892b Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 2 May 2026 07:46:05 +0000 Subject: [PATCH 08/11] task13 --- task_08/src/get_k_element.hpp | 28 --------- task_08/src/main.cpp | 20 +++---- task_08/src/order_statistic.hpp | 23 ++++++++ task_08/src/test.cpp | 97 ++++++++++++++++---------------- task_11/src/main.cpp | 12 +++- task_11/src/substring_search.hpp | 23 ++++++++ task_11/src/test.cpp | 73 +++++++++++++++++++++++- task_13/src/main.cpp | 20 ++++++- task_13/src/scheduling.hpp | 30 ++++++++++ task_13/src/test.cpp | 48 +++++++++++++++- task_14/src/main.cpp | 25 +++++++- task_14/src/sorted_column.hpp | 30 ++++++++++ 12 files changed, 332 insertions(+), 97 deletions(-) delete mode 100644 task_08/src/get_k_element.hpp create mode 100644 task_08/src/order_statistic.hpp create mode 100644 task_11/src/substring_search.hpp create mode 100644 task_13/src/scheduling.hpp create mode 100644 task_14/src/sorted_column.hpp diff --git a/task_08/src/get_k_element.hpp b/task_08/src/get_k_element.hpp deleted file mode 100644 index 3b06ba8..0000000 --- a/task_08/src/get_k_element.hpp +++ /dev/null @@ -1,28 +0,0 @@ -#include -#include - -using namespace std; - -int get_k_element(vector v, int K, int left, int right) { - int pivot = right; - - for (int i = left; i < right; ++i) { - if (pivot > i) { - if (v[i] > v[pivot]) { - swap(v[i], v[pivot]); - pivot = i; - } - } else { - if (v[i] < v[pivot]) { - swap(v[i], v[pivot]); - pivot = i; - } - } - } - - if (pivot + 1 == K) return v[pivot]; - if (pivot + 1 > K) - return get_k_element(v, K, left, pivot - 1); - else - return get_k_element(v, K, pivot + 1, right); -} \ No newline at end of file diff --git a/task_08/src/main.cpp b/task_08/src/main.cpp index 9534489..588aab7 100644 --- a/task_08/src/main.cpp +++ b/task_08/src/main.cpp @@ -1,22 +1,16 @@ #include #include -#include "get_k_element.hpp" - -using namespace std; +#include "order_statistic.hpp" int main() { - int N, K; - cin >> N >> K; + int n, K; + std::cin >> n >> K; - vector v; + std::vector array(n); - for (int i = 0; i < N; ++i) { - int n; - cin >> n; - v.push_back(n); - } + for (int i = 0; i < n; ++i) std::cin >> array[i]; - int left{0}, right(N - 1); - cout << get_k_element(v, K, left, right) << endl; + int left{0}, right(n - 1); + std::cout << OrderStatistic(array, K, left, right) << "\n"; } diff --git a/task_08/src/order_statistic.hpp b/task_08/src/order_statistic.hpp new file mode 100644 index 0000000..62b5c88 --- /dev/null +++ b/task_08/src/order_statistic.hpp @@ -0,0 +1,23 @@ +#include +#include + +int OrderStatistic(std::vector array, int K, int left, int right) { + if (left >= right) return array[left]; + int pivot = right; + int border = left; + + for (int i = left; i < right; ++i) { + if (array[i] <= array[pivot]) { + std::swap(array[i], array[border]); + ++border; + } + } + std::swap(array[border], array[pivot]); + pivot = border; + + if (pivot + 1 == K) return array[pivot]; + if (pivot + 1 > K) + return OrderStatistic(array, K, left, pivot - 1); + else + return OrderStatistic(array, K, pivot + 1, right); +} \ No newline at end of file diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 2854e00..1f68b07 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -1,82 +1,81 @@ #include -#include #include -using namespace std; +#include "order_statistic.hpp" TEST(TopologySort, Simple) { - vector v1{0, 1}; - vector v2{0, 0, 0, 1, 1}; - vector v3{0, 0, 0, 0, 0, 1}; - vector v4{0, 1, 1, 1, 1}; - vector v5{0, 0, 1, 1, 1, 1}; + std::vector v1{0, 1}; + std::vector v2{0, 0, 0, 1, 1}; + std::vector v3{0, 0, 0, 0, 0, 1}; + std::vector v4{0, 1, 1, 1, 1}; + std::vector v5{0, 0, 1, 1, 1, 1}; - ASSERT_EQ(get_k_element(v1, 1, 0, v1.size() - 1), 0); - ASSERT_EQ(get_k_element(v2, 1, 0, v2.size() - 1), 0); - ASSERT_EQ(get_k_element(v3, 1, 0, v3.size() - 1), 0); - ASSERT_EQ(get_k_element(v4, 1, 0, v4.size() - 1), 0); - ASSERT_EQ(get_k_element(v5, 1, 0, v5.size() - 1), 0); + ASSERT_EQ(OrderStatistic(v1, 1, 0, v1.size() - 1), 0); + ASSERT_EQ(OrderStatistic(v2, 1, 0, v2.size() - 1), 0); + ASSERT_EQ(OrderStatistic(v3, 1, 0, v3.size() - 1), 0); + ASSERT_EQ(OrderStatistic(v4, 1, 0, v4.size() - 1), 0); + ASSERT_EQ(OrderStatistic(v5, 1, 0, v5.size() - 1), 0); - ASSERT_EQ(get_k_element(v1, 2, 0, v1.size() - 1), 1); - ASSERT_EQ(get_k_element(v2, 5, 0, v2.size() - 1), 1); - ASSERT_EQ(get_k_element(v3, 6, 0, v3.size() - 1), 1); + ASSERT_EQ(OrderStatistic(v1, 2, 0, v1.size() - 1), 1); + ASSERT_EQ(OrderStatistic(v2, 5, 0, v2.size() - 1), 1); + ASSERT_EQ(OrderStatistic(v3, 6, 0, v3.size() - 1), 1); - ASSERT_EQ(get_k_element(v2, 3, 0, v2.size() - 1), 0); - ASSERT_EQ(get_k_element(v4, 3, 0, v4.size() - 1), 1); - ASSERT_EQ(get_k_element(v5, 4, 0, v5.size() - 1), 1); + ASSERT_EQ(OrderStatistic(v2, 3, 0, v2.size() - 1), 0); + ASSERT_EQ(OrderStatistic(v4, 3, 0, v4.size() - 1), 1); + ASSERT_EQ(OrderStatistic(v5, 4, 0, v5.size() - 1), 1); } TEST(Test, DifferentNumbers) { // положительные числа - vector v1{7, 10, 4, 3, 20}; - ASSERT_EQ(get_k_element(v1, 1, 0, v1.size() - 1), 3); - ASSERT_EQ(get_k_element(v1, 3, 0, v1.size() - 1), 7); - ASSERT_EQ(get_k_element(v1, 5, 0, v1.size() - 1), 20); + std::vector v1{7, 10, 4, 3, 20}; + ASSERT_EQ(OrderStatistic(v1, 1, 0, v1.size() - 1), 3); + ASSERT_EQ(OrderStatistic(v1, 3, 0, v1.size() - 1), 7); + ASSERT_EQ(OrderStatistic(v1, 5, 0, v1.size() - 1), 20); // отрицательные числа - vector v2{-5, -2, -8, -1, -3}; - ASSERT_EQ(get_k_element(v2, 1, 0, v2.size() - 1), -8); - ASSERT_EQ(get_k_element(v2, 3, 0, v2.size() - 1), -3); - ASSERT_EQ(get_k_element(v2, 5, 0, v2.size() - 1), -1); + std::vector v2{-5, -2, -8, -1, -3}; + ASSERT_EQ(OrderStatistic(v2, 1, 0, v2.size() - 1), -8); + ASSERT_EQ(OrderStatistic(v2, 3, 0, v2.size() - 1), -3); + ASSERT_EQ(OrderStatistic(v2, 5, 0, v2.size() - 1), -1); // положительные и отрицательные - vector v3{-10, 5, -3, 8, 0, -7, 2}; - ASSERT_EQ(get_k_element(v3, 1, 0, v3.size() - 1), -10); - ASSERT_EQ(get_k_element(v3, 4, 0, v3.size() - 1), 0); - ASSERT_EQ(get_k_element(v3, 7, 0, v3.size() - 1), 8); + std::vector v3{-10, 5, -3, 8, 0, -7, 2}; + ASSERT_EQ(OrderStatistic(v3, 1, 0, v3.size() - 1), -10); + ASSERT_EQ(OrderStatistic(v3, 4, 0, v3.size() - 1), 0); + ASSERT_EQ(OrderStatistic(v3, 7, 0, v3.size() - 1), 8); // повторяющиеся элементы - vector v4{5, 5, 5, 1, 1, 9, 9, 9, 9}; - ASSERT_EQ(get_k_element(v4, 1, 0, v4.size() - 1), 1); - ASSERT_EQ(get_k_element(v4, 3, 0, v4.size() - 1), 5); - ASSERT_EQ(get_k_element(v4, 6, 0, v4.size() - 1), 9); - ASSERT_EQ(get_k_element(v4, 9, 0, v4.size() - 1), 9); + std::vector v4{5, 5, 5, 1, 1, 9, 9, 9, 9}; + ASSERT_EQ(OrderStatistic(v4, 1, 0, v4.size() - 1), 1); + ASSERT_EQ(OrderStatistic(v4, 3, 0, v4.size() - 1), 5); + ASSERT_EQ(OrderStatistic(v4, 6, 0, v4.size() - 1), 9); + ASSERT_EQ(OrderStatistic(v4, 9, 0, v4.size() - 1), 9); } TEST(Test, TooSimple) { // один элемент - vector v1{42}; - ASSERT_EQ(get_k_element(v1, 1, 0, 0), 42); + std::vector v1{42}; + ASSERT_EQ(OrderStatistic(v1, 1, 0, 0), 42); // два элемента - vector v2{100, 200}; - ASSERT_EQ(get_k_element(v2, 1, 0, 1), 100); - ASSERT_EQ(get_k_element(v2, 2, 0, 1), 200); + std::vector v2{100, 200}; + ASSERT_EQ(OrderStatistic(v2, 1, 0, 1), 100); + ASSERT_EQ(OrderStatistic(v2, 2, 0, 1), 200); // два одинаковых элемента - vector v3{7, 7}; - ASSERT_EQ(get_k_element(v3, 1, 0, 1), 7); - ASSERT_EQ(get_k_element(v3, 2, 0, 1), 7); + std::vector v3{7, 7}; + ASSERT_EQ(OrderStatistic(v3, 1, 0, 1), 7); + ASSERT_EQ(OrderStatistic(v3, 2, 0, 1), 7); // одинаковые - vector v4{3, 3, 3, 3, 3}; + std::vector v4{3, 3, 3, 3, 3}; for (int k = 1; k <= 5; k++) { - ASSERT_EQ(get_k_element(v4, k, 0, v4.size() - 1), 3); + ASSERT_EQ(OrderStatistic(v4, k, 0, v4.size() - 1), 3); } - vector v5{-1, 0, -1, 0, -2}; - ASSERT_EQ(get_k_element(v5, 1, 0, v5.size() - 1), -2); - ASSERT_EQ(get_k_element(v5, 3, 0, v5.size() - 1), -1); - ASSERT_EQ(get_k_element(v5, 5, 0, v5.size() - 1), 0); + std::vector v5{-1, 0, -1, 0, -2}; + ASSERT_EQ(OrderStatistic(v5, 1, 0, v5.size() - 1), -2); + ASSERT_EQ(OrderStatistic(v5, 3, 0, v5.size() - 1), -1); + ASSERT_EQ(OrderStatistic(v5, 5, 0, v5.size() - 1), 0); } \ No newline at end of file diff --git a/task_11/src/main.cpp b/task_11/src/main.cpp index 0e4393b..a069c96 100644 --- a/task_11/src/main.cpp +++ b/task_11/src/main.cpp @@ -1,3 +1,13 @@ #include +#include -int main() { return 0; } +#include "substring_search.hpp" + +int main() { + std::string string, substring; + + std::getline(std::cin, string); + std::getline(std::cin, substring); + + std::cout << SubstringSearch(string, substring) << "\n"; +} diff --git a/task_11/src/substring_search.hpp b/task_11/src/substring_search.hpp new file mode 100644 index 0000000..ba220fb --- /dev/null +++ b/task_11/src/substring_search.hpp @@ -0,0 +1,23 @@ +#include + +int SubstringSearch(const std::string& string, const std::string& substring) { + if (substring.size() > string.size()) return -1; + + int letters[256] = {0}; + for (char c : substring) ++letters[c]; + + int need = substring.length(); + + for (int i = 0; i < string.length(); ++i) { + --letters[string[i]]; + if (letters[string[i]] >= 0) --need; + if (letters[string[i]] < 0 && need + 1 <= substring.length()) { + ++need; + ++letters[string[i]]; + } + + if (need == 0) return i - substring.length() + 2; + } + + return -1; +} \ No newline at end of file diff --git a/task_11/src/test.cpp b/task_11/src/test.cpp index 869094d..540d26c 100644 --- a/task_11/src/test.cpp +++ b/task_11/src/test.cpp @@ -1,4 +1,73 @@ - #include -TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); } +#include "substring_search.hpp" + +TEST(Test, Simple) { + std::string S1 = "abbbc"; + std::string P1 = "abc"; + ASSERT_EQ(SubstringSearch(S1, P1), -1); + + std::string S2 = "xyzacbdef"; + std::string P2 = "abc"; + ASSERT_EQ(SubstringSearch(S2, P2), 4); + + std::string S3 = "aabbcc"; + std::string P3 = "abc"; + ASSERT_EQ(SubstringSearch(S3, P3), -1); +} + +TEST(Test, SingleCharacter) { + // Один символ + std::string S1 = "abcdef"; + std::string P1 = "d"; + ASSERT_EQ(SubstringSearch(S1, P1), 4); + + std::string S2 = "abcdef"; + std::string P2 = "z"; + ASSERT_EQ(SubstringSearch(S2, P2), -1); + + std::string S3 = "a"; + std::string P3 = "a"; + ASSERT_EQ(SubstringSearch(S3, P3), 1); +} + +TEST(Test, MultipleOccurrences) { + // Несколько вхождений + std::string S = "abcabcabc"; + std::string P = "cab"; + ASSERT_EQ(SubstringSearch(S, P), 1); +} + +TEST(Test, AllSameLetters) { + // Все буквы одинаковые + std::string S = "aaaaaa"; + std::string P1 = "aaa"; + std::string P2 = "bbb"; + ASSERT_EQ(SubstringSearch(S, P1), 1); + ASSERT_EQ(SubstringSearch(S, P2), -1); +} + +TEST(Test, End) { + // В конце + std::string S = "abcdefgh"; + std::string P = "fgh"; + ASSERT_EQ(SubstringSearch(S, P), 6); +} + +TEST(Test, Start) { + // В начале + std::string S = "jhktruopfd"; + std::string P = "trkjh"; + ASSERT_EQ(SubstringSearch(S, P), 1); +} + +TEST(Test, SubstringGreater) { + // Подстрока больше строки + std::string S1 = "abcd"; + std::string P1 = "skfdksdkf"; + ASSERT_EQ(SubstringSearch(S1, P1), -1); + + std::string S2 = "abcd"; + std::string P2 = "abcde"; + ASSERT_EQ(SubstringSearch(S2, P2), -1); +} diff --git a/task_13/src/main.cpp b/task_13/src/main.cpp index 0e4393b..34988c1 100644 --- a/task_13/src/main.cpp +++ b/task_13/src/main.cpp @@ -1,3 +1,21 @@ #include -int main() { return 0; } +#include "scheduling.hpp" + +int main() { + int n; + std::cin >> n; + + std::vector lessons(n); + for (int i = 0; i < n; ++i) { + double start, end; + std::cin >> start >> end; + lessons[i] = {start, end}; + } + + std::vector selected_lessons = GetSelectedLessons(lessons); + std::cout << selected_lessons.size() << "\n"; + + for (Lesson lesson : selected_lessons) + std::cout << lesson.start << " " << lesson.end << "\n"; +} diff --git a/task_13/src/scheduling.hpp b/task_13/src/scheduling.hpp new file mode 100644 index 0000000..0cff31d --- /dev/null +++ b/task_13/src/scheduling.hpp @@ -0,0 +1,30 @@ +#include +#include + +struct Lesson { + double start; + double end; + + // для тестов + bool operator==(const Lesson& other) const { + return start == other.start && end == other.end; + } +}; + +std::vector GetSelectedLessons(std::vector& lessons) { + if (lessons.empty()) return lessons; + + std::sort(lessons.begin(), lessons.end(), + [](const Lesson& a, const Lesson& b) { return a.end < b.end; }); + + std::vector selected_lessons; + + double last_end = -2e9; + for (int i = 0; i < lessons.size(); ++i) { + if (lessons[i].start >= last_end) { + selected_lessons.push_back(lessons[i]); + last_end = lessons[i].end; + } + } + return selected_lessons; +} \ No newline at end of file diff --git a/task_13/src/test.cpp b/task_13/src/test.cpp index 869094d..0ed5760 100644 --- a/task_13/src/test.cpp +++ b/task_13/src/test.cpp @@ -1,4 +1,48 @@ - #include -TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); } +#include "scheduling.hpp" + +TEST(Test, Simple) { + std::vector v1 = {{9, 12}, {10, 13}, {11, 14}}; + std::vector expected1 = {{9, 12}}; + ASSERT_EQ(GetSelectedLessons(v1), expected1); + + // не пересекающиеся + std::vector v2 = {{9, 10}, {10, 11}, {11, 12}}; + std::vector expected2 = {{9, 10}, {10, 11}, {11, 12}}; + ASSERT_EQ(GetSelectedLessons(v2), expected2); + + // пересекающиеся + std::vector v3 = {{9, 12}, {10, 13}, {11, 14}}; + std::vector expected3 = {{9, 12}}; + ASSERT_EQ(GetSelectedLessons(v3), expected3); + + // с вложенными интервалами + std::vector v4 = {{8, 17}, {9, 16}, {10, 15}, {11, 14}, {12, 13}}; + std::vector expected4 = {{12, 13}}; + ASSERT_EQ(GetSelectedLessons(v4), expected4); + + // вещественные числа + std::vector v5 = {{9.1, 9.5}, {9.3, 9.8}, {9.5, 10.2}, {9.8, 10}}; + std::vector expected5 = {{9.1, 9.5}, {9.8, 10}}; + ASSERT_EQ(GetSelectedLessons(v5), expected5); +} + +TEST(Test, Empty) { + std::vector v = {}; + std::vector expected = {}; + ASSERT_EQ(GetSelectedLessons(v), expected); +} + +TEST(Test, SingleLesson) { + std::vector v = {{9, 12}}; + std::vector expected = {{9, 12}}; + ASSERT_EQ(GetSelectedLessons(v), expected); +} + +TEST(Test, SameEnd) { + // Одинаковое время окончания + std::vector v = {{9, 12}, {10, 12}, {11, 12}}; + std::vector expected = {{9, 12}}; + ASSERT_EQ(GetSelectedLessons(v), expected); +} diff --git a/task_14/src/main.cpp b/task_14/src/main.cpp index c3aeba4..c6ba8bc 100644 --- a/task_14/src/main.cpp +++ b/task_14/src/main.cpp @@ -1 +1,24 @@ -int main() { return 0; } \ No newline at end of file +#include + +#include "sorted_column.hpp" + +int main() { + int n, m, k; + std::cin >> n >> m >> k; + + std::vector> table(n, std::vector(m)); + for (int i = 0; i < n; ++i) + for (int j = 0; j < m; ++j) std::cin >> table[i][j]; + + std::vector max_right_rows(n); + max_right_rows = GetNonDecreasingRanges(table); + + for (int i = 0; i < k; ++i) { + int left, right; + std::cin >> left >> right; + if (max_right_rows[left - 1] >= right - 1) + std::cout << "Yes\n"; + else + std::cout << "No\n"; + } +} \ No newline at end of file diff --git a/task_14/src/sorted_column.hpp b/task_14/src/sorted_column.hpp new file mode 100644 index 0000000..df46e4a --- /dev/null +++ b/task_14/src/sorted_column.hpp @@ -0,0 +1,30 @@ +#include + +std::vector GetNonDecreasingRanges( + const std::vector>& table) { + if (table.empty()) return std::vector{}; + int n = table.size(); + int m = table[0].size(); + + std::vector> max_right_by_columns( + n, std::vector(m, 0)); // максимальное значение + // правой строки для каждого столбца + for (int j = 0; j < m; ++j) max_right_by_columns[n - 1][j] = n - 1; + + std::vector max_right_rows( + n, 0); // i-ый элемент - максимальное значение + // правой строки из всех столбцов для i-ой строки + + for (int i = n - 2; i >= 0; --i) { + int max_in_row = i; + for (int j = 0; j < m; ++j) { + if (table[i][j] <= table[i + 1][j]) + max_right_by_columns[i][j] = max_right_by_columns[i + 1][j]; + else + max_right_by_columns[i][j] = i; + max_in_row = std::max(max_in_row, max_right_by_columns[i][j]); + } + max_right_rows[i] = max_in_row; + } + return max_right_rows; +} \ No newline at end of file From 15184b2d9fad326be663fef3e2b5ad04a6540248 Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 2 May 2026 08:08:14 +0000 Subject: [PATCH 09/11] . --- task_08/src/test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 1f68b07..65875e2 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -4,7 +4,7 @@ #include "order_statistic.hpp" -TEST(TopologySort, Simple) { +TEST(Test, Simple) { std::vector v1{0, 1}; std::vector v2{0, 0, 0, 1, 1}; std::vector v3{0, 0, 0, 0, 0, 1}; From e7c777ef3e54c46251769a15ef5bb1a796c16402 Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Sat, 2 May 2026 09:19:10 +0000 Subject: [PATCH 10/11] task14 --- task_08/tests/err.in | 2 + task_08/tests/err.out | 1 + task_14/src/main.cpp | 8 +- ...d_column.hpp => non_decreasing_ranges.hpp} | 10 ++ task_14/src/test.cpp | 105 +++++++++++++++--- 5 files changed, 103 insertions(+), 23 deletions(-) create mode 100644 task_08/tests/err.in create mode 100644 task_08/tests/err.out rename task_14/src/{sorted_column.hpp => non_decreasing_ranges.hpp} (79%) diff --git a/task_08/tests/err.in b/task_08/tests/err.in new file mode 100644 index 0000000..e6dda23 --- /dev/null +++ b/task_08/tests/err.in @@ -0,0 +1,2 @@ +4 2 +2 3 -5 -4 \ No newline at end of file diff --git a/task_08/tests/err.out b/task_08/tests/err.out new file mode 100644 index 0000000..03d0e45 --- /dev/null +++ b/task_08/tests/err.out @@ -0,0 +1 @@ +-4 \ No newline at end of file diff --git a/task_14/src/main.cpp b/task_14/src/main.cpp index c6ba8bc..e8e7c50 100644 --- a/task_14/src/main.cpp +++ b/task_14/src/main.cpp @@ -1,6 +1,6 @@ #include -#include "sorted_column.hpp" +#include "non_decreasing_ranges.hpp" int main() { int n, m, k; @@ -16,9 +16,7 @@ int main() { for (int i = 0; i < k; ++i) { int left, right; std::cin >> left >> right; - if (max_right_rows[left - 1] >= right - 1) - std::cout << "Yes\n"; - else - std::cout << "No\n"; + std::cout << IsThereNonDecreasingColumn(left, right, max_right_rows) + << "\n"; } } \ No newline at end of file diff --git a/task_14/src/sorted_column.hpp b/task_14/src/non_decreasing_ranges.hpp similarity index 79% rename from task_14/src/sorted_column.hpp rename to task_14/src/non_decreasing_ranges.hpp index df46e4a..3839d4f 100644 --- a/task_14/src/sorted_column.hpp +++ b/task_14/src/non_decreasing_ranges.hpp @@ -1,3 +1,4 @@ +#include #include std::vector GetNonDecreasingRanges( @@ -27,4 +28,13 @@ std::vector GetNonDecreasingRanges( max_right_rows[i] = max_in_row; } return max_right_rows; +} + +std::string IsThereNonDecreasingColumn(int left, int right, + const std::vector& max_right_rows) { + if (max_right_rows.empty()) return "No"; + if (max_right_rows[left - 1] >= right - 1) + return "Yes"; + else + return "No"; } \ No newline at end of file diff --git a/task_14/src/test.cpp b/task_14/src/test.cpp index a42caa4..b53950a 100644 --- a/task_14/src/test.cpp +++ b/task_14/src/test.cpp @@ -1,23 +1,92 @@ #include -#include - -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"})); +#include "non_decreasing_ranges.hpp" + +TEST(CanReachNonDecreasingSegment, Simple) { + std::vector answers = {"Yes", "No", "Yes", "Yes", "Yes", "No"}; + std::vector> ranges = {{1, 1}, {2, 5}, {4, 5}, + {3, 5}, {1, 3}, {1, 5}}; + 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 max_right_rows = GetNonDecreasingRanges(table); + for (int i = 0; i < answers.size(); ++i) { + ASSERT_EQ(IsThereNonDecreasingColumn(ranges[i].first, ranges[i].second, + max_right_rows), + answers[i]); + } +} + +TEST(CanReachNonDecreasingSegment, OneRow) { + std::vector answers = {"Yes"}; + std::vector> ranges = {{1, 1}}; + std::vector> table = {{1, 1}}; + + std::vector max_right_rows = GetNonDecreasingRanges(table); + for (int i = 0; i < answers.size(); ++i) { + ASSERT_EQ(IsThereNonDecreasingColumn(ranges[i].first, ranges[i].second, + max_right_rows), + answers[i]); + } +} + +TEST(CanReachNonDecreasingSegment, EmptyTable) { + std::vector answers = {"No", "No"}; + std::vector> ranges = {{52, 67}, {4, 2}}; + std::vector> table = {{}}; + + std::vector max_right_rows = GetNonDecreasingRanges(table); + for (int i = 0; i < answers.size(); ++i) { + ASSERT_EQ(IsThereNonDecreasingColumn(ranges[i].first, ranges[i].second, + max_right_rows), + answers[i]); + } } -TEST(CanReachNonDecreasingSegment, 2) { - // ASSERT_EQ(SolveFunction(1, 1, 1, std::vector>{{1, 1}}, - // std::vector>{{1, 1}}), - // (std::vector{"Yes"})); +TEST(CanReachNonDecreasingSegment, NegativeNumbers) { + std::vector answers = {"Yes", "No", "Yes", "No", "Yes", "Yes"}; + std::vector> ranges = {{1, 1}, {2, 4}, {3, 4}, + {1, 4}, {1, 3}, {1, 2}}; + std::vector> table = { + {1, 2, 3, 0}, + {-3, 6, 3, 2}, + {4, 5, 52, 3}, + {0, 5, 3, 2}, + }; + + std::vector max_right_rows = GetNonDecreasingRanges(table); + for (int i = 0; i < answers.size(); ++i) { + ASSERT_EQ(IsThereNonDecreasingColumn(ranges[i].first, ranges[i].second, + max_right_rows), + answers[i]); + } +} + +TEST(CanReachNonDecreasingSegment, AllSame) { + std::vector answers = {"Yes", "Yes", "Yes", "Yes", "Yes", "Yes"}; + std::vector> ranges = {{1, 1}, {2, 5}, {4, 5}, + {3, 5}, {1, 3}, {1, 5}}; + std::vector> table = { + {5, 5, 5, 5}, {5, 5, 5, 5}, {5, 5, 5, 5}, {5, 5, 5, 5}, {5, 5, 5, 5}}; + + std::vector max_right_rows = GetNonDecreasingRanges(table); + for (int i = 0; i < answers.size(); ++i) { + ASSERT_EQ(IsThereNonDecreasingColumn(ranges[i].first, ranges[i].second, + max_right_rows), + answers[i]); + } +} + +TEST(CanReachNonDecreasingSegment, OneColumn) { + std::vector answers = {"Yes", "Yes", "No", "No", "No", "No"}; + std::vector> ranges = {{1, 1}, {2, 3}, {4, 5}, + {3, 5}, {1, 3}, {1, 5}}; + std::vector> table = {{5}, {2}, {4}, {4}, {0}}; + + std::vector max_right_rows = GetNonDecreasingRanges(table); + for (int i = 0; i < answers.size(); ++i) { + ASSERT_EQ(IsThereNonDecreasingColumn(ranges[i].first, ranges[i].second, + max_right_rows), + answers[i]); + } } From 58e6850bd62b9f7f6a0cb56f1729a5c7715185a5 Mon Sep 17 00:00:00 2001 From: melanikot-mipt Date: Fri, 15 May 2026 13:18:57 +0000 Subject: [PATCH 11/11] task_06 added --- task_02/src/get_border_index.hpp | 9 +-- task_02/src/main.cpp | 6 +- task_03/src/test.cpp | 55 ++++++++-------- task_04/src/stack.cpp | 2 +- task_06/src/get_min_cost.hpp | 43 ++++-------- task_06/src/test.cpp | 68 ++++++++++++++++++- task_07/src/main.cpp | 12 ++-- task_07/src/merge_sort.hpp | 18 +++--- task_07/src/test.cpp | 16 ++--- task_08/src/order_statistic.hpp | 1 - task_09/src/splay_tree.cpp | 108 +++++++++++++++---------------- task_11/src/main.cpp | 6 +- task_13/src/scheduling.hpp | 6 +- 13 files changed, 194 insertions(+), 156 deletions(-) diff --git a/task_02/src/get_border_index.hpp b/task_02/src/get_border_index.hpp index 343c1d0..6a9c418 100644 --- a/task_02/src/get_border_index.hpp +++ b/task_02/src/get_border_index.hpp @@ -1,12 +1,7 @@ #include -int GetBorderIndex(std::vector v) { - int N = v.size(); - - if (v[1] == 1) return 0; - if (v[N - 2] == 0) return N - 2; - - int left = 0, right = N - 1; +int GetBorderIndex(const std::vector &v) { + int left = 0, right = v.size() - 1; while (left + 1 < right) { int mid = (left + right) / 2; diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp index c0c3ea6..88d59c5 100644 --- a/task_02/src/main.cpp +++ b/task_02/src/main.cpp @@ -9,8 +9,8 @@ int main() { std::vector v; std::string line1, line2; - getline(cin, line1); - getline(cin, line2); + getline(std::cin, line1); + getline(std::cin, line2); N = stoi(line1); @@ -18,6 +18,6 @@ int main() { int x; while (is >> x) v.push_back(x); - std::cout << GetBorderIndex(v) << endl; + std::cout << GetBorderIndex(v) << std::endl; return 0; } diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index 477635c..002a58c 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -7,44 +7,45 @@ TEST(Test, Single) { // Одна цифра std::vector empty{}; - std::vector v2{"a", "b", "c"}; - std::vector v3{"d", "e", "f"}; - std::vector v4{"g", "h", "i"}; - std::vector v5{"j", "k", "l"}; - std::vector v6{"m", "n", "o"}; - std::vector v7{"p", "q", "r", "s"}; - std::vector v8{"t", "u", "v"}; - std::vector v9{"w", "x", "y", "z"}; + std::vector expected2{"a", "b", "c"}; + std::vector expected3{"d", "e", "f"}; + std::vector expected4{"g", "h", "i"}; + std::vector expected5{"j", "k", "l"}; + std::vector expected6{"m", "n", "o"}; + std::vector expected7{"p", "q", "r", "s"}; + std::vector expected8{"t", "u", "v"}; + std::vector expected9{"w", "x", "y", "z"}; ASSERT_EQ(GetCombinations("0"), empty); ASSERT_EQ(GetCombinations("1"), empty); - ASSERT_EQ(GetCombinations("2"), v2); - ASSERT_EQ(GetCombinations("3"), v3); - ASSERT_EQ(GetCombinations("4"), v4); - ASSERT_EQ(GetCombinations("5"), v5); - ASSERT_EQ(GetCombinations("6"), v6); - ASSERT_EQ(GetCombinations("7"), v7); - ASSERT_EQ(GetCombinations("8"), v8); - ASSERT_EQ(GetCombinations("9"), v9); + ASSERT_EQ(GetCombinations("2"), expected2); + ASSERT_EQ(GetCombinations("3"), expected3); + ASSERT_EQ(GetCombinations("4"), expected4); + ASSERT_EQ(GetCombinations("5"), expected5); + ASSERT_EQ(GetCombinations("6"), expected6); + ASSERT_EQ(GetCombinations("7"), expected7); + ASSERT_EQ(GetCombinations("8"), expected8); + ASSERT_EQ(GetCombinations("9"), expected9); } TEST(Test, TwoDigits) { // Две цифры - std::vector v1{"ad", "ae", "af", "bd", "be", - "bf", "cd", "ce", "cf"}; - std::vector v2{"pw", "px", "py", "pz", "qw", "qx", "qy", "qz", - "rw", "rx", "ry", "rz", "sw", "sx", "sy", "sz"}; - ASSERT_EQ(GetCombinations("23"), v1); - ASSERT_EQ(GetCombinations("79"), v2); + std::vector expected1{"ad", "ae", "af", "bd", "be", + "bf", "cd", "ce", "cf"}; + std::vector expected2{"pw", "px", "py", "pz", "qw", "qx", + "qy", "qz", "rw", "rx", "ry", "rz", + "sw", "sx", "sy", "sz"}; + ASSERT_EQ(GetCombinations("23"), expected1); + ASSERT_EQ(GetCombinations("79"), expected2); } TEST(Test, ThreeDigits) { // Три цифры - std::vector v1{"adg", "adh", "adi", "aeg", "aeh", "aei", "afg", - "afh", "afi", "bdg", "bdh", "bdi", "beg", "beh", - "bei", "bfg", "bfh", "bfi", "cdg", "cdh", "cdi", - "ceg", "ceh", "cei", "cfg", "cfh", "cfi"}; - ASSERT_EQ(GetCombinations("234"), v1); + std::vector expected{ + "adg", "adh", "adi", "aeg", "aeh", "aei", "afg", "afh", "afi", + "bdg", "bdh", "bdi", "beg", "beh", "bei", "bfg", "bfh", "bfi", + "cdg", "cdh", "cdi", "ceg", "ceh", "cei", "cfg", "cfh", "cfi"}; + ASSERT_EQ(GetCombinations("234"), expected); } TEST(Test, Empty) { diff --git a/task_04/src/stack.cpp b/task_04/src/stack.cpp index fd732b6..0d99bcf 100644 --- a/task_04/src/stack.cpp +++ b/task_04/src/stack.cpp @@ -10,7 +10,7 @@ int Stack::Pop() { void MinStack::Push(int value) { stack_.push_back(value); - if (min_stack_.size() == 0 || value < min_stack_.back()) + if (min_stack_.empty() || value < min_stack_.back()) min_stack_.push_back(value); else min_stack_.push_back(min_stack_.back()); diff --git a/task_06/src/get_min_cost.hpp b/task_06/src/get_min_cost.hpp index e6faa9a..e6a9aaa 100644 --- a/task_06/src/get_min_cost.hpp +++ b/task_06/src/get_min_cost.hpp @@ -1,37 +1,22 @@ -#include #include -#include #include double GetMinCost(int K, std::vector fish_cost) { - std::deque min_costs; - double min_sum = 0; - for (int i = 0; i < fish_cost.size(); ++i) { - if (min_costs.size() >= K) { - min_costs.pop_front(); - } - if (min_costs.empty()) { - min_costs.push_back(fish_cost[i]); - min_sum += fish_cost[i]; - continue; - } - min_costs.push_back(std::min(fish_cost[i], min_costs.back())); - min_sum += min_costs.back(); - // std::cout << min_sum << " "; - } - return min_sum; -} + double sum = 0.0; + std::deque rising_costs; // индексы с возрастающими ценами -/* -double GetMinCost(int K, std::vector fish_cost) { - std::vector min_costs; - int left = 0; for (int i = 0; i < fish_cost.size(); ++i) { - if (i == 0) continue; // min_costs.push_back(fish_cost[0]); + if (!rising_costs.empty() && rising_costs.front() < i - K + 1) + rising_costs.pop_front(); + + while (!rising_costs.empty() && + fish_cost[rising_costs.back()] > fish_cost[i]) { + rising_costs.pop_back(); + } + rising_costs.push_back(i); - if (fish_cost[i] <= fish_cost[i - 1]) // min_costs.back()) - // min_costs.push_back(fish_cost[i]); - else min_costs.push_back(min_costs.back()); + sum += fish_cost[rising_costs.front()]; } -} - */ \ No newline at end of file + + return sum; +} \ No newline at end of file diff --git a/task_06/src/test.cpp b/task_06/src/test.cpp index 97fce0c..e8c3374 100644 --- a/task_06/src/test.cpp +++ b/task_06/src/test.cpp @@ -1,8 +1,72 @@ - #include #include TEST(Test, Simple) { - ASSERT_EQ(1, 1); // Stack [] + std::vector v1{2, 8, 1, 5}; + ASSERT_DOUBLE_EQ(GetMinCost(3, v1), 6); + + std::vector v2{5, 5, 5, 2, 2, 2}; + ASSERT_DOUBLE_EQ(GetMinCost(3, v2), 21); + + std::vector v3{2, 4, 6, 8, 10, 8, 6, 4, 2}; + ASSERT_DOUBLE_EQ(GetMinCost(3, v3), 36); // 2+2+2+4+6+6+8+4+2 +} + +TEST(Test, SingleDay) { + std::vector v1{5}; + ASSERT_DOUBLE_EQ(GetMinCost(1, v1), 5.0); +} + +TEST(Test, TwoDays) { + std::vector v1{5, 3}; + ASSERT_DOUBLE_EQ(GetMinCost(1, v1), 8.0); // 5+3 + ASSERT_DOUBLE_EQ(GetMinCost(2, v1), 8.0); // 5+3 +} +TEST(Test, ThreeDays) { + std::vector v1{5, 3, 4}; + ASSERT_DOUBLE_EQ(GetMinCost(1, v1), 12.0); // 5+3+4 + ASSERT_DOUBLE_EQ(GetMinCost(2, v1), 11.0); // 5+3+3 + ASSERT_DOUBLE_EQ(GetMinCost(3, v1), 11.0); // 5+3+3 +} + +TEST(Test, IncreasingPrices) { + std::vector v1{1, 2, 3, 4, 5}; + ASSERT_DOUBLE_EQ(GetMinCost(2, v1), 11.0); // 1 + 1 + 2 + 3 + 4 +} + +TEST(Test, DecreasingPrices) { + std::vector v1{5, 4, 3, 2, 1}; + ASSERT_DOUBLE_EQ(GetMinCost(2, v1), 15.0); } + +TEST(Test, AllSamePrices) { + std::vector v1{3, 3, 3, 3}; + ASSERT_DOUBLE_EQ(GetMinCost(2, v1), 12.0); // 3+3+3+3 +} + +TEST(Test, KBiggerN) { + std::vector v1{10, 5, 7}; + ASSERT_DOUBLE_EQ(GetMinCost(5, v1), 20); // 10+5+5 +} + +TEST(Test, KEqualsN) { + std::vector v1{8, 3, 6, 2, 9}; + ASSERT_DOUBLE_EQ(GetMinCost(5, v1), 18.0); // 8+3+3+2+2 +} + +TEST(Test, KEquals1) { + std::vector v1{4, 1, 3, 2, 5}; + ASSERT_DOUBLE_EQ(GetMinCost(1, v1), 15.0); // 4+1+3+2+5 +} + +TEST(Test, FloatingPrices) { + std::vector v1{2.5, 1.8, 3.2, 2.1}; + ASSERT_DOUBLE_EQ(GetMinCost(2, v1), 8.2); // 2.5 + 1.8 + 1.8 + 2.1 + ASSERT_DOUBLE_EQ(GetMinCost(3, v1), 7.9); // 2.5 + 1.8 + 1.8 + 1.8 +} + +TEST(Test, LargeK) { + std::vector v1{100, 1, 100, 1, 100}; + ASSERT_DOUBLE_EQ(GetMinCost(100, v1), 104); // 100+1+1+1+1 +} \ No newline at end of file diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index 65c08b6..73cfec8 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -2,19 +2,17 @@ #include #include -using namespace std; - int main() { int N; - cin >> N; - vector v; + std::cin >> N; + std::vector v; for (int i = 0; i < N; ++i) { int n; - cin >> n; + std::cin >> n; v.push_back(n); } - vector v_sorted = MergeSort(v); + std::vector v_sorted = MergeSort(v); - for (int i = 0; i < N; ++i) cout << v_sorted[i] << " "; + for (int i = 0; i < N; ++i) std::cout << v_sorted[i] << " "; } diff --git a/task_07/src/merge_sort.hpp b/task_07/src/merge_sort.hpp index c4e63a4..8780709 100644 --- a/task_07/src/merge_sort.hpp +++ b/task_07/src/merge_sort.hpp @@ -1,11 +1,9 @@ #include -using namespace std; - -vector MergingArrays(const std::vector& v1_sorted, - const std::vector& v2_sorted) { +std::vector MergingArrays(const std::vector& v1_sorted, + const std::vector& v2_sorted) { // Слияние - vector v_sorted; + std::vector v_sorted; size_t ptr1 = 0, ptr2 = 0; while (ptr1 < v1_sorted.size() && ptr2 < v2_sorted.size()) { @@ -31,16 +29,16 @@ vector MergingArrays(const std::vector& v1_sorted, return v_sorted; } -vector MergeSort(vector v) { +std::vector MergeSort(std::vector v) { int n = v.size(); if (n == 1 || n == 0) return v; // Деление на две части - vector v1(v.begin(), v.begin() + n / 2); - vector v2(v.begin() + n / 2, v.end()); + std::vector v1(v.begin(), v.begin() + n / 2); + std::vector v2(v.begin() + n / 2, v.end()); - vector v1_sorted = MergeSort(v1); - vector v2_sorted = MergeSort(v2); + std::vector v1_sorted = MergeSort(v1); + std::vector v2_sorted = MergeSort(v2); return MergingArrays(v1_sorted, v2_sorted); } \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index 158aa1c..2564a11 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -4,14 +4,14 @@ #include TEST(MergeSort, Simple) { - vector v1{1, 2, 3, 4, 5}; - vector v2{5, 3, 1, 4, 2}; - vector v3{5, 3, -7, 4, -2, 0}; - vector v03{-7, -2, 0, 3, 4, 5}; - vector v4{1, 1, 42, 0, 42, 42, 52, 42, 67, 52, -52, -52, -52}; - vector v04{-52, -52, -52, 0, 1, 1, 42, 42, 42, 42, 52, 52, 67}; - vector v5{15000, 20, 17, 13, 10, 8, 5, 2, -1, -52}; - vector v05{-52, -1, 2, 5, 8, 10, 13, 17, 20, 15000}; + std::vector v1{1, 2, 3, 4, 5}; + std::vector v2{5, 3, 1, 4, 2}; + std::vector v3{5, 3, -7, 4, -2, 0}; + std::vector v03{-7, -2, 0, 3, 4, 5}; + std::vector v4{1, 1, 42, 0, 42, 42, 52, 42, 67, 52, -52, -52, -52}; + std::vector v04{-52, -52, -52, 0, 1, 1, 42, 42, 42, 42, 52, 52, 67}; + std::vector v5{15000, 20, 17, 13, 10, 8, 5, 2, -1, -52}; + std::vector v05{-52, -1, 2, 5, 8, 10, 13, 17, 20, 15000}; ASSERT_EQ(MergeSort(v1), v1); // уже отсортированный ASSERT_EQ(MergeSort(v2), v1); // нечетное количество элементов diff --git a/task_08/src/order_statistic.hpp b/task_08/src/order_statistic.hpp index 62b5c88..ec56c77 100644 --- a/task_08/src/order_statistic.hpp +++ b/task_08/src/order_statistic.hpp @@ -1,4 +1,3 @@ -#include #include int OrderStatistic(std::vector array, int K, int left, int right) { diff --git a/task_09/src/splay_tree.cpp b/task_09/src/splay_tree.cpp index c7889c6..3b4de72 100644 --- a/task_09/src/splay_tree.cpp +++ b/task_09/src/splay_tree.cpp @@ -1,77 +1,75 @@ #include "splay_tree.hpp" -#include +void SplayTree::RotateLeft(Node* node) { + Node* node_right = node->right; + if (!node_right) return; -void SplayTree::RotateLeft(Node* n) { - Node* m = n->right; - if (!m) return; + Node* parent = node->parent; + node->right = node_right->left; + if (node_right->left) node_right->left->parent = node; - Node* parent = n->parent; - n->right = m->left; - if (m->left) m->left->parent = n; - - m->left = n; - n->parent = m; - m->parent = parent; + node_right->left = node; + node->parent = node_right; + node_right->parent = parent; if (parent) { - if (parent->left == n) - parent->left = m; + if (parent->left == node) + parent->left = node_right; else - parent->right = m; + parent->right = node_right; } else - root = m; + root = node_right; } -void SplayTree::RotateRight(Node* n) { - Node* m = n->left; - if (!m) return; +void SplayTree::RotateRight(Node* node) { + Node* node_left = node->left; + if (!node_left) return; - Node* parent = n->parent; - n->left = m->right; - if (m->right) m->right->parent = n; + Node* parent = node->parent; + node->left = node_left->right; + if (node_left->right) node_left->right->parent = node; - m->right = n; - n->parent = m; - m->parent = parent; + node_left->right = node; + node->parent = node_left; + node_left->parent = parent; if (parent) { - if (parent->left == n) - parent->left = m; + if (parent->left == node) + parent->left = node_left; else - parent->right = m; + parent->right = node_left; } else - root = m; + root = node_left; } -void SplayTree::Splay(Node* n) { - if (!n->parent) return; +void SplayTree::Splay(Node* node) { + if (!node->parent) return; - if (!n->parent->parent) { - if (n->parent->left == n) - RotateRight(n->parent); + if (!node->parent->parent) { + if (node->parent->left == node) + RotateRight(node->parent); else - RotateLeft(n->parent); + RotateLeft(node->parent); return; } - if (n->parent->right == n) { - if (n->parent->parent->right == n->parent) { - RotateLeft(n->parent->parent); - RotateLeft(n->parent); + if (node->parent->right == node) { + if (node->parent->parent->right == node->parent) { + RotateLeft(node->parent->parent); + RotateLeft(node->parent); } else { - RotateLeft(n->parent); - RotateRight(n->parent); + RotateLeft(node->parent); + RotateRight(node->parent); } } else { - if (n->parent->parent->left == n->parent) { - RotateRight(n->parent->parent); - RotateRight(n->parent); + if (node->parent->parent->left == node->parent) { + RotateRight(node->parent->parent); + RotateRight(node->parent); } else { - RotateRight(n->parent); - RotateLeft(n->parent); + RotateRight(node->parent); + RotateLeft(node->parent); } } - Splay(n); + Splay(node); } void SplayTree::Insert(int key) { @@ -91,15 +89,15 @@ void SplayTree::Insert(int key) { current = current->right; } - Node* new_n = new Node(key); - new_n->parent = parent; + Node* new_node = new Node(key); + new_node->parent = parent; if (key <= parent->key) - parent->left = new_n; + parent->left = new_node; else - parent->right = new_n; + parent->right = new_node; - Splay(new_n); + Splay(new_node); } bool SplayTree::Find(int key) { @@ -124,7 +122,7 @@ bool SplayTree::Find(int key) { void SplayTree::Remove(int key) { if (Find(key)) { - Node* n = root; + Node* node = root; Node* left_tree = root->left; Node* right_tree = root->right; @@ -132,13 +130,13 @@ void SplayTree::Remove(int key) { if (!left_tree) { root = right_tree; if (right_tree) right_tree->parent = nullptr; - delete n; + delete node; return; } if (!right_tree) { root = left_tree; if (left_tree) left_tree->parent = nullptr; - delete n; + delete node; return; } @@ -159,6 +157,6 @@ void SplayTree::Remove(int key) { last->left = left_tree; left_tree->parent = last; - delete n; + delete node; } } \ No newline at end of file diff --git a/task_11/src/main.cpp b/task_11/src/main.cpp index a069c96..6f65f30 100644 --- a/task_11/src/main.cpp +++ b/task_11/src/main.cpp @@ -4,10 +4,10 @@ #include "substring_search.hpp" int main() { - std::string string, substring; + std::string text, substring; - std::getline(std::cin, string); + std::getline(std::cin, text); std::getline(std::cin, substring); - std::cout << SubstringSearch(string, substring) << "\n"; + std::cout << SubstringSearch(text, substring) << "\n"; } diff --git a/task_13/src/scheduling.hpp b/task_13/src/scheduling.hpp index 0cff31d..cc15478 100644 --- a/task_13/src/scheduling.hpp +++ b/task_13/src/scheduling.hpp @@ -11,11 +11,11 @@ struct Lesson { } }; -std::vector GetSelectedLessons(std::vector& lessons) { +std::vector GetSelectedLessons(std::vector lessons) { if (lessons.empty()) return lessons; - std::sort(lessons.begin(), lessons.end(), - [](const Lesson& a, const Lesson& b) { return a.end < b.end; }); + sort(lessons.begin(), lessons.end(), + [](const Lesson& a, const Lesson& b) { return a.end < b.end; }); std::vector selected_lessons;