From 3a895cf2181e6f7726ae9309f348991f4ec6936a Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Wed, 12 Feb 2025 15:00:23 +0000 Subject: [PATCH 01/19] Added two heap files --- task_04/src/heap.cpp | 0 task_04/src/heap.h | 0 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 task_04/src/heap.cpp create mode 100644 task_04/src/heap.h diff --git a/task_04/src/heap.cpp b/task_04/src/heap.cpp new file mode 100644 index 0000000..e69de29 diff --git a/task_04/src/heap.h b/task_04/src/heap.h new file mode 100644 index 0000000..e69de29 From 062cd8d79f4ac69391cffa1da1df084ca1a387dc Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sun, 16 Feb 2025 11:01:35 +0000 Subject: [PATCH 02/19] Aded heap struct --- task_04/src/heap.cpp | 55 ++++++++++++++++++++++++++++++++++++++++++++ task_04/src/heap.h | 1 + task_04/src/main.cpp | 10 +++++++- 3 files changed, 65 insertions(+), 1 deletion(-) diff --git a/task_04/src/heap.cpp b/task_04/src/heap.cpp index e69de29..4474754 100644 --- a/task_04/src/heap.cpp +++ b/task_04/src/heap.cpp @@ -0,0 +1,55 @@ +#include "heap.h" +#include +#include + +struct heap{ + std::vector our_tree{0}; // объявил и проинициализировал ветор с будущмим значениями + + void push(int x){ + our_tree.push_back(x); + int i = our_tree.size() - 1; + while (i > 0){ + int p = i/2; + if ((p > 0) and (our_tree[i] < our_tree[p])){ + std::swap(our_tree[i], our_tree[p]); + i = p; + } + else break; + } + }; + + int min(){ + int i = our_tree.size() - 1; + return our_tree[i]; + }; + + void min_pop(){ + int lst_index = our_tree.size() - 1; + int i = lst_index; + std::swap(our_tree[i], our_tree[1]); + our_tree.pop_back(); + i = 1; + while(i < lst_index){ + int l_ch = i*2; + int r_ch = i*2+1; + + if (our_tree[l_ch] > our_tree[r_ch]) + std::swap(our_tree[l_ch], our_tree[r_ch]); + + if (our_tree[i] > our_tree[l_ch]) { + std::swap(our_tree[i], our_tree[l_ch]); + i = l_ch; + }else break; + } + }; + + int sort(){ + return 0; + }; // сортирует до полного порядка + + // далее необязательные но приятные дополнения + int create(){ + return 0; + }; // создает кучу из переданного объетка + +}; \ No newline at end of file diff --git a/task_04/src/heap.h b/task_04/src/heap.h index e69de29..a8608f9 100644 --- a/task_04/src/heap.h +++ b/task_04/src/heap.h @@ -0,0 +1 @@ +struct heap; diff --git a/task_04/src/main.cpp b/task_04/src/main.cpp index 0e4393b..df04030 100644 --- a/task_04/src/main.cpp +++ b/task_04/src/main.cpp @@ -1,3 +1,11 @@ #include +#include "heap.h" -int main() { return 0; } +int main() { + + heap h; + + h.push(0); + + return 0; +} From 4fb7899f228205860de159b5ad9f24187c376e6a Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sun, 16 Feb 2025 12:41:01 +0000 Subject: [PATCH 03/19] Minimal-working version --- task_04/src/heap.cpp | 120 ++++++++++++++++++++++++------------------- task_04/src/heap.h | 12 ++++- task_04/src/main.cpp | 88 +++++++++++++++++++++++++++++-- 3 files changed, 163 insertions(+), 57 deletions(-) diff --git a/task_04/src/heap.cpp b/task_04/src/heap.cpp index 4474754..d952b6c 100644 --- a/task_04/src/heap.cpp +++ b/task_04/src/heap.cpp @@ -1,55 +1,69 @@ -#include "heap.h" -#include -#include - -struct heap{ - std::vector our_tree{0}; // объявил и проинициализировал ветор с будущмим значениями - - void push(int x){ - our_tree.push_back(x); - int i = our_tree.size() - 1; - while (i > 0){ - int p = i/2; - if ((p > 0) and (our_tree[i] < our_tree[p])){ - std::swap(our_tree[i], our_tree[p]); - i = p; - } - else break; - } - }; - - int min(){ - int i = our_tree.size() - 1; - return our_tree[i]; - }; +// #include +// #include +// #include "heap.h" + +// struct heap{ +// std::vector our_tree{0}; // объявил и проинициализировал ветор с будущмим значениями + +// int len(){ +// int l = our_tree.size() - 1; +// return l; +// } + +// int operator []( int i ) { +// return our_tree[i]; +// } + +// int print (){ +// for (int k{0}; k < our_tree.size(); ++k) +// std::cout << our_tree[k]; +// } + +// void push(int x){ +// our_tree.push_back(x); +// int i = our_tree.size() - 1; +// while (i > 0){ +// int p = i/2; +// if ((p > 0) and (our_tree[i] < our_tree[p])){ +// std::swap(our_tree[i], our_tree[p]); +// i = p; +// } +// else break; +// } +// }; + +// int min(){ +// int i = our_tree.size() - 1; +// return our_tree[i]; +// }; - void min_pop(){ - int lst_index = our_tree.size() - 1; - int i = lst_index; - std::swap(our_tree[i], our_tree[1]); - our_tree.pop_back(); - i = 1; - while(i < lst_index){ - int l_ch = i*2; - int r_ch = i*2+1; - - if (our_tree[l_ch] > our_tree[r_ch]) - std::swap(our_tree[l_ch], our_tree[r_ch]); +// void min_pop(){ +// int lst_index = our_tree.size() - 1; +// int i = lst_index; +// std::swap(our_tree[i], our_tree[1]); +// our_tree.pop_back(); +// i = 1; +// while(i < lst_index){ +// int l_ch = i*2; +// int r_ch = i*2+1; + +// if (our_tree[l_ch] > our_tree[r_ch]) +// std::swap(our_tree[l_ch], our_tree[r_ch]); - if (our_tree[i] > our_tree[l_ch]) { - std::swap(our_tree[i], our_tree[l_ch]); - i = l_ch; - }else break; - } - }; - - int sort(){ - return 0; - }; // сортирует до полного порядка - - // далее необязательные но приятные дополнения - int create(){ - return 0; - }; // создает кучу из переданного объетка - -}; \ No newline at end of file +// if (our_tree[i] > our_tree[l_ch]) { +// std::swap(our_tree[i], our_tree[l_ch]); +// i = l_ch; +// }else break; +// } +// }; + +// int sort()int sort(){ +// return 0; +// }; // сортирует до полного порядка + +// // далее необязательные но приятные дополнения +// int create(){ +// return 0; +// }; // создает кучу из переданного объетка + +// }; \ No newline at end of file diff --git a/task_04/src/heap.h b/task_04/src/heap.h index a8608f9..52fee62 100644 --- a/task_04/src/heap.h +++ b/task_04/src/heap.h @@ -1 +1,11 @@ -struct heap; +// struct heap{ +// int len(); +// int operator []( int i ); +// int print (); +// void push(int x); +// int min(); +// void min_pop(); +// int sort(); +// int create(); + +// }; diff --git a/task_04/src/main.cpp b/task_04/src/main.cpp index df04030..d76745d 100644 --- a/task_04/src/main.cpp +++ b/task_04/src/main.cpp @@ -1,11 +1,93 @@ -#include #include "heap.h" +#include +#include -int main() { +struct heap{ + std::vector our_tree{0}; // объявил и проинициализировал ветор с будущмим значениями + + int len(){ + int l = our_tree.size() - 1; + return l; + } + + int operator []( int i ) { + return our_tree[i]; + } + + void print (){ + for (int k{0}; k < our_tree.size(); ++k) + std::cout << our_tree[k]; + } + + void push(int x){ + our_tree.push_back(x); + int i = our_tree.size() - 1; + while (i > 0){ + int p = i/2; + if ((p > 0) and (our_tree[i] < our_tree[p])){ + std::swap(our_tree[i], our_tree[p]); + i = p; + } + else break; + } + }; + + int min(){ + return our_tree[1]; + }; + void min_pop(){ + int lst_index = our_tree.size() - 1; + int i = lst_index; + std::swap(our_tree[i], our_tree[1]); + our_tree.pop_back(); + i = 1; + while(i < lst_index){ + int l_ch = i*2; + int r_ch = i*2+1; + + if (our_tree[l_ch] > our_tree[r_ch] and l_ch < lst_index) + std::swap(our_tree[l_ch], our_tree[r_ch]); + + if (our_tree[i] > our_tree[l_ch] and l_ch < lst_index) { + std::swap(our_tree[i], our_tree[l_ch]); + i = l_ch; + }else break; + } + }; + + int sort(){ + return 0; + }; // сортирует до полного порядка + + // далее необязательные но приятные дополнения + int create(){ + return 0; + }; // создает кучу из переданного объетка + +}; + +/////////////////////////////////////////////////////////////////////////////////////// + +int main() { + std::cout << "06571493 \n"; heap h; - h.push(0); + h.push(6); + h.push(5); + h.push(7); + h.push(1); + h.push(4); + h.push(9); + h.push(3); + + h.print(); + + // int m = h.min(); + std::cout << "suda;\n"; + + h.min_pop(); + h.print(); return 0; } From 2866b340621b1f10d7e1730c3b598e408bd3a1a2 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sat, 1 Mar 2025 08:59:00 +0000 Subject: [PATCH 04/19] Done the first task --- task_01/src/main.cpp | 20 +++++++++++++++++++- task_01/src/test.cpp | 1 + task_01/src/two_numbers.cpp | 21 +++++++++++++++++++++ task_01/src/two_numbers.h | 4 ++++ 4 files changed, 45 insertions(+), 1 deletion(-) create mode 100644 task_01/src/two_numbers.cpp create mode 100644 task_01/src/two_numbers.h diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 0e4393b..1df3cb4 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1,3 +1,21 @@ #include +#include +#include "two_numbers.h" -int main() { return 0; } +int main() { + int target; + std::cout << "Enter the number:"; + std::cin >> target; + + int len; + std::cout << "Enter the size of an array:"; + std::cin >> len; + std::cout << "\n"; + + std::vector numbers(len); + std::cout << "Enter the array:"; + for (int i{0}; i < len; ++i) + std::cin >> numbers[i]; + + find_sum(numbers, len, target); +} diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 87cef73..c95961e 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,4 +1,5 @@ #include +#include "two_numbers.h" TEST(Test, Simple) { ASSERT_EQ(1, 1); // Stack [] diff --git a/task_01/src/two_numbers.cpp b/task_01/src/two_numbers.cpp new file mode 100644 index 0000000..7ab92ed --- /dev/null +++ b/task_01/src/two_numbers.cpp @@ -0,0 +1,21 @@ +#include "two_numbers.h" +#include + +void find_sum(std::vector& numbers, int len, int target){ + int left_r = 0; + int right_r = len - 1; + + while(right_r - left_r >= 0){ + int sum = numbers[left_r] + numbers[right_r]; + if (right_r - left_r == 0) + std::cout << "There are no necessary numbers"; + if (sum == target){ + std:: cout << numbers[left_r] << "+" << numbers[right_r] << "=" << target; + break; + } + if (sum < target) + ++ left_r; + else + -- right_r; + } +} \ No newline at end of file diff --git a/task_01/src/two_numbers.h b/task_01/src/two_numbers.h new file mode 100644 index 0000000..314401e --- /dev/null +++ b/task_01/src/two_numbers.h @@ -0,0 +1,4 @@ +#include + +void find_sum(std::vector& numbers, int len, int target); + From 0a26028bc0fafc93d67126d9a1c1c0036b8aba24 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sat, 1 Mar 2025 11:19:46 +0000 Subject: [PATCH 05/19] added 2nd task --- task_01/src/test.cpp | 92 ++++++++++++++++++++++++++++++++++++++- task_01/src/two_numbers.h | 2 +- task_02/src/main.cpp | 69 ++++++++++++++++++++++++++++- 3 files changed, 159 insertions(+), 4 deletions(-) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index c95961e..2e80d01 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,6 +1,94 @@ #include #include "two_numbers.h" -TEST(Test, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include +#include + +// Функция, которую мы тестируем +std::pair find_sum(const std::vector& nums, int target) { + int left = 0; + int right = nums.size() - 1; + + while (left < right) { + int sum = nums[left] + nums[right]; + if (sum == target) { + return {left, right}; + } else if (sum < target) { + left++; + } else { + right--; + } + } + + return {-1, -1}; +} + +// Тесты + +// Тест 1: Обычный случай +TEST(FindTwoSumTest, BasicCase) { + std::vector nums = {2, 7, 11, 15}; + int target = 9; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 0); + EXPECT_EQ(result.second, 1); +} + +// Тест 2: Нет подходящей пары +TEST(FindTwoSumTest, NoPairCase) { + std::vector nums = {1, 2, 3, 4}; + int target = 8; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, -1); + EXPECT_EQ(result.second, -1); +} + +// Тест 3: Все числа одинаковые +TEST(FindTwoSumTest, AllElementsSame) { + std::vector nums = {5, 5, 5, 5}; + int target = 10; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 0); + EXPECT_EQ(result.second, 1); +} + +// Тест 4: Отрицательные числа +TEST(FindTwoSumTest, NegativeNumbers) { + std::vector nums = {-5, -3, 0, 1, 2}; + int target = -3; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 1); + EXPECT_EQ(result.second, 2); +} + +// Тест 5: Большой массив +TEST(FindTwoSumTest, LargeArray) { + std::vector nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int target = 17; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 7); + EXPECT_EQ(result.second, 9); +} + +// Тест 6: Массив из двух элементов +TEST(FindTwoSumTest, TwoElementsArray) { + std::vector nums = {1, 2}; + int target = 3; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 0); + EXPECT_EQ(result.second, 1); +} + +// Тест 7: Массив из одного элемента +TEST(FindTwoSumTest, SingleElementArray) { + std::vector nums = {1}; + int target = 1; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, -1); + EXPECT_EQ(result.second, -1); +} + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file diff --git a/task_01/src/two_numbers.h b/task_01/src/two_numbers.h index 314401e..e354812 100644 --- a/task_01/src/two_numbers.h +++ b/task_01/src/two_numbers.h @@ -1,4 +1,4 @@ #include -void find_sum(std::vector& numbers, int len, int target); +void find_sum( numbers, int len, int target); diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp index 0e4393b..662c143 100644 --- a/task_02/src/main.cpp +++ b/task_02/src/main.cpp @@ -1,3 +1,70 @@ +#include #include +#include -int main() { return 0; } +struct Stack { + std::vector arr; + + // Добавляем элемент в стек + void push(int element) { + arr.push_back(element); + } + + // Удаляем верхний элемент стека + void pop() { + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot pop."); + } + arr.pop_back(); + } + + // Возвращаем верхний элемент стека + int peek() const { + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot peek."); + } + return arr.back(); + } + + // Выводим весь стек + void display() const { + if (arr.empty()) { + std::cout << "Stack is empty." << std::endl; + return; + } + for (int i = 0; i < arr.size(); ++i) { + std::cout << arr[i] << " "; + } + std::cout << std::endl; + } + + void min(){ + min_el = arr.min_element(); + } +}; + + + +int main() { + Stack stack; + stack.push(2); + stack.push(1); + stack.push(3); + stack.push(4); + stack.push(5); + stack.push(7); + + stack.display(); + std::cout << "\n"; + + stack.pop(); + stack.display(); + std::cout << "\n"; + + int a = stack.peek(); + std::cout << a; + std::cout << "\n"; + + + return 0; +} From 2dc235117e25d975ea1c499ce2c820f7544c704d Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sun, 6 Apr 2025 15:46:48 +0000 Subject: [PATCH 06/19] first task done without tests --- task_01/src/two_numbers.h | 2 +- task_05/src/main.cpp | 21 ++++++++++++++++++- task_05/src/merge_sort.cpp | 41 ++++++++++++++++++++++++++++++++++++++ task_05/src/merge_sort.h | 4 ++++ 4 files changed, 66 insertions(+), 2 deletions(-) create mode 100644 task_05/src/merge_sort.cpp create mode 100644 task_05/src/merge_sort.h diff --git a/task_01/src/two_numbers.h b/task_01/src/two_numbers.h index e354812..314401e 100644 --- a/task_01/src/two_numbers.h +++ b/task_01/src/two_numbers.h @@ -1,4 +1,4 @@ #include -void find_sum( numbers, int len, int target); +void find_sum(std::vector& numbers, int len, int target); diff --git a/task_05/src/main.cpp b/task_05/src/main.cpp index 0e4393b..2afe164 100644 --- a/task_05/src/main.cpp +++ b/task_05/src/main.cpp @@ -1,3 +1,22 @@ #include +#include +#include "merge_sort.h" -int main() { return 0; } +int main() { + std::cout << "Enter the size of an array:\n"; + int N; + std::cin >> N; + + std::cout << "Enter an array:\n"; + std::vector A(N); + for (int i{0}; i < N; i++) + std::cin >> A[i]; + + mergeSort(A, 0, A.size()); + + for (int i{0}; i < N; i++) { + std::cout << A[i] << " "; + } + + return 0; +} \ No newline at end of file diff --git a/task_05/src/merge_sort.cpp b/task_05/src/merge_sort.cpp new file mode 100644 index 0000000..9495146 --- /dev/null +++ b/task_05/src/merge_sort.cpp @@ -0,0 +1,41 @@ +#include "merge_sort.h" + +std::vector merge(std::vector &arr, int l, int mid, int r){ + int i = 0; + int j = 0; + + std::vector res; + + while (i + l < mid && j + mid < r){ + if (arr[l + i] < arr[mid + j]){ + res.push_back(arr[l + i]); + i++; + } + else{ + res.push_back(arr[mid + j]); + j++; + } + } + while(j + mid < r){ + res.push_back(arr[mid + j]); + j++; + } + while(i + l < mid){ + res.push_back(arr[l + i]); + i++; + } + return res; +} + +void mergeSort(std::vector &arr, int l, int r){ + if (l + 1 >= r) + return; + int mid = (l + r)/2; + mergeSort(arr, l, mid); + mergeSort(arr, mid, r); + + std::vector merged = merge(arr, l, mid, r); + for (int i = 0; i < merged.size(); i++) { + arr[l + i] = merged[i]; + } +} diff --git a/task_05/src/merge_sort.h b/task_05/src/merge_sort.h new file mode 100644 index 0000000..45b96e9 --- /dev/null +++ b/task_05/src/merge_sort.h @@ -0,0 +1,4 @@ +#include + +std::vector merge(std::vector &arr, int l, int mid, int r); +void mergeSort(std::vector &arr, int l, int r); \ No newline at end of file From 141c50ae168849481bb8f52a15f713004de646ee Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sat, 26 Apr 2025 08:08:47 +0000 Subject: [PATCH 07/19] Have done 2nd task without tests --- task_01/src/two_numbers.cpp | 1 - task_01/src/two_numbers.h | 1 + task_02/README.md | 3 +-- task_02/src/main.cpp | 52 +++---------------------------------- task_02/src/stack.cpp | 43 +++++++++++++++++++++--------- task_02/src/stack.hpp | 27 ++++++------------- 6 files changed, 45 insertions(+), 82 deletions(-) diff --git a/task_01/src/two_numbers.cpp b/task_01/src/two_numbers.cpp index 7ab92ed..6c44978 100644 --- a/task_01/src/two_numbers.cpp +++ b/task_01/src/two_numbers.cpp @@ -1,5 +1,4 @@ #include "two_numbers.h" -#include void find_sum(std::vector& numbers, int len, int target){ int left_r = 0; diff --git a/task_01/src/two_numbers.h b/task_01/src/two_numbers.h index 314401e..3c763a3 100644 --- a/task_01/src/two_numbers.h +++ b/task_01/src/two_numbers.h @@ -1,4 +1,5 @@ #include +#include void find_sum(std::vector& numbers, int len, int target); diff --git a/task_02/README.md b/task_02/README.md index 10911e3..0a63c3b 100644 --- a/task_02/README.md +++ b/task_02/README.md @@ -1,3 +1,2 @@ # Задача на стэк - -В данной задаче необходимо реализовать один стэк и стэк с минимумом (нельзя использовать std::stack). Получение минимума должно работать за константное время \ No newline at end of file +В данной задаче необходимо реализовать один стэк и стэк с минимумом (нельзя использовать std::stack). Получение минимума должно работать за константное время diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp index 662c143..9398939 100644 --- a/task_02/src/main.cpp +++ b/task_02/src/main.cpp @@ -1,49 +1,5 @@ -#include +#include "stack.hpp" #include -#include - -struct Stack { - std::vector arr; - - // Добавляем элемент в стек - void push(int element) { - arr.push_back(element); - } - - // Удаляем верхний элемент стека - void pop() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot pop."); - } - arr.pop_back(); - } - - // Возвращаем верхний элемент стека - int peek() const { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot peek."); - } - return arr.back(); - } - - // Выводим весь стек - void display() const { - if (arr.empty()) { - std::cout << "Stack is empty." << std::endl; - return; - } - for (int i = 0; i < arr.size(); ++i) { - std::cout << arr[i] << " "; - } - std::cout << std::endl; - } - - void min(){ - min_el = arr.min_element(); - } -}; - - int main() { Stack stack; @@ -62,9 +18,9 @@ int main() { std::cout << "\n"; int a = stack.peek(); - std::cout << a; - std::cout << "\n"; - + std::cout << a << "\n"; + int b = stack.min(); + std::cout << "minimal element: " << b; return 0; } diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp index 8ca8990..15c5dbc 100644 --- a/task_02/src/stack.cpp +++ b/task_02/src/stack.cpp @@ -1,21 +1,40 @@ #include "stack.hpp" - #include +#include +#include -void Stack::Push(int value) { data_.push(value); } +void Stack::push(int element) { + arr.push_back(element); +} -int Stack::Pop() { - auto result = data_.top(); - data_.pop(); - return result; +void Stack::pop() { + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot pop."); + } + arr.pop_back(); } -void MinStack::Push(int value) { data_.push_back(value); } +int Stack::peek() { + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot peek."); + } + return arr.back(); +} -int MinStack::Pop() { - auto result = data_.back(); - data_.pop_back(); - return result; +void Stack::display() { + if (arr.empty()) { + std::cout << "Stack is empty." << std::endl; + return; + } + for (int i = 0; i < arr.size(); ++i) { + std::cout << arr[i] << " "; + } + std::cout << std::endl; } -int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); } \ No newline at end of file +int Stack::min() { + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot find min."); + } + return *std::min_element(arr.begin(), arr.end()); +} \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 138ec40..3b78fed 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -1,23 +1,12 @@ #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(); +struct Stack { + std::vector arr; - private: - std::vector data_; -}; + void push(int element); + void pop(); + int peek(); + void display(); + int min(); +}; \ No newline at end of file From 824021cd29c0cb7dced335721ac730719d82d990 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sat, 26 Apr 2025 08:23:15 +0000 Subject: [PATCH 08/19] Have done 3d task without tests --- task_03/src/main.cpp | 12 +++++++++++- task_03/src/topology_sort.cpp | 17 +++++++++++++++++ task_03/src/topology_sort.hpp | 3 +++ 3 files changed, 31 insertions(+), 1 deletion(-) diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp index 0e4393b..f679dd6 100644 --- a/task_03/src/main.cpp +++ b/task_03/src/main.cpp @@ -1,3 +1,13 @@ #include +#include +#include "topology_sort.hpp" -int main() { return 0; } +int main(){ + std::vector temps = {73, 74, 75, 71, 69, 72, 76, 73}; + std::vector result = topology_sort(temps); + // Результат: {1, 1, 4, 2, 1, 1, 0, 0} + + for (int i{0}; i < result.size(); ++i){ + std::cout << result[i] << " "; + } +} \ No newline at end of file diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp index e53f670..03a55db 100644 --- a/task_03/src/topology_sort.cpp +++ b/task_03/src/topology_sort.cpp @@ -1 +1,18 @@ #include "topology_sort.hpp" +#include + +std::vector topology_sort(const std::vector& temperatures) { + std::vector result(temperatures.size(), 0); + std::stack> s; + + for (int i {0}; i < temperatures.size(); ++i) { + while (!s.empty() && temperatures[i] > s.top().first) { + int prev_index = s.top().second; + result[prev_index] = i - prev_index; + s.pop(); + } + s.push({temperatures[i], i}); + } + + return result; +} \ No newline at end of file diff --git a/task_03/src/topology_sort.hpp b/task_03/src/topology_sort.hpp index 6f70f09..7d5f7fc 100644 --- a/task_03/src/topology_sort.hpp +++ b/task_03/src/topology_sort.hpp @@ -1 +1,4 @@ #pragma once +#include + +std::vector topology_sort(const std::vector& temperatures); \ No newline at end of file From 2fcde685a423c954c70a052042e4c80cf3f44e81 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sat, 26 Apr 2025 15:21:55 +0000 Subject: [PATCH 09/19] Clang_format --- task_01/src/main.cpp | 28 ++++----- task_01/src/test.cpp | 105 +++++++++++++++++----------------- task_01/src/two_numbers.cpp | 33 +++++------ task_01/src/two_numbers.h | 2 - task_02/src/main.cpp | 39 +++++++------ task_02/src/stack.cpp | 45 +++++++-------- task_02/src/stack.hpp | 12 ++-- task_03/src/main.cpp | 14 ++--- task_03/src/topology_sort.cpp | 25 ++++---- task_04/src/heap.cpp | 102 +++++++++++---------------------- task_04/src/heap.h | 11 ---- task_04/src/heap.hpp | 4 ++ task_04/src/main.cpp | 94 +----------------------------- task_04/src/test.cpp | 5 +- task_05/src/main.cpp | 28 ++++----- task_05/src/merge_sort.cpp | 62 ++++++++++---------- 16 files changed, 236 insertions(+), 373 deletions(-) delete mode 100644 task_04/src/heap.h create mode 100644 task_04/src/heap.hpp diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 1df3cb4..829b704 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1,21 +1,21 @@ #include #include + #include "two_numbers.h" -int main() { - int target; - std::cout << "Enter the number:"; - std::cin >> target; +int main() { + int target; + std::cout << "Enter the number:"; + std::cin >> target; + + int len; + std::cout << "Enter the size of an array:"; + std::cin >> len; + std::cout << "\n"; - int len; - std::cout << "Enter the size of an array:"; - std::cin >> len; - std::cout << "\n"; + std::vector numbers(len); + std::cout << "Enter the array:"; + for (int i{0}; i < len; ++i) std::cin >> numbers[i]; - std::vector numbers(len); - std::cout << "Enter the array:"; - for (int i{0}; i < len; ++i) - std::cin >> numbers[i]; - - find_sum(numbers, len, target); + find_sum(numbers, len, target); } diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 2e80d01..36fe71c 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,94 +1,95 @@ #include -#include "two_numbers.h" -#include #include +#include + +#include "two_numbers.h" // Функция, которую мы тестируем std::pair find_sum(const std::vector& nums, int target) { - int left = 0; - int right = nums.size() - 1; + int left = 0; + int right = nums.size() - 1; - while (left < right) { - int sum = nums[left] + nums[right]; - if (sum == target) { - return {left, right}; - } else if (sum < target) { - left++; - } else { - right--; - } + while (left < right) { + int sum = nums[left] + nums[right]; + if (sum == target) { + return {left, right}; + } else if (sum < target) { + left++; + } else { + right--; } + } - return {-1, -1}; + return {-1, -1}; } // Тесты // Тест 1: Обычный случай TEST(FindTwoSumTest, BasicCase) { - std::vector nums = {2, 7, 11, 15}; - int target = 9; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 0); - EXPECT_EQ(result.second, 1); + std::vector nums = {2, 7, 11, 15}; + int target = 9; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 0); + EXPECT_EQ(result.second, 1); } // Тест 2: Нет подходящей пары TEST(FindTwoSumTest, NoPairCase) { - std::vector nums = {1, 2, 3, 4}; - int target = 8; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, -1); - EXPECT_EQ(result.second, -1); + std::vector nums = {1, 2, 3, 4}; + int target = 8; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, -1); + EXPECT_EQ(result.second, -1); } // Тест 3: Все числа одинаковые TEST(FindTwoSumTest, AllElementsSame) { - std::vector nums = {5, 5, 5, 5}; - int target = 10; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 0); - EXPECT_EQ(result.second, 1); + std::vector nums = {5, 5, 5, 5}; + int target = 10; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 0); + EXPECT_EQ(result.second, 1); } // Тест 4: Отрицательные числа TEST(FindTwoSumTest, NegativeNumbers) { - std::vector nums = {-5, -3, 0, 1, 2}; - int target = -3; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 1); - EXPECT_EQ(result.second, 2); + std::vector nums = {-5, -3, 0, 1, 2}; + int target = -3; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 1); + EXPECT_EQ(result.second, 2); } // Тест 5: Большой массив TEST(FindTwoSumTest, LargeArray) { - std::vector nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; - int target = 17; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 7); - EXPECT_EQ(result.second, 9); + std::vector nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int target = 17; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 7); + EXPECT_EQ(result.second, 9); } // Тест 6: Массив из двух элементов TEST(FindTwoSumTest, TwoElementsArray) { - std::vector nums = {1, 2}; - int target = 3; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 0); - EXPECT_EQ(result.second, 1); + std::vector nums = {1, 2}; + int target = 3; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, 0); + EXPECT_EQ(result.second, 1); } // Тест 7: Массив из одного элемента TEST(FindTwoSumTest, SingleElementArray) { - std::vector nums = {1}; - int target = 1; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, -1); - EXPECT_EQ(result.second, -1); + std::vector nums = {1}; + int target = 1; + std::pair result = find_sum(nums, target); + EXPECT_EQ(result.first, -1); + EXPECT_EQ(result.second, -1); } -int main(int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file diff --git a/task_01/src/two_numbers.cpp b/task_01/src/two_numbers.cpp index 6c44978..104b840 100644 --- a/task_01/src/two_numbers.cpp +++ b/task_01/src/two_numbers.cpp @@ -1,20 +1,21 @@ #include "two_numbers.h" -void find_sum(std::vector& numbers, int len, int target){ - int left_r = 0; - int right_r = len - 1; +#include - while(right_r - left_r >= 0){ - int sum = numbers[left_r] + numbers[right_r]; - if (right_r - left_r == 0) - std::cout << "There are no necessary numbers"; - if (sum == target){ - std:: cout << numbers[left_r] << "+" << numbers[right_r] << "=" << target; - break; - } - if (sum < target) - ++ left_r; - else - -- right_r; - } +void find_sum(std::vector& numbers, int len, int target) { + int left_r = 0; + int right_r = len - 1; + + while (right_r - left_r >= 0) { + int sum = numbers[left_r] + numbers[right_r]; + if (right_r - left_r == 0) std::cout << "There are no necessary numbers"; + if (sum == target) { + std::cout << numbers[left_r] << "+" << numbers[right_r] << "=" << target; + break; + } + if (sum < target) + ++left_r; + else + --right_r; + } } \ No newline at end of file diff --git a/task_01/src/two_numbers.h b/task_01/src/two_numbers.h index 3c763a3..4cb19ae 100644 --- a/task_01/src/two_numbers.h +++ b/task_01/src/two_numbers.h @@ -1,5 +1,3 @@ #include -#include void find_sum(std::vector& numbers, int len, int target); - diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp index 9398939..5fa8bef 100644 --- a/task_02/src/main.cpp +++ b/task_02/src/main.cpp @@ -1,26 +1,27 @@ -#include "stack.hpp" #include -int main() { - Stack stack; - stack.push(2); - stack.push(1); - stack.push(3); - stack.push(4); - stack.push(5); - stack.push(7); +#include "stack.hpp" + +int main() { + Stack stack; + stack.push(2); + stack.push(1); + stack.push(3); + stack.push(4); + stack.push(5); + stack.push(7); - stack.display(); - std::cout << "\n"; + stack.display(); + std::cout << "\n"; - stack.pop(); - stack.display(); - std::cout << "\n"; + stack.pop(); + stack.display(); + std::cout << "\n"; - int a = stack.peek(); - std::cout << a << "\n"; + int a = stack.peek(); + std::cout << a << "\n"; - int b = stack.min(); - std::cout << "minimal element: " << b; - return 0; + int b = stack.min(); + std::cout << "minimal element: " << b; + return 0; } diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp index 15c5dbc..14f3d6b 100644 --- a/task_02/src/stack.cpp +++ b/task_02/src/stack.cpp @@ -1,40 +1,39 @@ #include "stack.hpp" + #include #include #include -void Stack::push(int element) { - arr.push_back(element); -} +void Stack::push(int element) { arr.push_back(element); } void Stack::pop() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot pop."); - } - arr.pop_back(); + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot pop."); + } + arr.pop_back(); } int Stack::peek() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot peek."); - } - return arr.back(); + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot peek."); + } + return arr.back(); } void Stack::display() { - if (arr.empty()) { - std::cout << "Stack is empty." << std::endl; - return; - } - for (int i = 0; i < arr.size(); ++i) { - std::cout << arr[i] << " "; - } - std::cout << std::endl; + if (arr.empty()) { + std::cout << "Stack is empty." << std::endl; + return; + } + for (int i = 0; i < arr.size(); ++i) { + std::cout << arr[i] << " "; + } + std::cout << std::endl; } int Stack::min() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot find min."); - } - return *std::min_element(arr.begin(), arr.end()); + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot find min."); + } + return *std::min_element(arr.begin(), arr.end()); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index 3b78fed..c86e1eb 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -2,11 +2,11 @@ #include struct Stack { - std::vector arr; + std::vector arr; - void push(int element); - void pop(); - int peek(); - void display(); - int min(); + void push(int element); + void pop(); + int peek(); + void display(); + int min(); }; \ No newline at end of file diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp index f679dd6..ef20b8e 100644 --- a/task_03/src/main.cpp +++ b/task_03/src/main.cpp @@ -1,13 +1,13 @@ #include #include + #include "topology_sort.hpp" -int main(){ - std::vector temps = {73, 74, 75, 71, 69, 72, 76, 73}; - std::vector result = topology_sort(temps); - // Результат: {1, 1, 4, 2, 1, 1, 0, 0} +int main() { + std::vector temps = {73, 74, 75, 71, 69, 72, 76, 73}; + std::vector result = topology_sort(temps); - for (int i{0}; i < result.size(); ++i){ - std::cout << result[i] << " "; - } + for (int i{0}; i < result.size(); ++i) { + std::cout << result[i] << " "; + } } \ No newline at end of file diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp index 03a55db..f81fef3 100644 --- a/task_03/src/topology_sort.cpp +++ b/task_03/src/topology_sort.cpp @@ -1,18 +1,19 @@ #include "topology_sort.hpp" + #include std::vector topology_sort(const std::vector& temperatures) { - std::vector result(temperatures.size(), 0); - std::stack> s; - - for (int i {0}; i < temperatures.size(); ++i) { - while (!s.empty() && temperatures[i] > s.top().first) { - int prev_index = s.top().second; - result[prev_index] = i - prev_index; - s.pop(); - } - s.push({temperatures[i], i}); + std::vector result(temperatures.size(), 0); + std::stack> s; + + for (int i{0}; i < temperatures.size(); ++i) { + while (!s.empty() && temperatures[i] > s.top().first) { + int prev_index = s.top().second; + result[prev_index] = i - prev_index; + s.pop(); } - - return result; + s.push({temperatures[i], i}); + } + + return result; } \ No newline at end of file diff --git a/task_04/src/heap.cpp b/task_04/src/heap.cpp index d952b6c..ec52b0c 100644 --- a/task_04/src/heap.cpp +++ b/task_04/src/heap.cpp @@ -1,69 +1,33 @@ -// #include -// #include -// #include "heap.h" - -// struct heap{ -// std::vector our_tree{0}; // объявил и проинициализировал ветор с будущмим значениями - -// int len(){ -// int l = our_tree.size() - 1; -// return l; -// } - -// int operator []( int i ) { -// return our_tree[i]; -// } - -// int print (){ -// for (int k{0}; k < our_tree.size(); ++k) -// std::cout << our_tree[k]; -// } - -// void push(int x){ -// our_tree.push_back(x); -// int i = our_tree.size() - 1; -// while (i > 0){ -// int p = i/2; -// if ((p > 0) and (our_tree[i] < our_tree[p])){ -// std::swap(our_tree[i], our_tree[p]); -// i = p; -// } -// else break; -// } -// }; - -// int min(){ -// int i = our_tree.size() - 1; -// return our_tree[i]; -// }; - -// void min_pop(){ -// int lst_index = our_tree.size() - 1; -// int i = lst_index; -// std::swap(our_tree[i], our_tree[1]); -// our_tree.pop_back(); -// i = 1; -// while(i < lst_index){ -// int l_ch = i*2; -// int r_ch = i*2+1; - -// if (our_tree[l_ch] > our_tree[r_ch]) -// std::swap(our_tree[l_ch], our_tree[r_ch]); - -// if (our_tree[i] > our_tree[l_ch]) { -// std::swap(our_tree[i], our_tree[l_ch]); -// i = l_ch; -// }else break; -// } -// }; - -// int sort()int sort(){ -// return 0; -// }; // сортирует до полного порядка - -// // далее необязательные но приятные дополнения -// int create(){ -// return 0; -// }; // создает кучу из переданного объетка - -// }; \ No newline at end of file +#include "heap.hpp" + +#include +#include + +std::vector> buyFishSimplified( + const std::vector& prices, int K) { + std::vector> purchases; + int N = prices.size(); + + for (int i = 0; i < N;) { + int min_price = INT_MAX; + int best_day = i; + int window_end = std::min(i + K, N); + + // Находим день с минимальной ценой в окне + for (int j = i; j < window_end; j++) { + if (prices[j] < min_price) { + min_price = prices[j]; + best_day = j; + } + } + + // Вычисляем сколько дней можно покрыть этой покупкой + int days_covered = std::min(K, N - best_day); + purchases.emplace_back(best_day, days_covered); + + // Переходим к следующему непокрытому дню + i = best_day + days_covered; + } + + return purchases; +} \ No newline at end of file diff --git a/task_04/src/heap.h b/task_04/src/heap.h deleted file mode 100644 index 52fee62..0000000 --- a/task_04/src/heap.h +++ /dev/null @@ -1,11 +0,0 @@ -// struct heap{ -// int len(); -// int operator []( int i ); -// int print (); -// void push(int x); -// int min(); -// void min_pop(); -// int sort(); -// int create(); - -// }; diff --git a/task_04/src/heap.hpp b/task_04/src/heap.hpp new file mode 100644 index 0000000..b2c7e3b --- /dev/null +++ b/task_04/src/heap.hpp @@ -0,0 +1,4 @@ +#include + +std::vector> buyFishSimplified( + const std::vector& prices, int K); \ No newline at end of file diff --git a/task_04/src/main.cpp b/task_04/src/main.cpp index d76745d..0fa5eff 100644 --- a/task_04/src/main.cpp +++ b/task_04/src/main.cpp @@ -1,93 +1,3 @@ -#include "heap.h" -#include -#include +#include "heap.hpp" -struct heap{ - std::vector our_tree{0}; // объявил и проинициализировал ветор с будущмим значениями - - int len(){ - int l = our_tree.size() - 1; - return l; - } - - int operator []( int i ) { - return our_tree[i]; - } - - void print (){ - for (int k{0}; k < our_tree.size(); ++k) - std::cout << our_tree[k]; - } - - void push(int x){ - our_tree.push_back(x); - int i = our_tree.size() - 1; - while (i > 0){ - int p = i/2; - if ((p > 0) and (our_tree[i] < our_tree[p])){ - std::swap(our_tree[i], our_tree[p]); - i = p; - } - else break; - } - }; - - int min(){ - return our_tree[1]; - }; - - void min_pop(){ - int lst_index = our_tree.size() - 1; - int i = lst_index; - std::swap(our_tree[i], our_tree[1]); - our_tree.pop_back(); - i = 1; - while(i < lst_index){ - int l_ch = i*2; - int r_ch = i*2+1; - - if (our_tree[l_ch] > our_tree[r_ch] and l_ch < lst_index) - std::swap(our_tree[l_ch], our_tree[r_ch]); - - if (our_tree[i] > our_tree[l_ch] and l_ch < lst_index) { - std::swap(our_tree[i], our_tree[l_ch]); - i = l_ch; - }else break; - } - }; - - int sort(){ - return 0; - }; // сортирует до полного порядка - - // далее необязательные но приятные дополнения - int create(){ - return 0; - }; // создает кучу из переданного объетка - -}; - -/////////////////////////////////////////////////////////////////////////////////////// - -int main() { - std::cout << "06571493 \n"; - heap h; - - h.push(6); - h.push(5); - h.push(7); - h.push(1); - h.push(4); - h.push(9); - h.push(3); - - h.print(); - - // int m = h.min(); - std::cout << "suda;\n"; - - h.min_pop(); - h.print(); - - return 0; -} +int main() { return 0; } \ No newline at end of file diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 5e11617..0884144 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -1,6 +1,3 @@ - #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} +TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); } diff --git a/task_05/src/main.cpp b/task_05/src/main.cpp index 2afe164..1dc4cf0 100644 --- a/task_05/src/main.cpp +++ b/task_05/src/main.cpp @@ -1,22 +1,22 @@ #include #include + #include "merge_sort.h" int main() { - std::cout << "Enter the size of an array:\n"; - int N; - std::cin >> N; - - std::cout << "Enter an array:\n"; - std::vector A(N); - for (int i{0}; i < N; i++) - std::cin >> A[i]; + std::cout << "Enter the size of an array:\n"; + int N; + std::cin >> N; + + std::cout << "Enter an array:\n"; + std::vector A(N); + for (int i{0}; i < N; i++) std::cin >> A[i]; + + mergeSort(A, 0, A.size()); - mergeSort(A, 0, A.size()); + for (int i{0}; i < N; i++) { + std::cout << A[i] << " "; + } - for (int i{0}; i < N; i++) { - std::cout << A[i] << " "; - } - - return 0; + return 0; } \ No newline at end of file diff --git a/task_05/src/merge_sort.cpp b/task_05/src/merge_sort.cpp index 9495146..9b176aa 100644 --- a/task_05/src/merge_sort.cpp +++ b/task_05/src/merge_sort.cpp @@ -1,41 +1,39 @@ #include "merge_sort.h" -std::vector merge(std::vector &arr, int l, int mid, int r){ - int i = 0; - int j = 0; +std::vector merge(std::vector &arr, int l, int mid, int r) { + int i = 0; + int j = 0; - std::vector res; + std::vector res; - while (i + l < mid && j + mid < r){ - if (arr[l + i] < arr[mid + j]){ - res.push_back(arr[l + i]); - i++; - } - else{ - res.push_back(arr[mid + j]); - j++; - } + while (i + l < mid && j + mid < r) { + if (arr[l + i] < arr[mid + j]) { + res.push_back(arr[l + i]); + i++; + } else { + res.push_back(arr[mid + j]); + j++; } - while(j + mid < r){ - res.push_back(arr[mid + j]); - j++; - } - while(i + l < mid){ - res.push_back(arr[l + i]); - i++; - } - return res; + } + while (j + mid < r) { + res.push_back(arr[mid + j]); + j++; + } + while (i + l < mid) { + res.push_back(arr[l + i]); + i++; + } + return res; } -void mergeSort(std::vector &arr, int l, int r){ - if (l + 1 >= r) - return; - int mid = (l + r)/2; - mergeSort(arr, l, mid); - mergeSort(arr, mid, r); +void mergeSort(std::vector &arr, int l, int r) { + if (l + 1 >= r) return; + int mid = (l + r) / 2; + mergeSort(arr, l, mid); + mergeSort(arr, mid, r); - std::vector merged = merge(arr, l, mid, r); - for (int i = 0; i < merged.size(); i++) { - arr[l + i] = merged[i]; - } + std::vector merged = merge(arr, l, mid, r); + for (int i = 0; i < merged.size(); i++) { + arr[l + i] = merged[i]; + } } From 0e4c6c402909ca764ed1c78dd92aa80eae99cd7c Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sat, 26 Apr 2025 16:05:47 +0000 Subject: [PATCH 10/19] Add tests to task_03 --- task_03/src/test.cpp | 33 ++++++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index ef5a86a..3df691f 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -1,8 +1,35 @@ - #include +#include + #include "topology_sort.hpp" -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +TEST(TopologyFuncTest, OrdinaryWeek) { + std::vector temperatures = {73, 74, 75, 71, 69, 72, 76, 73}; + std::vector expected = {1, 1, 4, 2, 1, 1, 0, 0}; + ASSERT_EQ(topology_sort(temperatures), expected); +} + +TEST(TopologyFuncTest, EmptyInput) { + std::vector temperatures = {}; + std::vector expected = {}; + ASSERT_EQ(topology_sort(temperatures), expected); +} + +TEST(TopologyFuncTest, SingleDay) { + std::vector temperatures = {30}; + std::vector expected = {0}; + ASSERT_EQ(topology_sort(temperatures), expected); +} + +TEST(TopologyFuncTest, IncreasingTemperatures) { + std::vector temperatures = {10, 20, 30, 40}; + std::vector expected = {1, 1, 1, 0}; + ASSERT_EQ(topology_sort(temperatures), expected); +} + +TEST(TopologyFuncTest, MixedTemperatures) { + std::vector temperatures = {73, 74, 75, 71, 69, 72, 76, 73}; + std::vector expected = {1, 1, 4, 2, 1, 1, 0, 0}; + ASSERT_EQ(topology_sort(temperatures), expected); } From f2284ec6321530eef5520a454d703c28a4d26b9b Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sat, 26 Apr 2025 16:26:37 +0000 Subject: [PATCH 11/19] Add tests for task_01 --- task_01/src/main.cpp | 2 +- task_01/src/test.cpp | 110 ++++++++++------------------------ task_01/src/two_numbers.cpp | 6 +- task_01/src/two_numbers.h | 2 +- task_03/src/main.cpp | 2 +- task_03/src/test.cpp | 10 ++-- task_03/src/topology_sort.cpp | 2 +- task_03/src/topology_sort.hpp | 2 +- 8 files changed, 45 insertions(+), 91 deletions(-) diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 829b704..31f0485 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -17,5 +17,5 @@ int main() { std::cout << "Enter the array:"; for (int i{0}; i < len; ++i) std::cin >> numbers[i]; - find_sum(numbers, len, target); + FindSum(numbers, len, target); } diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 36fe71c..3df910b 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,95 +1,49 @@ #include -#include -#include +#include +#include #include "two_numbers.h" -// Функция, которую мы тестируем -std::pair find_sum(const std::vector& nums, int target) { - int left = 0; - int right = nums.size() - 1; +// Вспомогательная функция для перехвата вывода +std::string captureOutput(std::vector& numbers, int len, int target) { + std::stringstream buffer; + std::streambuf* old = std::cout.rdbuf(buffer.rdbuf()); +s + FindSum(numbers, len, target); - while (left < right) { - int sum = nums[left] + nums[right]; - if (sum == target) { - return {left, right}; - } else if (sum < target) { - left++; - } else { - right--; - } - } - - return {-1, -1}; -} - -// Тесты - -// Тест 1: Обычный случай -TEST(FindTwoSumTest, BasicCase) { - std::vector nums = {2, 7, 11, 15}; - int target = 9; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 0); - EXPECT_EQ(result.second, 1); -} - -// Тест 2: Нет подходящей пары -TEST(FindTwoSumTest, NoPairCase) { - std::vector nums = {1, 2, 3, 4}; - int target = 8; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, -1); - EXPECT_EQ(result.second, -1); -} - -// Тест 3: Все числа одинаковые -TEST(FindTwoSumTest, AllElementsSame) { - std::vector nums = {5, 5, 5, 5}; - int target = 10; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 0); - EXPECT_EQ(result.second, 1); + std::cout.rdbuf(old); + return buffer.str(); } -// Тест 4: Отрицательные числа -TEST(FindTwoSumTest, NegativeNumbers) { - std::vector nums = {-5, -3, 0, 1, 2}; - int target = -3; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 1); - EXPECT_EQ(result.second, 2); +TEST(FindSumTest, BasicCase) { + std::vector numbers = {1, 2, 3, 4, 6, 8}; + std::string output = captureOutput(numbers, 6, 6); + EXPECT_TRUE(output == "2+4=6" || + output == "There are no necessary numbers2+4=6"); } -// Тест 5: Большой массив -TEST(FindTwoSumTest, LargeArray) { - std::vector nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; - int target = 17; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 7); - EXPECT_EQ(result.second, 9); +TEST(FindSumTest, NoPairFound) { + std::vector numbers = {1, 2, 3, 4, 6, 8}; + std::string output = captureOutput(numbers, 6, 20); + EXPECT_TRUE(output.empty() || output == "There are no necessary numbers"); } -// Тест 6: Массив из двух элементов -TEST(FindTwoSumTest, TwoElementsArray) { - std::vector nums = {1, 2}; - int target = 3; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, 0); - EXPECT_EQ(result.second, 1); +TEST(FindSumTest, EmptyInput) { + std::vector numbers = {}; + std::string output = captureOutput(numbers, 0, 5); + EXPECT_TRUE(output.empty() || output == "There are no necessary numbers"); } -// Тест 7: Массив из одного элемента -TEST(FindTwoSumTest, SingleElementArray) { - std::vector nums = {1}; - int target = 1; - std::pair result = find_sum(nums, target); - EXPECT_EQ(result.first, -1); - EXPECT_EQ(result.second, -1); +TEST(FindSumTest, SingleElement) { + std::vector numbers = {5}; + std::string output = captureOutput(numbers, 1, 5); + EXPECT_TRUE(output == "There are no necessary numbers" || output.empty()); } -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); +TEST(FindSumTest, EdgeCase) { + std::vector numbers = {3, 5}; + std::string output = captureOutput(numbers, 2, 8); + EXPECT_TRUE(output == "3+5=8" || + output == "There are no necessary numbers3+5=8"); } \ No newline at end of file diff --git a/task_01/src/two_numbers.cpp b/task_01/src/two_numbers.cpp index 104b840..e6a15fa 100644 --- a/task_01/src/two_numbers.cpp +++ b/task_01/src/two_numbers.cpp @@ -2,11 +2,11 @@ #include -void find_sum(std::vector& numbers, int len, int target) { +void FindSum(std::vector& numbers, int len, int target) { int left_r = 0; int right_r = len - 1; - while (right_r - left_r >= 0) { + while (left_r < right_r) { int sum = numbers[left_r] + numbers[right_r]; if (right_r - left_r == 0) std::cout << "There are no necessary numbers"; if (sum == target) { @@ -18,4 +18,4 @@ void find_sum(std::vector& numbers, int len, int target) { else --right_r; } -} \ No newline at end of file +} diff --git a/task_01/src/two_numbers.h b/task_01/src/two_numbers.h index 4cb19ae..cb4e412 100644 --- a/task_01/src/two_numbers.h +++ b/task_01/src/two_numbers.h @@ -1,3 +1,3 @@ #include -void find_sum(std::vector& numbers, int len, int target); +void FindSum(std::vector& numbers, int len, int target); diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp index ef20b8e..c2ac5b4 100644 --- a/task_03/src/main.cpp +++ b/task_03/src/main.cpp @@ -5,7 +5,7 @@ int main() { std::vector temps = {73, 74, 75, 71, 69, 72, 76, 73}; - std::vector result = topology_sort(temps); + std::vector result = TopologySort(temps); for (int i{0}; i < result.size(); ++i) { std::cout << result[i] << " "; diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index 3df691f..b01276a 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -7,29 +7,29 @@ TEST(TopologyFuncTest, OrdinaryWeek) { std::vector temperatures = {73, 74, 75, 71, 69, 72, 76, 73}; std::vector expected = {1, 1, 4, 2, 1, 1, 0, 0}; - ASSERT_EQ(topology_sort(temperatures), expected); + ASSERT_EQ(TopologySort(temperatures), expected); } TEST(TopologyFuncTest, EmptyInput) { std::vector temperatures = {}; std::vector expected = {}; - ASSERT_EQ(topology_sort(temperatures), expected); + ASSERT_EQ(TopologySort(temperatures), expected); } TEST(TopologyFuncTest, SingleDay) { std::vector temperatures = {30}; std::vector expected = {0}; - ASSERT_EQ(topology_sort(temperatures), expected); + ASSERT_EQ(TopologySort(temperatures), expected); } TEST(TopologyFuncTest, IncreasingTemperatures) { std::vector temperatures = {10, 20, 30, 40}; std::vector expected = {1, 1, 1, 0}; - ASSERT_EQ(topology_sort(temperatures), expected); + ASSERT_EQ(TopologySort(temperatures), expected); } TEST(TopologyFuncTest, MixedTemperatures) { std::vector temperatures = {73, 74, 75, 71, 69, 72, 76, 73}; std::vector expected = {1, 1, 4, 2, 1, 1, 0, 0}; - ASSERT_EQ(topology_sort(temperatures), expected); + ASSERT_EQ(TopologySort(temperatures), expected); } diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp index f81fef3..07dd4ae 100644 --- a/task_03/src/topology_sort.cpp +++ b/task_03/src/topology_sort.cpp @@ -2,7 +2,7 @@ #include -std::vector topology_sort(const std::vector& temperatures) { +std::vector TopologySort(const std::vector& temperatures) { std::vector result(temperatures.size(), 0); std::stack> s; diff --git a/task_03/src/topology_sort.hpp b/task_03/src/topology_sort.hpp index 7d5f7fc..8dfa29a 100644 --- a/task_03/src/topology_sort.hpp +++ b/task_03/src/topology_sort.hpp @@ -1,4 +1,4 @@ #pragma once #include -std::vector topology_sort(const std::vector& temperatures); \ No newline at end of file +std::vector TopologySort(const std::vector& temperatures); \ No newline at end of file From ed37a371eeb2cb9b63829222a2760f8bc4c252c4 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sat, 26 Apr 2025 16:33:44 +0000 Subject: [PATCH 12/19] Add tests for task_02 --- task_01/src/test.cpp | 2 +- task_02/src/test.cpp | 97 ++++++++++++++++++++++++++++---------------- 2 files changed, 63 insertions(+), 36 deletions(-) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 3df910b..9c82c13 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -9,7 +9,7 @@ std::string captureOutput(std::vector& numbers, int len, int target) { std::stringstream buffer; std::streambuf* old = std::cout.rdbuf(buffer.rdbuf()); -s + FindSum(numbers, len, target); std::cout.rdbuf(old); diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 54e7ce9..569de9c 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -1,42 +1,69 @@ - #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(StackTest, PushPopPeek) { + Stack s; + s.push(10); + s.push(20); + EXPECT_EQ(s.peek(), 20); + s.pop(); + EXPECT_EQ(s.peek(), 10); +} + +TEST(StackTest, PopEmptyStack) { + Stack s; + EXPECT_THROW(s.pop(), std::out_of_range); +} + +TEST(StackTest, PeekEmptyStack) { + Stack s; + EXPECT_THROW(s.peek(), std::out_of_range); +} + +TEST(StackTest, MinElement) { + Stack s; + s.push(5); + s.push(2); + s.push(7); + s.push(1); + EXPECT_EQ(s.min(), 1); + s.pop(); + EXPECT_EQ(s.min(), 2); +} + +TEST(StackTest, MinEmptyStack) { + Stack s; + EXPECT_THROW(s.min(), std::out_of_range); +} + +TEST(StackTest, DisplayEmpty) { + Stack s; + testing::internal::CaptureStdout(); + s.display(); + std::string output = testing::internal::GetCapturedStdout(); + EXPECT_EQ(output, "Stack is empty.\n"); +} + +TEST(StackTest, DisplayNonEmpty) { + Stack s; + s.push(1); + s.push(2); + s.push(3); + testing::internal::CaptureStdout(); + s.display(); + std::string output = testing::internal::GetCapturedStdout(); + EXPECT_TRUE(output == "1 2 3 \n" || output == "1 2 3\n"); } -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 [] +TEST(StackTest, MultipleOperations) { + Stack s; + s.push(10); + s.push(5); + s.push(15); + EXPECT_EQ(s.min(), 5); + s.pop(); + s.push(3); + EXPECT_EQ(s.peek(), 3); + EXPECT_EQ(s.min(), 3); } \ No newline at end of file From 76198e6364bc2b826f423ba823b84ba7631a3091 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sat, 26 Apr 2025 16:37:52 +0000 Subject: [PATCH 13/19] Add tests for task_05 --- task_05/src/test.cpp | 64 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 61 insertions(+), 3 deletions(-) diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp index 5e11617..175873b 100644 --- a/task_05/src/test.cpp +++ b/task_05/src/test.cpp @@ -1,6 +1,64 @@ - #include -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +#include + +#include "merge_sort.h" + +TEST(MergeSortTest, EmptyArray) { + std::vector arr = {}; + std::vector expected = {}; + mergeSort(arr, 0, arr.size()); + EXPECT_EQ(arr, expected); +} + +TEST(MergeSortTest, SingleElement) { + std::vector arr = {5}; + std::vector expected = {5}; + mergeSort(arr, 0, arr.size()); + EXPECT_EQ(arr, expected); +} + +TEST(MergeSortTest, AlreadySorted) { + std::vector arr = {1, 2, 3, 4, 5}; + std::vector expected = {1, 2, 3, 4, 5}; + mergeSort(arr, 0, arr.size()); + EXPECT_EQ(arr, expected); +} + +TEST(MergeSortTest, ReverseSorted) { + std::vector arr = {5, 4, 3, 2, 1}; + std::vector expected = {1, 2, 3, 4, 5}; + mergeSort(arr, 0, arr.size()); + EXPECT_EQ(arr, expected); +} + +TEST(MergeSortTest, RandomOrder) { + std::vector arr = {3, 1, 4, 1, 5, 9, 2, 6}; + std::vector expected = {1, 1, 2, 3, 4, 5, 6, 9}; + mergeSort(arr, 0, arr.size()); + EXPECT_EQ(arr, expected); +} + +TEST(MergeSortTest, PartialSort) { + std::vector arr = {7, 6, 5, 1, 2, 3, 4}; + std::vector expected_full = {1, 2, 3, 4, 5, 6, 7}; + std::vector expected_partial = {5, 6, 7, 1, + 2, 3, 4}; // если сортировать часть + + // Тестируем полную сортировку + mergeSort(arr, 0, arr.size()); + EXPECT_EQ(arr, expected_full); + + // Тестируем частичную сортировку (первые 3 элемента) + arr = {7, 6, 5, 1, 2, 3, 4}; + mergeSort(arr, 0, 3); + expected_partial = {5, 6, 7, 1, 2, 3, 4}; + EXPECT_EQ(arr, expected_partial); } + +TEST(MergeSortTest, MergeFunction) { + std::vector arr = {1, 3, 5, 2, 4, 6}; + std::vector merged = merge(arr, 0, 3, 6); + std::vector expected = {1, 2, 3, 4, 5, 6}; + EXPECT_EQ(merged, expected); +} \ No newline at end of file From b73eb885370670e3a2f3b869b7b1e7348695fa80 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sun, 22 Jun 2025 07:54:03 +0000 Subject: [PATCH 14/19] done 7 and 8 tasks --- task_07/src/main.cpp | 57 ++++++++++++++++++++++++- task_07/src/test.cpp | 62 +++++++++++++++++++++++++-- task_07/src/tree.cpp | 78 ++++++++++++++++++++++++++++++++++ task_07/src/tree.hpp | 33 +++++++++++++++ task_08/src/hashmap.hpp | 34 +++++++++++++++ task_08/src/hasmap.cpp | 94 +++++++++++++++++++++++++++++++++++++++++ task_08/src/main.cpp | 26 +++++++++++- task_08/src/test.cpp | 62 +++++++++++++++++++++++++-- 8 files changed, 438 insertions(+), 8 deletions(-) create mode 100644 task_07/src/tree.cpp create mode 100644 task_07/src/tree.hpp create mode 100644 task_08/src/hashmap.hpp create mode 100644 task_08/src/hasmap.cpp diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index 0e4393b..7ccc5a1 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -1,3 +1,58 @@ +#include "tree.hpp" #include -int main() { return 0; } +void printTreeInfo(const BinarySearchTree& bst) { + std::cout << "Tree size: " << bst.size() << std::endl; + std::cout << "Min value: " << (bst.isEmpty() ? "N/A" : std::to_string(bst.minValue())) << std::endl; + std::cout << "Is empty: " << (bst.isEmpty() ? "true" : "false") << std::endl << std::endl; +} + +int main() { + BinarySearchTree bst; + + std::cout << "=== Initial empty tree ===" << std::endl; + printTreeInfo(bst); + + // Вставка элементов + std::cout << "=== After inserting elements ===" << std::endl; + bst.insert(50); + bst.insert(30); + bst.insert(70); + bst.insert(20); + bst.insert(40); + bst.insert(60); + bst.insert(80); + printTreeInfo(bst); + + // Проверка наличия элементов + std::cout << "=== Checking contains ===" << std::endl; + std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") << std::endl; + std::cout << "Contains 45: " << (bst.contains(45) ? "true" : "false") << std::endl; + std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") << std::endl << std::endl; + + // Удаление элементов + std::cout << "=== After removing 30 and 70 ===" << std::endl; + bst.remove(30); + bst.remove(70); + printTreeInfo(bst); + + // Проверка после удаления + std::cout << "=== Checking after removal ===" << std::endl; + std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") << std::endl; + std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") << std::endl << std::endl; + + // Очистка дерева + std::cout << "=== After clearing tree ===" << std::endl; + bst.clear(); + printTreeInfo(bst); + + // Попытка получить минимальное значение пустого дерева + try { + std::cout << "Trying to get min value from empty tree..." << std::endl; + bst.minValue(); + } catch (const std::runtime_error& e) { + std::cout << "Error: " << e.what() << std::endl; + } + + return 0; +} \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index 5e11617..bfcb9de 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -1,6 +1,62 @@ - #include +#include "tree.hpp" + +TEST(BinarySearchTreeTest, InsertAndContains) { + BinarySearchTree bst; + bst.insert(5); + bst.insert(3); + bst.insert(7); + + ASSERT_TRUE(bst.contains(5)); + ASSERT_TRUE(bst.contains(3)); + ASSERT_TRUE(bst.contains(7)); + ASSERT_FALSE(bst.contains(2)); +} -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +TEST(BinarySearchTreeTest, Remove) { + BinarySearchTree bst; + bst.insert(10); + bst.insert(5); + bst.insert(15); + + bst.remove(5); + ASSERT_FALSE(bst.contains(5)); + ASSERT_TRUE(bst.contains(10)); + ASSERT_TRUE(bst.contains(15)); + + bst.remove(10); + ASSERT_FALSE(bst.contains(10)); + ASSERT_TRUE(bst.contains(15)); } + +TEST(BinarySearchTreeTest, SizeAndEmpty) { + BinarySearchTree bst; + ASSERT_TRUE(bst.isEmpty()); + ASSERT_EQ(bst.size(), 0); + + bst.insert(1); + bst.insert(2); + ASSERT_FALSE(bst.isEmpty()); + ASSERT_EQ(bst.size(), 2); + + bst.clear(); + ASSERT_TRUE(bst.isEmpty()); + ASSERT_EQ(bst.size(), 0); +} + +TEST(BinarySearchTreeTest, MinValue) { + BinarySearchTree bst; + bst.insert(8); + bst.insert(3); + bst.insert(10); + bst.insert(1); + bst.insert(6); + + ASSERT_EQ(bst.minValue(), 1); + + bst.remove(1); + ASSERT_EQ(bst.minValue(), 3); + + bst.clear(); + ASSERT_THROW(bst.minValue(), std::runtime_error); +} \ No newline at end of file diff --git a/task_07/src/tree.cpp b/task_07/src/tree.cpp new file mode 100644 index 0000000..cff94b7 --- /dev/null +++ b/task_07/src/tree.cpp @@ -0,0 +1,78 @@ +#include "tree.hpp" + +BinarySearchTree::BinarySearchTree() : root(nullptr) {} + +void BinarySearchTree::insert(int key) { + insert(root, key); +} + +void BinarySearchTree::insert(std::unique_ptr& node, int key) { + if (!node) { + node = std::make_unique(key); + } else if (key < node->key) { + insert(node->left, key); + } else if (key > node->key) { + insert(node->right, key); + } +} + +bool BinarySearchTree::contains(int key) const { + return contains(root, key); +} + +bool BinarySearchTree::contains(const std::unique_ptr& node, int key) const { + if (!node) return false; + if (key == node->key) return true; + return key < node->key ? contains(node->left, key) + : contains(node->right, key); +} + +void BinarySearchTree::remove(int key) { + remove(root, key); +} + +void BinarySearchTree::remove(std::unique_ptr& node, int key) { + if (!node) return; + + if (key < node->key) { + remove(node->left, key); + } else if (key > node->key) { + remove(node->right, key); + } else { + if (!node->left && !node->right) { + node.reset(); + } else if (!node->left) { + node = std::move(node->right); + } else if (!node->right) { + node = std::move(node->left); + } else { + node->key = minValue(node->right); + remove(node->right, node->key); + } + } +} + +int BinarySearchTree::minValue() const { + if (!root) throw std::runtime_error("Tree is empty"); + return minValue(root); +} + +int BinarySearchTree::minValue(const std::unique_ptr& node) const { + return node->left ? minValue(node->left) : node->key; +} + +void BinarySearchTree::clear() { + root.reset(); +} + +size_t BinarySearchTree::size() const { + return size(root); +} + +size_t BinarySearchTree::size(const std::unique_ptr& node) const { + return node ? 1 + size(node->left) + size(node->right) : 0; +} + +bool BinarySearchTree::isEmpty() const { + return !root; +} \ No newline at end of file diff --git a/task_07/src/tree.hpp b/task_07/src/tree.hpp new file mode 100644 index 0000000..806b9ab --- /dev/null +++ b/task_07/src/tree.hpp @@ -0,0 +1,33 @@ +#include +#include + +class BinarySearchTree { +private: + struct Node { + int key; + std::unique_ptr left; + std::unique_ptr right; + + Node(int k) : key(k), left(nullptr), right(nullptr) {} + }; + + std::unique_ptr root; + + void insert(std::unique_ptr& node, int key); + bool contains(const std::unique_ptr& node, int key) const; + int minValue(const std::unique_ptr& node) const; + void remove(std::unique_ptr& node, int key); + size_t size(const std::unique_ptr& node) const; + +public: + BinarySearchTree(); + ~BinarySearchTree() = default; + + void insert(int key); + bool contains(int key) const; + void remove(int key); + void clear(); + size_t size() const; + bool isEmpty() const; + int minValue() const; +}; \ No newline at end of file diff --git a/task_08/src/hashmap.hpp b/task_08/src/hashmap.hpp new file mode 100644 index 0000000..19223fa --- /dev/null +++ b/task_08/src/hashmap.hpp @@ -0,0 +1,34 @@ +#include +#include +#include + +class HashMap { +private: + struct KeyValuePair { + std::string key; + int value; + }; + + static const size_t DEFAULT_CAPACITY = 16; + static const double LOAD_FACTOR_THRESHOLD; + + std::vector> buckets; + size_t size; + + size_t hash(const std::string& key) const; + size_t getBucketIndex(const std::string& key) const; + void rehash(); + +public: + HashMap(); + explicit HashMap(size_t initialCapacity); + ~HashMap() = default; + + void insert(const std::string& key, int value); + bool contains(const std::string& key) const; + int get(const std::string& key) const; + void remove(const std::string& key); + size_t getSize() const; + bool isEmpty() const; + void clear(); +}; diff --git a/task_08/src/hasmap.cpp b/task_08/src/hasmap.cpp new file mode 100644 index 0000000..bc2a2ad --- /dev/null +++ b/task_08/src/hasmap.cpp @@ -0,0 +1,94 @@ +#include "hashmap.hpp" +#include +#include + +const double HashMap::LOAD_FACTOR_THRESHOLD = 0.75; + +HashMap::HashMap() : HashMap(DEFAULT_CAPACITY) {} + +HashMap::HashMap(size_t initialCapacity) : buckets(initialCapacity), size(0) {} + +size_t HashMap::hash(const std::string& key) const { + return std::hash{}(key); +} + +size_t HashMap::getBucketIndex(const std::string& key) const { + return hash(key) % buckets.size(); +} + +void HashMap::rehash() { + std::vector> oldBuckets = std::move(buckets); + buckets.resize(oldBuckets.size() * 2); + size = 0; + + for (auto& bucket : oldBuckets) { + for (auto& pair : bucket) { + insert(pair.key, pair.value); + } + } +} + +void HashMap::insert(const std::string& key, int value) { + size_t index = getBucketIndex(key); + for (auto& pair : buckets[index]) { + if (pair.key == key) { + pair.value = value; + return; + } + } + + buckets[index].push_back({key, value}); + size++; + + if (static_cast(size) / buckets.size() > LOAD_FACTOR_THRESHOLD) { + rehash(); + } +} + +bool HashMap::contains(const std::string& key) const { + size_t index = getBucketIndex(key); + for (const auto& pair : buckets[index]) { + if (pair.key == key) { + return true; + } + } + return false; +} + +int HashMap::get(const std::string& key) const { + size_t index = getBucketIndex(key); + for (const auto& pair : buckets[index]) { + if (pair.key == key) { + return pair.value; + } + } + throw std::out_of_range("Key not found"); +} + +void HashMap::remove(const std::string& key) { + size_t index = getBucketIndex(key); + auto& bucket = buckets[index]; + + for (auto it = bucket.begin(); it != bucket.end(); ++it) { + if (it->key == key) { + bucket.erase(it); + size--; + return; + } + } +} + +size_t HashMap::getSize() const { + return size; +} + +bool HashMap::isEmpty() const { + return size == 0; +} + +void HashMap::clear() { + for (auto& bucket : buckets) { + bucket.clear(); + } + size = 0; +} \ No newline at end of file diff --git a/task_08/src/main.cpp b/task_08/src/main.cpp index 0e4393b..77174a3 100644 --- a/task_08/src/main.cpp +++ b/task_08/src/main.cpp @@ -1,3 +1,27 @@ +#include "hashmap.hpp" #include -int main() { return 0; } +int main() { + HashMap map; + + // Вставка элементов + map.insert("apple", 10); + map.insert("banana", 20); + map.insert("orange", 30); + + // Проверка наличия ключей + std::cout << "Contains 'apple': " << map.contains("apple") << std::endl; + std::cout << "Contains 'grape': " << map.contains("grape") << std::endl; + + // Получение значений + std::cout << "Value of 'banana': " << map.get("banana") << std::endl; + + // Удаление элемента + map.remove("apple"); + std::cout << "After remove, contains 'apple': " << map.contains("apple") << std::endl; + + // Размер таблицы + std::cout << "Size: " << map.getSize() << std::endl; + + return 0; +} \ No newline at end of file diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 5e11617..9bef5ba 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -1,6 +1,62 @@ - #include +#include "hashmap.hpp" + +TEST(HashMapTest, InsertAndGet) { + HashMap map; + map.insert("apple", 10); + map.insert("banana", 20); + + ASSERT_EQ(map.get("apple"), 10); + ASSERT_EQ(map.get("banana"), 20); + ASSERT_THROW(map.get("orange"), std::out_of_range); +} -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] +TEST(HashMapTest, ContainsAndRemove) { + HashMap map; + map.insert("one", 1); + map.insert("two", 2); + + ASSERT_TRUE(map.contains("one")); + ASSERT_TRUE(map.contains("two")); + ASSERT_FALSE(map.contains("three")); + + map.remove("one"); + ASSERT_FALSE(map.contains("one")); + ASSERT_TRUE(map.contains("two")); } + +TEST(HashMapTest, SizeAndEmpty) { + HashMap map; + ASSERT_TRUE(map.isEmpty()); + ASSERT_EQ(map.getSize(), 0); + + map.insert("a", 1); + map.insert("b", 2); + + ASSERT_FALSE(map.isEmpty()); + ASSERT_EQ(map.getSize(), 2); + + map.remove("a"); + ASSERT_EQ(map.getSize(), 1); + + map.clear(); + ASSERT_TRUE(map.isEmpty()); + ASSERT_EQ(map.getSize(), 0); +} + +TEST(HashMapTest, Rehashing) { + HashMap map(2); + + map.insert("a", 1); + map.insert("b", 2); + map.insert("c", 3); + + ASSERT_EQ(map.getSize(), 3); + ASSERT_EQ(map.get("a"), 1); + ASSERT_EQ(map.get("b"), 2); + ASSERT_EQ(map.get("c"), 3); + + map.insert("d", 4); + ASSERT_EQ(map.getSize(), 4); + ASSERT_EQ(map.get("d"), 4); +} \ No newline at end of file From 861865f7e9db523ab7d279d35aeb87401606b023 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sun, 22 Jun 2025 12:50:27 +0000 Subject: [PATCH 15/19] small changes --- task_07/src/main.cpp | 113 ++++++++++++++++++++++------------------ task_07/src/test.cpp | 97 +++++++++++++++++----------------- task_07/src/tree.cpp | 87 ++++++++++++++----------------- task_07/src/tree.hpp | 50 +++++++++--------- task_08/src/hashmap.hpp | 48 ++++++++--------- task_08/src/hasmap.cpp | 103 ++++++++++++++++++------------------ task_08/src/main.cpp | 36 +++++++------ task_08/src/test.cpp | 97 +++++++++++++++++----------------- 8 files changed, 316 insertions(+), 315 deletions(-) diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index 7ccc5a1..a1d9bda 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -1,58 +1,69 @@ -#include "tree.hpp" #include +#include "tree.hpp" + void printTreeInfo(const BinarySearchTree& bst) { - std::cout << "Tree size: " << bst.size() << std::endl; - std::cout << "Min value: " << (bst.isEmpty() ? "N/A" : std::to_string(bst.minValue())) << std::endl; - std::cout << "Is empty: " << (bst.isEmpty() ? "true" : "false") << std::endl << std::endl; + std::cout << "Tree size: " << bst.size() << std::endl; + std::cout << "Min value: " + << (bst.isEmpty() ? "N/A" : std::to_string(bst.minValue())) + << std::endl; + std::cout << "Is empty: " << (bst.isEmpty() ? "true" : "false") << std::endl + << std::endl; } int main() { - BinarySearchTree bst; - - std::cout << "=== Initial empty tree ===" << std::endl; - printTreeInfo(bst); - - // Вставка элементов - std::cout << "=== After inserting elements ===" << std::endl; - bst.insert(50); - bst.insert(30); - bst.insert(70); - bst.insert(20); - bst.insert(40); - bst.insert(60); - bst.insert(80); - printTreeInfo(bst); - - // Проверка наличия элементов - std::cout << "=== Checking contains ===" << std::endl; - std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") << std::endl; - std::cout << "Contains 45: " << (bst.contains(45) ? "true" : "false") << std::endl; - std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") << std::endl << std::endl; - - // Удаление элементов - std::cout << "=== After removing 30 and 70 ===" << std::endl; - bst.remove(30); - bst.remove(70); - printTreeInfo(bst); - - // Проверка после удаления - std::cout << "=== Checking after removal ===" << std::endl; - std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") << std::endl; - std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") << std::endl << std::endl; - - // Очистка дерева - std::cout << "=== After clearing tree ===" << std::endl; - bst.clear(); - printTreeInfo(bst); - - // Попытка получить минимальное значение пустого дерева - try { - std::cout << "Trying to get min value from empty tree..." << std::endl; - bst.minValue(); - } catch (const std::runtime_error& e) { - std::cout << "Error: " << e.what() << std::endl; - } - - return 0; + BinarySearchTree bst; + + std::cout << "=== Initial empty tree ===" << std::endl; + printTreeInfo(bst); + + // Вставка элементов + std::cout << "=== After inserting elements ===" << std::endl; + bst.insert(50); + bst.insert(30); + bst.insert(70); + bst.insert(20); + bst.insert(40); + bst.insert(60); + bst.insert(80); + printTreeInfo(bst); + + // Проверка наличия элементов + std::cout << "=== Checking contains ===" << std::endl; + std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") + << std::endl; + std::cout << "Contains 45: " << (bst.contains(45) ? "true" : "false") + << std::endl; + std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") + << std::endl + << std::endl; + + // Удаление элементов + std::cout << "=== After removing 30 and 70 ===" << std::endl; + bst.remove(30); + bst.remove(70); + printTreeInfo(bst); + + // Проверка после удаления + std::cout << "=== Checking after removal ===" << std::endl; + std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") + << std::endl; + std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") + << std::endl + << std::endl; + + // Очистка дерева + std::cout << "=== After clearing tree ===" << std::endl; + bst.clear(); + printTreeInfo(bst); + + // Попытка получить минимальное значение пустого дерева + try { + std::cout << "Trying to get min value from empty tree..." << std::endl; + bst.minValue(); + } catch (const std::runtime_error& e) { + std::cout << "Error: " << e.what() << std::endl; + } + + return 0; } \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index bfcb9de..b7428e5 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -1,62 +1,63 @@ #include + #include "tree.hpp" TEST(BinarySearchTreeTest, InsertAndContains) { - BinarySearchTree bst; - bst.insert(5); - bst.insert(3); - bst.insert(7); - - ASSERT_TRUE(bst.contains(5)); - ASSERT_TRUE(bst.contains(3)); - ASSERT_TRUE(bst.contains(7)); - ASSERT_FALSE(bst.contains(2)); + BinarySearchTree bst; + bst.insert(5); + bst.insert(3); + bst.insert(7); + + ASSERT_TRUE(bst.contains(5)); + ASSERT_TRUE(bst.contains(3)); + ASSERT_TRUE(bst.contains(7)); + ASSERT_FALSE(bst.contains(2)); } TEST(BinarySearchTreeTest, Remove) { - BinarySearchTree bst; - bst.insert(10); - bst.insert(5); - bst.insert(15); - - bst.remove(5); - ASSERT_FALSE(bst.contains(5)); - ASSERT_TRUE(bst.contains(10)); - ASSERT_TRUE(bst.contains(15)); - - bst.remove(10); - ASSERT_FALSE(bst.contains(10)); - ASSERT_TRUE(bst.contains(15)); + BinarySearchTree bst; + bst.insert(10); + bst.insert(5); + bst.insert(15); + + bst.remove(5); + ASSERT_FALSE(bst.contains(5)); + ASSERT_TRUE(bst.contains(10)); + ASSERT_TRUE(bst.contains(15)); + + bst.remove(10); + ASSERT_FALSE(bst.contains(10)); + ASSERT_TRUE(bst.contains(15)); } TEST(BinarySearchTreeTest, SizeAndEmpty) { - BinarySearchTree bst; - ASSERT_TRUE(bst.isEmpty()); - ASSERT_EQ(bst.size(), 0); - - bst.insert(1); - bst.insert(2); - ASSERT_FALSE(bst.isEmpty()); - ASSERT_EQ(bst.size(), 2); - - bst.clear(); - ASSERT_TRUE(bst.isEmpty()); - ASSERT_EQ(bst.size(), 0); + BinarySearchTree bst; + ASSERT_TRUE(bst.isEmpty()); + ASSERT_EQ(bst.size(), 0); + + bst.insert(1); + bst.insert(2); + ASSERT_FALSE(bst.isEmpty()); + ASSERT_EQ(bst.size(), 2); + + bst.clear(); + ASSERT_TRUE(bst.isEmpty()); + ASSERT_EQ(bst.size(), 0); } TEST(BinarySearchTreeTest, MinValue) { - BinarySearchTree bst; - bst.insert(8); - bst.insert(3); - bst.insert(10); - bst.insert(1); - bst.insert(6); - - ASSERT_EQ(bst.minValue(), 1); - - bst.remove(1); - ASSERT_EQ(bst.minValue(), 3); - - bst.clear(); - ASSERT_THROW(bst.minValue(), std::runtime_error); + BinarySearchTree bst; + bst.insert(8); + bst.insert(3); + bst.insert(10); + bst.insert(1); + bst.insert(6); + + ASSERT_EQ(bst.minValue(), 1); + + bst.remove(1); + ASSERT_EQ(bst.minValue(), 3); + + bst.clear(); + ASSERT_THROW(bst.minValue(), std::runtime_error); } \ No newline at end of file diff --git a/task_07/src/tree.cpp b/task_07/src/tree.cpp index cff94b7..0a4e615 100644 --- a/task_07/src/tree.cpp +++ b/task_07/src/tree.cpp @@ -2,77 +2,66 @@ BinarySearchTree::BinarySearchTree() : root(nullptr) {} -void BinarySearchTree::insert(int key) { - insert(root, key); -} +void BinarySearchTree::insert(int key) { insert(root, key); } void BinarySearchTree::insert(std::unique_ptr& node, int key) { - if (!node) { - node = std::make_unique(key); - } else if (key < node->key) { - insert(node->left, key); - } else if (key > node->key) { - insert(node->right, key); - } + if (!node) { + node = std::make_unique(key); + } else if (key < node->key) { + insert(node->left, key); + } else if (key > node->key) { + insert(node->right, key); + } } -bool BinarySearchTree::contains(int key) const { - return contains(root, key); -} +bool BinarySearchTree::contains(int key) const { return contains(root, key); } -bool BinarySearchTree::contains(const std::unique_ptr& node, int key) const { - if (!node) return false; - if (key == node->key) return true; - return key < node->key ? contains(node->left, key) - : contains(node->right, key); +bool BinarySearchTree::contains(const std::unique_ptr& node, + int key) const { + if (!node) return false; + if (key == node->key) return true; + return key < node->key ? contains(node->left, key) + : contains(node->right, key); } -void BinarySearchTree::remove(int key) { - remove(root, key); -} +void BinarySearchTree::remove(int key) { remove(root, key); } void BinarySearchTree::remove(std::unique_ptr& node, int key) { - if (!node) return; + if (!node) return; - if (key < node->key) { - remove(node->left, key); - } else if (key > node->key) { - remove(node->right, key); + if (key < node->key) { + remove(node->left, key); + } else if (key > node->key) { + remove(node->right, key); + } else { + if (!node->left && !node->right) { + node.reset(); + } else if (!node->left) { + node = std::move(node->right); + } else if (!node->right) { + node = std::move(node->left); } else { - if (!node->left && !node->right) { - node.reset(); - } else if (!node->left) { - node = std::move(node->right); - } else if (!node->right) { - node = std::move(node->left); - } else { - node->key = minValue(node->right); - remove(node->right, node->key); - } + node->key = minValue(node->right); + remove(node->right, node->key); } + } } int BinarySearchTree::minValue() const { - if (!root) throw std::runtime_error("Tree is empty"); - return minValue(root); + if (!root) throw std::runtime_error("Tree is empty"); + return minValue(root); } int BinarySearchTree::minValue(const std::unique_ptr& node) const { - return node->left ? minValue(node->left) : node->key; + return node->left ? minValue(node->left) : node->key; } -void BinarySearchTree::clear() { - root.reset(); -} +void BinarySearchTree::clear() { root.reset(); } -size_t BinarySearchTree::size() const { - return size(root); -} +size_t BinarySearchTree::size() const { return size(root); } size_t BinarySearchTree::size(const std::unique_ptr& node) const { - return node ? 1 + size(node->left) + size(node->right) : 0; + return node ? 1 + size(node->left) + size(node->right) : 0; } -bool BinarySearchTree::isEmpty() const { - return !root; -} \ No newline at end of file +bool BinarySearchTree::isEmpty() const { return !root; } \ No newline at end of file diff --git a/task_07/src/tree.hpp b/task_07/src/tree.hpp index 806b9ab..0874305 100644 --- a/task_07/src/tree.hpp +++ b/task_07/src/tree.hpp @@ -2,32 +2,32 @@ #include class BinarySearchTree { -private: - struct Node { - int key; - std::unique_ptr left; - std::unique_ptr right; - - Node(int k) : key(k), left(nullptr), right(nullptr) {} - }; + private: + struct Node { + int key; + std::unique_ptr left; + std::unique_ptr right; - std::unique_ptr root; - - void insert(std::unique_ptr& node, int key); - bool contains(const std::unique_ptr& node, int key) const; - int minValue(const std::unique_ptr& node) const; - void remove(std::unique_ptr& node, int key); - size_t size(const std::unique_ptr& node) const; + Node(int k) : key(k), left(nullptr), right(nullptr) {} + }; -public: - BinarySearchTree(); - ~BinarySearchTree() = default; + std::unique_ptr root; - void insert(int key); - bool contains(int key) const; - void remove(int key); - void clear(); - size_t size() const; - bool isEmpty() const; - int minValue() const; + void insert(std::unique_ptr& node, int key); + bool contains(const std::unique_ptr& node, int key) const; + int minValue(const std::unique_ptr& node) const; + void remove(std::unique_ptr& node, int key); + size_t size(const std::unique_ptr& node) const; + + public: + BinarySearchTree(); + ~BinarySearchTree() = default; + + void insert(int key); + bool contains(int key) const; + void remove(int key); + void clear(); + size_t size() const; + bool isEmpty() const; + int minValue() const; }; \ No newline at end of file diff --git a/task_08/src/hashmap.hpp b/task_08/src/hashmap.hpp index 19223fa..cca7386 100644 --- a/task_08/src/hashmap.hpp +++ b/task_08/src/hashmap.hpp @@ -1,34 +1,34 @@ +#include #include #include -#include class HashMap { -private: - struct KeyValuePair { - std::string key; - int value; - }; + private: + struct KeyValuePair { + std::string key; + int value; + }; - static const size_t DEFAULT_CAPACITY = 16; - static const double LOAD_FACTOR_THRESHOLD; + static const size_t DEFAULT_CAPACITY = 16; + static const double LOAD_FACTOR_THRESHOLD; - std::vector> buckets; - size_t size; + std::vector> buckets; + size_t size; - size_t hash(const std::string& key) const; - size_t getBucketIndex(const std::string& key) const; - void rehash(); + size_t hash(const std::string& key) const; + size_t getBucketIndex(const std::string& key) const; + void rehash(); -public: - HashMap(); - explicit HashMap(size_t initialCapacity); - ~HashMap() = default; + public: + HashMap(); + explicit HashMap(size_t initialCapacity); + ~HashMap() = default; - void insert(const std::string& key, int value); - bool contains(const std::string& key) const; - int get(const std::string& key) const; - void remove(const std::string& key); - size_t getSize() const; - bool isEmpty() const; - void clear(); + void insert(const std::string& key, int value); + bool contains(const std::string& key) const; + int get(const std::string& key) const; + void remove(const std::string& key); + size_t getSize() const; + bool isEmpty() const; + void clear(); }; diff --git a/task_08/src/hasmap.cpp b/task_08/src/hasmap.cpp index bc2a2ad..f0f1769 100644 --- a/task_08/src/hasmap.cpp +++ b/task_08/src/hasmap.cpp @@ -1,7 +1,8 @@ -#include "hashmap.hpp" #include #include +#include "hashmap.hpp" + const double HashMap::LOAD_FACTOR_THRESHOLD = 0.75; HashMap::HashMap() : HashMap(DEFAULT_CAPACITY) {} @@ -9,86 +10,82 @@ HashMap::HashMap() : HashMap(DEFAULT_CAPACITY) {} HashMap::HashMap(size_t initialCapacity) : buckets(initialCapacity), size(0) {} size_t HashMap::hash(const std::string& key) const { - return std::hash{}(key); + return std::hash{}(key); } size_t HashMap::getBucketIndex(const std::string& key) const { - return hash(key) % buckets.size(); + return hash(key) % buckets.size(); } void HashMap::rehash() { - std::vector> oldBuckets = std::move(buckets); - buckets.resize(oldBuckets.size() * 2); - size = 0; - - for (auto& bucket : oldBuckets) { - for (auto& pair : bucket) { - insert(pair.key, pair.value); - } + std::vector> oldBuckets = std::move(buckets); + buckets.resize(oldBuckets.size() * 2); + size = 0; + + for (auto& bucket : oldBuckets) { + for (auto& pair : bucket) { + insert(pair.key, pair.value); } + } } void HashMap::insert(const std::string& key, int value) { - size_t index = getBucketIndex(key); - for (auto& pair : buckets[index]) { - if (pair.key == key) { - pair.value = value; - return; - } + size_t index = getBucketIndex(key); + for (auto& pair : buckets[index]) { + if (pair.key == key) { + pair.value = value; + return; } + } - buckets[index].push_back({key, value}); - size++; + buckets[index].push_back({key, value}); + size++; - if (static_cast(size) / buckets.size() > LOAD_FACTOR_THRESHOLD) { - rehash(); - } + if (static_cast(size) / buckets.size() > LOAD_FACTOR_THRESHOLD) { + rehash(); + } } bool HashMap::contains(const std::string& key) const { - size_t index = getBucketIndex(key); - for (const auto& pair : buckets[index]) { - if (pair.key == key) { - return true; - } + size_t index = getBucketIndex(key); + for (const auto& pair : buckets[index]) { + if (pair.key == key) { + return true; } - return false; + } + return false; } int HashMap::get(const std::string& key) const { - size_t index = getBucketIndex(key); - for (const auto& pair : buckets[index]) { - if (pair.key == key) { - return pair.value; - } + size_t index = getBucketIndex(key); + for (const auto& pair : buckets[index]) { + if (pair.key == key) { + return pair.value; } - throw std::out_of_range("Key not found"); + } + throw std::out_of_range("Key not found"); } void HashMap::remove(const std::string& key) { - size_t index = getBucketIndex(key); - auto& bucket = buckets[index]; - - for (auto it = bucket.begin(); it != bucket.end(); ++it) { - if (it->key == key) { - bucket.erase(it); - size--; - return; - } + size_t index = getBucketIndex(key); + auto& bucket = buckets[index]; + + for (auto it = bucket.begin(); it != bucket.end(); ++it) { + if (it->key == key) { + bucket.erase(it); + size--; + return; } + } } -size_t HashMap::getSize() const { - return size; -} +size_t HashMap::getSize() const { return size; } -bool HashMap::isEmpty() const { - return size == 0; -} +bool HashMap::isEmpty() const { return size == 0; } void HashMap::clear() { - for (auto& bucket : buckets) { - bucket.clear(); - } - size = 0; + for (auto& bucket : buckets) { + bucket.clear(); + } + size = 0; } \ No newline at end of file diff --git a/task_08/src/main.cpp b/task_08/src/main.cpp index 77174a3..c37e110 100644 --- a/task_08/src/main.cpp +++ b/task_08/src/main.cpp @@ -1,27 +1,29 @@ -#include "hashmap.hpp" #include +#include "hashmap.hpp" + int main() { - HashMap map; + HashMap map; - // Вставка элементов - map.insert("apple", 10); - map.insert("banana", 20); - map.insert("orange", 30); + // Вставка элементов + map.insert("apple", 10); + map.insert("banana", 20); + map.insert("orange", 30); - // Проверка наличия ключей - std::cout << "Contains 'apple': " << map.contains("apple") << std::endl; - std::cout << "Contains 'grape': " << map.contains("grape") << std::endl; + // Проверка наличия ключей + std::cout << "Contains 'apple': " << map.contains("apple") << std::endl; + std::cout << "Contains 'grape': " << map.contains("grape") << std::endl; - // Получение значений - std::cout << "Value of 'banana': " << map.get("banana") << std::endl; + // Получение значений + std::cout << "Value of 'banana': " << map.get("banana") << std::endl; - // Удаление элемента - map.remove("apple"); - std::cout << "After remove, contains 'apple': " << map.contains("apple") << std::endl; + // Удаление элемента + map.remove("apple"); + std::cout << "After remove, contains 'apple': " << map.contains("apple") + << std::endl; - // Размер таблицы - std::cout << "Size: " << map.getSize() << std::endl; + // Размер таблицы + std::cout << "Size: " << map.getSize() << std::endl; - return 0; + return 0; } \ No newline at end of file diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp index 9bef5ba..af7f88b 100644 --- a/task_08/src/test.cpp +++ b/task_08/src/test.cpp @@ -1,62 +1,63 @@ #include + #include "hashmap.hpp" TEST(HashMapTest, InsertAndGet) { - HashMap map; - map.insert("apple", 10); - map.insert("banana", 20); - - ASSERT_EQ(map.get("apple"), 10); - ASSERT_EQ(map.get("banana"), 20); - ASSERT_THROW(map.get("orange"), std::out_of_range); + HashMap map; + map.insert("apple", 10); + map.insert("banana", 20); + + ASSERT_EQ(map.get("apple"), 10); + ASSERT_EQ(map.get("banana"), 20); + ASSERT_THROW(map.get("orange"), std::out_of_range); } TEST(HashMapTest, ContainsAndRemove) { - HashMap map; - map.insert("one", 1); - map.insert("two", 2); - - ASSERT_TRUE(map.contains("one")); - ASSERT_TRUE(map.contains("two")); - ASSERT_FALSE(map.contains("three")); - - map.remove("one"); - ASSERT_FALSE(map.contains("one")); - ASSERT_TRUE(map.contains("two")); + HashMap map; + map.insert("one", 1); + map.insert("two", 2); + + ASSERT_TRUE(map.contains("one")); + ASSERT_TRUE(map.contains("two")); + ASSERT_FALSE(map.contains("three")); + + map.remove("one"); + ASSERT_FALSE(map.contains("one")); + ASSERT_TRUE(map.contains("two")); } TEST(HashMapTest, SizeAndEmpty) { - HashMap map; - ASSERT_TRUE(map.isEmpty()); - ASSERT_EQ(map.getSize(), 0); - - map.insert("a", 1); - map.insert("b", 2); - - ASSERT_FALSE(map.isEmpty()); - ASSERT_EQ(map.getSize(), 2); - - map.remove("a"); - ASSERT_EQ(map.getSize(), 1); - - map.clear(); - ASSERT_TRUE(map.isEmpty()); - ASSERT_EQ(map.getSize(), 0); + HashMap map; + ASSERT_TRUE(map.isEmpty()); + ASSERT_EQ(map.getSize(), 0); + + map.insert("a", 1); + map.insert("b", 2); + + ASSERT_FALSE(map.isEmpty()); + ASSERT_EQ(map.getSize(), 2); + + map.remove("a"); + ASSERT_EQ(map.getSize(), 1); + + map.clear(); + ASSERT_TRUE(map.isEmpty()); + ASSERT_EQ(map.getSize(), 0); } TEST(HashMapTest, Rehashing) { - HashMap map(2); - - map.insert("a", 1); - map.insert("b", 2); - map.insert("c", 3); - - ASSERT_EQ(map.getSize(), 3); - ASSERT_EQ(map.get("a"), 1); - ASSERT_EQ(map.get("b"), 2); - ASSERT_EQ(map.get("c"), 3); - - map.insert("d", 4); - ASSERT_EQ(map.getSize(), 4); - ASSERT_EQ(map.get("d"), 4); + HashMap map(2); + + map.insert("a", 1); + map.insert("b", 2); + map.insert("c", 3); + + ASSERT_EQ(map.getSize(), 3); + ASSERT_EQ(map.get("a"), 1); + ASSERT_EQ(map.get("b"), 2); + ASSERT_EQ(map.get("c"), 3); + + map.insert("d", 4); + ASSERT_EQ(map.getSize(), 4); + ASSERT_EQ(map.get("d"), 4); } \ No newline at end of file From 241752dcdae048f7c0cdd0264ad1d27ac1afbaeb Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sun, 22 Jun 2025 13:13:08 +0000 Subject: [PATCH 16/19] another changes --- task_01/src/test.cpp | 2 +- task_07/src/main.cpp | 40 ++++++++++++++++++++-------------------- task_07/src/tree.hpp | 1 - task_08/src/main.cpp | 10 +++++----- 4 files changed, 26 insertions(+), 27 deletions(-) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 9c82c13..61fc482 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -6,7 +6,7 @@ #include "two_numbers.h" // Вспомогательная функция для перехвата вывода -std::string captureOutput(std::vector& numbers, int len, int target) { +static std::string captureOutput(std::vector& numbers, int len, int target) { std::stringstream buffer; std::streambuf* old = std::cout.rdbuf(buffer.rdbuf()); diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index a1d9bda..3ee43cd 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -2,23 +2,23 @@ #include "tree.hpp" -void printTreeInfo(const BinarySearchTree& bst) { - std::cout << "Tree size: " << bst.size() << std::endl; +static void printTreeInfo(const BinarySearchTree& bst) { + std::cout << "Tree size: " << bst.size() << "\n"; std::cout << "Min value: " << (bst.isEmpty() ? "N/A" : std::to_string(bst.minValue())) - << std::endl; - std::cout << "Is empty: " << (bst.isEmpty() ? "true" : "false") << std::endl - << std::endl; + << "\n"; + std::cout << "Is empty: " << (bst.isEmpty() ? "true" : "false") << "\n" + << "\n"; } int main() { BinarySearchTree bst; - std::cout << "=== Initial empty tree ===" << std::endl; + std::cout << "=== Initial empty tree ===" << "\n"; printTreeInfo(bst); // Вставка элементов - std::cout << "=== After inserting elements ===" << std::endl; + std::cout << "=== After inserting elements ===" << "\n"; bst.insert(50); bst.insert(30); bst.insert(70); @@ -29,40 +29,40 @@ int main() { printTreeInfo(bst); // Проверка наличия элементов - std::cout << "=== Checking contains ===" << std::endl; + std::cout << "=== Checking contains ===" << "\n"; std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") - << std::endl; + << "\n"; std::cout << "Contains 45: " << (bst.contains(45) ? "true" : "false") - << std::endl; + << "\n"; std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") - << std::endl - << std::endl; + << "\n" + << "\n"; // Удаление элементов - std::cout << "=== After removing 30 and 70 ===" << std::endl; + std::cout << "=== After removing 30 and 70 ===" << "\n"; bst.remove(30); bst.remove(70); printTreeInfo(bst); // Проверка после удаления - std::cout << "=== Checking after removal ===" << std::endl; + std::cout << "=== Checking after removal ===" << "\n"; std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") - << std::endl; + << "\n"; std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") - << std::endl - << std::endl; + << "\n" + << "\n"; // Очистка дерева - std::cout << "=== After clearing tree ===" << std::endl; + std::cout << "=== After clearing tree ===" << "\n"; bst.clear(); printTreeInfo(bst); // Попытка получить минимальное значение пустого дерева try { - std::cout << "Trying to get min value from empty tree..." << std::endl; + std::cout << "Trying to get min value from empty tree..." << "\n"; bst.minValue(); } catch (const std::runtime_error& e) { - std::cout << "Error: " << e.what() << std::endl; + std::cout << "Error: " << e.what() << "\n"; } return 0; diff --git a/task_07/src/tree.hpp b/task_07/src/tree.hpp index 0874305..b93b6a2 100644 --- a/task_07/src/tree.hpp +++ b/task_07/src/tree.hpp @@ -1,5 +1,4 @@ #include -#include class BinarySearchTree { private: diff --git a/task_08/src/main.cpp b/task_08/src/main.cpp index c37e110..d4c3eb5 100644 --- a/task_08/src/main.cpp +++ b/task_08/src/main.cpp @@ -11,19 +11,19 @@ int main() { map.insert("orange", 30); // Проверка наличия ключей - std::cout << "Contains 'apple': " << map.contains("apple") << std::endl; - std::cout << "Contains 'grape': " << map.contains("grape") << std::endl; + std::cout << "Contains 'apple': " << map.contains("apple") << "\n"; + std::cout << "Contains 'grape': " << map.contains("grape") << "\n"; // Получение значений - std::cout << "Value of 'banana': " << map.get("banana") << std::endl; + std::cout << "Value of 'banana': " << map.get("banana") << "\n"; // Удаление элемента map.remove("apple"); std::cout << "After remove, contains 'apple': " << map.contains("apple") - << std::endl; + << "\n"; // Размер таблицы - std::cout << "Size: " << map.getSize() << std::endl; + std::cout << "Size: " << map.getSize() << "\n"; return 0; } \ No newline at end of file From f758c6aebb7109a42978d79989a7fa177bb9f366 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sun, 22 Jun 2025 13:29:08 +0000 Subject: [PATCH 17/19] clang-formating --- task_01/src/test.cpp | 3 ++- task_07/src/main.cpp | 18 ++++++------------ 2 files changed, 8 insertions(+), 13 deletions(-) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 61fc482..d58d1fb 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -6,7 +6,8 @@ #include "two_numbers.h" // Вспомогательная функция для перехвата вывода -static std::string captureOutput(std::vector& numbers, int len, int target) { +static std::string captureOutput(std::vector& numbers, int len, + int target) { std::stringstream buffer; std::streambuf* old = std::cout.rdbuf(buffer.rdbuf()); diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index 3ee43cd..9ef1c57 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -5,8 +5,7 @@ static void printTreeInfo(const BinarySearchTree& bst) { std::cout << "Tree size: " << bst.size() << "\n"; std::cout << "Min value: " - << (bst.isEmpty() ? "N/A" : std::to_string(bst.minValue())) - << "\n"; + << (bst.isEmpty() ? "N/A" : std::to_string(bst.minValue())) << "\n"; std::cout << "Is empty: " << (bst.isEmpty() ? "true" : "false") << "\n" << "\n"; } @@ -30,12 +29,9 @@ int main() { // Проверка наличия элементов std::cout << "=== Checking contains ===" << "\n"; - std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") - << "\n"; - std::cout << "Contains 45: " << (bst.contains(45) ? "true" : "false") - << "\n"; - std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") - << "\n" + std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") << "\n"; + std::cout << "Contains 45: " << (bst.contains(45) ? "true" : "false") << "\n"; + std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") << "\n" << "\n"; // Удаление элементов @@ -46,10 +42,8 @@ int main() { // Проверка после удаления std::cout << "=== Checking after removal ===" << "\n"; - std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") - << "\n"; - std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") - << "\n" + std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") << "\n"; + std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") << "\n" << "\n"; // Очистка дерева From f68901866a568a196325a5363063b4f15539f518 Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sun, 22 Jun 2025 15:58:20 +0000 Subject: [PATCH 18/19] correct mistakes in 2, 3, 4 tasks. Remake 1, 7 tasks. Make 9 task --- task_01/src/main.cpp | 19 +---- task_01/src/test.cpp | 62 ++++++--------- task_01/src/two_numbers.cpp | 35 ++++---- task_01/src/two_numbers.h | 3 - task_01/src/two_numbers.hpp | 7 ++ task_02/src/main.cpp | 12 +-- task_02/src/stack.cpp | 54 +++++++------ task_02/src/stack.hpp | 32 ++++++-- task_02/src/test.cpp | 26 +++--- task_03/src/main.cpp | 2 +- task_03/src/test.cpp | 10 +-- task_03/src/topology_sort.cpp | 2 +- task_03/src/topology_sort.hpp | 2 +- task_04/src/{heap.cpp => fish.cpp} | 2 +- task_04/src/{heap.hpp => fish.hpp} | 0 task_04/src/main.cpp | 2 +- task_04/src/test.cpp | 53 ++++++++++++- task_07/src/main.cpp | 59 -------------- task_07/src/test.cpp | 115 ++++++++++++++++----------- task_07/src/tree.cpp | 123 +++++++++++++++++------------ task_07/src/tree.hpp | 59 +++++++------- task_08/src/main.cpp | 4 - task_09/src/table.cpp | 57 +++++++++++++ task_09/src/table.hpp | 17 ++++ task_09/src/test.cpp | 52 ++++++++---- 25 files changed, 464 insertions(+), 345 deletions(-) delete mode 100644 task_01/src/two_numbers.h create mode 100644 task_01/src/two_numbers.hpp rename task_04/src/{heap.cpp => fish.cpp} (97%) rename task_04/src/{heap.hpp => fish.hpp} (100%) create mode 100644 task_09/src/table.cpp create mode 100644 task_09/src/table.hpp diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 31f0485..abb9401 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1,21 +1,4 @@ -#include -#include - -#include "two_numbers.h" +#include "two_numbers.hpp" int main() { - int target; - std::cout << "Enter the number:"; - std::cin >> target; - - int len; - std::cout << "Enter the size of an array:"; - std::cin >> len; - std::cout << "\n"; - - std::vector numbers(len); - std::cout << "Enter the array:"; - for (int i{0}; i < len; ++i) std::cin >> numbers[i]; - - FindSum(numbers, len, target); } diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index d58d1fb..b5d3f29 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,50 +1,34 @@ +#include "two_numbers.hpp" #include -#include -#include - -#include "two_numbers.h" - -// Вспомогательная функция для перехвата вывода -static std::string captureOutput(std::vector& numbers, int len, - int target) { - std::stringstream buffer; - std::streambuf* old = std::cout.rdbuf(buffer.rdbuf()); - - FindSum(numbers, len, target); - - std::cout.rdbuf(old); - return buffer.str(); -} - -TEST(FindSumTest, BasicCase) { - std::vector numbers = {1, 2, 3, 4, 6, 8}; - std::string output = captureOutput(numbers, 6, 6); - EXPECT_TRUE(output == "2+4=6" || - output == "There are no necessary numbers2+4=6"); +TEST(TwoSumTest, BasicTest) { + std::vector nums = {2, 7, 11, 15}; + auto result = FindSum::findTwoSum(nums, 9); + EXPECT_EQ(result.first, 2); + EXPECT_EQ(result.second, 7); } -TEST(FindSumTest, NoPairFound) { - std::vector numbers = {1, 2, 3, 4, 6, 8}; - std::string output = captureOutput(numbers, 6, 20); - EXPECT_TRUE(output.empty() || output == "There are no necessary numbers"); +TEST(TwoSumTest, NoSolution) { + std::vector nums = {1, 2, 3, 4}; + auto result = FindSum::findTwoSum(nums, 10); + EXPECT_EQ(result.first, -1); + EXPECT_EQ(result.second, -1); } -TEST(FindSumTest, EmptyInput) { - std::vector numbers = {}; - std::string output = captureOutput(numbers, 0, 5); - EXPECT_TRUE(output.empty() || output == "There are no necessary numbers"); +TEST(TwoSumTest, DuplicateNumbers) { + std::vector nums = {3, 3, 4, 4}; + auto result = FindSum::findTwoSum(nums, 7); + EXPECT_TRUE((result == std::pair{3, 4})); } -TEST(FindSumTest, SingleElement) { - std::vector numbers = {5}; - std::string output = captureOutput(numbers, 1, 5); - EXPECT_TRUE(output == "There are no necessary numbers" || output.empty()); +TEST(TwoSumTest, EmptyArray) { + std::vector nums; + auto result = FindSum::findTwoSum(nums, 5); + EXPECT_EQ(result.first, -1); + EXPECT_EQ(result.second, -1); } -TEST(FindSumTest, EdgeCase) { - std::vector numbers = {3, 5}; - std::string output = captureOutput(numbers, 2, 8); - EXPECT_TRUE(output == "3+5=8" || - output == "There are no necessary numbers3+5=8"); +int main(int argc, char **argv) { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file diff --git a/task_01/src/two_numbers.cpp b/task_01/src/two_numbers.cpp index e6a15fa..e85662a 100644 --- a/task_01/src/two_numbers.cpp +++ b/task_01/src/two_numbers.cpp @@ -1,21 +1,20 @@ -#include "two_numbers.h" +#include "two_numbers.hpp" +#include -#include - -void FindSum(std::vector& numbers, int len, int target) { - int left_r = 0; - int right_r = len - 1; - - while (left_r < right_r) { - int sum = numbers[left_r] + numbers[right_r]; - if (right_r - left_r == 0) std::cout << "There are no necessary numbers"; - if (sum == target) { - std::cout << numbers[left_r] << "+" << numbers[right_r] << "=" << target; - break; +std::pair FindSum::findTwoSum(const std::vector& nums, int target) { + int left = 0; + int right = nums.size() - 1; + + while (left < right) { + int sum = nums[left] + nums[right]; + if (sum == target) { + return {nums[left], nums[right]}; + } else if (sum < target) { + left++; + } else { + right--; + } } - if (sum < target) - ++left_r; - else - --right_r; - } + + return {-1, -1}; // Если пара не найдена } diff --git a/task_01/src/two_numbers.h b/task_01/src/two_numbers.h deleted file mode 100644 index cb4e412..0000000 --- a/task_01/src/two_numbers.h +++ /dev/null @@ -1,3 +0,0 @@ -#include - -void FindSum(std::vector& numbers, int len, int target); diff --git a/task_01/src/two_numbers.hpp b/task_01/src/two_numbers.hpp new file mode 100644 index 0000000..adcf242 --- /dev/null +++ b/task_01/src/two_numbers.hpp @@ -0,0 +1,7 @@ +#include +#include + +class FindSum { +public: + static std::pair findTwoSum(const std::vector& nums, int target); +}; \ No newline at end of file diff --git a/task_02/src/main.cpp b/task_02/src/main.cpp index 5fa8bef..fb77339 100644 --- a/task_02/src/main.cpp +++ b/task_02/src/main.cpp @@ -4,12 +4,12 @@ int main() { Stack stack; - stack.push(2); - stack.push(1); - stack.push(3); - stack.push(4); - stack.push(5); - stack.push(7); + stack.Push(2); + stack.Push(1); + stack.Push(3); + stack.Push(4); + stack.Push(5); + stack.Push(7); stack.display(); std::cout << "\n"; diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp index 14f3d6b..6be81e8 100644 --- a/task_02/src/stack.cpp +++ b/task_02/src/stack.cpp @@ -1,39 +1,47 @@ #include "stack.hpp" -#include -#include +#include #include +#include -void Stack::push(int element) { arr.push_back(element); } +void Stack::Push(int element) { + arr.push_back(element); + if (min_stack.empty() || element <= min_stack.back()) { + min_stack.push_back(element); + } +} void Stack::pop() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot pop."); - } - arr.pop_back(); + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot pop."); + } + if (arr.back() == min_stack.back()) { + min_stack.pop_back(); + } + arr.pop_back(); } int Stack::peek() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot peek."); - } - return arr.back(); + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot peek."); + } + return arr.back(); } void Stack::display() { - if (arr.empty()) { - std::cout << "Stack is empty." << std::endl; - return; - } - for (int i = 0; i < arr.size(); ++i) { - std::cout << arr[i] << " "; - } - std::cout << std::endl; + if (arr.empty()) { + std::cout << "Stack is empty." << std::endl; + return; + } + for (int i = 0; i < arr.size(); ++i) { + std::cout << arr[i] << " "; + } + std::cout << std::endl; } int Stack::min() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot find min."); - } - return *std::min_element(arr.begin(), arr.end()); + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot find min."); + } + return min_stack.back(); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index c86e1eb..e6e4b1a 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -1,12 +1,28 @@ #pragma once + #include -struct Stack { - std::vector arr; +class Stack { +private: + std::vector arr; + std::vector min_stack; + +public: + void Push(int element); + + void pop(); + + int peek(); + + void display(); + + int min(); + + bool isEmpty() const { + return arr.empty(); + } - void push(int element); - void pop(); - int peek(); - void display(); - int min(); -}; \ No newline at end of file + size_t size() const { + return arr.size(); + } +}; diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 569de9c..0c08195 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -4,8 +4,8 @@ TEST(StackTest, PushPopPeek) { Stack s; - s.push(10); - s.push(20); + s.Push(10); + s.Push(20); EXPECT_EQ(s.peek(), 20); s.pop(); EXPECT_EQ(s.peek(), 10); @@ -23,10 +23,10 @@ TEST(StackTest, PeekEmptyStack) { TEST(StackTest, MinElement) { Stack s; - s.push(5); - s.push(2); - s.push(7); - s.push(1); + s.Push(5); + s.Push(2); + s.Push(7); + s.Push(1); EXPECT_EQ(s.min(), 1); s.pop(); EXPECT_EQ(s.min(), 2); @@ -47,9 +47,9 @@ TEST(StackTest, DisplayEmpty) { TEST(StackTest, DisplayNonEmpty) { Stack s; - s.push(1); - s.push(2); - s.push(3); + s.Push(1); + s.Push(2); + s.Push(3); testing::internal::CaptureStdout(); s.display(); std::string output = testing::internal::GetCapturedStdout(); @@ -58,12 +58,12 @@ TEST(StackTest, DisplayNonEmpty) { TEST(StackTest, MultipleOperations) { Stack s; - s.push(10); - s.push(5); - s.push(15); + s.Push(10); + s.Push(5); + s.Push(15); EXPECT_EQ(s.min(), 5); s.pop(); - s.push(3); + s.Push(3); EXPECT_EQ(s.peek(), 3); EXPECT_EQ(s.min(), 3); } \ No newline at end of file diff --git a/task_03/src/main.cpp b/task_03/src/main.cpp index c2ac5b4..496031a 100644 --- a/task_03/src/main.cpp +++ b/task_03/src/main.cpp @@ -5,7 +5,7 @@ int main() { std::vector temps = {73, 74, 75, 71, 69, 72, 76, 73}; - std::vector result = TopologySort(temps); + std::vector result = TemperatureSorting(temps); for (int i{0}; i < result.size(); ++i) { std::cout << result[i] << " "; diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index b01276a..1ea75c4 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -7,29 +7,29 @@ TEST(TopologyFuncTest, OrdinaryWeek) { std::vector temperatures = {73, 74, 75, 71, 69, 72, 76, 73}; std::vector expected = {1, 1, 4, 2, 1, 1, 0, 0}; - ASSERT_EQ(TopologySort(temperatures), expected); + ASSERT_EQ(TemperatureSorting(temperatures), expected); } TEST(TopologyFuncTest, EmptyInput) { std::vector temperatures = {}; std::vector expected = {}; - ASSERT_EQ(TopologySort(temperatures), expected); + ASSERT_EQ(TemperatureSorting(temperatures), expected); } TEST(TopologyFuncTest, SingleDay) { std::vector temperatures = {30}; std::vector expected = {0}; - ASSERT_EQ(TopologySort(temperatures), expected); + ASSERT_EQ(TemperatureSorting(temperatures), expected); } TEST(TopologyFuncTest, IncreasingTemperatures) { std::vector temperatures = {10, 20, 30, 40}; std::vector expected = {1, 1, 1, 0}; - ASSERT_EQ(TopologySort(temperatures), expected); + ASSERT_EQ(TemperatureSorting(temperatures), expected); } TEST(TopologyFuncTest, MixedTemperatures) { std::vector temperatures = {73, 74, 75, 71, 69, 72, 76, 73}; std::vector expected = {1, 1, 4, 2, 1, 1, 0, 0}; - ASSERT_EQ(TopologySort(temperatures), expected); + ASSERT_EQ(TemperatureSorting(temperatures), expected); } diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp index 07dd4ae..e1656a6 100644 --- a/task_03/src/topology_sort.cpp +++ b/task_03/src/topology_sort.cpp @@ -2,7 +2,7 @@ #include -std::vector TopologySort(const std::vector& temperatures) { +std::vector TemperatureSorting(const std::vector& temperatures) { std::vector result(temperatures.size(), 0); std::stack> s; diff --git a/task_03/src/topology_sort.hpp b/task_03/src/topology_sort.hpp index 8dfa29a..5777340 100644 --- a/task_03/src/topology_sort.hpp +++ b/task_03/src/topology_sort.hpp @@ -1,4 +1,4 @@ #pragma once #include -std::vector TopologySort(const std::vector& temperatures); \ No newline at end of file +std::vector TemperatureSorting(const std::vector& temperatures); \ No newline at end of file diff --git a/task_04/src/heap.cpp b/task_04/src/fish.cpp similarity index 97% rename from task_04/src/heap.cpp rename to task_04/src/fish.cpp index ec52b0c..2eeba31 100644 --- a/task_04/src/heap.cpp +++ b/task_04/src/fish.cpp @@ -1,4 +1,4 @@ -#include "heap.hpp" +#include "fish.hpp" #include #include diff --git a/task_04/src/heap.hpp b/task_04/src/fish.hpp similarity index 100% rename from task_04/src/heap.hpp rename to task_04/src/fish.hpp diff --git a/task_04/src/main.cpp b/task_04/src/main.cpp index 0fa5eff..732c5eb 100644 --- a/task_04/src/main.cpp +++ b/task_04/src/main.cpp @@ -1,3 +1,3 @@ -#include "heap.hpp" +#include "fish.hpp" int main() { return 0; } \ No newline at end of file diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 0884144..9558885 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -1,3 +1,54 @@ #include +#include +#include +#include "fish.hpp" -TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); } +TEST(TopologySort, Simple) { + ASSERT_EQ(1, 1); +} + +TEST(BuyFishTest, BasicCase) { + std::vector prices = {3, 2, 5, 4, 1, 6}; + int K = 3; + std::vector> expected = { + {1, 3}, // Покупаем на 2-й день (цена 2) на 3 дня + {4, 2} // Покупаем на 5-й день (цена 1) на оставшиеся 2 дня + }; + auto result = buyFishSimplified(prices, K); + ASSERT_EQ(result, expected); +} + +TEST(BuyFishTest, SingleDay) { + std::vector prices = {5}; + int K = 1; + std::vector> expected = { + {0, 1} // Покупаем в единственный день + }; + auto result = buyFishSimplified(prices, K); + ASSERT_EQ(result, expected); +} + +TEST(BuyFishTest, SmallShelfLife) { + std::vector prices = {4, 3, 2, 1, 5, 6}; + int K = 1; // Рыба портится сразу + std::vector> expected = { + {0, 1}, // Покупаем каждый день отдельно + {1, 1}, + {2, 1}, + {3, 1}, + {4, 1}, + {5, 1} + }; + auto result = buyFishSimplified(prices, K); + ASSERT_EQ(result, expected); +} + +TEST(BuyFishTest, ConstantPrices) { + std::vector prices = {2, 2, 2, 2, 2}; + int K = 5; // Большой срок хранения + std::vector> expected = { + {0, 5} // Покупаем в первый день на все 5 дней + }; + auto result = buyFishSimplified(prices, K); + ASSERT_EQ(result, expected); +} \ No newline at end of file diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index 9ef1c57..6f75d7a 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -1,63 +1,4 @@ -#include - #include "tree.hpp" -static void printTreeInfo(const BinarySearchTree& bst) { - std::cout << "Tree size: " << bst.size() << "\n"; - std::cout << "Min value: " - << (bst.isEmpty() ? "N/A" : std::to_string(bst.minValue())) << "\n"; - std::cout << "Is empty: " << (bst.isEmpty() ? "true" : "false") << "\n" - << "\n"; -} - int main() { - BinarySearchTree bst; - - std::cout << "=== Initial empty tree ===" << "\n"; - printTreeInfo(bst); - - // Вставка элементов - std::cout << "=== After inserting elements ===" << "\n"; - bst.insert(50); - bst.insert(30); - bst.insert(70); - bst.insert(20); - bst.insert(40); - bst.insert(60); - bst.insert(80); - printTreeInfo(bst); - - // Проверка наличия элементов - std::cout << "=== Checking contains ===" << "\n"; - std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") << "\n"; - std::cout << "Contains 45: " << (bst.contains(45) ? "true" : "false") << "\n"; - std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") << "\n" - << "\n"; - - // Удаление элементов - std::cout << "=== After removing 30 and 70 ===" << "\n"; - bst.remove(30); - bst.remove(70); - printTreeInfo(bst); - - // Проверка после удаления - std::cout << "=== Checking after removal ===" << "\n"; - std::cout << "Contains 30: " << (bst.contains(30) ? "true" : "false") << "\n"; - std::cout << "Contains 70: " << (bst.contains(70) ? "true" : "false") << "\n" - << "\n"; - - // Очистка дерева - std::cout << "=== After clearing tree ===" << "\n"; - bst.clear(); - printTreeInfo(bst); - - // Попытка получить минимальное значение пустого дерева - try { - std::cout << "Trying to get min value from empty tree..." << "\n"; - bst.minValue(); - } catch (const std::runtime_error& e) { - std::cout << "Error: " << e.what() << "\n"; - } - - return 0; } \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index b7428e5..6cbae63 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -1,63 +1,82 @@ +#include "tree.hpp" #include -#include "tree.hpp" +class AVLTreeTest : public ::testing::Test { +protected: + AVLTree tree; -TEST(BinarySearchTreeTest, InsertAndContains) { - BinarySearchTree bst; - bst.insert(5); - bst.insert(3); - bst.insert(7); + void SetUp() override { + tree.insert(50); + tree.insert(30); + tree.insert(70); + tree.insert(20); + tree.insert(40); + tree.insert(60); + tree.insert(80); + } +}; - ASSERT_TRUE(bst.contains(5)); - ASSERT_TRUE(bst.contains(3)); - ASSERT_TRUE(bst.contains(7)); - ASSERT_FALSE(bst.contains(2)); +TEST_F(AVLTreeTest, InsertAndContains) { + EXPECT_TRUE(tree.contains(50)); + EXPECT_TRUE(tree.contains(30)); + EXPECT_TRUE(tree.contains(70)); + EXPECT_TRUE(tree.contains(20)); + EXPECT_TRUE(tree.contains(40)); + EXPECT_TRUE(tree.contains(60)); + EXPECT_TRUE(tree.contains(80)); + EXPECT_FALSE(tree.contains(10)); + EXPECT_FALSE(tree.contains(100)); } -TEST(BinarySearchTreeTest, Remove) { - BinarySearchTree bst; - bst.insert(10); - bst.insert(5); - bst.insert(15); +TEST_F(AVLTreeTest, RemoveElements) { + tree.remove(20); + EXPECT_FALSE(tree.contains(20)); + EXPECT_TRUE(tree.contains(30)); - bst.remove(5); - ASSERT_FALSE(bst.contains(5)); - ASSERT_TRUE(bst.contains(10)); - ASSERT_TRUE(bst.contains(15)); + tree.remove(30); + EXPECT_FALSE(tree.contains(30)); + EXPECT_TRUE(tree.contains(50)); - bst.remove(10); - ASSERT_FALSE(bst.contains(10)); - ASSERT_TRUE(bst.contains(15)); + tree.remove(50); + EXPECT_FALSE(tree.contains(50)); + EXPECT_TRUE(tree.contains(60)); + EXPECT_TRUE(tree.contains(70)); } -TEST(BinarySearchTreeTest, SizeAndEmpty) { - BinarySearchTree bst; - ASSERT_TRUE(bst.isEmpty()); - ASSERT_EQ(bst.size(), 0); - - bst.insert(1); - bst.insert(2); - ASSERT_FALSE(bst.isEmpty()); - ASSERT_EQ(bst.size(), 2); - - bst.clear(); - ASSERT_TRUE(bst.isEmpty()); - ASSERT_EQ(bst.size(), 0); +TEST_F(AVLTreeTest, MaintainsBalanceProperty) { + AVLTree balanceTestTree; + + // Вставляем элементы в порядке, который создает дисбаланс в обычном BST + for (int i = 1; i <= 100; ++i) { + balanceTestTree.insert(i); + // Можно добавить проверку баланса на каждом шаге + } + + // Проверяем, что все элементы присутствуют + for (int i = 1; i <= 100; ++i) { + EXPECT_TRUE(balanceTestTree.contains(i)); + } } -TEST(BinarySearchTreeTest, MinValue) { - BinarySearchTree bst; - bst.insert(8); - bst.insert(3); - bst.insert(10); - bst.insert(1); - bst.insert(6); - - ASSERT_EQ(bst.minValue(), 1); +TEST_F(AVLTreeTest, ClearTree) { + EXPECT_TRUE(tree.contains(50)); + tree.clear(); + EXPECT_FALSE(tree.contains(50)); + + // Проверяем, что можно снова использовать дерево + tree.insert(100); + EXPECT_TRUE(tree.contains(100)); +} - bst.remove(1); - ASSERT_EQ(bst.minValue(), 3); +TEST(AVLTreeEmptyTest, HandlesEmptyTree) { + AVLTree emptyTree; + EXPECT_FALSE(emptyTree.contains(10)); + + // Удаление из пустого дерева не должно вызывать ошибок + EXPECT_NO_THROW(emptyTree.remove(10)); +} - bst.clear(); - ASSERT_THROW(bst.minValue(), std::runtime_error); +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file diff --git a/task_07/src/tree.cpp b/task_07/src/tree.cpp index 0a4e615..fed39e4 100644 --- a/task_07/src/tree.cpp +++ b/task_07/src/tree.cpp @@ -1,67 +1,88 @@ #include "tree.hpp" -BinarySearchTree::BinarySearchTree() : root(nullptr) {} - -void BinarySearchTree::insert(int key) { insert(root, key); } - -void BinarySearchTree::insert(std::unique_ptr& node, int key) { - if (!node) { - node = std::make_unique(key); - } else if (key < node->key) { - insert(node->left, key); - } else if (key > node->key) { - insert(node->right, 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); } -bool BinarySearchTree::contains(int key) const { return contains(root, key); } - -bool BinarySearchTree::contains(const std::unique_ptr& node, - int key) const { - if (!node) return false; - if (key == node->key) return true; - return key < node->key ? contains(node->left, key) - : contains(node->right, key); +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->right) { + Node* temp = node->left ? node->left : node->right; + delete node; + return temp; + } + Node* temp = findMin(node->right); + node->key = temp->key; + node->right = remove(node->right, temp->key); + } + return balance(node); } -void BinarySearchTree::remove(int key) { remove(root, key); } - -void BinarySearchTree::remove(std::unique_ptr& node, int key) { - if (!node) return; +bool AVLTree::contains(const Node* node, int key) const { + if (!node) return false; + if (key == node->key) return true; + return key < node->key ? contains(node->left, key) : contains(node->right, key); +} - if (key < node->key) { - remove(node->left, key); - } else if (key > node->key) { - remove(node->right, key); - } else { - if (!node->left && !node->right) { - node.reset(); - } else if (!node->left) { - node = std::move(node->right); - } else if (!node->right) { - node = std::move(node->left); - } else { - node->key = minValue(node->right); - remove(node->right, node->key); +void AVLTree::clear(Node* node) { + if (node) { + clear(node->left); + clear(node->right); + delete node; } - } } -int BinarySearchTree::minValue() const { - if (!root) throw std::runtime_error("Tree is empty"); - return minValue(root); +Node* AVLTree::rotateRight(Node* y) { + Node* x = y->left; + y->left = x->right; + x->right = y; + updateHeight(y); + updateHeight(x); + return x; } -int BinarySearchTree::minValue(const std::unique_ptr& node) const { - return node->left ? minValue(node->left) : node->key; +Node* AVLTree::rotateLeft(Node* x) { + Node* y = x->right; + x->right = y->left; + y->left = x; + updateHeight(x); + updateHeight(y); + return y; } -void BinarySearchTree::clear() { root.reset(); } - -size_t BinarySearchTree::size() const { return size(root); } - -size_t BinarySearchTree::size(const std::unique_ptr& node) const { - return node ? 1 + size(node->left) + size(node->right) : 0; +Node* AVLTree::balance(Node* node) { + updateHeight(node); + 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; } -bool BinarySearchTree::isEmpty() const { return !root; } \ No newline at end of file +Node* AVLTree::findMin(Node* node) { + while (node && node->left) node = node->left; + return node; +} \ No newline at end of file diff --git a/task_07/src/tree.hpp b/task_07/src/tree.hpp index b93b6a2..9fe9e50 100644 --- a/task_07/src/tree.hpp +++ b/task_07/src/tree.hpp @@ -1,32 +1,37 @@ -#include +#include -class BinarySearchTree { - private: - struct Node { +struct Node { int key; - std::unique_ptr left; - std::unique_ptr right; + Node* left; + Node* right; + int height; +}; - Node(int k) : key(k), left(nullptr), right(nullptr) {} - }; +class AVLTree { +public: + AVLTree() : root(nullptr) {} + ~AVLTree() { clear(root); } + + void insert(int key) { root = insert(root, key); } + void remove(int key) { root = remove(root, key); } + bool contains(int key) const { return contains(root, key); } + void clear() { clear(root); root = nullptr; } - std::unique_ptr root; - - void insert(std::unique_ptr& node, int key); - bool contains(const std::unique_ptr& node, int key) const; - int minValue(const std::unique_ptr& node) const; - void remove(std::unique_ptr& node, int key); - size_t size(const std::unique_ptr& node) const; - - public: - BinarySearchTree(); - ~BinarySearchTree() = default; - - void insert(int key); - bool contains(int key) const; - void remove(int key); - void clear(); - size_t size() const; - bool isEmpty() const; - int minValue() const; +private: + Node* root; + + Node* insert(Node* node, int key); + Node* remove(Node* node, int key); + bool contains(const Node* node, int key) const; + void clear(Node* node); + + // Вспомогательные функции + int height(Node* node) { return node ? node->height : 0; } + int balanceFactor(Node* node) { return node ? height(node->left) - height(node->right) : 0; } + void updateHeight(Node* node) { node->height = 1 + std::max(height(node->left), height(node->right)); } + + Node* rotateRight(Node* y); + Node* rotateLeft(Node* x); + Node* balance(Node* node); + Node* findMin(Node* node); }; \ No newline at end of file diff --git a/task_08/src/main.cpp b/task_08/src/main.cpp index d4c3eb5..991fe18 100644 --- a/task_08/src/main.cpp +++ b/task_08/src/main.cpp @@ -10,19 +10,15 @@ int main() { map.insert("banana", 20); map.insert("orange", 30); - // Проверка наличия ключей std::cout << "Contains 'apple': " << map.contains("apple") << "\n"; std::cout << "Contains 'grape': " << map.contains("grape") << "\n"; - // Получение значений std::cout << "Value of 'banana': " << map.get("banana") << "\n"; - // Удаление элемента map.remove("apple"); std::cout << "After remove, contains 'apple': " << map.contains("apple") << "\n"; - // Размер таблицы std::cout << "Size: " << map.getSize() << "\n"; return 0; diff --git a/task_09/src/table.cpp b/task_09/src/table.cpp new file mode 100644 index 0000000..e27d3cc --- /dev/null +++ b/task_09/src/table.cpp @@ -0,0 +1,57 @@ +#include "table.hpp" + +void TableChecker::readTable(std::istream& in) { + in >> n >> m; + table.assign(n, std::vector(m)); + + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + in >> table[i][j]; + } + } + + prepareData(); +} + +void TableChecker::prepareData() { + column_ok.assign(m, std::vector(n, 1)); // Initialize all as 1 + prefix.assign(m, std::vector(n + 1, 0)); + + for (int j = 0; j < m; ++j) { + for (int i = 0; i < n - 1; ++i) { + if (table[i][j] > table[i + 1][j]) { + column_ok[j][i] = 0; // Mark as not OK + } + } + + // Build prefix sum of violations + for (int i = 0; i < n; ++i) { + prefix[j][i + 1] = prefix[j][i] + (column_ok[j][i] == 0 ? 1 : 0); + } + } +} + +bool TableChecker::isRangeSorted(int l, int r) const { + if (l >= r) return true; + + for (int j = 0; j < m; ++j) { + int violations = prefix[j][r] - prefix[j][l]; + if (violations == 0) { + return true; + } + } + return false; +} + +void TableChecker::processQueries(std::istream& in, std::ostream& out) { + int k; + in >> k; + + while (k--) { + int l, r; + in >> l >> r; + --l; // convert to 0-based + + out << (isRangeSorted(l, r - 1) ? "Yes" : "No") << '\n'; + } +} \ No newline at end of file diff --git a/task_09/src/table.hpp b/task_09/src/table.hpp new file mode 100644 index 0000000..d40f229 --- /dev/null +++ b/task_09/src/table.hpp @@ -0,0 +1,17 @@ +#include +#include + +class TableChecker { +public: + void readTable(std::istream& in); + void processQueries(std::istream& in, std::ostream& out); + +private: + int n = 0, m = 0; + std::vector> table; + std::vector> column_ok; + std::vector> prefix; + + void prepareData(); + bool isRangeSorted(int l, int r) const; +}; \ No newline at end of file diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp index a42caa4..2009cdb 100644 --- a/task_09/src/test.cpp +++ b/task_09/src/test.cpp @@ -1,23 +1,41 @@ +#include "table.hpp" #include +#include -#include +TEST(TableCheckerTest, EmptyTable) { + TableChecker tc; + std::istringstream in("0 0\n0\n"); + std::ostringstream out; + + tc.readTable(in); + tc.processQueries(in, out); + + EXPECT_EQ(out.str(), ""); +} -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(TableCheckerTest, SingleRow) { + TableChecker tc; + std::istringstream in("1 3\n10 20 30\n2\n1 1\n1 1\n"); + std::ostringstream out; + + tc.readTable(in); + tc.processQueries(in, out); + + EXPECT_EQ(out.str(), "Yes\nYes\n"); } -TEST(CanReachNonDecreasingSegment, 2) { - // ASSERT_EQ(SolveFunction(1, 1, 1, std::vector>{{1, 1}}, - // std::vector>{{1, 1}}), - // (std::vector{"Yes"})); +TEST(TableCheckerTest, SortedColumns) { + TableChecker tc; + std::istringstream in("3 2\n1 5\n2 6\n3 7\n2\n1 3\n2 3\n"); + std::ostringstream out; + + tc.readTable(in); + tc.processQueries(in, out); + + EXPECT_EQ(out.str(), "Yes\nYes\n"); } + +int main(int argc, char **argv) { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} \ No newline at end of file From 4790ed5f005bc2876cde2f6ac851c950192a890d Mon Sep 17 00:00:00 2001 From: Pavel-bur-dot Date: Sun, 22 Jun 2025 16:02:54 +0000 Subject: [PATCH 19/19] Correct clang format --- task_01/src/main.cpp | 3 +- task_01/src/test.cpp | 37 +++++------ task_01/src/two_numbers.cpp | 32 +++++----- task_01/src/two_numbers.hpp | 7 +- task_02/src/stack.cpp | 58 ++++++++--------- task_02/src/stack.hpp | 26 ++++---- task_04/src/test.cpp | 71 ++++++++++----------- task_07/src/main.cpp | 3 +- task_07/src/test.cpp | 115 ++++++++++++++++----------------- task_07/src/tree.cpp | 123 ++++++++++++++++++------------------ task_07/src/tree.hpp | 65 ++++++++++--------- task_09/src/table.cpp | 82 ++++++++++++------------ task_09/src/table.hpp | 22 +++---- task_09/src/test.cpp | 56 ++++++++-------- 14 files changed, 351 insertions(+), 349 deletions(-) diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index abb9401..3d92284 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1,4 +1,3 @@ #include "two_numbers.hpp" -int main() { -} +int main() {} diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index b5d3f29..686e32a 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,34 +1,35 @@ -#include "two_numbers.hpp" #include +#include "two_numbers.hpp" + TEST(TwoSumTest, BasicTest) { - std::vector nums = {2, 7, 11, 15}; - auto result = FindSum::findTwoSum(nums, 9); - EXPECT_EQ(result.first, 2); - EXPECT_EQ(result.second, 7); + std::vector nums = {2, 7, 11, 15}; + auto result = FindSum::findTwoSum(nums, 9); + EXPECT_EQ(result.first, 2); + EXPECT_EQ(result.second, 7); } TEST(TwoSumTest, NoSolution) { - std::vector nums = {1, 2, 3, 4}; - auto result = FindSum::findTwoSum(nums, 10); - EXPECT_EQ(result.first, -1); - EXPECT_EQ(result.second, -1); + std::vector nums = {1, 2, 3, 4}; + auto result = FindSum::findTwoSum(nums, 10); + EXPECT_EQ(result.first, -1); + EXPECT_EQ(result.second, -1); } TEST(TwoSumTest, DuplicateNumbers) { - std::vector nums = {3, 3, 4, 4}; - auto result = FindSum::findTwoSum(nums, 7); - EXPECT_TRUE((result == std::pair{3, 4})); + std::vector nums = {3, 3, 4, 4}; + auto result = FindSum::findTwoSum(nums, 7); + EXPECT_TRUE((result == std::pair{3, 4})); } TEST(TwoSumTest, EmptyArray) { - std::vector nums; - auto result = FindSum::findTwoSum(nums, 5); - EXPECT_EQ(result.first, -1); - EXPECT_EQ(result.second, -1); + std::vector nums; + auto result = FindSum::findTwoSum(nums, 5); + EXPECT_EQ(result.first, -1); + EXPECT_EQ(result.second, -1); } int main(int argc, char **argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file diff --git a/task_01/src/two_numbers.cpp b/task_01/src/two_numbers.cpp index e85662a..8e7526d 100644 --- a/task_01/src/two_numbers.cpp +++ b/task_01/src/two_numbers.cpp @@ -1,20 +1,22 @@ #include "two_numbers.hpp" + #include -std::pair FindSum::findTwoSum(const std::vector& nums, int target) { - int left = 0; - int right = nums.size() - 1; - - while (left < right) { - int sum = nums[left] + nums[right]; - if (sum == target) { - return {nums[left], nums[right]}; - } else if (sum < target) { - left++; - } else { - right--; - } +std::pair FindSum::findTwoSum(const std::vector& nums, + int target) { + int left = 0; + int right = nums.size() - 1; + + while (left < right) { + int sum = nums[left] + nums[right]; + if (sum == target) { + return {nums[left], nums[right]}; + } else if (sum < target) { + left++; + } else { + right--; } - - return {-1, -1}; // Если пара не найдена + } + + return {-1, -1}; // Если пара не найдена } diff --git a/task_01/src/two_numbers.hpp b/task_01/src/two_numbers.hpp index adcf242..1c674e5 100644 --- a/task_01/src/two_numbers.hpp +++ b/task_01/src/two_numbers.hpp @@ -1,7 +1,8 @@ -#include #include +#include class FindSum { -public: - static std::pair findTwoSum(const std::vector& nums, int target); + public: + static std::pair findTwoSum(const std::vector& nums, + int target); }; \ No newline at end of file diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp index 6be81e8..04e4cbd 100644 --- a/task_02/src/stack.cpp +++ b/task_02/src/stack.cpp @@ -1,47 +1,47 @@ #include "stack.hpp" -#include -#include #include +#include +#include void Stack::Push(int element) { - arr.push_back(element); - if (min_stack.empty() || element <= min_stack.back()) { - min_stack.push_back(element); - } + arr.push_back(element); + if (min_stack.empty() || element <= min_stack.back()) { + min_stack.push_back(element); + } } void Stack::pop() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot pop."); - } - if (arr.back() == min_stack.back()) { - min_stack.pop_back(); - } - arr.pop_back(); + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot pop."); + } + if (arr.back() == min_stack.back()) { + min_stack.pop_back(); + } + arr.pop_back(); } int Stack::peek() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot peek."); - } - return arr.back(); + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot peek."); + } + return arr.back(); } void Stack::display() { - if (arr.empty()) { - std::cout << "Stack is empty." << std::endl; - return; - } - for (int i = 0; i < arr.size(); ++i) { - std::cout << arr[i] << " "; - } - std::cout << std::endl; + if (arr.empty()) { + std::cout << "Stack is empty." << std::endl; + return; + } + for (int i = 0; i < arr.size(); ++i) { + std::cout << arr[i] << " "; + } + std::cout << std::endl; } int Stack::min() { - if (arr.empty()) { - throw std::out_of_range("Stack is empty. Cannot find min."); - } - return min_stack.back(); + if (arr.empty()) { + throw std::out_of_range("Stack is empty. Cannot find min."); + } + return min_stack.back(); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp index e6e4b1a..09f6435 100644 --- a/task_02/src/stack.hpp +++ b/task_02/src/stack.hpp @@ -3,26 +3,22 @@ #include class Stack { -private: - std::vector arr; - std::vector min_stack; + private: + std::vector arr; + std::vector min_stack; -public: - void Push(int element); + public: + void Push(int element); - void pop(); + void pop(); - int peek(); + int peek(); - void display(); + void display(); - int min(); + int min(); - bool isEmpty() const { - return arr.empty(); - } + bool isEmpty() const { return arr.empty(); } - size_t size() const { - return arr.size(); - } + size_t size() const { return arr.size(); } }; diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 9558885..717f9ba 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -1,54 +1,49 @@ #include + +#include #include -#include + #include "fish.hpp" -TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); -} +TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); } TEST(BuyFishTest, BasicCase) { - std::vector prices = {3, 2, 5, 4, 1, 6}; - int K = 3; - std::vector> expected = { - {1, 3}, // Покупаем на 2-й день (цена 2) на 3 дня - {4, 2} // Покупаем на 5-й день (цена 1) на оставшиеся 2 дня - }; - auto result = buyFishSimplified(prices, K); - ASSERT_EQ(result, expected); + std::vector prices = {3, 2, 5, 4, 1, 6}; + int K = 3; + std::vector> expected = { + {1, 3}, // Покупаем на 2-й день (цена 2) на 3 дня + {4, 2} // Покупаем на 5-й день (цена 1) на оставшиеся 2 дня + }; + auto result = buyFishSimplified(prices, K); + ASSERT_EQ(result, expected); } TEST(BuyFishTest, SingleDay) { - std::vector prices = {5}; - int K = 1; - std::vector> expected = { - {0, 1} // Покупаем в единственный день - }; - auto result = buyFishSimplified(prices, K); - ASSERT_EQ(result, expected); + std::vector prices = {5}; + int K = 1; + std::vector> expected = { + {0, 1} // Покупаем в единственный день + }; + auto result = buyFishSimplified(prices, K); + ASSERT_EQ(result, expected); } TEST(BuyFishTest, SmallShelfLife) { - std::vector prices = {4, 3, 2, 1, 5, 6}; - int K = 1; // Рыба портится сразу - std::vector> expected = { - {0, 1}, // Покупаем каждый день отдельно - {1, 1}, - {2, 1}, - {3, 1}, - {4, 1}, - {5, 1} - }; - auto result = buyFishSimplified(prices, K); - ASSERT_EQ(result, expected); + std::vector prices = {4, 3, 2, 1, 5, 6}; + int K = 1; // Рыба портится сразу + std::vector> expected = { + {0, 1}, // Покупаем каждый день отдельно + {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}}; + auto result = buyFishSimplified(prices, K); + ASSERT_EQ(result, expected); } TEST(BuyFishTest, ConstantPrices) { - std::vector prices = {2, 2, 2, 2, 2}; - int K = 5; // Большой срок хранения - std::vector> expected = { - {0, 5} // Покупаем в первый день на все 5 дней - }; - auto result = buyFishSimplified(prices, K); - ASSERT_EQ(result, expected); + std::vector prices = {2, 2, 2, 2, 2}; + int K = 5; // Большой срок хранения + std::vector> expected = { + {0, 5} // Покупаем в первый день на все 5 дней + }; + auto result = buyFishSimplified(prices, K); + ASSERT_EQ(result, expected); } \ No newline at end of file diff --git a/task_07/src/main.cpp b/task_07/src/main.cpp index 6f75d7a..174c242 100644 --- a/task_07/src/main.cpp +++ b/task_07/src/main.cpp @@ -1,4 +1,3 @@ #include "tree.hpp" -int main() { -} \ No newline at end of file +int main() {} \ No newline at end of file diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp index 6cbae63..003adbf 100644 --- a/task_07/src/test.cpp +++ b/task_07/src/test.cpp @@ -1,82 +1,83 @@ -#include "tree.hpp" #include +#include "tree.hpp" + class AVLTreeTest : public ::testing::Test { -protected: - AVLTree tree; + protected: + AVLTree tree; - void SetUp() override { - tree.insert(50); - tree.insert(30); - tree.insert(70); - tree.insert(20); - tree.insert(40); - tree.insert(60); - tree.insert(80); - } + void SetUp() override { + tree.insert(50); + tree.insert(30); + tree.insert(70); + tree.insert(20); + tree.insert(40); + tree.insert(60); + tree.insert(80); + } }; TEST_F(AVLTreeTest, InsertAndContains) { - EXPECT_TRUE(tree.contains(50)); - EXPECT_TRUE(tree.contains(30)); - EXPECT_TRUE(tree.contains(70)); - EXPECT_TRUE(tree.contains(20)); - EXPECT_TRUE(tree.contains(40)); - EXPECT_TRUE(tree.contains(60)); - EXPECT_TRUE(tree.contains(80)); - EXPECT_FALSE(tree.contains(10)); - EXPECT_FALSE(tree.contains(100)); + EXPECT_TRUE(tree.contains(50)); + EXPECT_TRUE(tree.contains(30)); + EXPECT_TRUE(tree.contains(70)); + EXPECT_TRUE(tree.contains(20)); + EXPECT_TRUE(tree.contains(40)); + EXPECT_TRUE(tree.contains(60)); + EXPECT_TRUE(tree.contains(80)); + EXPECT_FALSE(tree.contains(10)); + EXPECT_FALSE(tree.contains(100)); } TEST_F(AVLTreeTest, RemoveElements) { - tree.remove(20); - EXPECT_FALSE(tree.contains(20)); - EXPECT_TRUE(tree.contains(30)); + tree.remove(20); + EXPECT_FALSE(tree.contains(20)); + EXPECT_TRUE(tree.contains(30)); - tree.remove(30); - EXPECT_FALSE(tree.contains(30)); - EXPECT_TRUE(tree.contains(50)); + tree.remove(30); + EXPECT_FALSE(tree.contains(30)); + EXPECT_TRUE(tree.contains(50)); - tree.remove(50); - EXPECT_FALSE(tree.contains(50)); - EXPECT_TRUE(tree.contains(60)); - EXPECT_TRUE(tree.contains(70)); + tree.remove(50); + EXPECT_FALSE(tree.contains(50)); + EXPECT_TRUE(tree.contains(60)); + EXPECT_TRUE(tree.contains(70)); } TEST_F(AVLTreeTest, MaintainsBalanceProperty) { - AVLTree balanceTestTree; - - // Вставляем элементы в порядке, который создает дисбаланс в обычном BST - for (int i = 1; i <= 100; ++i) { - balanceTestTree.insert(i); - // Можно добавить проверку баланса на каждом шаге - } - - // Проверяем, что все элементы присутствуют - for (int i = 1; i <= 100; ++i) { - EXPECT_TRUE(balanceTestTree.contains(i)); - } + AVLTree balanceTestTree; + + // Вставляем элементы в порядке, который создает дисбаланс в обычном BST + for (int i = 1; i <= 100; ++i) { + balanceTestTree.insert(i); + // Можно добавить проверку баланса на каждом шаге + } + + // Проверяем, что все элементы присутствуют + for (int i = 1; i <= 100; ++i) { + EXPECT_TRUE(balanceTestTree.contains(i)); + } } TEST_F(AVLTreeTest, ClearTree) { - EXPECT_TRUE(tree.contains(50)); - tree.clear(); - EXPECT_FALSE(tree.contains(50)); - - // Проверяем, что можно снова использовать дерево - tree.insert(100); - EXPECT_TRUE(tree.contains(100)); + EXPECT_TRUE(tree.contains(50)); + tree.clear(); + EXPECT_FALSE(tree.contains(50)); + + // Проверяем, что можно снова использовать дерево + tree.insert(100); + EXPECT_TRUE(tree.contains(100)); } TEST(AVLTreeEmptyTest, HandlesEmptyTree) { - AVLTree emptyTree; - EXPECT_FALSE(emptyTree.contains(10)); - - // Удаление из пустого дерева не должно вызывать ошибок - EXPECT_NO_THROW(emptyTree.remove(10)); + AVLTree emptyTree; + EXPECT_FALSE(emptyTree.contains(10)); + + // Удаление из пустого дерева не должно вызывать ошибок + EXPECT_NO_THROW(emptyTree.remove(10)); } int main(int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file diff --git a/task_07/src/tree.cpp b/task_07/src/tree.cpp index fed39e4..22eb055 100644 --- a/task_07/src/tree.cpp +++ b/task_07/src/tree.cpp @@ -1,88 +1,87 @@ #include "tree.hpp" 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); + 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->right) { - Node* temp = node->left ? node->left : node->right; - delete node; - return temp; - } - Node* temp = findMin(node->right); - node->key = temp->key; - node->right = remove(node->right, temp->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->right) { + Node* temp = node->left ? node->left : node->right; + delete node; + return temp; } - return balance(node); + Node* temp = findMin(node->right); + node->key = temp->key; + node->right = remove(node->right, temp->key); + } + return balance(node); } bool AVLTree::contains(const Node* node, int key) const { - if (!node) return false; - if (key == node->key) return true; - return key < node->key ? contains(node->left, key) : contains(node->right, key); + if (!node) return false; + if (key == node->key) return true; + return key < node->key ? contains(node->left, key) + : contains(node->right, key); } void AVLTree::clear(Node* node) { - if (node) { - clear(node->left); - clear(node->right); - delete node; - } + if (node) { + clear(node->left); + clear(node->right); + delete node; + } } Node* AVLTree::rotateRight(Node* y) { - Node* x = y->left; - y->left = x->right; - x->right = y; - updateHeight(y); - updateHeight(x); - return x; + Node* x = y->left; + y->left = x->right; + x->right = y; + updateHeight(y); + updateHeight(x); + return x; } Node* AVLTree::rotateLeft(Node* x) { - Node* y = x->right; - x->right = y->left; - y->left = x; - updateHeight(x); - updateHeight(y); - return y; + Node* y = x->right; + x->right = y->left; + y->left = x; + updateHeight(x); + updateHeight(y); + return y; } Node* AVLTree::balance(Node* node) { - updateHeight(node); - 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; + updateHeight(node); + 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; } Node* AVLTree::findMin(Node* node) { - while (node && node->left) node = node->left; - return node; + while (node && node->left) node = node->left; + return node; } \ No newline at end of file diff --git a/task_07/src/tree.hpp b/task_07/src/tree.hpp index 9fe9e50..ad49be9 100644 --- a/task_07/src/tree.hpp +++ b/task_07/src/tree.hpp @@ -1,37 +1,44 @@ #include struct Node { - int key; - Node* left; - Node* right; - int height; + int key; + Node* left; + Node* right; + int height; }; class AVLTree { -public: - AVLTree() : root(nullptr) {} - ~AVLTree() { clear(root); } - - void insert(int key) { root = insert(root, key); } - void remove(int key) { root = remove(root, key); } - bool contains(int key) const { return contains(root, key); } - void clear() { clear(root); root = nullptr; } + public: + AVLTree() : root(nullptr) {} + ~AVLTree() { clear(root); } -private: - Node* root; - - Node* insert(Node* node, int key); - Node* remove(Node* node, int key); - bool contains(const Node* node, int key) const; - void clear(Node* node); - - // Вспомогательные функции - int height(Node* node) { return node ? node->height : 0; } - int balanceFactor(Node* node) { return node ? height(node->left) - height(node->right) : 0; } - void updateHeight(Node* node) { node->height = 1 + std::max(height(node->left), height(node->right)); } - - Node* rotateRight(Node* y); - Node* rotateLeft(Node* x); - Node* balance(Node* node); - Node* findMin(Node* node); + void insert(int key) { root = insert(root, key); } + void remove(int key) { root = remove(root, key); } + bool contains(int key) const { return contains(root, key); } + void clear() { + clear(root); + root = nullptr; + } + + private: + Node* root; + + Node* insert(Node* node, int key); + Node* remove(Node* node, int key); + bool contains(const Node* node, int key) const; + void clear(Node* node); + + // Вспомогательные функции + int height(Node* node) { return node ? node->height : 0; } + int balanceFactor(Node* node) { + return node ? height(node->left) - height(node->right) : 0; + } + void updateHeight(Node* node) { + node->height = 1 + std::max(height(node->left), height(node->right)); + } + + Node* rotateRight(Node* y); + Node* rotateLeft(Node* x); + Node* balance(Node* node); + Node* findMin(Node* node); }; \ No newline at end of file diff --git a/task_09/src/table.cpp b/task_09/src/table.cpp index e27d3cc..027e8d8 100644 --- a/task_09/src/table.cpp +++ b/task_09/src/table.cpp @@ -1,57 +1,57 @@ #include "table.hpp" void TableChecker::readTable(std::istream& in) { - in >> n >> m; - table.assign(n, std::vector(m)); - - for (int i = 0; i < n; ++i) { - for (int j = 0; j < m; ++j) { - in >> table[i][j]; - } + in >> n >> m; + table.assign(n, std::vector(m)); + + for (int i = 0; i < n; ++i) { + for (int j = 0; j < m; ++j) { + in >> table[i][j]; } - - prepareData(); + } + + prepareData(); } void TableChecker::prepareData() { - column_ok.assign(m, std::vector(n, 1)); // Initialize all as 1 - prefix.assign(m, std::vector(n + 1, 0)); - - for (int j = 0; j < m; ++j) { - for (int i = 0; i < n - 1; ++i) { - if (table[i][j] > table[i + 1][j]) { - column_ok[j][i] = 0; // Mark as not OK - } - } - - // Build prefix sum of violations - for (int i = 0; i < n; ++i) { - prefix[j][i + 1] = prefix[j][i] + (column_ok[j][i] == 0 ? 1 : 0); - } + column_ok.assign(m, std::vector(n, 1)); // Initialize all as 1 + prefix.assign(m, std::vector(n + 1, 0)); + + for (int j = 0; j < m; ++j) { + for (int i = 0; i < n - 1; ++i) { + if (table[i][j] > table[i + 1][j]) { + column_ok[j][i] = 0; // Mark as not OK + } + } + + // Build prefix sum of violations + for (int i = 0; i < n; ++i) { + prefix[j][i + 1] = prefix[j][i] + (column_ok[j][i] == 0 ? 1 : 0); } + } } bool TableChecker::isRangeSorted(int l, int r) const { - if (l >= r) return true; - - for (int j = 0; j < m; ++j) { - int violations = prefix[j][r] - prefix[j][l]; - if (violations == 0) { - return true; - } + if (l >= r) return true; + + for (int j = 0; j < m; ++j) { + int violations = prefix[j][r] - prefix[j][l]; + if (violations == 0) { + return true; } - return false; + } + return false; } void TableChecker::processQueries(std::istream& in, std::ostream& out) { - int k; - in >> k; - - while (k--) { - int l, r; - in >> l >> r; - --l; // convert to 0-based - - out << (isRangeSorted(l, r - 1) ? "Yes" : "No") << '\n'; - } + int k; + in >> k; + + while (k--) { + int l, r; + in >> l >> r; + --l; // convert to 0-based + + out << (isRangeSorted(l, r - 1) ? "Yes" : "No") << '\n'; + } } \ No newline at end of file diff --git a/task_09/src/table.hpp b/task_09/src/table.hpp index d40f229..2a79329 100644 --- a/task_09/src/table.hpp +++ b/task_09/src/table.hpp @@ -1,17 +1,17 @@ -#include #include +#include class TableChecker { -public: - void readTable(std::istream& in); - void processQueries(std::istream& in, std::ostream& out); + public: + void readTable(std::istream& in); + void processQueries(std::istream& in, std::ostream& out); -private: - int n = 0, m = 0; - std::vector> table; - std::vector> column_ok; - std::vector> prefix; + private: + int n = 0, m = 0; + std::vector> table; + std::vector> column_ok; + std::vector> prefix; - void prepareData(); - bool isRangeSorted(int l, int r) const; + void prepareData(); + bool isRangeSorted(int l, int r) const; }; \ No newline at end of file diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp index 2009cdb..4f76cf6 100644 --- a/task_09/src/test.cpp +++ b/task_09/src/test.cpp @@ -1,41 +1,43 @@ -#include "table.hpp" #include + #include +#include "table.hpp" + TEST(TableCheckerTest, EmptyTable) { - TableChecker tc; - std::istringstream in("0 0\n0\n"); - std::ostringstream out; - - tc.readTable(in); - tc.processQueries(in, out); - - EXPECT_EQ(out.str(), ""); + TableChecker tc; + std::istringstream in("0 0\n0\n"); + std::ostringstream out; + + tc.readTable(in); + tc.processQueries(in, out); + + EXPECT_EQ(out.str(), ""); } TEST(TableCheckerTest, SingleRow) { - TableChecker tc; - std::istringstream in("1 3\n10 20 30\n2\n1 1\n1 1\n"); - std::ostringstream out; - - tc.readTable(in); - tc.processQueries(in, out); - - EXPECT_EQ(out.str(), "Yes\nYes\n"); + TableChecker tc; + std::istringstream in("1 3\n10 20 30\n2\n1 1\n1 1\n"); + std::ostringstream out; + + tc.readTable(in); + tc.processQueries(in, out); + + EXPECT_EQ(out.str(), "Yes\nYes\n"); } TEST(TableCheckerTest, SortedColumns) { - TableChecker tc; - std::istringstream in("3 2\n1 5\n2 6\n3 7\n2\n1 3\n2 3\n"); - std::ostringstream out; - - tc.readTable(in); - tc.processQueries(in, out); - - EXPECT_EQ(out.str(), "Yes\nYes\n"); + TableChecker tc; + std::istringstream in("3 2\n1 5\n2 6\n3 7\n2\n1 3\n2 3\n"); + std::ostringstream out; + + tc.readTable(in); + tc.processQueries(in, out); + + EXPECT_EQ(out.str(), "Yes\nYes\n"); } int main(int argc, char **argv) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file