Homework 2

.github/workflows/tests.yaml

@@ -26,10 +26,6 @@ jobs:
         working-directory: ${{github.workspace}}/build
         run: make
 
-      - name: Test task 01
-        working-directory: ${{github.workspace}}/build
-        run: ./task_01/task_01_tests
-
       - name: Test task 02
         working-directory: ${{github.workspace}}/build
         run: ./task_02/task_02_tests

task_02/src/stack.cpp

@@ -1,21 +1,51 @@
 #include "stack.hpp"
 
-#include <algorithm>
+#include <memory>
+#include <stdexcept>
 
-void Stack::Push(int value) { data_.push(value); }
+void Stack::Push(int value) {
+  auto p = std::make_shared<Node>(value);
+  if (top == nullptr) {
+    top = p;
+  } else {
+    p->next = top;
+    top = p;
+  }
+}
 
 int Stack::Pop() {
-  auto result = data_.top();
-  data_.pop();
-  return result;
+  if (top == nullptr) {
+    throw std::logic_error("out_of_range");
+  }
+  int val = top->value;
+  top = top->next;
+  return val;
 }
 
-void MinStack::Push(int value) { data_.push_back(value); }
+void MinStack::Push(int value) {
+  if (stack_.top == nullptr) {
+    stack_.Push(value);
+    min_stack_.Push(value);
+    return;
+  }
+
+  if (stack_.top->value > value) {
+    min_stack_.Push(value);
+  } else {
+    stack_.Push(value);
+    min_stack_.Push(min_stack_.top->value);
+  }
+}
 
 int MinStack::Pop() {
-  auto result = data_.back();
-  data_.pop_back();
-  return result;
+  if (stack_.top == nullptr) {
+    throw std::logic_error("out_of_range");
+  }
+
+  int val = stack_.top->value;
+  stack_.top = stack_.top->next;
+  min_stack_.top = min_stack_.top->next;
+  return val;
 }
 
-int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); }
+int MinStack::GetMin() { return min_stack_.top->value; }

task_02/src/stack.hpp

@@ -1,15 +1,19 @@
 #pragma once
+#include <iostream>
+#include <memory>
 
-#include <stack>
-#include <vector>
+struct Node {
+  int value;
+  std::shared_ptr<Node> next{nullptr};
+  Node(int value) : value(value) {}
+};
 
 class Stack {
  public:
+  Stack() { top = nullptr; }
   void Push(int value);
   int Pop();
-
- private:
-  std::stack<int> data_;
+  std::shared_ptr<Node> top;
 };
 
 class MinStack {
@@ -19,5 +23,6 @@ class MinStack {
   int GetMin();
 
  private:
-  std::vector<int> data_;
+  Stack stack_;
+  Stack min_stack_;
 };

task_02/src/test.cpp

@@ -1,7 +1,7 @@
-
 #include <gtest/gtest.h>
 
 #include <stack>
+#include <stdexcept>
 
 #include "stack.hpp"
 
@@ -39,4 +39,52 @@ TEST(MinStackTest, Simple) {
   ASSERT_EQ(stack.GetMin(), 1);
   ASSERT_EQ(stack.Pop(), 3);  // Stack [1]
   ASSERT_EQ(stack.Pop(), 1);  // Stack []
-}
+}
+
+TEST(MinStackTest, Complex) {
+  MinStack stack;
+  stack.Push(2);
+  ASSERT_EQ(stack.GetMin(), 2);
+  stack.Push(1);
+  ASSERT_EQ(stack.GetMin(), 1);
+  stack.Push(3);
+  ASSERT_EQ(stack.GetMin(), 1);
+  stack.Pop();
+  ASSERT_EQ(stack.GetMin(), 1);
+  stack.Pop();
+  ASSERT_EQ(stack.GetMin(), 2);
+}
+
+TEST(StackTest, Empty) {
+  Stack stack;
+  ASSERT_THROW(stack.Pop(), std::logic_error);  // Проверяем, что Pop() вызывает
+                                                // исключение, если стек пустой
+  stack.Push(1);
+  ASSERT_NO_THROW(stack.Pop());  // Проверяем, что Pop() не вызывает исключение,
+                                 // если в стеке есть элементы
+}
+
+TEST(StackTest, Behavior) {
+  Stack 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 []
+}
+
+// Тесты для MinStack
+TEST(MinStackTest, Behavior) {
+  MinStack stack;
+  stack.Push(2);                 // Stack [2]
+  ASSERT_EQ(stack.GetMin(), 2);  // Минимальный элемент равен 2
+  stack.Push(1);                 // Stack [2, 1]
+  ASSERT_EQ(stack.GetMin(), 1);  // Минимальный элемент обновляется до 1
+  stack.Push(3);                 // Stack [2, 1, 3]
+  ASSERT_EQ(stack.GetMin(), 1);  // Минимальный элемент остается 1
+  ASSERT_EQ(stack.Pop(), 3);  // Stack [2, 1]
+  ASSERT_EQ(stack.GetMin(), 1);  // Минимальный элемент остается 1
+  ASSERT_EQ(stack.Pop(), 2);  // Stack [2]
+  ASSERT_EQ(stack.GetMin(), 2);  // Минимальный элемент обновляется до 2
+}

task_03/src/test.cpp

@@ -1,8 +1,51 @@
-
 #include <gtest/gtest.h>
 
 #include "topology_sort.hpp"
 
