From 8a7e532613c80979148fd39f75c73dd2197fbc9e Mon Sep 17 00:00:00 2001 From: accaunt213 Date: Sun, 22 Jun 2025 18:07:24 +0000 Subject: [PATCH 1/2] test --- task_01/src/main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 0e4393b..c56a315 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1,3 +1,3 @@ #include - +пролорпав int main() { return 0; } From 1090cbe96d11c4f084f5df0485a1ec5f15129b00 Mon Sep 17 00:00:00 2001 From: accaunt213 Date: Sun, 22 Jun 2025 18:45:30 +0000 Subject: [PATCH 2/2] homework --- task_01/src/main.cpp | 3 - task_01/src/test.cpp | 5 -- task_01/task1/tests.cpp | 66 ++++++++++++++ task_01/task1/two_sum.cpp | 22 +++++ task_01/task1/two_sum.hpp | 8 ++ task_02/src/main.cpp | 3 - task_02/src/stack.cpp | 21 ----- task_02/src/stack.hpp | 23 ----- task_02/src/test.cpp | 42 --------- task_02/task2/stack.cpp | 84 ++++++++++++++++++ task_02/task2/stack.hpp | 30 +++++++ task_02/task2/tests.cpp | 34 ++++++++ task_03/src/main.cpp | 3 - task_03/src/test.cpp | 8 -- task_03/src/topology_sort.cpp | 1 - task_03/src/topology_sort.hpp | 1 - task_03/task3/solution.cpp | 18 ++++ task_03/task3/solution.hpp | 3 + task_03/task3/tests.cpp | 32 +++++++ task_04/src/main.cpp | 3 - task_04/src/test.cpp | 6 -- task_04/task4/fish.cpp | 40 +++++++++ task_04/task4/fish.hpp | 9 ++ task_04/task4/tests.cpp | 34 ++++++++ task_05/src/main.cpp | 3 - task_05/src/test.cpp | 6 -- task_05/task5/sort.cpp | 45 ++++++++++ task_05/task5/sort.hpp | 6 ++ task_05/task5/tests.cpp | 51 +++++++++++ task_06/src/main.cpp | 3 - task_06/src/test.cpp | 6 -- task_06/task6/order_statistic.cpp | 48 +++++++++++ task_06/task6/order_statistic.hpp | 6 ++ task_06/task6/tests.cpp | 38 ++++++++ task_07/src/main.cpp | 3 - task_07/src/test.cpp | 6 -- task_07/task7/avltree.cpp | 138 ++++++++++++++++++++++++++++++ task_07/task7/avltree.hpp | 33 +++++++ task_07/task7/tests.cpp | 28 ++++++ task_08/src/main.cpp | 3 - task_08/src/test.cpp | 6 -- task_08/task8/hash_table.cpp | 40 +++++++++ task_08/task8/hash_table.hpp | 20 +++++ task_08/task8/tests.cpp | 25 ++++++ task_09/src/main.cpp | 9 +- task_09/src/test.cpp | 71 ++++++++++----- 46 files changed, 917 insertions(+), 176 deletions(-) delete mode 100644 task_01/src/main.cpp delete mode 100644 task_01/src/test.cpp create mode 100644 task_01/task1/tests.cpp create mode 100644 task_01/task1/two_sum.cpp create mode 100644 task_01/task1/two_sum.hpp delete mode 100644 task_02/src/main.cpp delete mode 100644 task_02/src/stack.cpp delete mode 100644 task_02/src/stack.hpp delete mode 100644 task_02/src/test.cpp create mode 100644 task_02/task2/stack.cpp create mode 100644 task_02/task2/stack.hpp create mode 100644 task_02/task2/tests.cpp delete mode 100644 task_03/src/main.cpp delete mode 100644 task_03/src/test.cpp delete mode 100644 task_03/src/topology_sort.cpp delete mode 100644 task_03/src/topology_sort.hpp create mode 100644 task_03/task3/solution.cpp create mode 100644 task_03/task3/solution.hpp create mode 100644 task_03/task3/tests.cpp delete mode 100644 task_04/src/main.cpp delete mode 100644 task_04/src/test.cpp create mode 100644 task_04/task4/fish.cpp create mode 100644 task_04/task4/fish.hpp create mode 100644 task_04/task4/tests.cpp delete mode 100644 task_05/src/main.cpp delete mode 100644 task_05/src/test.cpp create mode 100644 task_05/task5/sort.cpp create mode 100644 task_05/task5/sort.hpp create mode 100644 task_05/task5/tests.cpp delete mode 100644 task_06/src/main.cpp delete mode 100644 task_06/src/test.cpp create mode 100644 task_06/task6/order_statistic.cpp create mode 100644 task_06/task6/order_statistic.hpp create mode 100644 task_06/task6/tests.cpp delete mode 100644 task_07/src/main.cpp delete mode 100644 task_07/src/test.cpp create mode 100644 task_07/task7/avltree.cpp create mode 100644 task_07/task7/avltree.hpp create mode 100644 task_07/task7/tests.cpp delete mode 100644 task_08/src/main.cpp delete mode 100644 task_08/src/test.cpp create mode 100644 task_08/task8/hash_table.cpp create mode 100644 task_08/task8/hash_table.hpp create mode 100644 task_08/task8/tests.cpp diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp deleted file mode 100644 index c56a315..0000000 --- a/task_01/src/main.cpp +++ /dev/null @@ -1,3 +0,0 @@ -#include -пролорпав -int main() { return 0; } diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp deleted file mode 100644 index 87cef73..0000000 --- a/task_01/src/test.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include - -TEST(Test, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} \ No newline at end of file diff --git a/task_01/task1/tests.cpp b/task_01/task1/tests.cpp new file mode 100644 index 0000000..aa02a69 --- /dev/null +++ b/task_01/task1/tests.cpp @@ -0,0 +1,66 @@ +#include "two_sum.hpp" +#include +#include +#include + +void runTests() { + { + std::vector nums = {2, 7, 11, 15}; + std::vector result = twoSum(nums, 9); + assert((result == std::vector{2, 7})); + } + { + std::vector nums = {1, 2, 3, 4}; + std::vector result = twoSum(nums, 5); + assert((result == std::vector{1, 4})); + } + { + std::vector nums = {3, 3}; + std::vector result = twoSum(nums, 6); + assert((result == std::vector{3, 3})); + } + { + std::vector nums = {1, 2, 3, 4}; + std::vector result = twoSum(nums, 10); + assert(result.empty()); + } + { + std::vector nums; + std::vector result = twoSum(nums, 5); + assert(result.empty()); + } + { + std::vector nums = {5}; + std::vector result = twoSum(nums, 5); + assert(result.empty()); + } + { + std::vector nums = {-4, -1, 0, 3, 5}; + std::vector result = twoSum(nums, -1); + assert((result == std::vector{-4, 3})); + } + { + std::vector nums = {10, 20, 30}; + std::vector result = twoSum(nums, 5); + assert(result.empty()); + } + { + std::vector nums = {1, 2, 3}; + std::vector result = twoSum(nums, 10); + assert(result.empty()); + } + { + std::vector nums = {1, 2, 3, 4, 5}; + std::vector result = twoSum(nums, 6); + assert((result == std::vector{1, 5})); + } + { + std::vector nums = {-5, -3, -2, 0, 1}; + std::vector result = twoSum(nums, -5); + assert((result == std::vector{-5, 0})); + } +} +int main() { + runTests(); + return 0; +} \ No newline at end of file diff --git a/task_01/task1/two_sum.cpp b/task_01/task1/two_sum.cpp new file mode 100644 index 0000000..e055f2d --- /dev/null +++ b/task_01/task1/two_sum.cpp @@ -0,0 +1,22 @@ +#include "two_sum.hpp" + +std::vector twoSum(const std::vector& nums, int target) { + int left_index = 0; + int right_index = nums.size() - 1; + + while (left_index < right_index) { + const int sum = nums[left_index] + nums[right_index]; + + if (sum == target) { + return {nums[left_index], nums[right_index]}; + } + else if (sum < target) { + left_index++; + } + else { + right_index--; + } + } + + return {}; +} \ No newline at end of file diff --git a/task_01/task1/two_sum.hpp b/task_01/task1/two_sum.hpp new file mode 100644 index 0000000..ad1aa60 --- /dev/null +++ b/task_01/task1/two_sum.hpp @@ -0,0 +1,8 @@ +#ifndef TWO_SUM_HPP +#define TWO_SUM_HPP + +#include + +std::vector twoSum(const std::vector& nums, int target); + +#endif \ No newline at end of file diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp deleted file mode 100644 index 0e4393b..0000000 --- a/task_02/src/main.cpp +++ /dev/null @@ -1,3 +0,0 @@ -#include - -int main() { return 0; } diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp deleted file mode 100644 index 8ca8990..0000000 --- a/task_02/src/stack.cpp +++ /dev/null @@ -1,21 +0,0 @@ -#include "stack.hpp" - -#include - -void Stack::Push(int value) { data_.push(value); } - -int Stack::Pop() { - auto result = data_.top(); - data_.pop(); - return result; -} - -void MinStack::Push(int value) { data_.push_back(value); } - -int MinStack::Pop() { - auto result = data_.back(); - data_.pop_back(); - return result; -} - -int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp deleted file mode 100644 index 138ec40..0000000 --- a/task_02/src/stack.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include -#include - -class Stack { - public: - void Push(int value); - int Pop(); - - private: - std::stack data_; -}; - -class MinStack { - public: - void Push(int value); - int Pop(); - int GetMin(); - - private: - std::vector data_; -}; diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp deleted file mode 100644 index 54e7ce9..0000000 --- a/task_02/src/test.cpp +++ /dev/null @@ -1,42 +0,0 @@ - -#include - -#include - -#include "stack.hpp" - -TEST(StackTest, Simple) { - Stack stack; - stack.Push(1); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - stack.Push(3); // Stack [1, 3] - ASSERT_EQ(stack.Pop(), 3); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] -} - -TEST(MinStackTest, Simple) { - MinStack stack; - stack.Push(1); // Stack [1] - ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - stack.Push(3); // Stack [1, 3] - ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 3); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] -} \ No newline at end of file diff --git a/task_02/task2/stack.cpp b/task_02/task2/stack.cpp new file mode 100644 index 0000000..6379759 --- /dev/null +++ b/task_02/task2/stack.cpp @@ -0,0 +1,84 @@ +#include "stack.hpp" + +Stack::Stack() : capacity(10), _size(0) { + arr = new int[capacity]; +} + +Stack::~Stack() { + delete[] arr; +} + +void Stack::resize(size_t newCapacity) { + int* newArr = new int[newCapacity]; + for (size_t i = 0; i < _size; ++i) { + newArr[i] = arr[i]; + } + delete[] arr; + arr = newArr; + capacity = newCapacity; +} + +void Stack::push(int value) { + if (_size == capacity) { + resize(capacity * 2); + } + arr[_size++] = value; +} + +void Stack::pop() { + if (empty()) { + throw std::out_of_range("empty"); + } + --_size; +} + +int Stack::top() const { + if (empty()) { + throw std::out_of_range("empty"); + } + return arr[_size - 1]; +} + +bool Stack::empty() const { + return _size == 0; +} + +size_t Stack::size() const { + return _size; +} + +void MinStack::push(int value) { + dataStack.push(value); + if (minStack.empty() || value <= minStack.top()) { + minStack.push(value); + } +} + +void MinStack::pop() { + if (dataStack.empty()) { + throw std::out_of_range("empty"); + } + if (dataStack.top() == minStack.top()) { + minStack.pop(); + } + dataStack.pop(); +} + +int MinStack::top() const { + return dataStack.top(); +} + +int MinStack::getMin() const { + if (minStack.empty()) { + throw std::out_of_range("empty"); + } + return minStack.top(); +} + +bool MinStack::empty() const { + return dataStack.empty(); +} + +size_t MinStack::size() const { + return dataStack.size(); +} \ No newline at end of file diff --git a/task_02/task2/stack.hpp b/task_02/task2/stack.hpp new file mode 100644 index 0000000..7ad0888 --- /dev/null +++ b/task_02/task2/stack.hpp @@ -0,0 +1,30 @@ +#include + +class Stack { +private: + int* arr; + size_t capacity; + size_t _size; + void resize(size_t newCapacity); +public: + Stack(); + ~Stack(); + void push(int value); + void pop(); + int top() const; + bool empty() const; + size_t size() const; +}; + +class MinStack { +private: + Stack dataStack; + Stack minStack; +public: + void push(int value); + void pop(); + int top() const; + int getMin() const; + bool empty() const; + size_t size() const; +}; \ No newline at end of file diff --git a/task_02/task2/tests.cpp b/task_02/task2/tests.cpp new file mode 100644 index 0000000..51b36c6 --- /dev/null +++ b/task_02/task2/tests.cpp @@ -0,0 +1,34 @@ +#include "stack.hpp" +#include + +int main() { + Stack s; + assert(s.empty()); + s.push(1); + s.push(2); + assert(s.size() == 2); + assert(s.top() == 2); + s.pop(); + assert(s.top() == 1); + s.pop(); + assert(s.empty()); + + MinStack ms; + ms.push(3); + ms.push(2); + ms.push(5); + assert(ms.getMin() == 2); + ms.push(1); + assert(ms.getMin() == 1); + ms.pop(); + assert(ms.getMin() == 2); + ms.pop(); + assert(ms.top() == 2); + assert(ms.getMin() == 2); + ms.push(2); + ms.push(0); + ms.pop(); + assert(ms.getMin() == 2); + + return 0; +} \ No newline at end of file diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp deleted file mode 100644 index 0e4393b..0000000 --- a/task_03/src/main.cpp +++ /dev/null @@ -1,3 +0,0 @@ -#include - -int main() { return 0; } diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp deleted file mode 100644 index ef5a86a..0000000 --- a/task_03/src/test.cpp +++ /dev/null @@ -1,8 +0,0 @@ - -#include - -#include "topology_sort.hpp" - -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp deleted file mode 100644 index e53f670..0000000 --- a/task_03/src/topology_sort.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "topology_sort.hpp" diff --git a/task_03/src/topology_sort.hpp b/task_03/src/topology_sort.hpp deleted file mode 100644 index 6f70f09..0000000 --- a/task_03/src/topology_sort.hpp +++ /dev/null @@ -1 +0,0 @@ -#pragma once diff --git a/task_03/task3/solution.cpp b/task_03/task3/solution.cpp new file mode 100644 index 0000000..1ab4b65 --- /dev/null +++ b/task_03/task3/solution.cpp @@ -0,0 +1,18 @@ +#include "solution.hpp" +#include +#include + +std::vector dailyTemperatures(const std::vector& temperatures) { + std::vector result(temperatures.size(), 0); + std::stack stack; + + for (int i = 0; i < temperatures.size(); ++i) { + while (!stack.empty() && temperatures[i] > temperatures[stack.top()]) { + int idx = stack.top(); + stack.pop(); + result[idx] = i - idx; + } + stack.push(i); + } + return result; +} \ No newline at end of file diff --git a/task_03/task3/solution.hpp b/task_03/task3/solution.hpp new file mode 100644 index 0000000..27f94f5 --- /dev/null +++ b/task_03/task3/solution.hpp @@ -0,0 +1,3 @@ +#include + +std::vector dailyTemperatures(const std::vector& temperatures); \ No newline at end of file diff --git a/task_03/task3/tests.cpp b/task_03/task3/tests.cpp new file mode 100644 index 0000000..5dd5a9d --- /dev/null +++ b/task_03/task3/tests.cpp @@ -0,0 +1,32 @@ +#include "solution.hpp" +#include + +int main() { + { + std::vector input = {73, 74, 75, 71, 69, 72, 76, 73}; + std::vector expected = {1, 1, 4, 2, 1, 1, 0, 0}; + if (dailyTemperatures(input) != expected) return 1; + } + { + std::vector input = {5, 4, 3, 2, 1}; + std::vector expected = {0, 0, 0, 0, 0}; + if (dailyTemperatures(input) != expected) return 2; + } + { + std::vector input = {42}; + std::vector expected = {0}; + if (dailyTemperatures(input) != expected) return 3; + } + { + std::vector input = {30, 60, 90}; + std::vector expected = {1, 1, 0}; + if (dailyTemperatures(input) != expected) return 4; + } + { + std::vector input = {50, 40, 30, 40, 50, 60, 30}; + std::vector expected = {4, 2, 1, 1, 1, 0, 0}; + if (dailyTemperatures(input) != expected) return 5; + } + + return 0; +} \ No newline at end of file diff --git a/task_04/src/main.cpp b/task_04/src/main.cpp deleted file mode 100644 index 0e4393b..0000000 --- a/task_04/src/main.cpp +++ /dev/null @@ -1,3 +0,0 @@ -#include - -int main() { return 0; } diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp deleted file mode 100644 index 5e11617..0000000 --- a/task_04/src/test.cpp +++ /dev/null @@ -1,6 +0,0 @@ - -#include - -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} diff --git a/task_04/task4/fish.cpp b/task_04/task4/fish.cpp new file mode 100644 index 0000000..58bc0b1 --- /dev/null +++ b/task_04/task4/fish.cpp @@ -0,0 +1,40 @@ +#include "fish.hpp" +#include +#include + +std::pair> solve(int N, int K, std::vector prices) { + if (N == 0) { + return {0, {}}; + } + + std::vector next_cheaper(N); + std::stack st; + + for (int i = 0; i < N; ++i) { + while (!st.empty() && prices[i] < prices[st.top()]) { + next_cheaper[st.top()] = i; + st.pop(); + } + st.push(i); + } + + while (!st.empty()) { + int i = st.top(); + st.pop(); + next_cheaper[i] = i + K; + } + + std::vector buy(N, 0); + long long total_cost = 0; + int i = 0; + while (i < N) { + int cover = next_cheaper[i] - i; + if (cover > K) cover = K; + if (cover > N - i) cover = N - i; + buy[i] = cover; + total_cost += static_cast(prices[i]) * cover; + i += cover; + } + + return {total_cost, buy}; +} \ No newline at end of file diff --git a/task_04/task4/fish.hpp b/task_04/task4/fish.hpp new file mode 100644 index 0000000..02958c4 --- /dev/null +++ b/task_04/task4/fish.hpp @@ -0,0 +1,9 @@ +#ifndef FISH_HPP +#define FISH_HPP + +#include +#include + +std::pair> solve(int N, int K, const std::vector& prices); + +#endif \ No newline at end of file diff --git a/task_04/task4/tests.cpp b/task_04/task4/tests.cpp new file mode 100644 index 0000000..3a246c1 --- /dev/null +++ b/task_04/task4/tests.cpp @@ -0,0 +1,34 @@ +#include "fish.hpp" +#include +#include +#include + +void test1() { + int N = 3, K = 2; + std::vector prices = {1, 2, 3}; + auto [cost, buy] = solve(N, K, prices); + assert(cost == 5); + assert(buy == std::vector({2, 0, 1})); +} + +void test2() { + int N = 3, K = 2; + std::vector prices = {3, 2, 1}; + auto [cost, buy] = solve(N, K, prices); + assert(cost == 6); + assert(buy == std::vector({1, 1, 1})); +} + +void test3() { + int N = 3, K = 3; + std::vector prices = {1, 3, 2}; + auto [cost, buy] = solve(N, K, prices); + assert(cost == 3); + assert(buy == std::vector({3, 0, 0})); +} +int main() { + test1(); + test2(); + test3(); + return 0; +} \ No newline at end of file diff --git a/task_05/src/main.cpp b/task_05/src/main.cpp deleted file mode 100644 index 0e4393b..0000000 --- a/task_05/src/main.cpp +++ /dev/null @@ -1,3 +0,0 @@ -#include - -int main() { return 0; } diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp deleted file mode 100644 index 5e11617..0000000 --- a/task_05/src/test.cpp +++ /dev/null @@ -1,6 +0,0 @@ - -#include - -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} diff --git a/task_05/task5/sort.cpp b/task_05/task5/sort.cpp new file mode 100644 index 0000000..8ac401a --- /dev/null +++ b/task_05/task5/sort.cpp @@ -0,0 +1,45 @@ +#include "sort.hpp" + +namespace { + void merge(int arr[], int left, int mid, int right, int temp[]) { + int i = left; + int j = mid + 1; + int k = 0; + + while (i <= mid && j <= right) { + if (arr[i] <= arr[j]) { + temp[k++] = arr[i++]; + } else { + temp[k++] = arr[j++]; + } + } + + while (i <= mid) { + temp[k++] = arr[i++]; + } + + while (j <= right) { + temp[k++] = arr[j++]; + } + + for (i = 0; i < k; i++) { + arr[left + i] = temp[i]; + } + } + + void mergeSortHelper(int arr[], int left, int right, int temp[]) { + if (left < right) { + int mid = left + (right - left) / 2; + mergeSortHelper(arr, left, mid, temp); + mergeSortHelper(arr, mid + 1, right, temp); + merge(arr, left, mid, right, temp); + } + } +} + +void mergeSort(int arr[], int size) { + if (size <= 1) return; + int* temp = new int[size]; + mergeSortHelper(arr, 0, size - 1, temp); + delete[] temp; +} \ No newline at end of file diff --git a/task_05/task5/sort.hpp b/task_05/task5/sort.hpp new file mode 100644 index 0000000..79096dc --- /dev/null +++ b/task_05/task5/sort.hpp @@ -0,0 +1,6 @@ +#ifndef SORT_HPP +#define SORT_HPP + +void mergeSort(int arr[], int size); + +#endif \ No newline at end of file diff --git a/task_05/task5/tests.cpp b/task_05/task5/tests.cpp new file mode 100644 index 0000000..49d52a2 --- /dev/null +++ b/task_05/task5/tests.cpp @@ -0,0 +1,51 @@ +#include "sort.hpp" +#include +#include +#include +#include +#include + +void test1() { + int arr[] = {}; + mergeSort(arr, 0); +} + +void test2() { + int arr[] = {5}; + mergeSort(arr, 1); + assert(arr[0] == 5); +} + +void test3() { + int arr[] = {1, 2, 3, 4, 5}; + mergeSort(arr, 5); + for (int i = 0; i < 5; i++) { + assert(arr[i] == i + 1); + } +} + +void test4() { + int arr[] = {5, 4, 3, 2, 1}; + mergeSort(arr, 5); + for (int i = 0; i < 5; i++) { + assert(arr[i] == i + 1); + } +} + +void test5() { + int arr[] = {2, 1, 2, 1, 3}; + mergeSort(arr, 5); + assert(arr[0] == 1); + assert(arr[1] == 1); + assert(arr[2] == 2); + assert(arr[3] == 2); + assert(arr[4] == 3); +} +int main() { + test1(); + test2(); + test3(); + test4(); + test5(); + return 0; +} \ No newline at end of file diff --git a/task_06/src/main.cpp b/task_06/src/main.cpp deleted file mode 100644 index 0e4393b..0000000 --- a/task_06/src/main.cpp +++ /dev/null @@ -1,3 +0,0 @@ -#include - -int main() { return 0; } diff --git a/task_06/src/test.cpp b/task_06/src/test.cpp deleted file mode 100644 index 5e11617..0000000 --- a/task_06/src/test.cpp +++ /dev/null @@ -1,6 +0,0 @@ - -#include - -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} diff --git a/task_06/task6/order_statistic.cpp b/task_06/task6/order_statistic.cpp new file mode 100644 index 0000000..583ef3c --- /dev/null +++ b/task_06/task6/order_statistic.cpp @@ -0,0 +1,48 @@ +#include "order_statistic.hpp" +#include +#include +#include +#include + +namespace { + int partition(int *array, int left, int right, int pivot_index) { + int pivot_value = array[pivot_index]; + std::swap(array[pivot_index], array[right]); + int store_index = left; + for (int i = left; i < right; ++i) { + if (array[i] < pivot_value) { + std::swap(array[i], array[store_index]); + ++store_index; + } + } + std::swap(array[store_index], array[right]); + return store_index; + } +} + +int order_statistic(int *array, int n, int k) { + if (k < 0 || k >= n) { + throw std::invalid_argument("k is out of bounds"); + } + static bool first_time = true; + if (first_time) { + std::srand(static_cast(std::time(nullptr))); + first_time = false; + } + int left = 0; + int right = n - 1; + while (true) { + if (left == right) { + return array[left]; + } + int pivot_index = left + std::rand() % (right - left + 1); + pivot_index = partition(array, left, right, pivot_index); + if (k == pivot_index) { + return array[k]; + } else if (k < pivot_index) { + right = pivot_index - 1; + } else { + left = pivot_index + 1; + } + } +} \ No newline at end of file diff --git a/task_06/task6/order_statistic.hpp b/task_06/task6/order_statistic.hpp new file mode 100644 index 0000000..7c65bd9 --- /dev/null +++ b/task_06/task6/order_statistic.hpp @@ -0,0 +1,6 @@ +#ifndef ORDER_STATISTIC_HPP +#define ORDER_STATISTIC_HPP + +int order_statistic(int *array, int n, int k); + +#endif \ No newline at end of file diff --git a/task_06/task6/tests.cpp b/task_06/task6/tests.cpp new file mode 100644 index 0000000..63b0eeb --- /dev/null +++ b/task_06/task6/tests.cpp @@ -0,0 +1,38 @@ +#include "order_statistic.hpp" +#include +#include +#include +#include + +void test1() { + int base[] = {3, 1, 4, 2, 5}; + int n = 5; + int sorted[] = {1, 2, 3, 4, 5}; + for (int k = 0; k < n; ++k) { + int arr[n]; + std::copy(base, base + n, arr); + assert(order_statistic(arr, n, k) == sorted[k]); + } +} + +void test2() { + int arr[] = {42}; + assert(order_statistic(arr, 1, 0) == 42); +} + +void test3() { + int base[] = {2, 1, 2, 1, 3}; + int n = 5; + int sorted[] = {1, 1, 2, 2, 3}; + for (int k = 0; k < n; ++k) { + int arr[n]; + std::copy(base, base + n, arr); + assert(order_statistic(arr, n, k) == sorted[k]); + } +} +int main() { + test1(); + test2(); + test3(); + return 0; +} \ No newline at end of file diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp deleted file mode 100644 index 0e4393b..0000000 --- a/task_07/src/main.cpp +++ /dev/null @@ -1,3 +0,0 @@ -#include - -int main() { return 0; } diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp deleted file mode 100644 index 5e11617..0000000 --- a/task_07/src/test.cpp +++ /dev/null @@ -1,6 +0,0 @@ - -#include - -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} diff --git a/task_07/task7/avltree.cpp b/task_07/task7/avltree.cpp new file mode 100644 index 0000000..9f7e552 --- /dev/null +++ b/task_07/task7/avltree.cpp @@ -0,0 +1,138 @@ +#include "avltree.hpp" +#include + +AVLTree::AVLTree() : root(nullptr) {} + +AVLTree::~AVLTree() { + destroyTree(root); +} + +void AVLTree::destroyTree(Node* node) { + if (node) { + destroyTree(node->left); + destroyTree(node->right); + delete node; + } +} + +int AVLTree::height(Node* node) const { + return node ? node->height : 0; +} + +int AVLTree::balanceFactor(Node* node) const { + return node ? height(node->left) - height(node->right) : 0; +} + +void AVLTree::insert(int key) { + root = insert(root, key); +} + +void AVLTree::remove(int key) { + root = remove(root, key); +} + +bool AVLTree::search(int key) const { + return search(root, key); +} + +Node* AVLTree::insert(Node* node, int key) { + if (!node) { + return new Node{key, nullptr, nullptr, 1}; + } + if (key < node->key) { + node->left = insert(node->left, key); + } else if (key > node->key) { + node->right = insert(node->right, key); + } else { + return node; + } + return balance(node); +} + +Node* AVLTree::remove(Node* node, int key) { + if (!node) { + return nullptr; + } + if (key < node->key) { + node->left = remove(node->left, key); + } else if (key > node->key) { + node->right = remove(node->right, key); + } else { + if (!node->left) { + Node* temp = node->right; + delete node; + return temp; + } else if (!node->right) { + Node* temp = node->left; + delete node; + return temp; + } else { + Node* temp = minValueNode(node->right); + node->key = temp->key; + node->right = remove(node->right, temp->key); + } + } + if (!node) { + return node; + } + return balance(node); +} + +Node* AVLTree::minValueNode(Node* node) { + Node* current = node; + while (current->left) { + current = current->left; + } + return current; +} + +bool AVLTree::search(Node* node, int key) const { + if (!node) { + return false; + } + if (key == node->key) { + return true; + } else if (key < node->key) { + return search(node->left, key); + } else { + return search(node->right, key); + } +} + +Node* AVLTree::rotateRight(Node* y) { + Node* x = y->left; + Node* T2 = x->right; + x->right = y; + y->left = T2; + y->height = std::max(height(y->left), height(y->right)) + 1; + x->height = std::max(height(x->left), height(x->right)) + 1; + return x; +} + +Node* AVLTree::rotateLeft(Node* x) { + Node* y = x->right; + Node* T2 = y->left; + y->left = x; + x->right = T2; + x->height = std::max(height(x->left), height(x->right)) + 1; + y->height = std::max(height(y->left), height(y->right)) + 1; + return y; +} + +Node* AVLTree::balance(Node* node) { + node->height = 1 + std::max(height(node->left), height(node->right)); + int bf = balanceFactor(node); + if (bf > 1) { + if (balanceFactor(node->left) < 0) { + node->left = rotateLeft(node->left); + } + return rotateRight(node); + } + if (bf < -1) { + if (balanceFactor(node->right) > 0) { + node->right = rotateRight(node->right); + } + return rotateLeft(node); + } + return node; +} \ No newline at end of file diff --git a/task_07/task7/avltree.hpp b/task_07/task7/avltree.hpp new file mode 100644 index 0000000..a79c9d5 --- /dev/null +++ b/task_07/task7/avltree.hpp @@ -0,0 +1,33 @@ +#ifndef AVLTREE_HPP +#define AVLTREE_HPP + +struct Node { + int key; + Node* left; + Node* right; + int height; +}; + +class AVLTree { +public: + AVLTree(); + ~AVLTree(); + void insert(int key); + void remove(int key); + bool search(int key) const; + +private: + Node* root; + Node* insert(Node* node, int key); + Node* remove(Node* node, int key); + Node* minValueNode(Node* node); + bool search(Node* node, int key) const; + int height(Node* node) const; + int balanceFactor(Node* node) const; + Node* rotateRight(Node* y); + Node* rotateLeft(Node* x); + Node* balance(Node* node); + void destroyTree(Node* node); +}; + +#endif \ No newline at end of file diff --git a/task_07/task7/tests.cpp b/task_07/task7/tests.cpp new file mode 100644 index 0000000..573a58a --- /dev/null +++ b/task_07/task7/tests.cpp @@ -0,0 +1,28 @@ +#include "avltree.hpp" +#include +#include + +int main() { + AVLTree tree; + tree.insert(10); + tree.insert(20); + tree.insert(30); + assert(tree.search(10)); + assert(tree.search(20)); + assert(tree.search(30)); + assert(!tree.search(5)); + tree.remove(20); + assert(!tree.search(20)); + tree.insert(25); + tree.insert(15); + tree.insert(5); + assert(tree.search(25)); + assert(tree.search(15)); + assert(tree.search(5)); + tree.remove(10); + assert(!tree.search(10)); + tree.insert(100); + tree.remove(100); + assert(!tree.search(100)); + return 0; +} \ No newline at end of file diff --git a/task_08/src/main.cpp b/task_08/src/main.cpp deleted file mode 100644 index 0e4393b..0000000 --- a/task_08/src/main.cpp +++ /dev/null @@ -1,3 +0,0 @@ -#include - -int main() { return 0; } diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp deleted file mode 100644 index 5e11617..0000000 --- a/task_08/src/test.cpp +++ /dev/null @@ -1,6 +0,0 @@ - -#include - -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} diff --git a/task_08/task8/hash_table.cpp b/task_08/task8/hash_table.cpp new file mode 100644 index 0000000..99eda58 --- /dev/null +++ b/task_08/task8/hash_table.cpp @@ -0,0 +1,40 @@ +#include "hash_table.hpp" + +HashTable::HashTable(int size) : size(size), table(size) {} + +int HashTable::hash(int key) { + return key % size; +} + +void HashTable::insert(int key, int value) { + int index = hash(key); + for (auto it = table[index].begin(); it != table[index].end(); ++it) { + if (it->first == key) { + it->second = value; + return; + } + } + table[index].push_back({key, value}); +} + +bool HashTable::find(int key, int& value) { + int index = hash(key); + for (auto it = table[index].begin(); it != table[index].end(); ++it) { + if (it->first == key) { + value = it->second; + return true; + } + } + return false; +} + +bool HashTable::erase(int key) { + int index = hash(key); + for (auto it = table[index].begin(); it != table[index].end(); ++it) { + if (it->first == key) { + table[index].erase(it); + return true; + } + } + return false; +} \ No newline at end of file diff --git a/task_08/task8/hash_table.hpp b/task_08/task8/hash_table.hpp new file mode 100644 index 0000000..d680c1b --- /dev/null +++ b/task_08/task8/hash_table.hpp @@ -0,0 +1,20 @@ +#ifndef HASH_TABLE_HPP +#define HASH_TABLE_HPP + +#include +#include + +class HashTable { +public: + HashTable(int size = 10); + void insert(int key, int value); + bool find(int key, int& value); + bool erase(int key); + +private: + int size; + std::vector>> table; + int hash(int key); +}; + +#endif \ No newline at end of file diff --git a/task_08/task8/tests.cpp b/task_08/task8/tests.cpp new file mode 100644 index 0000000..d4dd58f --- /dev/null +++ b/task_08/task8/tests.cpp @@ -0,0 +1,25 @@ +#include "hash_table.hpp" +#include + +int main() { + HashTable ht; + + ht.insert(1, 100); + ht.insert(2, 200); + ht.insert(3, 300); + + int value = 0; + assert(ht.find(1, value) && value == 100); + assert(ht.find(2, value) && value == 200); + assert(ht.find(3, value) && value == 300); + assert(!ht.find(4, value)); + + ht.insert(1, 111); + assert(ht.find(1, value) && value == 111); + + assert(ht.erase(2)); + assert(!ht.find(2, value)); + assert(!ht.erase(2)); + + return 0; +} \ No newline at end of file diff --git a/task_09/src/main.cpp b/task_09/src/main.cpp index c3aeba4..0f9edcf 100644 --- a/task_09/src/main.cpp +++ b/task_09/src/main.cpp @@ -1 +1,8 @@ -int main() { return 0; } \ No newline at end of file +#include + +void solve_table_problem(std::istream& in, std::ostream& out); + +int main() { + solve_table_problem(std::cin, std::cout); + return 0; +} \ No newline at end of file diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp index a42caa4..d9c1022 100644 --- a/task_09/src/test.cpp +++ b/task_09/src/test.cpp @@ -1,23 +1,54 @@ -#include - #include +#include + +void solve_table_problem(std::istream& in, std::ostream& out) { + int n, m; + in >> n >> m; + + std::vector> table(n, std::vector(m)); + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + in >> table[i][j]; + } + } -TEST(CanReachNonDecreasingSegment, 1) { - // ASSERT_EQ(SolveFunction(5, 4, 6, - // std::vector>{{1, 2, 3, 5}, - // {3, 1, 3, 2}, - // {4, 5, 2, 3}, - // {5, 5, 3, 2}, - // {4, 4, 3, 4}}, - // std::vector>{ - // {1, 1}, {2, 5}, {4, 5}, {3, 5}, {1, 3}, {1, - // 5}}), - // (std::vector{"Yes", "No", "Yes", "Yes", "Yes", - // "No"})); -} + std::vector> prefix(m, std::vector(n, 0)); + for (int j = 0; j < m; j++) { + for (int i = 1; i < n; i++) { + int add_value = 0; + if (table[i-1][j] <= table[i][j]) { + add_value = 1; + } + prefix[j][i] = prefix[j][i-1] + add_value; + } + } -TEST(CanReachNonDecreasingSegment, 2) { - // ASSERT_EQ(SolveFunction(1, 1, 1, std::vector>{{1, 1}}, - // std::vector>{{1, 1}}), - // (std::vector{"Yes"})); -} + int k; + in >> k; + while (k--) { + int l, r; + in >> l >> r; + + if (l == r) { + out << "Yes\n"; + continue; + } + + bool found_good = false; + int need_count = r - l; + + for (int j = 0; j < m; j++) { + int total_good = prefix[j][r-1] - prefix[j][l-1]; + if (total_good == need_count) { + found_good = true; + break; + } + } + + if (found_good) { + out << "Yes\n"; + } else { + out << "No\n"; + } + } +} \ No newline at end of file