diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp
index ef5a86ae..a632bd75 100644
--- a/task_01/src/test.cpp
+++ b/task_01/src/test.cpp
@@ -1,8 +1,22 @@
-
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include <vector>
+
+#include "utils.h"
+
+TEST(main, Simple) {
+  ASSERT_EQ(Task1(9, std::vector<int>{1, 2, 4, 5, 6, 8, 10, 12}),
+            (std::pair<int, int>{1, 8}));
+
+  ASSERT_EQ(Task1(39, std::vector<int>{1, 2, 4, 5, 6, 9, 10, 35}),
+            (std::pair<int, int>{4, 35}));
+
+  ASSERT_EQ(Task1(14, std::vector<int>{1, 2, 4, 5, 6, 8, 10, 12}),
+            (std::pair<int, int>{2, 12}));
+
+  ASSERT_EQ(Task1(1338, std::vector<int>{10, 20, 40, 50, 60, 87, 100, 1278}),
+            (std::pair<int, int>{60, 1278}));
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+  ASSERT_EQ(Task1(22, std::vector<int>{10, 10, 11, 11, 12, 15}),
+            (std::pair<int, int>{10, 12}));
+}
\ No newline at end of file
diff --git a/task_01/src/topology_sort.cpp b/task_01/src/topology_sort.cpp
deleted file mode 100644
index e53f670c..00000000
--- a/task_01/src/topology_sort.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "topology_sort.hpp"
diff --git a/task_01/src/topology_sort.hpp b/task_01/src/topology_sort.hpp
deleted file mode 100644
index 6f70f09b..00000000
--- a/task_01/src/topology_sort.hpp
+++ /dev/null
@@ -1 +0,0 @@
-#pragma once
diff --git a/task_01/src/utils.cpp b/task_01/src/utils.cpp
new file mode 100644
index 00000000..942e17ed
--- /dev/null
+++ b/task_01/src/utils.cpp
@@ -0,0 +1,11 @@
+#include "utils.h"
+
+std::pair<int, int> Task1(int number, std::vector<int> array_of_numbers) {
+  int i = 0;
+  int j = array_of_numbers.size() - 1;
+  while (array_of_numbers[i] + array_of_numbers[j] != number) {
+    if (array_of_numbers[i] + array_of_numbers[j] < number) i++;
+    if (array_of_numbers[i] + array_of_numbers[j] > number) j--;
+  }
+  return {array_of_numbers[i], array_of_numbers[j]};
+}
\ No newline at end of file
diff --git a/task_01/src/utils.h b/task_01/src/utils.h
new file mode 100644
index 00000000..78b046d6
--- /dev/null
+++ b/task_01/src/utils.h
@@ -0,0 +1,3 @@
+#include <vector>
+
+std::pair<int, int> Task1(int, std::vector<int>);
\ No newline at end of file
diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp
index 8ca89902..7ae5f572 100644
--- a/task_02/src/stack.cpp
+++ b/task_02/src/stack.cpp
@@ -2,20 +2,48 @@
 
 #include <algorithm>
 
-void Stack::Push(int value) { data_.push(value); }
+void Stack::Push(int value) { elements_.push_back(value); }
 
 int Stack::Pop() {
-  auto result = data_.top();
-  data_.pop();
+  if (elements_.size() == 0) {
+    throw std::out_of_range("Stack is empty");
+  }
+  int result = elements_.back();
+  elements_.pop_back();
   return result;
 }
 
-void MinStack::Push(int value) { data_.push_back(value); }
+int Stack::Size() { return elements_.size(); }
+
+int Stack::Top() {
+  if (elements_.size() == 0) {
+    throw std::out_of_range("Stack is empty");
+  }
+  return elements_.back();
+}
+
+///////////////////
+
+void MinStack::Push(int value) {
+  main_stack_.Push(value);
+  if (min_stack_.Size() && min_stack_.Top() > value) {
+    min_stack_.Push(value);
+  }
+  if (min_stack_.Size() == 0) {
+    min_stack_.Push(value);
+  }
+}
 
 int MinStack::Pop() {
-  auto result = data_.back();
-  data_.pop_back();
-  return result;
+  if (main_stack_.Size() && min_stack_.Size() &&
+      main_stack_.Top() == min_stack_.Top()) {
+    min_stack_.Pop();
+  }
+  return main_stack_.Pop();
 }
 
