From d3d7d03eda6e4b9f55c055c65b0729e4d609db42 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 09:55:10 +0000 Subject: [PATCH 01/23] task_1_done_no_tests --- task_01/src/task_01.cpp | 18 ++++++++++++++++++ task_01/src/task_01.hpp | 4 ++++ 2 files changed, 22 insertions(+) create mode 100644 task_01/src/task_01.cpp create mode 100644 task_01/src/task_01.hpp diff --git a/task_01/src/task_01.cpp b/task_01/src/task_01.cpp new file mode 100644 index 0000000..3b2c74a --- /dev/null +++ b/task_01/src/task_01.cpp @@ -0,0 +1,18 @@ +#include "task_01.hpp" + +std::vector find_two_nums(int target, std::vector arr){ + int left = 0; + int right = arr.size() - 1; + int sum = arr[right] + arr[left]; + while (left < right) { + int sum = arr[left] + arr[right]; + if(sum == target){ + return {arr[left], arr[right]}; + } else if(sum < target){ + ++left; + } else { + --right; + } + } + return {}; +}; \ No newline at end of file diff --git a/task_01/src/task_01.hpp b/task_01/src/task_01.hpp new file mode 100644 index 0000000..f0ac4da --- /dev/null +++ b/task_01/src/task_01.hpp @@ -0,0 +1,4 @@ +#pragma once +#include + +std::vector find_two_nums(int target, std::vector arr); \ No newline at end of file From 7db5c52d3d004f93d47932fb455ae272fde00a15 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 10:02:43 +0000 Subject: [PATCH 02/23] task_01 clang-format --- task_01/src/task_01.cpp | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/task_01/src/task_01.cpp b/task_01/src/task_01.cpp index 3b2c74a..76f51ff 100644 --- a/task_01/src/task_01.cpp +++ b/task_01/src/task_01.cpp @@ -1,18 +1,18 @@ #include "task_01.hpp" -std::vector find_two_nums(int target, std::vector arr){ - int left = 0; - int right = arr.size() - 1; - int sum = arr[right] + arr[left]; - while (left < right) { - int sum = arr[left] + arr[right]; - if(sum == target){ - return {arr[left], arr[right]}; - } else if(sum < target){ - ++left; - } else { - --right; - } +std::vector find_two_nums(int target, std::vector arr) { + int left = 0; + int right = arr.size() - 1; + int sum = arr[right] + arr[left]; + while (left < right) { + int sum = arr[left] + arr[right]; + if (sum == target) { + return {arr[left], arr[right]}; + } else if (sum < target) { + ++left; + } else { + --right; } - return {}; + } + return {}; }; \ No newline at end of file From 5c4d4d8f685393c8b82f7f9ff206a17dd160fb68 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 10:08:03 +0000 Subject: [PATCH 03/23] task_03 done without test, clang-formatted --- task_03/src/topology_sort.cpp | 17 +++++++++++++++++ task_03/src/topology_sort.hpp | 4 ++++ 2 files changed, 21 insertions(+) diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp index e53f670..dd03a63 100644 --- a/task_03/src/topology_sort.cpp +++ b/task_03/src/topology_sort.cpp @@ -1 +1,18 @@ #include "topology_sort.hpp" + +std::vector days_until_warmer(const std::vector& temperatures) { + int n = temperatures.size(); + std::vector result(n, 0); + std::stack st; + + for (int i = 0; i < n; ++i) { + while (!st.empty() && temperatures[i] > temperatures[st.top()]) { + int prev_index = st.top(); + st.pop(); + result[prev_index] = i - prev_index; + } + st.push(i); + } + + return result; +} diff --git a/task_03/src/topology_sort.hpp b/task_03/src/topology_sort.hpp index 6f70f09..3b518a9 100644 --- a/task_03/src/topology_sort.hpp +++ b/task_03/src/topology_sort.hpp @@ -1 +1,5 @@ #pragma once +#include +#include + +std::vector days_until_warmer(const std::vector& temperatures); From 9ddc619cfd2c641f10c38a00778ce2dbe3f15092 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 10:22:21 +0000 Subject: [PATCH 04/23] task_04 done no test, clang-formatted --- task_04/src/buy_fish.cpp | 24 ++++++++++++++++++++++++ task_04/src/buy_fish.hpp | 6 ++++++ 2 files changed, 30 insertions(+) create mode 100644 task_04/src/buy_fish.cpp create mode 100644 task_04/src/buy_fish.hpp diff --git a/task_04/src/buy_fish.cpp b/task_04/src/buy_fish.cpp new file mode 100644 index 0000000..5b0cf5d --- /dev/null +++ b/task_04/src/buy_fish.cpp @@ -0,0 +1,24 @@ +#include "buy_fish.hpp" + +std::vector buy_fish(const std::vector& prices, int k) { + int N = prices.size(); + std::vector result(N, 0); + std::deque dq; + + for (int i = 0; i < N; ++i) { + while (!dq.empty() && dq.front() < i - k + 1) { + dq.pop_front(); + } + + while (!dq.empty() && prices[dq.back()] >= prices[i]) { + dq.pop_back(); + } + + dq.push_back(i); + + int bestDay = dq.front(); + result[bestDay]++; + } + + return result; +} diff --git a/task_04/src/buy_fish.hpp b/task_04/src/buy_fish.hpp new file mode 100644 index 0000000..8e153b6 --- /dev/null +++ b/task_04/src/buy_fish.hpp @@ -0,0 +1,6 @@ +#pragma once + +#include +#include + +std::vector buy_fish(const std::vector& prices, int k); \ No newline at end of file From 94dfe8d97884550db58ff68d60b32c52bac22682 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 10:24:50 +0000 Subject: [PATCH 05/23] task_05 done no test, clang-formatted --- task_05/src/QuickSort.cpp | 26 ++++++++++++++++++++++++++ task_05/src/QuickSort.hpp | 5 +++++ 2 files changed, 31 insertions(+) create mode 100644 task_05/src/QuickSort.cpp create mode 100644 task_05/src/QuickSort.hpp diff --git a/task_05/src/QuickSort.cpp b/task_05/src/QuickSort.cpp new file mode 100644 index 0000000..453acca --- /dev/null +++ b/task_05/src/QuickSort.cpp @@ -0,0 +1,26 @@ +#include "QuickSort.hpp" + +void quickSortwrap(std::vector& arr, int low, int high) { + if (low < high) { + int pivot = arr[high]; + int i = low - 1; + + for (int j = low; j < high; j++) { + if (arr[j] < pivot) { + i++; + std::swap(arr[i], arr[j]); + } + } + std::swap(arr[i + 1], arr[high]); + int pi = i + 1; + + quickSortwrap(arr, low, pi - 1); + quickSortwrap(arr, pi + 1, high); + } +}; + +void quickSort(std::vector& arr) { + if (!arr.empty()) { + quickSortwrap(arr, 0, arr.size() - 1); + } +}; \ No newline at end of file diff --git a/task_05/src/QuickSort.hpp b/task_05/src/QuickSort.hpp new file mode 100644 index 0000000..40e0fa9 --- /dev/null +++ b/task_05/src/QuickSort.hpp @@ -0,0 +1,5 @@ +#pragma once +#include + +void quickSortwrap(std::vector& arr, int low, int high); +void quickSort(std::vector& arr); \ No newline at end of file From 221fe942dbed7a09604767d70d7caba223deba83 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 10:26:52 +0000 Subject: [PATCH 06/23] task_06 done no test, clang-formatted --- task_06/src/ord_stat.cpp | 30 ++++++++++++++++++++++++++++++ task_06/src/ord_stat.hpp | 6 ++++++ 2 files changed, 36 insertions(+) create mode 100644 task_06/src/ord_stat.cpp create mode 100644 task_06/src/ord_stat.hpp diff --git a/task_06/src/ord_stat.cpp b/task_06/src/ord_stat.cpp new file mode 100644 index 0000000..6fbebff --- /dev/null +++ b/task_06/src/ord_stat.cpp @@ -0,0 +1,30 @@ +#include "ord_stat.hpp" + +int ordstat(std::vector& arr, int k) { + int left = 0; + int right = arr.size() - 1; + + while (left <= right) { + int pivotIndex = left + rand() % (right - left + 1); + int pivotValue = arr[pivotIndex]; + std::swap(arr[pivotIndex], arr[right]); + + int storeIndex = left; + for (int i = left; i < right; i++) { + if (arr[i] <= pivotValue) { + std::swap(arr[i], arr[storeIndex]); + storeIndex++; + } + } + std::swap(arr[storeIndex], arr[right]); + + if (storeIndex == k) + return arr[storeIndex]; + else if (storeIndex < k) + left = storeIndex + 1; + else + right = storeIndex - 1; + } + + return -1; +} \ No newline at end of file diff --git a/task_06/src/ord_stat.hpp b/task_06/src/ord_stat.hpp new file mode 100644 index 0000000..3ddab27 --- /dev/null +++ b/task_06/src/ord_stat.hpp @@ -0,0 +1,6 @@ +#pragma once + +#include +#include + +int ordstat(std::vector& arr, int k); \ No newline at end of file From 5a5182ff7a8ac81e56ce36b1b67f3fe04bea94af Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 17:19:48 +0000 Subject: [PATCH 07/23] task_07 done no tests, clang-formatted --- task_07/src/AVLTree.cpp | 112 ++++++++++++++++++++++++++++++++++++++++ task_07/src/AVLTree.hpp | 47 +++++++++++++++++ 2 files changed, 159 insertions(+) create mode 100644 task_07/src/AVLTree.cpp create mode 100644 task_07/src/AVLTree.hpp diff --git a/task_07/src/AVLTree.cpp b/task_07/src/AVLTree.cpp new file mode 100644 index 0000000..59c9eb4 --- /dev/null +++ b/task_07/src/AVLTree.cpp @@ -0,0 +1,112 @@ +#include "AVLTree.hpp" + +Node* AVLTree::rotateRight(Node* y) { + Node* x = y->left; + Node* T2 = x->right; + + x->right = y; + y->left = T2; + + updateHeight(y); + updateHeight(x); + + return x; +} + +Node* AVLTree::rotateLeft(Node* x) { + Node* y = x->right; + Node* T2 = y->left; + + y->left = x; + x->right = T2; + + updateHeight(x); + updateHeight(y); + + return y; +} + +Node* AVLTree::balance(Node* n) { + updateHeight(n); + int bf = balanceFactor(n); + + if (bf > 1) { + if (balanceFactor(n->left) < 0) { + n->left = rotateLeft(n->left); + } + return rotateRight(n); + } + + if (bf < -1) { + if (balanceFactor(n->right) > 0) { + n->right = rotateRight(n->right); + } + return rotateLeft(n); + } + + return n; +} + +Node* AVLTree::insert(Node* node, int key) { + if (!node) return new Node(key); + + 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::minValueNode(Node* node) { + Node* current = node; + while (current->left) current = current->left; + return current; +} + +Node* AVLTree::erase(Node* node, int key) { + if (!node) return node; + + if (key < node->key) + node->left = erase(node->left, key); + else if (key > node->key) + node->right = erase(node->right, key); + else { + if (!node->left || !node->right) { + Node* temp = node->left ? node->left : node->right; + if (!temp) { + temp = node; + node = nullptr; + } else { + *node = *temp; + } + delete temp; + } else { + Node* temp = minValueNode(node->right); + node->key = temp->key; + node->right = erase(node->right, temp->key); + } + } + + if (!node) return node; + + return balance(node); +} + +bool AVLTree::find(Node* node, int key) const { + if (!node) return false; + if (key == node->key) return true; + if (key < node->key) + return find(node->left, key); + else + return find(node->right, key); +} + +void AVLTree::inorder(Node* node) const { + if (!node) return; + inorder(node->left); + std::cout << node->key << " "; + inorder(node->right); +} diff --git a/task_07/src/AVLTree.hpp b/task_07/src/AVLTree.hpp new file mode 100644 index 0000000..ce01275 --- /dev/null +++ b/task_07/src/AVLTree.hpp @@ -0,0 +1,47 @@ +#pragma once + +#include + +struct Node { + int key; + Node* left; + Node* right; + int height; + Node(int k) : key(k), left(nullptr), right(nullptr), height(1) {} +}; + +class AVLTree { + private: + Node* root = nullptr; + + int height(Node* n) { return n ? n->height : 0; } + + int balanceFactor(Node* n) { + return n ? height(n->left) - height(n->right) : 0; + } + + void updateHeight(Node* n) { + n->height = 1 + std::max(height(n->left), height(n->right)); + } + + Node* rotateRight(Node* y); + Node* rotateLeft(Node* x); + Node* balance(Node* n); + Node* insert(Node* node, int key); + Node* minValueNode(Node* node); + Node* erase(Node* node, int key); + bool find(Node* node, int key) const; + void inorder(Node* node) const; + + public: + void insert(int key) { root = insert(root, key); } + + void erase(int key) { root = erase(root, key); } + + bool find(int key) const { return find(root, key); } + + void printInorder() const { + inorder(root); + std::cout << "\n"; + } +}; \ No newline at end of file From 8345d8a9f592420d017894771b50caa5190c4c20 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 17:24:13 +0000 Subject: [PATCH 08/23] task_08 done no test, clang-formatted --- task_08/src/HashTable.cpp | 61 +++++++++++++++++++++++++++++++++++++++ task_08/src/HashTable.hpp | 39 +++++++++++++++++++++++++ 2 files changed, 100 insertions(+) create mode 100644 task_08/src/HashTable.cpp create mode 100644 task_08/src/HashTable.hpp diff --git a/task_08/src/HashTable.cpp b/task_08/src/HashTable.cpp new file mode 100644 index 0000000..2613ffb --- /dev/null +++ b/task_08/src/HashTable.cpp @@ -0,0 +1,61 @@ +#include "HashTable.hpp" + +void HashTable::rehash() { + int old_capacity = capacity; + capacity *= 2; + std::vector>> new_table(capacity); + + for (const auto& bucket : table) { + for (const auto& entry : bucket) { + int idx = std::hash{}(entry.first) % capacity; + new_table[idx].emplace_back(entry.first, entry.second); + } + } + + table = std::move(new_table); +}; + +void HashTable::insert(const std::string& key, int value) { + int idx = getIndex(key); + for (auto& entry : table[idx]) { + if (entry.first == key) { + entry.second = value; + return; + } + } + table[idx].emplace_back(key, value); + ++size; + checkLoadFactorAndRehash(); +}; + +std::optional HashTable::find(const std::string& key) const { + int idx = getIndex(key); + for (const auto& entry : table[idx]) { + if (entry.first == key) { + return entry.second; + } + } + return std::nullopt; +}; + +bool HashTable::erase(const std::string& key) { + int idx = getIndex(key); + for (auto it = table[idx].begin(); it != table[idx].end(); ++it) { + if (it->first == key) { + table[idx].erase(it); + --size; + return true; + } + } + return false; +}; + +void HashTable::print() const { + for (int i = 0; i < capacity; ++i) { + std::cout << "[" << i << "]: "; + for (const auto& entry : table[i]) { + std::cout << "(" << entry.first << ": " << entry.second << ") "; + } + std::cout << std::endl; + } +}; \ No newline at end of file diff --git a/task_08/src/HashTable.hpp b/task_08/src/HashTable.hpp new file mode 100644 index 0000000..949fd9d --- /dev/null +++ b/task_08/src/HashTable.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include +#include +#include +#include +#include + +class HashTable { + private: + std::vector>> table; + int capacity; + int size; + + int getIndex(const std::string& key) const { + return std::hash{}(key) % capacity; + } + + void rehash(); + + void checkLoadFactorAndRehash() { + if (size > capacity / 2) { + rehash(); + } + } + + public: + HashTable(int init_capacity = 8) : capacity(init_capacity), size(0) { + table.resize(capacity); + } + + void insert(const std::string& key, int value); + + std::optional find(const std::string& key) const; + + bool erase(const std::string& key); + + void print() const; +}; \ No newline at end of file From 2211c737474def71c52fcf477928a924a29af0a4 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 17:28:32 +0000 Subject: [PATCH 09/23] task_09 done no tests, clang-formatted --- task_09/src/good_table.cpp | 44 ++++++++++++++++++++++++++++++++++++++ task_09/src/good_table.hpp | 18 ++++++++++++++++ 2 files changed, 62 insertions(+) create mode 100644 task_09/src/good_table.cpp create mode 100644 task_09/src/good_table.hpp diff --git a/task_09/src/good_table.cpp b/task_09/src/good_table.cpp new file mode 100644 index 0000000..867e3d9 --- /dev/null +++ b/task_09/src/good_table.cpp @@ -0,0 +1,44 @@ +#include "good_table.hpp" + +SortedTableChecker::SortedTableChecker( + const std::vector>& table) + : a(table) { + n = (int)a.size(); + m = n > 0 ? (int)a[0].size() : 0; + preprocess(); +}; + +void SortedTableChecker::preprocess() { + if (n == 0 || m == 0) return; + + std::vector> maxReachCol(m, std::vector(n)); + + for (int j = 0; j < m; j++) { + maxReachCol[j][n - 1] = n - 1; + for (int i = n - 2; i >= 0; i--) { + if (a[i][j] <= a[i + 1][j]) + maxReachCol[j][i] = maxReachCol[j][i + 1]; + else + maxReachCol[j][i] = i; + } + } + + maxReachForRow.resize(n); + for (int i = 0; i < n; i++) { + int best = i; + for (int j = 0; j < m; j++) { + if (maxReachCol[j][i] > best) best = maxReachCol[j][i]; + } + maxReachForRow[i] = best; + } + + for (int i = 1; i < n; i++) { + if (maxReachForRow[i] < maxReachForRow[i - 1]) + maxReachForRow[i] = maxReachForRow[i - 1]; + } +}; + +bool SortedTableChecker::isSortedSegment(int l, int r) const { + if (l < 0 || r >= n || l > r) return false; + return maxReachForRow[l] >= r; +}; \ No newline at end of file diff --git a/task_09/src/good_table.hpp b/task_09/src/good_table.hpp new file mode 100644 index 0000000..4485fae --- /dev/null +++ b/task_09/src/good_table.hpp @@ -0,0 +1,18 @@ +#pragma once + +#include +#include +#include + +class SortedTableChecker { + int n, m; + std::vector> a; + std::vector maxReachForRow; + + public: + SortedTableChecker(const std::vector>& table); + + void preprocess(); + + bool isSortedSegment(int l, int r) const; +}; From e76926e32efbf4f9f5c0054f897cf2c8a0250cff Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 17:40:21 +0000 Subject: [PATCH 10/23] task_01 tests --- task_01/src/test.cpp | 38 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 36 insertions(+), 2 deletions(-) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 87cef73..f167048 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,5 +1,39 @@ #include -TEST(Test, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include +#include +#include + +#include "task_01.hpp" + +TEST(FindTwoNumsTest, BasicMatch) { + std::vector arr = {1, 2, 3, 4, 6}; + auto result = find_two_nums(7, arr); // 3 + 4 + std::sort(result.begin(), result.end()); + ASSERT_EQ(result, std::vector({1, 6})); // Stack [] +} + +TEST(FindTwoNumsTest, MultiplePairsPossible) { + std::vector arr = {1, 2, 3, 4, 4, 5}; + auto result = find_two_nums(8, arr); // could be 3+5 or 4+4 + ASSERT_EQ(result[0] + result[1], 8); // Stack [] +} + +TEST(FindTwoNumsTest, NoSolution) { + std::vector arr = {1, 2, 3}; + ASSERT_EQ(find_two_nums(10, arr), std::vector{}); // Stack [] +} + +TEST(FindTwoNumsTest, NegativeNumbers) { + std::vector arr = {-5, -2, 0, 3, 7, 9}; + auto result = find_two_nums(4, arr); // -5 + 9 = 4 + std::sort(result.begin(), result.end()); + ASSERT_EQ(result, std::vector({-5, 9})); // Stack [] +} + +TEST(FindTwoNumsTest, SameElementTwice) { + std::vector arr = {1, 2, 4, 4, 5, 6}; + auto result = find_two_nums(8, arr); // 4 + 4 + std::sort(result.begin(), result.end()); + ASSERT_EQ(result, std::vector({2, 6})); // Stack [] } \ No newline at end of file From 928a36352e09a746ebadb0b2c73398ff9d118491 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 17:44:24 +0000 Subject: [PATCH 11/23] task_03 tests --- task_03/src/test.cpp | 44 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 41 insertions(+), 3 deletions(-) diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index ef5a86a..be70d9b 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -1,8 +1,46 @@ #include - +#include #include "topology_sort.hpp" -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +TEST(DaysUntilWarmerTest, IncreasingTemperatures) { + std::vector temps = {10, 20, 30, 40}; + std::vector expected = {1, 1, 1, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] +} + +TEST(DaysUntilWarmerTest, DecreasingTemperatures) { + std::vector temps = {40, 30, 20, 10}; + std::vector expected = {0, 0, 0, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] +} + +TEST(DaysUntilWarmerTest, MixedTemperatures) { + std::vector temps = {30, 40, 35, 42, 38, 33, 50}; + std::vector expected = {1, 2, 1, 3, 2, 1, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] +} + +TEST(DaysUntilWarmerTest, AllSameTemperatures) { + std::vector temps = {25, 25, 25, 25}; + std::vector expected = {0, 0, 0, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] +} + +TEST(DaysUntilWarmerTest, OneDayOnly) { + std::vector temps = {31}; + std::vector expected = {0}; + EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] +} + +TEST(DaysUntilWarmerTest, SpikeAtTheEnd) { + std::vector temps = {30, 25, 20, 35}; + std::vector expected = {3, 2, 1, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] +} + +TEST(DaysUntilWarmerTest, ValleyInMiddle) { + std::vector temps = {45, 30, 35, 20, 50}; + std::vector expected = {4, 1, 2, 1, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] } From 51ed9cda7ff66718c6b44ee4f7d8c685824127a4 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 17:47:38 +0000 Subject: [PATCH 12/23] task_04 tests --- task_04/src/test.cpp | 80 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 78 insertions(+), 2 deletions(-) diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 5e11617..d57f880 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -1,6 +1,82 @@ #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include + +#include "buy_fish.hpp" + +int totalFishBought(const std::vector& purchases) { + int total = 0; + for (int p : purchases) total += p; + return total; +} + +bool isValidSchedule(const std::vector& purchases, int k) { + int n = purchases.size(); + std::vector stock(n + k, 0); + for (int i = 0; i < n; ++i) { + for (int j = i; j < std::min(i + k, n); ++j) { + stock[j] += purchases[i]; + } + } + for (int i = 0; i < n; ++i) { + if (stock[i] == 0) return false; + stock[i]--; + } + return true; +} + +TEST(BuyFishTest, SimpleIncreasingPrices) { + std::vector prices = {1, 2, 3, 4, 5}; + int k = 2; + auto result = buy_fish(prices, k); + EXPECT_EQ(result.size(), prices.size()); + EXPECT_EQ(totalFishBought(result), prices.size()); + EXPECT_TRUE(isValidSchedule(result, k)); +} + +TEST(BuyFishTest, SimpleDecreasingPrices) { + std::vector prices = {5, 4, 3, 2, 1}; + int k = 3; + auto result = buy_fish(prices, k); + EXPECT_EQ(result.size(), prices.size()); + EXPECT_EQ(totalFishBought(result), prices.size()); + EXPECT_TRUE(isValidSchedule(result, k)); +} + +TEST(BuyFishTest, ConstantPrices) { + std::vector prices = {10, 10, 10, 10, 10}; + int k = 2; + auto result = buy_fish(prices, k); + EXPECT_EQ(result.size(), prices.size()); + EXPECT_EQ(totalFishBought(result), prices.size()); + EXPECT_TRUE(isValidSchedule(result, k)); +} + +TEST(BuyFishTest, OneDayShelfLife) { + std::vector prices = {3, 2, 4, 1, 5}; + int k = 1; + auto result = buy_fish(prices, k); + EXPECT_EQ(result.size(), prices.size()); + EXPECT_EQ(totalFishBought(result), prices.size()); + EXPECT_TRUE(isValidSchedule(result, k)); +} + +TEST(BuyFishTest, LargeKLongPlanning) { + std::vector prices = {9, 1, 2, 3, 4, 1, 10, 2, 3, 4}; + int k = 5; + auto result = buy_fish(prices, k); + EXPECT_EQ(result.size(), prices.size()); + EXPECT_EQ(totalFishBought(result), prices.size()); + EXPECT_TRUE(isValidSchedule(result, k)); +} + +TEST(BuyFishTest, AlwaysBuyOnePerDay) { + std::vector prices = {5, 4, 6, 7, 3}; + int k = 1; + auto result = buy_fish(prices, k); + EXPECT_EQ(result.size(), prices.size()); + for (int r : result) { + EXPECT_EQ(r, 1); // можно купить только на сегодня + } } From 363407e7118f7277b3dac51e46e30b1650a80864 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 17:50:04 +0000 Subject: [PATCH 13/23] task_05 tests --- task_05/src/test.cpp | 81 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 78 insertions(+), 3 deletions(-) diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index 5e11617..e82c54e 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -1,6 +1,81 @@ - #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include +#include + +#include "QuickSort.hpp" + +bool isSorted(const std::vector& arr) { + return std::is_sorted(arr.begin(), arr.end()); +} + +TEST(QuickSortTest, AlreadySorted) { + std::vector arr = {1, 2, 3, 4, 5}; + quickSort(arr); + EXPECT_TRUE(isSorted(arr)); +} + +TEST(QuickSortTest, ReverseSorted) { + std::vector arr = {5, 4, 3, 2, 1}; + quickSort(arr); + EXPECT_TRUE(isSorted(arr)); +} + +TEST(QuickSortTest, RandomOrder) { + std::vector arr = {3, 1, 4, 1, 5, 9, 2}; + quickSort(arr); + EXPECT_TRUE(isSorted(arr)); +} + +// === ГРАНИЧНЫЕ СЛУЧАИ === + +TEST(QuickSortTest, EmptyArray) { + std::vector arr; + quickSort(arr); + EXPECT_TRUE(arr.empty()); +} + +TEST(QuickSortTest, SingleElement) { + std::vector arr = {42}; + quickSort(arr); + EXPECT_EQ(arr, std::vector({42})); +} + +TEST(QuickSortTest, TwoElementsSorted) { + std::vector arr = {1, 2}; + quickSort(arr); + EXPECT_EQ(arr, std::vector({1, 2})); +} + +TEST(QuickSortTest, TwoElementsUnsorted) { + std::vector arr = {2, 1}; + quickSort(arr); + EXPECT_EQ(arr, std::vector({1, 2})); +} + +// === ОСОБЫЕ СЛУЧАИ === + +TEST(QuickSortTest, AllEqualElements) { + std::vector arr = {7, 7, 7, 7, 7}; + quickSort(arr); + EXPECT_EQ(arr, std::vector({7, 7, 7, 7, 7})); +} + +TEST(QuickSortTest, ContainsNegatives) { + std::vector arr = {-3, -1, -4, -2, 0}; + quickSort(arr); + EXPECT_TRUE(isSorted(arr)); +} + +TEST(QuickSortTest, DuplicatesAndUnique) { + std::vector arr = {4, 1, 3, 4, 2, 4, 5}; + quickSort(arr); + EXPECT_TRUE(isSorted(arr)); +} + +TEST(QuickSortTest, LargeInput) { + std::vector arr(1000); + for (int i = 0; i < 1000; ++i) arr[i] = rand() % 10000; + quickSort(arr); + EXPECT_TRUE(isSorted(arr)); } From fa9d1a44f0ee1379227f1a7b092d2f04ce90ccf1 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 17:55:03 +0000 Subject: [PATCH 14/23] task_06 tests --- task_06/src/test.cpp | 56 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 53 insertions(+), 3 deletions(-) diff --git a/task_06/src/test.cpp b/task_06/src/test.cpp index 5e11617..7a086a2 100644 --- a/task_06/src/test.cpp +++ b/task_06/src/test.cpp @@ -1,6 +1,56 @@ - #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include +#include + +#include "ord_stat.hpp" + +TEST(OrdStatTest, MinimumElement) { + std::vector arr = {4, 2, 5, 1, 3}; + EXPECT_EQ(ordstat(arr, 0), 1); // Stack [] +} + +TEST(OrdStatTest, MaximumElement) { + std::vector arr = {7, 8, 2, 5, 9}; + EXPECT_EQ(ordstat(arr, arr.size() - 1), 9); // Stack [] +} + +TEST(OrdStatTest, MedianElementOdd) { + std::vector arr = {5, 1, 9, 3, 7}; + EXPECT_EQ(ordstat(arr, 2), 5); // Stack [] +} + +TEST(OrdStatTest, MedianElementEven) { + std::vector arr = {10, 20, 30, 40}; + int result = ordstat(arr, 1); // второй по возрастанию — 20 + EXPECT_EQ(result, 20); // Stack [] } + +TEST(OrdStatTest, AllEqualElements) { + std::vector arr = {6, 6, 6, 6, 6}; + EXPECT_EQ(ordstat(arr, 3), 6); // Stack [] +} + +TEST(OrdStatTest, ContainsNegatives) { + std::vector arr = {-5, -10, 0, 5, 10}; + EXPECT_EQ(ordstat(arr, 1), -5); // Stack [] + EXPECT_EQ(ordstat(arr, 4), 10); // Stack [] +} + +TEST(OrdStatTest, DuplicatesInArray) { + std::vector arr = {4, 1, 4, 2, 2, 3}; + EXPECT_EQ(ordstat(arr, 3), 3); // Stack [] +} + +TEST(OrdStatTest, SingleElement) { + std::vector arr = {99}; + EXPECT_EQ(ordstat(arr, 0), 99); // Stack [] +} + +TEST(OrdStatTest, LargeArrayRandom) { + std::vector arr(1000); + for (int i = 0; i < 1000; ++i) arr[i] = rand() % 10000; + std::vector sorted = arr; + std::sort(sorted.begin(), sorted.end()); + EXPECT_EQ(ordstat(arr, 500), sorted[500]); // Stack [] +} \ No newline at end of file From ca4da350699895e18fb2c96b729e9ee64eb25fe4 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 18:10:42 +0000 Subject: [PATCH 15/23] task_07 tests --- task_07/src/AVLTree.cpp | 112 ------------------------------------- task_07/src/AVLTree.hpp | 120 +++++++++++++++++++++++++++++++++++++--- task_07/src/test.cpp | 81 ++++++++++++++++++++++++++- 3 files changed, 190 insertions(+), 123 deletions(-) delete mode 100644 task_07/src/AVLTree.cpp diff --git a/task_07/src/AVLTree.cpp b/task_07/src/AVLTree.cpp deleted file mode 100644 index 59c9eb4..0000000 --- a/task_07/src/AVLTree.cpp +++ /dev/null @@ -1,112 +0,0 @@ -#include "AVLTree.hpp" - -Node* AVLTree::rotateRight(Node* y) { - Node* x = y->left; - Node* T2 = x->right; - - x->right = y; - y->left = T2; - - updateHeight(y); - updateHeight(x); - - return x; -} - -Node* AVLTree::rotateLeft(Node* x) { - Node* y = x->right; - Node* T2 = y->left; - - y->left = x; - x->right = T2; - - updateHeight(x); - updateHeight(y); - - return y; -} - -Node* AVLTree::balance(Node* n) { - updateHeight(n); - int bf = balanceFactor(n); - - if (bf > 1) { - if (balanceFactor(n->left) < 0) { - n->left = rotateLeft(n->left); - } - return rotateRight(n); - } - - if (bf < -1) { - if (balanceFactor(n->right) > 0) { - n->right = rotateRight(n->right); - } - return rotateLeft(n); - } - - return n; -} - -Node* AVLTree::insert(Node* node, int key) { - if (!node) return new Node(key); - - 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::minValueNode(Node* node) { - Node* current = node; - while (current->left) current = current->left; - return current; -} - -Node* AVLTree::erase(Node* node, int key) { - if (!node) return node; - - if (key < node->key) - node->left = erase(node->left, key); - else if (key > node->key) - node->right = erase(node->right, key); - else { - if (!node->left || !node->right) { - Node* temp = node->left ? node->left : node->right; - if (!temp) { - temp = node; - node = nullptr; - } else { - *node = *temp; - } - delete temp; - } else { - Node* temp = minValueNode(node->right); - node->key = temp->key; - node->right = erase(node->right, temp->key); - } - } - - if (!node) return node; - - return balance(node); -} - -bool AVLTree::find(Node* node, int key) const { - if (!node) return false; - if (key == node->key) return true; - if (key < node->key) - return find(node->left, key); - else - return find(node->right, key); -} - -void AVLTree::inorder(Node* node) const { - if (!node) return; - inorder(node->left); - std::cout << node->key << " "; - inorder(node->right); -} diff --git a/task_07/src/AVLTree.hpp b/task_07/src/AVLTree.hpp index ce01275..4daf222 100644 --- a/task_07/src/AVLTree.hpp +++ b/task_07/src/AVLTree.hpp @@ -24,14 +24,116 @@ class AVLTree { n->height = 1 + std::max(height(n->left), height(n->right)); } - Node* rotateRight(Node* y); - Node* rotateLeft(Node* x); - Node* balance(Node* n); - Node* insert(Node* node, int key); - Node* minValueNode(Node* node); - Node* erase(Node* node, int key); - bool find(Node* node, int key) const; - void inorder(Node* node) const; + Node* rotateRight(Node* y) { + Node* x = y->left; + Node* T2 = x->right; + + x->right = y; + y->left = T2; + + updateHeight(y); + updateHeight(x); + + return x; + } + + Node* rotateLeft(Node* x) { + Node* y = x->right; + Node* T2 = y->left; + + y->left = x; + x->right = T2; + + updateHeight(x); + updateHeight(y); + + return y; + } + + Node* balance(Node* n) { + updateHeight(n); + int bf = balanceFactor(n); + + if (bf > 1) { + if (balanceFactor(n->left) < 0) { + n->left = rotateLeft(n->left); + } + return rotateRight(n); + } + + if (bf < -1) { + if (balanceFactor(n->right) > 0) { + n->right = rotateRight(n->right); + } + return rotateLeft(n); + } + + return n; + } + + Node* insert(Node* node, int key) { + if (!node) return new Node(key); + + 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* minValueNode(Node* node) { + Node* current = node; + while (current->left) current = current->left; + return current; + } + + Node* erase(Node* node, int key) { + if (!node) return node; + + if (key < node->key) + node->left = erase(node->left, key); + else if (key > node->key) + node->right = erase(node->right, key); + else { + if (!node->left || !node->right) { + Node* temp = node->left ? node->left : node->right; + if (!temp) { + temp = node; + node = nullptr; + } else { + *node = *temp; + } + delete temp; + } else { + Node* temp = minValueNode(node->right); + node->key = temp->key; + node->right = erase(node->right, temp->key); + } + } + + if (!node) return node; + + return balance(node); + } + + bool find(Node* node, int key) const { + if (!node) return false; + if (key == node->key) return true; + if (key < node->key) + return find(node->left, key); + else + return find(node->right, key); + } + + void inorder(Node* node) const { + if (!node) return; + inorder(node->left); + std::cout << node->key << " "; + inorder(node->right); + } public: void insert(int key) { root = insert(root, key); } @@ -44,4 +146,4 @@ class AVLTree { inorder(root); std::cout << "\n"; } -}; \ No newline at end of file +}; diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index 5e11617..a54a95c 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -1,6 +1,83 @@ #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include +#include +#include + +#include "AVLTree.hpp" + +class AVLTreeTest : public ::testing::Test { + protected: + AVLTree tree; + + void collectInorder(std::vector& out) {} +}; + +TEST_F(AVLTreeTest, InsertAndFind) { + tree.insert(10); + tree.insert(20); + tree.insert(5); + + EXPECT_TRUE(tree.find(10)); + EXPECT_TRUE(tree.find(20)); + EXPECT_TRUE(tree.find(5)); + EXPECT_FALSE(tree.find(15)); +} + +TEST_F(AVLTreeTest, InsertDuplicates) { + tree.insert(10); + tree.insert(10); + tree.insert(10); + + EXPECT_TRUE(tree.find(10)); +} + +TEST_F(AVLTreeTest, EraseLeaf) { + tree.insert(10); + tree.insert(5); + tree.insert(15); + tree.erase(5); + + EXPECT_FALSE(tree.find(5)); + EXPECT_TRUE(tree.find(10)); + EXPECT_TRUE(tree.find(15)); +} + +TEST_F(AVLTreeTest, EraseNodeWithOneChild) { + tree.insert(10); + tree.insert(5); + tree.insert(7); + tree.erase(5); + + EXPECT_FALSE(tree.find(5)); + EXPECT_TRUE(tree.find(7)); + EXPECT_TRUE(tree.find(10)); +} + +TEST_F(AVLTreeTest, EraseNodeWithTwoChildren) { + tree.insert(10); + tree.insert(5); + tree.insert(15); + tree.insert(12); + tree.insert(18); + tree.erase(15); + + EXPECT_FALSE(tree.find(15)); + EXPECT_TRUE(tree.find(12)); + EXPECT_TRUE(tree.find(18)); + EXPECT_TRUE(tree.find(10)); +} + +TEST_F(AVLTreeTest, BalanceProperty) { + // Проверка высот и баланса вручную сложнее, + // но можно вставить много элементов и убедиться, + // что поиск не ломается и элементы в порядке. + for (int i = 1; i <= 1000; ++i) { + tree.insert(i); + } + + for (int i = 1; i <= 1000; ++i) { + EXPECT_TRUE(tree.find(i)); + } } From d587a5fec596e2b4ee72fce8d9ca4db5829537dc Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 18:14:12 +0000 Subject: [PATCH 16/23] task_08 tests --- task_08/src/HashTable.cpp | 61 --------------------------- task_08/src/HashTable.hpp | 60 +++++++++++++++++++++++--- task_08/src/test.cpp | 89 ++++++++++++++++++++++++++++++++++++++- 3 files changed, 142 insertions(+), 68 deletions(-) delete mode 100644 task_08/src/HashTable.cpp diff --git a/task_08/src/HashTable.cpp b/task_08/src/HashTable.cpp deleted file mode 100644 index 2613ffb..0000000 --- a/task_08/src/HashTable.cpp +++ /dev/null @@ -1,61 +0,0 @@ -#include "HashTable.hpp" - -void HashTable::rehash() { - int old_capacity = capacity; - capacity *= 2; - std::vector>> new_table(capacity); - - for (const auto& bucket : table) { - for (const auto& entry : bucket) { - int idx = std::hash{}(entry.first) % capacity; - new_table[idx].emplace_back(entry.first, entry.second); - } - } - - table = std::move(new_table); -}; - -void HashTable::insert(const std::string& key, int value) { - int idx = getIndex(key); - for (auto& entry : table[idx]) { - if (entry.first == key) { - entry.second = value; - return; - } - } - table[idx].emplace_back(key, value); - ++size; - checkLoadFactorAndRehash(); -}; - -std::optional HashTable::find(const std::string& key) const { - int idx = getIndex(key); - for (const auto& entry : table[idx]) { - if (entry.first == key) { - return entry.second; - } - } - return std::nullopt; -}; - -bool HashTable::erase(const std::string& key) { - int idx = getIndex(key); - for (auto it = table[idx].begin(); it != table[idx].end(); ++it) { - if (it->first == key) { - table[idx].erase(it); - --size; - return true; - } - } - return false; -}; - -void HashTable::print() const { - for (int i = 0; i < capacity; ++i) { - std::cout << "[" << i << "]: "; - for (const auto& entry : table[i]) { - std::cout << "(" << entry.first << ": " << entry.second << ") "; - } - std::cout << std::endl; - } -}; \ No newline at end of file diff --git a/task_08/src/HashTable.hpp b/task_08/src/HashTable.hpp index 949fd9d..2afb756 100644 --- a/task_08/src/HashTable.hpp +++ b/task_08/src/HashTable.hpp @@ -16,7 +16,20 @@ class HashTable { return std::hash{}(key) % capacity; } - void rehash(); + void rehash() { + int old_capacity = capacity; + capacity *= 2; + std::vector>> new_table(capacity); + + for (const auto& bucket : table) { + for (const auto& entry : bucket) { + int idx = std::hash{}(entry.first) % capacity; + new_table[idx].emplace_back(entry.first, entry.second); + } + } + + table = std::move(new_table); + } void checkLoadFactorAndRehash() { if (size > capacity / 2) { @@ -29,11 +42,48 @@ class HashTable { table.resize(capacity); } - void insert(const std::string& key, int value); + void insert(const std::string& key, int value) { + int idx = getIndex(key); + for (auto& entry : table[idx]) { + if (entry.first == key) { + entry.second = value; + return; + } + } + table[idx].emplace_back(key, value); + ++size; + checkLoadFactorAndRehash(); + } - std::optional find(const std::string& key) const; + std::optional find(const std::string& key) const { + int idx = getIndex(key); + for (const auto& entry : table[idx]) { + if (entry.first == key) { + return entry.second; + } + } + return std::nullopt; + } - bool erase(const std::string& key); + bool erase(const std::string& key) { + int idx = getIndex(key); + for (auto it = table[idx].begin(); it != table[idx].end(); ++it) { + if (it->first == key) { + table[idx].erase(it); + --size; + return true; + } + } + return false; + } - void print() const; + void print() const { + for (int i = 0; i < capacity; ++i) { + std::cout << "[" << i << "]: "; + for (const auto& entry : table[i]) { + std::cout << "(" << entry.first << ": " << entry.second << ") "; + } + std::cout << std::endl; + } + } }; \ No newline at end of file diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 5e11617..fb361c8 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -1,6 +1,91 @@ #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include + +#include "HashTable.hpp" + +class HashTableTest : public ::testing::Test { + protected: + HashTable ht; +}; + +TEST_F(HashTableTest, InsertAndFind) { + ht.insert("apple", 10); + ht.insert("banana", 20); + ht.insert("orange", 30); + + auto res = ht.find("apple"); + ASSERT_TRUE(res.has_value()); + EXPECT_EQ(res.value(), 10); + + res = ht.find("banana"); + ASSERT_TRUE(res.has_value()); + EXPECT_EQ(res.value(), 20); + + res = ht.find("orange"); + ASSERT_TRUE(res.has_value()); + EXPECT_EQ(res.value(), 30); +} + +TEST_F(HashTableTest, FindNonExistentKey) { + ht.insert("apple", 10); + auto res = ht.find("pear"); + EXPECT_FALSE(res.has_value()); +} + +TEST_F(HashTableTest, InsertOverwriteValue) { + ht.insert("apple", 10); + ht.insert("apple", 50); + + auto res = ht.find("apple"); + ASSERT_TRUE(res.has_value()); + EXPECT_EQ(res.value(), 50); +} + +TEST_F(HashTableTest, EraseExistingKey) { + ht.insert("apple", 10); + ht.insert("banana", 20); + + bool erased = ht.erase("apple"); + EXPECT_TRUE(erased); + + auto res = ht.find("apple"); + EXPECT_FALSE(res.has_value()); + + res = ht.find("banana"); + ASSERT_TRUE(res.has_value()); + EXPECT_EQ(res.value(), 20); +} + +TEST_F(HashTableTest, EraseNonExistentKey) { + ht.insert("apple", 10); + + bool erased = ht.erase("pear"); + EXPECT_FALSE(erased); +} + +TEST_F(HashTableTest, RehashTriggered) { + // Инициализируем маленькую таблицу, чтобы быстро вызвать rehash + HashTable small_ht(2); + small_ht.insert("key1", 1); + small_ht.insert( + "key2", 2); // После этого должен сработать rehash, capacity увеличится + + EXPECT_TRUE(small_ht.find("key1").has_value()); + EXPECT_TRUE(small_ht.find("key2").has_value()); + + small_ht.insert("key3", 3); + EXPECT_TRUE(small_ht.find("key3").has_value()); } + +TEST_F(HashTableTest, InsertManyAndFindAll) { + for (int i = 0; i < 1000; ++i) { + ht.insert("key" + std::to_string(i), i); + } + for (int i = 0; i < 1000; ++i) { + auto val = ht.find("key" + std::to_string(i)); + ASSERT_TRUE(val.has_value()); + EXPECT_EQ(val.value(), i); + } +} \ No newline at end of file From 248aa2c9b48ff5cac88f1fe274accaf77e14ef60 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 18:18:36 +0000 Subject: [PATCH 17/23] task_09 tests --- task_09/src/good_table.cpp | 44 -------------------- task_09/src/good_table.hpp | 41 +++++++++++++++++-- task_09/src/test.cpp | 84 ++++++++++++++++++++++++++++++-------- 3 files changed, 106 insertions(+), 63 deletions(-) delete mode 100644 task_09/src/good_table.cpp diff --git a/task_09/src/good_table.cpp b/task_09/src/good_table.cpp deleted file mode 100644 index 867e3d9..0000000 --- a/task_09/src/good_table.cpp +++ /dev/null @@ -1,44 +0,0 @@ -#include "good_table.hpp" - -SortedTableChecker::SortedTableChecker( - const std::vector>& table) - : a(table) { - n = (int)a.size(); - m = n > 0 ? (int)a[0].size() : 0; - preprocess(); -}; - -void SortedTableChecker::preprocess() { - if (n == 0 || m == 0) return; - - std::vector> maxReachCol(m, std::vector(n)); - - for (int j = 0; j < m; j++) { - maxReachCol[j][n - 1] = n - 1; - for (int i = n - 2; i >= 0; i--) { - if (a[i][j] <= a[i + 1][j]) - maxReachCol[j][i] = maxReachCol[j][i + 1]; - else - maxReachCol[j][i] = i; - } - } - - maxReachForRow.resize(n); - for (int i = 0; i < n; i++) { - int best = i; - for (int j = 0; j < m; j++) { - if (maxReachCol[j][i] > best) best = maxReachCol[j][i]; - } - maxReachForRow[i] = best; - } - - for (int i = 1; i < n; i++) { - if (maxReachForRow[i] < maxReachForRow[i - 1]) - maxReachForRow[i] = maxReachForRow[i - 1]; - } -}; - -bool SortedTableChecker::isSortedSegment(int l, int r) const { - if (l < 0 || r >= n || l > r) return false; - return maxReachForRow[l] >= r; -}; \ No newline at end of file diff --git a/task_09/src/good_table.hpp b/task_09/src/good_table.hpp index 4485fae..fc89bba 100644 --- a/task_09/src/good_table.hpp +++ b/task_09/src/good_table.hpp @@ -10,9 +10,44 @@ class SortedTableChecker { std::vector maxReachForRow; public: - SortedTableChecker(const std::vector>& table); + SortedTableChecker(const std::vector>& table) : a(table) { + n = (int)a.size(); + m = n > 0 ? (int)a[0].size() : 0; + preprocess(); + } - void preprocess(); + void preprocess() { + if (n == 0 || m == 0) return; - bool isSortedSegment(int l, int r) const; + std::vector> maxReachCol(m, std::vector(n)); + + for (int j = 0; j < m; j++) { + maxReachCol[j][n - 1] = n - 1; + for (int i = n - 2; i >= 0; i--) { + if (a[i][j] <= a[i + 1][j]) + maxReachCol[j][i] = maxReachCol[j][i + 1]; + else + maxReachCol[j][i] = i; + } + } + + maxReachForRow.resize(n); + for (int i = 0; i < n; i++) { + int best = i; + for (int j = 0; j < m; j++) { + if (maxReachCol[j][i] > best) best = maxReachCol[j][i]; + } + maxReachForRow[i] = best; + } + + for (int i = 1; i < n; i++) { + if (maxReachForRow[i] < maxReachForRow[i - 1]) + maxReachForRow[i] = maxReachForRow[i - 1]; + } + } + + bool isSortedSegment(int l, int r) const { + if (l < 0 || r >= n || l > r) return false; + return maxReachForRow[l] >= r; + } }; diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp index a42caa4..2866c6b 100644 --- a/task_09/src/test.cpp +++ b/task_09/src/test.cpp @@ -2,22 +2,74 @@ #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 "good_table.hpp" +// 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"})); +// } + +// TEST(CanReachNonDecreasingSegment, 2) { +// ASSERT_EQ(SolveFunction(1, 1, 1, std::vector>{{1, 1}}, +// std::vector>{{1, 1}}), +// (std::vector{"Yes"})); +// } + +TEST(SortedTableCheckerTest, SingleColumnSorted) { + std::vector> table = {{1}, {2}, {3}, {4}}; + SortedTableChecker checker(table); + EXPECT_TRUE(checker.isSortedSegment(0, 3)); + EXPECT_TRUE(checker.isSortedSegment(1, 2)); + EXPECT_TRUE(checker.isSortedSegment(2, 3)); +} + +TEST(SortedTableCheckerTest, MultiColumnOneSorted) { + std::vector> table = {{3, 2, 1}, {2, 2, 2}, {1, 2, 3}}; + SortedTableChecker checker(table); + EXPECT_TRUE(checker.isSortedSegment(0, 2)); // column 1 and 2 sorted + EXPECT_TRUE(checker.isSortedSegment(1, 2)); + EXPECT_TRUE(checker.isSortedSegment(0, 1)); +} + +TEST(SortedTableCheckerTest, NoSortedColumns) { + std::vector> table = {{3, 3, 3}, {2, 2, 2}, {1, 1, 1}}; + SortedTableChecker checker(table); + EXPECT_FALSE(checker.isSortedSegment(0, 2)); + EXPECT_FALSE(checker.isSortedSegment(1, 2)); } -TEST(CanReachNonDecreasingSegment, 2) { - // ASSERT_EQ(SolveFunction(1, 1, 1, std::vector>{{1, 1}}, - // std::vector>{{1, 1}}), - // (std::vector{"Yes"})); +TEST(SortedTableCheckerTest, AllColumnsSorted) { + std::vector> table = { + {1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}; + SortedTableChecker checker(table); + EXPECT_TRUE(checker.isSortedSegment(0, 3)); + EXPECT_TRUE(checker.isSortedSegment(1, 3)); + EXPECT_TRUE(checker.isSortedSegment(2, 3)); } + +TEST(SortedTableCheckerTest, EdgeCases) { + std::vector> table = {{5}}; + SortedTableChecker checker(table); + EXPECT_TRUE(checker.isSortedSegment(0, 0)); // Only one row, trivially sorted + + std::vector> emptyTable; + SortedTableChecker checkerEmpty(emptyTable); + EXPECT_FALSE( + checkerEmpty.isSortedSegment(0, 0)); // Invalid since table is empty +} + +TEST(SortedTableCheckerTest, OutOfBoundsQueries) { + std::vector> table = {{1, 2}, {3, 4}}; + SortedTableChecker checker(table); + EXPECT_FALSE(checker.isSortedSegment(-1, 1)); + EXPECT_FALSE(checker.isSortedSegment(0, 2)); + EXPECT_FALSE(checker.isSortedSegment(1, 0)); +} \ No newline at end of file From 90a2574cf7cfd668fee53c64dcd5ab3cf6d37148 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 20:28:17 +0000 Subject: [PATCH 18/23] task_08 template --- task_08/src/HashTable.hpp | 9 +++++---- task_08/src/test.cpp | 4 ++-- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/task_08/src/HashTable.hpp b/task_08/src/HashTable.hpp index 2afb756..21c8382 100644 --- a/task_08/src/HashTable.hpp +++ b/task_08/src/HashTable.hpp @@ -6,9 +6,10 @@ #include #include +template class HashTable { private: - std::vector>> table; + std::vector>> table; int capacity; int size; @@ -19,7 +20,7 @@ class HashTable { void rehash() { int old_capacity = capacity; capacity *= 2; - std::vector>> new_table(capacity); + std::vector>> new_table(capacity); for (const auto& bucket : table) { for (const auto& entry : bucket) { @@ -42,7 +43,7 @@ class HashTable { table.resize(capacity); } - void insert(const std::string& key, int value) { + void insert(const std::string& key, T value) { int idx = getIndex(key); for (auto& entry : table[idx]) { if (entry.first == key) { @@ -55,7 +56,7 @@ class HashTable { checkLoadFactorAndRehash(); } - std::optional find(const std::string& key) const { + std::optional find(const std::string& key) const { int idx = getIndex(key); for (const auto& entry : table[idx]) { if (entry.first == key) { diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index fb361c8..6559f13 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -7,7 +7,7 @@ class HashTableTest : public ::testing::Test { protected: - HashTable ht; + HashTable ht; }; TEST_F(HashTableTest, InsertAndFind) { @@ -67,7 +67,7 @@ TEST_F(HashTableTest, EraseNonExistentKey) { TEST_F(HashTableTest, RehashTriggered) { // Инициализируем маленькую таблицу, чтобы быстро вызвать rehash - HashTable small_ht(2); + HashTable small_ht(2); small_ht.insert("key1", 1); small_ht.insert( "key2", 2); // После этого должен сработать rehash, capacity увеличится From 8b50a8090c3516484432d813a373cd1686e9fb2d Mon Sep 17 00:00:00 2001 From: salexkon Date: Sat, 21 Jun 2025 20:36:33 +0000 Subject: [PATCH 19/23] all clang-formatted --- task_01/src/test.cpp | 18 +++++++++--------- task_03/src/test.cpp | 44 +++++++++++++++++++++++--------------------- task_05/src/test.cpp | 4 ---- task_06/src/test.cpp | 22 +++++++++++----------- task_07/src/test.cpp | 3 --- task_08/src/test.cpp | 4 +--- task_09/src/test.cpp | 7 +++---- 7 files changed, 47 insertions(+), 55 deletions(-) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index f167048..cd6ed7c 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -8,32 +8,32 @@ TEST(FindTwoNumsTest, BasicMatch) { std::vector arr = {1, 2, 3, 4, 6}; - auto result = find_two_nums(7, arr); // 3 + 4 + auto result = find_two_nums(7, arr); std::sort(result.begin(), result.end()); - ASSERT_EQ(result, std::vector({1, 6})); // Stack [] + ASSERT_EQ(result, std::vector({1, 6})); } TEST(FindTwoNumsTest, MultiplePairsPossible) { std::vector arr = {1, 2, 3, 4, 4, 5}; - auto result = find_two_nums(8, arr); // could be 3+5 or 4+4 - ASSERT_EQ(result[0] + result[1], 8); // Stack [] + auto result = find_two_nums(8, arr); + ASSERT_EQ(result[0] + result[1], 8); } TEST(FindTwoNumsTest, NoSolution) { std::vector arr = {1, 2, 3}; - ASSERT_EQ(find_two_nums(10, arr), std::vector{}); // Stack [] + ASSERT_EQ(find_two_nums(10, arr), std::vector{}); } TEST(FindTwoNumsTest, NegativeNumbers) { std::vector arr = {-5, -2, 0, 3, 7, 9}; - auto result = find_two_nums(4, arr); // -5 + 9 = 4 + auto result = find_two_nums(4, arr); std::sort(result.begin(), result.end()); - ASSERT_EQ(result, std::vector({-5, 9})); // Stack [] + ASSERT_EQ(result, std::vector({-5, 9})); } TEST(FindTwoNumsTest, SameElementTwice) { std::vector arr = {1, 2, 4, 4, 5, 6}; - auto result = find_two_nums(8, arr); // 4 + 4 + auto result = find_two_nums(8, arr); std::sort(result.begin(), result.end()); - ASSERT_EQ(result, std::vector({2, 6})); // Stack [] + ASSERT_EQ(result, std::vector({2, 6})); } \ No newline at end of file diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index be70d9b..322c4a9 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -1,46 +1,48 @@ #include + #include + #include "topology_sort.hpp" TEST(DaysUntilWarmerTest, IncreasingTemperatures) { - std::vector temps = {10, 20, 30, 40}; - std::vector expected = {1, 1, 1, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] + std::vector temps = {10, 20, 30, 40}; + std::vector expected = {1, 1, 1, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); } TEST(DaysUntilWarmerTest, DecreasingTemperatures) { - std::vector temps = {40, 30, 20, 10}; - std::vector expected = {0, 0, 0, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] + std::vector temps = {40, 30, 20, 10}; + std::vector expected = {0, 0, 0, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); } TEST(DaysUntilWarmerTest, MixedTemperatures) { - std::vector temps = {30, 40, 35, 42, 38, 33, 50}; - std::vector expected = {1, 2, 1, 3, 2, 1, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] + std::vector temps = {30, 40, 35, 42, 38, 33, 50}; + std::vector expected = {1, 2, 1, 3, 2, 1, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); } TEST(DaysUntilWarmerTest, AllSameTemperatures) { - std::vector temps = {25, 25, 25, 25}; - std::vector expected = {0, 0, 0, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] + std::vector temps = {25, 25, 25, 25}; + std::vector expected = {0, 0, 0, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); } TEST(DaysUntilWarmerTest, OneDayOnly) { - std::vector temps = {31}; - std::vector expected = {0}; - EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] + std::vector temps = {31}; + std::vector expected = {0}; + EXPECT_EQ(days_until_warmer(temps), expected); } TEST(DaysUntilWarmerTest, SpikeAtTheEnd) { - std::vector temps = {30, 25, 20, 35}; - std::vector expected = {3, 2, 1, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] + std::vector temps = {30, 25, 20, 35}; + std::vector expected = {3, 2, 1, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); } TEST(DaysUntilWarmerTest, ValleyInMiddle) { - std::vector temps = {45, 30, 35, 20, 50}; - std::vector expected = {4, 1, 2, 1, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); // Stack [] + std::vector temps = {45, 30, 35, 20, 50}; + std::vector expected = {4, 1, 2, 1, 0}; + EXPECT_EQ(days_until_warmer(temps), expected); } diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index e82c54e..994bec5 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -27,8 +27,6 @@ TEST(QuickSortTest, RandomOrder) { EXPECT_TRUE(isSorted(arr)); } -// === ГРАНИЧНЫЕ СЛУЧАИ === - TEST(QuickSortTest, EmptyArray) { std::vector arr; quickSort(arr); @@ -53,8 +51,6 @@ TEST(QuickSortTest, TwoElementsUnsorted) { EXPECT_EQ(arr, std::vector({1, 2})); } -// === ОСОБЫЕ СЛУЧАИ === - TEST(QuickSortTest, AllEqualElements) { std::vector arr = {7, 7, 7, 7, 7}; quickSort(arr); diff --git a/task_06/src/test.cpp b/task_06/src/test.cpp index 7a086a2..1c11790 100644 --- a/task_06/src/test.cpp +++ b/task_06/src/test.cpp @@ -7,44 +7,44 @@ TEST(OrdStatTest, MinimumElement) { std::vector arr = {4, 2, 5, 1, 3}; - EXPECT_EQ(ordstat(arr, 0), 1); // Stack [] + EXPECT_EQ(ordstat(arr, 0), 1); } TEST(OrdStatTest, MaximumElement) { std::vector arr = {7, 8, 2, 5, 9}; - EXPECT_EQ(ordstat(arr, arr.size() - 1), 9); // Stack [] + EXPECT_EQ(ordstat(arr, arr.size() - 1), 9); } TEST(OrdStatTest, MedianElementOdd) { std::vector arr = {5, 1, 9, 3, 7}; - EXPECT_EQ(ordstat(arr, 2), 5); // Stack [] + EXPECT_EQ(ordstat(arr, 2), 5); } TEST(OrdStatTest, MedianElementEven) { std::vector arr = {10, 20, 30, 40}; - int result = ordstat(arr, 1); // второй по возрастанию — 20 - EXPECT_EQ(result, 20); // Stack [] + int result = ordstat(arr, 1); + EXPECT_EQ(result, 20); } TEST(OrdStatTest, AllEqualElements) { std::vector arr = {6, 6, 6, 6, 6}; - EXPECT_EQ(ordstat(arr, 3), 6); // Stack [] + EXPECT_EQ(ordstat(arr, 3), 6); } TEST(OrdStatTest, ContainsNegatives) { std::vector arr = {-5, -10, 0, 5, 10}; - EXPECT_EQ(ordstat(arr, 1), -5); // Stack [] - EXPECT_EQ(ordstat(arr, 4), 10); // Stack [] + EXPECT_EQ(ordstat(arr, 1), -5); + EXPECT_EQ(ordstat(arr, 4), 10); } TEST(OrdStatTest, DuplicatesInArray) { std::vector arr = {4, 1, 4, 2, 2, 3}; - EXPECT_EQ(ordstat(arr, 3), 3); // Stack [] + EXPECT_EQ(ordstat(arr, 3), 3); } TEST(OrdStatTest, SingleElement) { std::vector arr = {99}; - EXPECT_EQ(ordstat(arr, 0), 99); // Stack [] + EXPECT_EQ(ordstat(arr, 0), 99); } TEST(OrdStatTest, LargeArrayRandom) { @@ -52,5 +52,5 @@ TEST(OrdStatTest, LargeArrayRandom) { for (int i = 0; i < 1000; ++i) arr[i] = rand() % 10000; std::vector sorted = arr; std::sort(sorted.begin(), sorted.end()); - EXPECT_EQ(ordstat(arr, 500), sorted[500]); // Stack [] + EXPECT_EQ(ordstat(arr, 500), sorted[500]); } \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index a54a95c..e335245 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -70,9 +70,6 @@ TEST_F(AVLTreeTest, EraseNodeWithTwoChildren) { } TEST_F(AVLTreeTest, BalanceProperty) { - // Проверка высот и баланса вручную сложнее, - // но можно вставить много элементов и убедиться, - // что поиск не ломается и элементы в порядке. for (int i = 1; i <= 1000; ++i) { tree.insert(i); } diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 6559f13..daa8be3 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -66,11 +66,9 @@ TEST_F(HashTableTest, EraseNonExistentKey) { } TEST_F(HashTableTest, RehashTriggered) { - // Инициализируем маленькую таблицу, чтобы быстро вызвать rehash HashTable small_ht(2); small_ht.insert("key1", 1); - small_ht.insert( - "key2", 2); // После этого должен сработать rehash, capacity увеличится + small_ht.insert("key2", 2); EXPECT_TRUE(small_ht.find("key1").has_value()); EXPECT_TRUE(small_ht.find("key2").has_value()); diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp index 2866c6b..69b6e94 100644 --- a/task_09/src/test.cpp +++ b/task_09/src/test.cpp @@ -34,7 +34,7 @@ TEST(SortedTableCheckerTest, SingleColumnSorted) { TEST(SortedTableCheckerTest, MultiColumnOneSorted) { std::vector> table = {{3, 2, 1}, {2, 2, 2}, {1, 2, 3}}; SortedTableChecker checker(table); - EXPECT_TRUE(checker.isSortedSegment(0, 2)); // column 1 and 2 sorted + EXPECT_TRUE(checker.isSortedSegment(0, 2)); EXPECT_TRUE(checker.isSortedSegment(1, 2)); EXPECT_TRUE(checker.isSortedSegment(0, 1)); } @@ -58,12 +58,11 @@ TEST(SortedTableCheckerTest, AllColumnsSorted) { TEST(SortedTableCheckerTest, EdgeCases) { std::vector> table = {{5}}; SortedTableChecker checker(table); - EXPECT_TRUE(checker.isSortedSegment(0, 0)); // Only one row, trivially sorted + EXPECT_TRUE(checker.isSortedSegment(0, 0)); std::vector> emptyTable; SortedTableChecker checkerEmpty(emptyTable); - EXPECT_FALSE( - checkerEmpty.isSortedSegment(0, 0)); // Invalid since table is empty + EXPECT_FALSE(checkerEmpty.isSortedSegment(0, 0)); } TEST(SortedTableCheckerTest, OutOfBoundsQueries) { From 772e03e2b7db67bb164335a35ee7334bfe582667 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sun, 22 Jun 2025 08:40:03 +0000 Subject: [PATCH 20/23] task_02 modified --- task_02/src/stack.cpp | 21 ---------- task_02/src/stack.hpp | 89 +++++++++++++++++++++++++++++++++++++++---- task_02/src/test.cpp | 4 +- 3 files changed, 83 insertions(+), 31 deletions(-) delete mode 100644 task_02/src/stack.cpp 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 index 138ec40..26776d3 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -1,23 +1,96 @@ #pragma once -#include +#include #include +template class Stack { public: - void Push(int value); - int Pop(); + Stack(){}; + Stack(std::vector vec) { + for (auto val : vec) { + push(val); + } + } + void Push(T value) { data_.push_back(value); } + T Pop() { + T result = data_.back(); + data_.pop_back(); + return result; + } private: - std::stack data_; + std::vector data_; }; +template class MinStack { public: - void Push(int value); - int Pop(); - int GetMin(); + MinStack(){}; + MinStack(std::vector vec) { + for (auto val : vec) { + push(val); + } + } + void Push(T value) { + data_.push_back(value); + if (data_mins.size() == 0 || value <= data_mins.back()) { + data_mins.push_back(value); + } else { + data_mins.push_back(data_mins.back()); + } + } + T Pop() { + T result = data_.back(); + data_.pop_back(); + data_mins.pop_back(); + return result; + } + + T GetMin() { + if (data_mins.size() == 0) { + throw std::runtime_error("Пустой стек - нет минимума"); + } + return data_mins.back(); + } private: - std::vector data_; + std::vector data_; + std::vector data_mins; }; + +template +class MaxStack { + public: + MaxStack(){}; + MaxStack(std::vector vec) { + for (auto val : vec) { + push(val); + } + } + void Push(T value) { + data_.push_back(value); + if (data_maxs.size() == 0 || value >= data_maxs.back()) { + data_maxs.push_back(value); + } else { + data_maxs.push_back(data_maxs.back()); + } + } + T Pop() { + T result = data_.back(); + data_.pop_back(); + data_maxs.pop_back(); + return result; + } + + T getmax() { + if (data_maxs.size() == 0) { + throw std::runtime_error("Пустой стек - нет минимума"); + } + return data_maxs.back(); + } + + private: + std::vector data_; + std::vector data_maxs; +}; \ No newline at end of file diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 54e7ce9..9960b93 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -6,7 +6,7 @@ #include "stack.hpp" TEST(StackTest, Simple) { - Stack stack; + Stack stack; stack.Push(1); // Stack [1] ASSERT_EQ(stack.Pop(), 1); // Stack [] stack.Push(1); // Stack [1] @@ -22,7 +22,7 @@ TEST(StackTest, Simple) { } TEST(MinStackTest, Simple) { - MinStack stack; + MinStack stack; stack.Push(1); // Stack [1] ASSERT_EQ(stack.GetMin(), 1); ASSERT_EQ(stack.Pop(), 1); // Stack [] From d1d812c536e8f7fea477f2ef037c4aaedab010f5 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sun, 22 Jun 2025 21:42:58 +0000 Subject: [PATCH 21/23] all tasks editted --- task_01/src/task_01.cpp | 3 +- task_01/src/task_01.hpp | 2 +- task_01/src/test.cpp | 10 +- task_02/src/stack.hpp | 28 +++-- task_02/src/test.cpp | 109 +++++++++++++++++- ...pology_sort.cpp => days_untill_warmer.cpp} | 9 +- task_03/src/days_untill_warmer.hpp | 5 + task_03/src/test.cpp | 21 ++-- task_03/src/topology_sort.hpp | 5 - task_04/src/test.cpp | 36 +++--- task_05/src/QuickSort.cpp | 2 + task_05/src/QuickSort.hpp | 1 - task_05/src/test.cpp | 6 +- task_06/src/ord_stat.cpp | 6 +- task_07/src/AVLTree.hpp | 20 ++-- task_08/src/HashTable.hpp | 5 +- 16 files changed, 205 insertions(+), 63 deletions(-) rename task_03/src/{topology_sort.cpp => days_untill_warmer.cpp} (62%) create mode 100644 task_03/src/days_untill_warmer.hpp delete mode 100644 task_03/src/topology_sort.hpp diff --git a/task_01/src/task_01.cpp b/task_01/src/task_01.cpp index 76f51ff..f9154da 100644 --- a/task_01/src/task_01.cpp +++ b/task_01/src/task_01.cpp @@ -1,9 +1,8 @@ #include "task_01.hpp" -std::vector find_two_nums(int target, std::vector arr) { +std::vector FindTwoNums(int target, const std::vector& arr) { int left = 0; int right = arr.size() - 1; - int sum = arr[right] + arr[left]; while (left < right) { int sum = arr[left] + arr[right]; if (sum == target) { diff --git a/task_01/src/task_01.hpp b/task_01/src/task_01.hpp index f0ac4da..13aefe2 100644 --- a/task_01/src/task_01.hpp +++ b/task_01/src/task_01.hpp @@ -1,4 +1,4 @@ #pragma once #include -std::vector find_two_nums(int target, std::vector arr); \ No newline at end of file +std::vector FindTwoNums(int target, const std::vector& arr); \ No newline at end of file diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index cd6ed7c..cf3c90f 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -8,32 +8,32 @@ TEST(FindTwoNumsTest, BasicMatch) { std::vector arr = {1, 2, 3, 4, 6}; - auto result = find_two_nums(7, arr); + auto result = FindTwoNums(7, arr); std::sort(result.begin(), result.end()); ASSERT_EQ(result, std::vector({1, 6})); } TEST(FindTwoNumsTest, MultiplePairsPossible) { std::vector arr = {1, 2, 3, 4, 4, 5}; - auto result = find_two_nums(8, arr); + auto result = FindTwoNums(8, arr); ASSERT_EQ(result[0] + result[1], 8); } TEST(FindTwoNumsTest, NoSolution) { std::vector arr = {1, 2, 3}; - ASSERT_EQ(find_two_nums(10, arr), std::vector{}); + ASSERT_EQ(FindTwoNums(10, arr), std::vector{}); } TEST(FindTwoNumsTest, NegativeNumbers) { std::vector arr = {-5, -2, 0, 3, 7, 9}; - auto result = find_two_nums(4, arr); + auto result = FindTwoNums(4, arr); std::sort(result.begin(), result.end()); ASSERT_EQ(result, std::vector({-5, 9})); } TEST(FindTwoNumsTest, SameElementTwice) { std::vector arr = {1, 2, 4, 4, 5, 6}; - auto result = find_two_nums(8, arr); + auto result = FindTwoNums(8, arr); std::sort(result.begin(), result.end()); ASSERT_EQ(result, std::vector({2, 6})); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 26776d3..0956f1c 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -19,6 +19,10 @@ class Stack { return result; } + int Size() { return data_.size(); } + + bool IsEmpty() { return data_.empty(); } + private: std::vector data_; }; @@ -34,29 +38,33 @@ class MinStack { } void Push(T value) { data_.push_back(value); - if (data_mins.size() == 0 || value <= data_mins.back()) { - data_mins.push_back(value); + if (data_mins_.size() == 0 || value <= data_mins_.back()) { + data_mins_.push_back(value); } else { - data_mins.push_back(data_mins.back()); + data_mins_.push_back(data_mins_.back()); } } T Pop() { T result = data_.back(); data_.pop_back(); - data_mins.pop_back(); + data_mins_.pop_back(); return result; } T GetMin() { - if (data_mins.size() == 0) { + if (data_mins_.size() == 0) { throw std::runtime_error("Пустой стек - нет минимума"); } - return data_mins.back(); + return data_mins_.back(); } + int Size() { return data_.size(); } + + bool IsEmpty() { return data_.empty(); } + private: std::vector data_; - std::vector data_mins; + std::vector data_mins_; }; template @@ -83,13 +91,17 @@ class MaxStack { return result; } - T getmax() { + T GetMax() { if (data_maxs.size() == 0) { throw std::runtime_error("Пустой стек - нет минимума"); } return data_maxs.back(); } + int Size() { return data_.size(); } + + bool IsEmpty() { return data_.empty(); } + private: std::vector data_; std::vector data_maxs; diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 9960b93..b4f43a4 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -39,4 +39,111 @@ TEST(MinStackTest, Simple) { ASSERT_EQ(stack.GetMin(), 1); ASSERT_EQ(stack.Pop(), 3); // Stack [1] ASSERT_EQ(stack.Pop(), 1); // Stack [] -} \ No newline at end of file +} + +// // ------------------------- Stack ---------------------------- + +TEST(StackTest, BasicPushPop) { + Stack s; + s.Push(1); + s.Push(2); + EXPECT_EQ(s.Pop(), 2); + EXPECT_EQ(s.Pop(), 1); +} + +TEST(StackTest, IsEmptyInitially) { + Stack s; + EXPECT_TRUE(s.IsEmpty()); + EXPECT_EQ(s.Size(), 0); +} + +TEST(StackTest, SizeIncreasesAndDecreases) { + Stack s; + s.Push(1); + s.Push(2); + EXPECT_EQ(s.Size(), 2); + s.Pop(); + EXPECT_EQ(s.Size(), 1); +} + +TEST(StackTest, PopFromEmptyStackThrows) { + Stack s; + EXPECT_THROW(s.Pop(), std::runtime_error); +} + +// ------------------------- MinStack ---------------------------- + +TEST(MinStackTest, GetMinBasic) { + MinStack s; + s.Push(5); + s.Push(3); + s.Push(7); + EXPECT_EQ(s.GetMin(), 3); + s.Pop(); // pop 7 + EXPECT_EQ(s.GetMin(), 3); + s.Pop(); // pop 3 + EXPECT_EQ(s.GetMin(), 5); +} + +TEST(MinStackTest, IsEmptyInitially) { + MinStack s; + EXPECT_TRUE(s.IsEmpty()); + EXPECT_EQ(s.Size(), 0); +} + +TEST(MinStackTest, SizeWorksCorrectly) { + MinStack s; + s.Push(10); + s.Push(20); + EXPECT_EQ(s.Size(), 2); + s.Pop(); + EXPECT_EQ(s.Size(), 1); +} + +TEST(MinStackTest, PopFromEmptyStackThrows) { + MinStack s; + EXPECT_THROW(s.Pop(), std::runtime_error); +} + +TEST(MinStackTest, GetMinFromEmptyThrows) { + MinStack s; + EXPECT_THROW(s.GetMin(), std::runtime_error); +} + +// ------------------------- MaxStack ---------------------------- + +TEST(MaxStackTest, GetMaxBasic) { + MaxStack s; + s.Push(1); + s.Push(3); + s.Push(2); + EXPECT_EQ(s.GetMax(), 3); + s.Pop(); // pop 2 + EXPECT_EQ(s.GetMax(), 3); + s.Pop(); // pop 3 + EXPECT_EQ(s.GetMax(), 1); +} + +TEST(MaxStackTest, IsEmptyInitially) { + MaxStack s; + EXPECT_TRUE(s.IsEmpty()); +} + +TEST(MaxStackTest, PopFromEmptyThrows) { + MaxStack s; + EXPECT_THROW(s.Pop(), std::runtime_error); +} + +TEST(MaxStackTest, GetMaxFromEmptyThrows) { + MaxStack s; + EXPECT_THROW(s.GetMax(), std::runtime_error); +} + +TEST(MaxStackTest, SizeWorksCorrectly) { + MaxStack s; + EXPECT_EQ(s.Size(), 0); + s.Push(42); + EXPECT_EQ(s.Size(), 1); + s.Pop(); + EXPECT_EQ(s.Size(), 0); +} diff --git a/task_03/src/topology_sort.cpp b/task_03/src/days_untill_warmer.cpp similarity index 62% rename from task_03/src/topology_sort.cpp rename to task_03/src/days_untill_warmer.cpp index dd03a63..49e4b44 100644 --- a/task_03/src/topology_sort.cpp +++ b/task_03/src/days_untill_warmer.cpp @@ -1,7 +1,12 @@ -#include "topology_sort.hpp" +#include "days_untill_warmer.hpp" -std::vector days_until_warmer(const std::vector& temperatures) { +#include + +std::vector DaysUntilWarmer(const std::vector& temperatures) { int n = temperatures.size(); + if (n == 0) { + throw std::runtime_error("Empty array"); + } std::vector result(n, 0); std::stack st; diff --git a/task_03/src/days_untill_warmer.hpp b/task_03/src/days_untill_warmer.hpp new file mode 100644 index 0000000..4b06535 --- /dev/null +++ b/task_03/src/days_untill_warmer.hpp @@ -0,0 +1,5 @@ +#pragma once +#include +#include + +std::vector DaysUntilWarmer(const std::vector& temperatures); diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index 322c4a9..34275c9 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -3,46 +3,51 @@ #include -#include "topology_sort.hpp" +#include "days_untill_warmer.hpp" TEST(DaysUntilWarmerTest, IncreasingTemperatures) { std::vector temps = {10, 20, 30, 40}; std::vector expected = {1, 1, 1, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); + EXPECT_EQ(DaysUntilWarmer(temps), expected); } TEST(DaysUntilWarmerTest, DecreasingTemperatures) { std::vector temps = {40, 30, 20, 10}; std::vector expected = {0, 0, 0, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); + EXPECT_EQ(DaysUntilWarmer(temps), expected); } TEST(DaysUntilWarmerTest, MixedTemperatures) { std::vector temps = {30, 40, 35, 42, 38, 33, 50}; std::vector expected = {1, 2, 1, 3, 2, 1, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); + EXPECT_EQ(DaysUntilWarmer(temps), expected); } TEST(DaysUntilWarmerTest, AllSameTemperatures) { std::vector temps = {25, 25, 25, 25}; std::vector expected = {0, 0, 0, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); + EXPECT_EQ(DaysUntilWarmer(temps), expected); } TEST(DaysUntilWarmerTest, OneDayOnly) { std::vector temps = {31}; std::vector expected = {0}; - EXPECT_EQ(days_until_warmer(temps), expected); + EXPECT_EQ(DaysUntilWarmer(temps), expected); } TEST(DaysUntilWarmerTest, SpikeAtTheEnd) { std::vector temps = {30, 25, 20, 35}; std::vector expected = {3, 2, 1, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); + EXPECT_EQ(DaysUntilWarmer(temps), expected); } TEST(DaysUntilWarmerTest, ValleyInMiddle) { std::vector temps = {45, 30, 35, 20, 50}; std::vector expected = {4, 1, 2, 1, 0}; - EXPECT_EQ(days_until_warmer(temps), expected); + EXPECT_EQ(DaysUntilWarmer(temps), expected); +} + +TEST(DaysUntilWarmerTest, Empty) { + std::vector temps = {}; + EXPECT_THROW(DaysUntilWarmer(temps), std::runtime_error); } diff --git a/task_03/src/topology_sort.hpp b/task_03/src/topology_sort.hpp deleted file mode 100644 index 3b518a9..0000000 --- a/task_03/src/topology_sort.hpp +++ /dev/null @@ -1,5 +0,0 @@ -#pragma once -#include -#include - -std::vector days_until_warmer(const std::vector& temperatures); diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index d57f880..0c81c91 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -5,25 +5,29 @@ #include "buy_fish.hpp" -int totalFishBought(const std::vector& purchases) { - int total = 0; - for (int p : purchases) total += p; - return total; -} +namespace { -bool isValidSchedule(const std::vector& purchases, int k) { - int n = purchases.size(); - std::vector stock(n + k, 0); - for (int i = 0; i < n; ++i) { - for (int j = i; j < std::min(i + k, n); ++j) { - stock[j] += purchases[i]; - } + int totalFishBought(const std::vector& purchases) { + int total = 0; + for (int p : purchases) total += p; + return total; } - for (int i = 0; i < n; ++i) { - if (stock[i] == 0) return false; - stock[i]--; + + bool isValidSchedule(const std::vector& purchases, int k) { + int n = purchases.size(); + std::vector stock(n + k, 0); + for (int i = 0; i < n; ++i) { + for (int j = i; j < std::min(i + k, n); ++j) { + stock[j] += purchases[i]; + } + } + for (int i = 0; i < n; ++i) { + if (stock[i] == 0) return false; + stock[i]--; + } + return true; } - return true; + } TEST(BuyFishTest, SimpleIncreasingPrices) { diff --git a/task_05/src/QuickSort.cpp b/task_05/src/QuickSort.cpp index 453acca..9ac0b08 100644 --- a/task_05/src/QuickSort.cpp +++ b/task_05/src/QuickSort.cpp @@ -1,5 +1,6 @@ #include "QuickSort.hpp" +namespace { void quickSortwrap(std::vector& arr, int low, int high) { if (low < high) { int pivot = arr[high]; @@ -18,6 +19,7 @@ void quickSortwrap(std::vector& arr, int low, int high) { quickSortwrap(arr, pi + 1, high); } }; +} // namespace void quickSort(std::vector& arr) { if (!arr.empty()) { diff --git a/task_05/src/QuickSort.hpp b/task_05/src/QuickSort.hpp index 40e0fa9..b6c92b9 100644 --- a/task_05/src/QuickSort.hpp +++ b/task_05/src/QuickSort.hpp @@ -1,5 +1,4 @@ #pragma once #include -void quickSortwrap(std::vector& arr, int low, int high); void quickSort(std::vector& arr); \ No newline at end of file diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index 994bec5..08219c4 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -5,8 +5,10 @@ #include "QuickSort.hpp" -bool isSorted(const std::vector& arr) { - return std::is_sorted(arr.begin(), arr.end()); +namespace { + bool isSorted(const std::vector& arr) { + return std::is_sorted(arr.begin(), arr.end()); + } } TEST(QuickSortTest, AlreadySorted) { diff --git a/task_06/src/ord_stat.cpp b/task_06/src/ord_stat.cpp index 6fbebff..746be01 100644 --- a/task_06/src/ord_stat.cpp +++ b/task_06/src/ord_stat.cpp @@ -5,9 +5,9 @@ int ordstat(std::vector& arr, int k) { int right = arr.size() - 1; while (left <= right) { - int pivotIndex = left + rand() % (right - left + 1); - int pivotValue = arr[pivotIndex]; - std::swap(arr[pivotIndex], arr[right]); + int pivot_index = left + rand() % (right - left + 1); + int pivotValue = arr[pivot_index]; + std::swap(arr[pivot_index], arr[right]); int storeIndex = left; for (int i = left; i < right; i++) { diff --git a/task_07/src/AVLTree.hpp b/task_07/src/AVLTree.hpp index 4daf222..a162734 100644 --- a/task_07/src/AVLTree.hpp +++ b/task_07/src/AVLTree.hpp @@ -2,16 +2,20 @@ #include -struct Node { - int key; - Node* left; - Node* right; - int height; - Node(int k) : key(k), left(nullptr), right(nullptr), height(1) {} -}; - class AVLTree { private: + struct Node { + int key; + Node* left{nullptr}; + Node* right{nullptr}; + int height; + Node(int k) : key(k), left(nullptr), right(nullptr), height(1) {} + ~Node() { + delete left; + delete right; + } + }; + Node* root = nullptr; int height(Node* n) { return n ? n->height : 0; } diff --git a/task_08/src/HashTable.hpp b/task_08/src/HashTable.hpp index 21c8382..bed494c 100644 --- a/task_08/src/HashTable.hpp +++ b/task_08/src/HashTable.hpp @@ -84,7 +84,10 @@ class HashTable { for (const auto& entry : table[i]) { std::cout << "(" << entry.first << ": " << entry.second << ") "; } - std::cout << std::endl; + std::cout << "\n"; } } + + int Size() { return size; } + bool IsEmpty() { return table.empty(); } }; \ No newline at end of file From f1ebb0998d4e73b06789aa104162c738465fcbab Mon Sep 17 00:00:00 2001 From: salexkon Date: Sun, 22 Jun 2025 21:45:26 +0000 Subject: [PATCH 22/23] clang-formatted --- task_04/src/test.cpp | 36 ++++++++++++++++++------------------ task_05/src/test.cpp | 6 +++--- 2 files changed, 21 insertions(+), 21 deletions(-) diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 0c81c91..dde9535 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -7,29 +7,29 @@ namespace { - int totalFishBought(const std::vector& purchases) { - int total = 0; - for (int p : purchases) total += p; - return total; - } +int totalFishBought(const std::vector& purchases) { + int total = 0; + for (int p : purchases) total += p; + return total; +} - bool isValidSchedule(const std::vector& purchases, int k) { - int n = purchases.size(); - std::vector stock(n + k, 0); - for (int i = 0; i < n; ++i) { - for (int j = i; j < std::min(i + k, n); ++j) { - stock[j] += purchases[i]; - } - } - for (int i = 0; i < n; ++i) { - if (stock[i] == 0) return false; - stock[i]--; +bool isValidSchedule(const std::vector& purchases, int k) { + int n = purchases.size(); + std::vector stock(n + k, 0); + for (int i = 0; i < n; ++i) { + for (int j = i; j < std::min(i + k, n); ++j) { + stock[j] += purchases[i]; } - return true; } - + for (int i = 0; i < n; ++i) { + if (stock[i] == 0) return false; + stock[i]--; + } + return true; } +} // namespace + TEST(BuyFishTest, SimpleIncreasingPrices) { std::vector prices = {1, 2, 3, 4, 5}; int k = 2; diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index 08219c4..40689ef 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -6,10 +6,10 @@ #include "QuickSort.hpp" namespace { - bool isSorted(const std::vector& arr) { - return std::is_sorted(arr.begin(), arr.end()); - } +bool isSorted(const std::vector& arr) { + return std::is_sorted(arr.begin(), arr.end()); } +} // namespace TEST(QuickSortTest, AlreadySorted) { std::vector arr = {1, 2, 3, 4, 5}; From c92c38963fd26132424886c50712782699c004d3 Mon Sep 17 00:00:00 2001 From: salexkon Date: Sun, 22 Jun 2025 21:56:59 +0000 Subject: [PATCH 23/23] task_02 tests fixed --- task_02/src/stack.hpp | 9 +++++++++ task_02/src/test.cpp | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 0956f1c..0377dc0 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -14,6 +14,9 @@ class Stack { } void Push(T value) { data_.push_back(value); } T Pop() { + if (data_.empty()) { + throw std::runtime_error("Stack is empty."); + } T result = data_.back(); data_.pop_back(); return result; @@ -45,6 +48,9 @@ class MinStack { } } T Pop() { + if (data_.empty()) { + throw std::runtime_error("Stack is empty."); + } T result = data_.back(); data_.pop_back(); data_mins_.pop_back(); @@ -85,6 +91,9 @@ class MaxStack { } } T Pop() { + if (data_.empty()) { + throw std::runtime_error("Stack is empty."); + } T result = data_.back(); data_.pop_back(); data_maxs.pop_back(); diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index b4f43a4..d6f4bd8 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -41,7 +41,7 @@ TEST(MinStackTest, Simple) { ASSERT_EQ(stack.Pop(), 1); // Stack [] } -// // ------------------------- Stack ---------------------------- +// ------------------------- Stack ---------------------------- TEST(StackTest, BasicPushPop) { Stack s; @@ -146,4 +146,4 @@ TEST(MaxStackTest, SizeWorksCorrectly) { EXPECT_EQ(s.Size(), 1); s.Pop(); EXPECT_EQ(s.Size(), 0); -} +} \ No newline at end of file