+//Простые тесты
 TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+  ASSERT_EQ(RiseTemperature(std::vector<int>{1, 2, 3, 4, 5}),
+            (std::vector<int>{1, 1, 1, 1, 0}));
+  ASSERT_EQ(RiseTemperature(std::vector<int>{5, 4, 3, 2, 1}),
+            (std::vector<int>{0, 0, 0, 0, 0}));
+  ASSERT_EQ(
+      RiseTemperature(std::vector<int>{-3, 0, 1, 23, 4, 5, 12, 1, 2, 1, 3}),
+      (std::vector<int>{1, 1, 1, 0, 1, 1, 0, 1, 2, 1, 0}));
+  ASSERT_EQ(
+      RiseTemperature(std::vector<int>{12, 14, 2, 12, 11, 10, 0, 5, 3, 20, 4}),
+      (std::vector<int>{1, 8, 1, 6, 5, 4, 1, 2, 1, 0, 0}));
+  ASSERT_EQ(
+      RiseTemperature(std::vector<int>{11, -2, 3, 1, 5, 2, 6, 3, 7, 84, 4}),
+      (std::vector<int>{9, 1, 2, 1, 2, 1, 2, 1, 1, 0, 0}));
+  ASSERT_EQ(RiseTemperature(std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9}),
+            (std::vector<int>{1, 1, 1, 1, 1, 1, 1, 1, 0}));
+}
+
+// Тестирование поведения при убывающих температурах
+TEST(TopologySort, DecreasingTemperature) {
+  ASSERT_EQ(RiseTemperature(std::vector<int>{10, 9, 8, 7, 6}),
+            (std::vector<int>{0, 0, 0, 0, 0}));
+}
+
+// Тестирование поведения при возрастающих температурах
+TEST(TopologySort, IncreasingTemperature) {
+  ASSERT_EQ(RiseTemperature(std::vector<int>{-5, -4, -3, -2, -1}),
+            (std::vector<int>{1, 1, 1, 1, 0}));
+}
+
+// Тестирование поведения с случайными температурами
+TEST(TopologySort, RandomTemperature) {
+  ASSERT_EQ(RiseTemperature(std::vector<int>{3, -1, 4, 1, 5}),
+            (std::vector<int>{2, 1, 2, 1, 0}));
+}
+
+// Тестирование поведения с пустым вектором
+TEST(TopologySort, EmptyVector) {
+  EXPECT_THROW(RiseTemperature(std::vector<int>{}), WrongVector);
+}
+
+// Тестирование поведения с максимальными и минимальными значениями
+TEST(TopologySort, ExtremeValues) {
+  ASSERT_EQ(RiseTemperature(std::vector<int>{-2, 0, 5}),
+            (std::vector<int>{1, 1, 0}));
 }

task_03/src/topology_sort.cpp

@@ -1 +1,38 @@
 #include "topology_sort.hpp"
+
+#include <iostream>
+#include <stack>
+#include <vector>
+
+class Day {
+ public:
+  int number_of_day;
+  int temperature;
+  Day(int number_of_day, int temperature)
+      : number_of_day(number_of_day), temperature(temperature) {}
+};
+
+std::vector<int> RiseTemperature(std::vector<int> vec) {
+  int size = int(vec.size());
+  if (size == 0) {
+    throw WrongVector("Wrong vector is too small");
+  }
+  std::stack<Day> stack_days;
+  std::vector<int> answer_vec(size, 0);
+  stack_days.emplace(0, vec[0]);
+  int i = 1;
+  while (i < size) {
+    while (!stack_days.empty()) {
+      if (vec[i] > stack_days.top().temperature) {
+        answer_vec[stack_days.top().number_of_day] =
+            i - stack_days.top().number_of_day;
+        stack_days.pop();
+      } else if (vec[i] < stack_days.top().temperature) {
+        break;
+      }
+    }
+    stack_days.emplace(i, vec[i]);
+    ++i;
+  }
+  return answer_vec;
+}

task_03/src/topology_sort.hpp

@@ -1 +1,9 @@
 #pragma once
+#include <iostream>
+#include <vector>
+
+class WrongVector : public std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+std::vector<int> RiseTemperature(std::vector<int> vec);

task_04/src/heap.cpp

@@ -0,0 +1,58 @@
+#include "heap.hpp"
+
+#include <iostream>
+#include <vector>
+
+void Heap::SiftDown(int cur_node) {
+  while (2 * cur_node + 1 < vec_.size()) {
+    int left = 2 * cur_node + 1;
+    int right = 2 * cur_node + 2;
+    int next_node = left;
+    if ((right < vec_.size()) && vec_[right] < vec_[left]) next_node = right;
+    if (vec_[cur_node] <= vec_[next_node]) break;
+    std::swap(vec_[cur_node], vec_[next_node]);
+    cur_node = next_node;
+  }
+}
+
+void Heap::SiftUp(int i) {
+  while (vec_[i] < (vec_[(i - 1) / 2])) {
+    std::swap(vec_[i], vec_[(i - 1) / 2]);
+    i = (i - 1) / 2;
+  }
+}
+
+int Heap::FindMin() { return vec_[0]; }
+
+int Heap::ExtractMin() {
+  int min = vec_[0];
+  vec_[0] = vec_[vec_.size() - 1];
+  vec_.pop_back();
+  SiftDown(0);
+  return min;
+}
+
+std::vector<int> Heap::CopyHeap() { return vec_; }
+
+void Heap::Insert(int value) {
+  vec_.push_back(value);
+  SiftUp(vec_.size() - 1);
+}
+
+void Heap::BuildHeap(std::vector<int> vec) {
+  for (int i = 0; i < vec.size(); ++i) {
+    Insert(vec[i]);
+  }
+}
+
+int FindMinimum(std::vector<int> vec) {
+  Heap heap;
+  heap.BuildHeap(vec);
+  return heap.FindMin();
+}
+
+std::vector<int> HeapReady(std::vector<int> vec) {
+  Heap heap;
+  heap.BuildHeap(vec);
+  return heap.CopyHeap();
+}