-int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); }
\ No newline at end of file
+int MinStack::GetMin() { return min_stack_.Top(); }
+
+int MinStack::Top() { return main_stack_.Top(); }
+
+int MinStack::Size() { return main_stack_.Size(); }
\ No newline at end of file
diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp
index 138ec40f..de84460c 100644
--- a/task_02/src/stack.hpp
+++ b/task_02/src/stack.hpp
@@ -7,17 +7,22 @@ class Stack {
  public:
   void Push(int value);
   int Pop();
+  int Top();
+  int Size();
 
  private:
-  std::stack<int> data_;
+  std::vector<int> elements_;
 };
 
 class MinStack {
  public:
   void Push(int value);
   int Pop();
+  int Top();
   int GetMin();
+  int Size();
 
  private:
-  std::vector<int> data_;
+  Stack main_stack_;
+  Stack min_stack_;
 };
diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp
index 54e7ce90..9e1fdb1c 100644
--- a/task_02/src/test.cpp
+++ b/task_02/src/test.cpp
@@ -7,36 +7,26 @@
 
 TEST(StackTest, Simple) {
   Stack stack;
-  stack.Push(1);              // Stack [1]
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
-  stack.Push(1);              // Stack [1]
-  stack.Push(2);              // Stack [1, 2]
-  ASSERT_EQ(stack.Pop(), 2);  // Stack [1]
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
-  stack.Push(1);              // Stack [1]
-  stack.Push(2);              // Stack [1, 2]
-  ASSERT_EQ(stack.Pop(), 2);  // Stack [1]
-  stack.Push(3);              // Stack [1, 3]
-  ASSERT_EQ(stack.Pop(), 3);  // Stack [1]
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
+  stack.Push(1);
+  ASSERT_EQ(stack.Pop(), 1);
+  ASSERT_EQ(stack.Size(), 0);
+  EXPECT_THROW(stack.Top(), std::out_of_range);
+  EXPECT_THROW(stack.Pop(), std::out_of_range);
+  stack.Push(3);
+  stack.Push(-1);
+  ASSERT_EQ(stack.Top(), -1);
 }
 
 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 []
+  stack.Push(1);
+  ASSERT_EQ(stack.Pop(), 1);
+  ASSERT_EQ(stack.Size(), 0);
+  EXPECT_THROW(stack.Top(), std::out_of_range);
+  EXPECT_THROW(stack.Pop(), std::out_of_range);
+  EXPECT_THROW(stack.GetMin(), std::out_of_range);
+  stack.Push(-2);
+  stack.Push(5);
+  ASSERT_EQ(stack.Top(), 5);
+  ASSERT_EQ(stack.GetMin(), -2);
 }
\ No newline at end of file
diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp
index ef5a86ae..7cc321be 100644
--- a/task_03/src/test.cpp
+++ b/task_03/src/test.cpp
@@ -1,8 +1,21 @@
 
 #include <gtest/gtest.h>
 
+#include <vector>
+
 #include "topology_sort.hpp"
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+TEST(DaysUntilWarmer, MultipleCases) {
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{73, 74, 75, 71, 69, 72, 76, 73}),
+            (std::vector<int>{1, 1, 4, 2, 1, 1, 0, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{30, 40, 50, 60}),
+            (std::vector<int>{1, 1, 1, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{30, 60, 90, 70, 80, 40, 30}),
+            (std::vector<int>{1, 1, 0, 1, 0, 0, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{55, 55, 55, 55, 55}),
+            (std::vector<int>{0, 0, 0, 0, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{76, 75, 74, 73, 72, 71, 70}),
+            (std::vector<int>{0, 0, 0, 0, 0, 0, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{75, 72, 71, 70, 74, 76}),
+            (std::vector<int>{5, 3, 2, 1, 1, 0}));
 }
diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp
index e53f670c..8b898315 100644
--- a/task_03/src/topology_sort.cpp
+++ b/task_03/src/topology_sort.cpp
@@ -1 +1,17 @@
 #include "topology_sort.hpp"
+
+std::vector<int> DaysUntilWarmer(std::vector<int> temperature) {
+  std::vector<int> result(temperature.size(), 0);
+  std::stack<int> index;
+
+  for (int i = 0; i < temperature.size(); ++i) {
+    while (!index.empty() && temperature[index.top()] < temperature[i]) {
+      int current_index = index.top();
+      index.pop();
+      result[current_index] = i - current_index;
+    }
+    index.push(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 6f70f09b..99b18616 100644
--- a/task_03/src/topology_sort.hpp
+++ b/task_03/src/topology_sort.hpp
@@ -1 +1,5 @@
 #pragma once
+#include <stack>
+#include <vector>
+
+std::vector<int> DaysUntilWarmer(std::vector<int>);
\ No newline at end of file
diff --git a/task_04/src/heap.cpp b/task_04/src/heap.cpp
new file mode 100644
index 00000000..f79f072c
--- /dev/null
+++ b/task_04/src/heap.cpp
@@ -0,0 +1,57 @@
+#include "heap.hpp"
+
+void Heap::SiftUp(int i) {
+  int half_i = i / 2;
+  while (elements[i] < elements[half_i]) {
+    std::swap(elements[i], elements[half_i]);
+    i /= 2;
+    half_i /= 2;
+  }
+}
+
+void Heap::SiftDown(int i) {
+  int leftChildIndex = 2 * i;
+  int rightChildIndex = 2 * i + 1;
+  while (leftChildIndex < n) {
+    int j = -1;
+    if (elements[leftChildIndex] < elements[i]) {
+      j = leftChildIndex;
+    }
+    if (rightChildIndex < n && elements[rightChildIndex] < elements[i] &&
+        (j == -1 || elements[leftChildIndex] > elements[rightChildIndex])) {
+      j = rightChildIndex;
+    }
+    if (j == -1)
+      break;
+    else {
+      std::swap(elements[i], elements[j]);
+      leftChildIndex = 2 * j;
+      rightChildIndex = 2 * j + 1;
+    }
+  }
+}
+
+int Heap::Size() { return elements.size(); }
+
+int Heap::GetMin() {
+  if (elements.size() == 0) {
+    throw std::out_of_range("Heap is empty");
+  }
+  return elements[0];
+}
+
+void Heap::Insert(int x) {
+  elements.push_back(x);
+  n++;
+  SiftUp(n - 1);
+}
+
+void Heap::ExtractMin() {
+  if (elements.size() == 0) {
+    throw std::out_of_range("Heap is empty");
+  }
+  elements[0] = elements[n - 1];
+  elements.erase(elements.begin() + n - 1);
+  n--;
+  SiftDown(0);
+}
diff --git a/task_04/src/heap.hpp b/task_04/src/heap.hpp
new file mode 100644
index 00000000..07a371d5
--- /dev/null
+++ b/task_04/src/heap.hpp
@@ -0,0 +1,16 @@
+#include <iostream>
+#include <vector>
+
+class Heap {
+ public:
+  void SiftUp(int i);
+  void SiftDown(int i);
+  void Insert(int x);
+  int GetMin();
+  void ExtractMin();
+  int Size();
+
+ private:
+  std::vector<int> elements;
+  int n = 0;
+};
\ No newline at end of file
diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp
index 5e11617e..6d867dc7 100644
--- a/task_04/src/test.cpp
+++ b/task_04/src/test.cpp
@@ -1,6 +1,27 @@
 
 #include <gtest/gtest.h>
 
+#include "heap.hpp"
+
 TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+  Heap heap;
+
+  EXPECT_THROW(heap.ExtractMin(), std::out_of_range);
+  EXPECT_THROW(heap.GetMin(), std::out_of_range);
+
+  heap.Insert(-1);
+
+  heap.ExtractMin();
+  EXPECT_THROW(heap.ExtractMin(), std::out_of_range);
+
+  ASSERT_EQ(heap.Size(), 0);
+  heap.Insert(5);
+  ASSERT_EQ(heap.GetMin(), 5);
+  heap.Insert(3);
+  heap.Insert(1);
+  heap.Insert(7);
+  heap.Insert(-2);
+  heap.ExtractMin();
+  ASSERT_EQ(heap.Size(), 4);
+  ASSERT_EQ(heap.GetMin(), 1);
+}
\ No newline at end of file
diff --git a/task_05/src/sort.hpp b/task_05/src/sort.hpp
new file mode 100644
index 00000000..b873c3c0
--- /dev/null
+++ b/task_05/src/sort.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <vector>
+
+std::vector<int> Merge(const std::vector<int>& left,
+                       const std::vector<int>& right) {
+  std::vector<int> result;
+  int i = 0, j = 0;
+
+  while (i < left.size() && j < right.size()) {
+    if (left[i] <= right[j]) {
+      result.push_back(left[i]);
+      ++i;
+    } else {
+      result.push_back(right[j]);
+      ++j;
+    }
+  }
+
+  while (i < left.size()) {
+    result.push_back(left[i]);
+    ++i;
+  }
+
+  while (j < right.size()) {
+    result.push_back(right[j]);
+    ++j;
+  }
+
+  return result;
+}
+
+std::vector<int> MergeSort(std::vector<int> arr) {
+  if (arr.size() <= 1) {
+    return arr;
+  }
+
+  int mid = arr.size() / 2;
+  std::vector<int> left(arr.begin(), arr.begin() + mid);
+  std::vector<int> right(arr.begin() + mid, arr.end());
+
+  return Merge(MergeSort(left), MergeSort(right));
+}
\ No newline at end of file
diff --git a/task_05/src/test.cpp b/task_05/src/test.cpp
index 5e11617e..25b06088 100644
--- a/task_05/src/test.cpp
+++ b/task_05/src/test.cpp
@@ -1,6 +1,38 @@
 
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include "sort.hpp"
+
+TEST(MergeSortTests, Case1) {
+  ASSERT_EQ(MergeSort(std::vector<int>{73, 74, 75, 71, 69, 72, 76, 73}),
+            (std::vector<int>{69, 71, 72, 73, 73, 74, 75, 76}));
+}
+
+TEST(MergeSortTests, Case2) {
+  ASSERT_EQ(MergeSort(std::vector<int>{30, 40, 50, 60}),
+            (std::vector<int>{30, 40, 50, 60}));
+}
+
+TEST(MergeSortTests, Case3) {
+  ASSERT_EQ(MergeSort(std::vector<int>{30, 60, 90, 70, 80, 40, 30}),
+            (std::vector<int>{30, 30, 40, 60, 70, 80, 90}));
+}
+
+TEST(MergeSortTests, Case4) {
+  ASSERT_EQ(MergeSort(std::vector<int>{55, 55, 55, 55, 55}),
+            (std::vector<int>{55, 55, 55, 55, 55}));
+}
+
+TEST(MergeSortTests, Case5) {
+  ASSERT_EQ(MergeSort(std::vector<int>{76, 75, 74, 73, 72, 71, 70}),
+            (std::vector<int>{70, 71, 72, 73, 74, 75, 76}));
 }
+
+TEST(MergeSortTests, Case6) {
+  ASSERT_EQ(MergeSort(std::vector<int>{75, 72, 71, 70, 74, 76}),
+            (std::vector<int>{70, 71, 72, 74, 75, 76}));
+}
+
+TEST(MergeSortTests, Case7) {
+  ASSERT_EQ(MergeSort(std::vector<int>{}), (std::vector<int>{}));
+}
\ No newline at end of file
diff --git a/task_06/src/task_06.hpp b/task_06/src/task_06.hpp
new file mode 100644
index 00000000..de49294c
--- /dev/null
+++ b/task_06/src/task_06.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <vector>
+
+int Partition(std::vector<int>& arr, int left, int right) {
+  int pivot_index = left + (right - left) / 2;
+  int pivot_value = arr[pivot_index];
+  std::swap(arr[pivot_index], arr[right]);
+  int store_index = left;
+  for (int i = left; i < right; ++i) {
+    if (arr[i] < pivot_value) {
+      std::swap(arr[i], arr[store_index]);
+      ++store_index;
+    }
+  }
+  std::swap(arr[store_index], arr[right]);
+  return store_index;
+}
+
+int QuickSelect(std::vector<int>& arr, int left, int right, int k) {
+  while (left <= right) {
+    int pivot_index = Partition(arr, left, right);
+    if (pivot_index == k) {
+      return arr[pivot_index];
+    } else if (pivot_index < k) {
+      left = pivot_index + 1;
+    } else {
+      right = pivot_index - 1;
+    }
+  }
+  return -1;
+}
+
+int FindNthOrder(std::vector<int> arr, int k) {
+  if (arr.size() == 0) {
+    throw std::invalid_argument("vector must be not empty");
+  }
+  return QuickSelect(arr, 0, arr.size() - 1, k - 1);
+}
\ No newline at end of file
diff --git a/task_06/src/test.cpp b/task_06/src/test.cpp
index 5e11617e..13c56ff2 100644
--- a/task_06/src/test.cpp
+++ b/task_06/src/test.cpp
@@ -1,6 +1,25 @@
 
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include "task_06.hpp"
+
+TEST(FindNthOrder, Case1) {
+  ASSERT_EQ(FindNthOrder(std::vector<int>{73, 74, 75, 71, 69, 72, 76, 73}, 2),
+            71);
+}
+
+TEST(findNthOrder, Case2) {
+  ASSERT_EQ(FindNthOrder(std::vector<int>{30, 40, 50, 60}, 1), 30);
+}
+
+TEST(findNthOrder, Case3) {
+  ASSERT_EQ(FindNthOrder(std::vector<int>{30, 60, 90, 70, 80, 40, 30}, 4), 60);
+}
+
+TEST(findNthOrder, Case4) {
+  ASSERT_EQ(FindNthOrder(std::vector<int>{55, 55, 55, 55, 55}, 5), 55);
+}
+
+TEST(findNthOrder, Case5) {
+  EXPECT_THROW(FindNthOrder(std::vector<int>{}, 5), std::invalid_argument);
 }
diff --git a/task_07/src/binary_search_tree.hpp b/task_07/src/binary_search_tree.hpp
new file mode 100644
index 00000000..fdcf8737
--- /dev/null
+++ b/task_07/src/binary_search_tree.hpp
@@ -0,0 +1,111 @@
+#include <vector>
+
+struct Node {
+  int value;
+  int Height;
+  Node* left;
+  Node* right;
+
+  Node(int k) {
+    value = k;
+    left = right = 0;
+    Height = 1;
+  }
+};
+
+int Height(Node* p) { return p ? p->Height : 0; }
+
+int Bfactor(Node* p) { return Height(p->right) - Height(p->left); }
+
+void FixHeight(Node* p) {
+  int hl = Height(p->left);
+  int hr = Height(p->right);
+  p->Height = (hl > hr ? hl : hr) + 1;
+}
+
+Node* RotateRight(Node* p) {
+  Node* q = p->left;
+  p->left = q->right;
+  q->right = p;
+  FixHeight(p);
+  FixHeight(q);
+  return q;
+}
+
+Node* RotateLeft(Node* q) {
+  Node* p = q->right;
+  q->right = p->left;
+  p->left = q;
+  FixHeight(q);
+  FixHeight(p);
+  return p;
+}
+
+Node* Balance(Node* p) {
+  FixHeight(p);
+  if (Bfactor(p) == 2) {
+    if (Bfactor(p->right) < 0) p->right = RotateRight(p->right);
+    return RotateLeft(p);
+  }
+  if (Bfactor(p) == -2) {
+    if (Bfactor(p->left) > 0) p->left = RotateLeft(p->left);
+    return RotateRight(p);
+  }
+  return p;
+}
+
+Node* Insert(Node* p, int k) {
+  if (!p) return new Node(k);
+  if (k < p->value)
+    p->left = Insert(p->left, k);
+  else
+    p->right = Insert(p->right, k);
+  return Balance(p);
+}
+
+Node* Find(Node* root, int value) {
+  if (root == nullptr) {
+    return nullptr;
+  }
+
+  if (value < root->value) {
+    return Find(root->left, value);
+  } else if (value > root->value) {
+    return Find(root->right, value);
+  } else {
+    return root;
+  }
+}
+
+Node* FindMin(Node* p) { return p->left ? FindMin(p->left) : p; }
+
+Node* RemoveMin(Node* p) {
+  if (p->left == 0) return p->right;
+  p->left = RemoveMin(p->left);
+  return Balance(p);
+}
+
+Node* Remove(Node* p, int k) {
+  if (!p) return 0;
+  if (k < p->value)
+    p->left = Remove(p->left, k);
+  else if (k > p->value)
+    p->right = Remove(p->right, k);
+  else {
+    Node* q = p->left;
+    Node* r = p->right;
+    delete p;
+    if (!r) return q;
+    Node* min = FindMin(r);
+    min->right = RemoveMin(r);
+    min->left = q;
+    return Balance(min);
+  }
+  return Balance(p);
+}
+
+void BuildBinarySearchTree(std::vector<int>& arr, Node*& root) {
+  for (int i = 0; i < arr.size(); ++i) {
+    root = Insert(root, arr[i]);
+  }
+}
\ No newline at end of file
diff --git a/task_07/src/test.cpp b/task_07/src/test.cpp
index 5e11617e..801293e6 100644
--- a/task_07/src/test.cpp
+++ b/task_07/src/test.cpp
@@ -1,6 +1,16 @@
 
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include "binary_search_tree.hpp"
+
+TEST(binary_search_tree, 1) {
+  std::vector<int> arr = {10, 3, 11, 5, 4, 2, 9};
+  Node* root = nullptr;
+  BuildBinarySearchTree(arr, root);
+  ASSERT_EQ(Find(root, 3)->value, 3);
+  ASSERT_EQ(Find(root, 8), nullptr);
+  ASSERT_EQ(FindMin(root)->value, 2);
+  root = Remove(root, 2);
+  ASSERT_EQ(Find(root, 2), nullptr);
+  root = Remove(root, 1);
 }
diff --git a/task_08/src/hash_table.hpp b/task_08/src/hash_table.hpp
new file mode 100644
index 00000000..8e038c3b
--- /dev/null
+++ b/task_08/src/hash_table.hpp
@@ -0,0 +1,48 @@
+#include <iostream>
+#include <list>
+#include <vector>
+
+class HashTable {
+ public:
+  HashTable(size_t size) : table(size) {}
+
+  // Вставка элемента
+  void Insert(int key, int value) {
+    auto& list = table[hashFunction(key, table.size())];
+    for (auto& pair : list) {
+      if (pair.first == key) {
+        pair.second = value;
+        return;
+      }
+    }
+    list.emplace_back(key, value);
+  }
+
+  // Удаление элемента
+  void Remove(int key) {
+    auto& list = table[hashFunction(key, table.size())];
+    for (auto it = list.begin(); it != list.end(); ++it) {
+      if (it->first == key) {
+        list.erase(it);
+        return;
+      }
+    }
+  }
+
+  // Поиск элемента
+  bool Find(int key, int& value) {
+    auto& list = table[hashFunction(key, table.size())];
+    for (auto pair : list) {
+      if (pair.first == key) {
+        value = pair.second;
+        return true;
+      }
+    }
+    return false;
+  }
+
+ private:
+  std::vector<std::list<std::pair<int, int>>> table;
+  std::function<size_t(int, size_t)> hashFunction =
+      [](int key, size_t mod) -> size_t { return (key * 1363) % mod; };
+};
\ No newline at end of file
diff --git a/task_08/src/test.cpp b/task_08/src/test.cpp
index 5e11617e..8815ba3b 100644
--- a/task_08/src/test.cpp
+++ b/task_08/src/test.cpp
@@ -1,6 +1,25 @@
-
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include "hash_table.hpp"
+
+TEST(hash_table, 1) {
+  HashTable hashTable(10);
+
+  hashTable.Insert(1, 100);
+  hashTable.Insert(2, 200);
+  hashTable.Insert(3, 300);
+
+  int value;
+  ASSERT_EQ(hashTable.Find(2, value), true);
+  ASSERT_EQ(value, 200);
+
+  hashTable.Remove(2);
+  ASSERT_EQ(hashTable.Find(2, value), false);
+
+  hashTable.Remove(2);
+  ASSERT_EQ(hashTable.Find(2, value), false);
+
+  hashTable.Insert(-1, -10);
+  ASSERT_EQ(hashTable.Find(-1, value), true);
+  ASSERT_EQ(value, -10);
 }
diff --git a/task_09/src/MinCoins.hpp b/task_09/src/MinCoins.hpp
new file mode 100644
index 00000000..ea430304
--- /dev/null
+++ b/task_09/src/MinCoins.hpp
@@ -0,0 +1,20 @@
+#include <iostream>
+#include <vector>
+
+int MinCoins(std::vector<int> coins, int amount) {
+  std::vector<int> dp(amount + 1, amount + 1);
+  dp[0] = 0;
+
+  for (int i = 1; i <= amount; ++i) {
+    for (int coin : coins) {
+      if (i - coin >= 0) {
+        dp[i] = std::min(dp[i], dp[i - coin] + 1);
+      }
+    }
+  }
+
+  if (dp[amount] == amount + 1)
+    return -1;
+  else
+    return dp[amount];
+}
\ No newline at end of file
diff --git a/task_09/src/test.cpp b/task_09/src/test.cpp
index 869094dd..cf297ede 100644
--- a/task_09/src/test.cpp
+++ b/task_09/src/test.cpp
@@ -1,4 +1,12 @@
 
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); }
+#include "MinCoins.hpp"
+
+TEST(MinCoins, 1) { ASSERT_EQ(MinCoins(std::vector<int>{1, 2, 5, 10}, 14), 3); }
+
+TEST(MinCoins, 2) { ASSERT_EQ(MinCoins(std::vector<int>{1, 2, 5, 10}, 19), 4); }
+
+TEST(MinCoins, 3) { ASSERT_EQ(MinCoins(std::vector<int>{2, 4, 6}, 13), -1); }
+
+TEST(MinCoins, 4) { ASSERT_EQ(MinCoins(std::vector<int>{3, 4, 5, 10}, 17), 3); }
\ No newline at end of file