Burachek_413_homework

task_01/src/main.cpp

@@ -1,3 +1,3 @@
-#include <iostream>
+#include "two_numbers.hpp"
 
-int main() { return 0; }
+int main() {}

task_01/src/test.cpp

@@ -1,5 +1,35 @@
 #include <gtest/gtest.h>
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include "two_numbers.hpp"
+
+TEST(TwoSumTest, BasicTest) {
+  std::vector<int> 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<int> 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<int> nums = {3, 3, 4, 4};
+  auto result = FindSum::findTwoSum(nums, 7);
+  EXPECT_TRUE((result == std::pair<int, int>{3, 4}));
+}
+
+TEST(TwoSumTest, EmptyArray) {
+  std::vector<int> 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();
 }

task_01/src/two_numbers.cpp

@@ -0,0 +1,22 @@
+#include "two_numbers.hpp"
+
+#include <utility>
+
+std::pair<int, int> FindSum::findTwoSum(const std::vector<int>& 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};  // Если пара не найдена
+}

task_01/src/two_numbers.hpp

@@ -0,0 +1,8 @@
+#include <utility>
+#include <vector>
+
+class FindSum {
+ public:
+  static std::pair<int, int> findTwoSum(const std::vector<int>& nums,
+                                        int target);
+};

task_02/README.md

@@ -1,3 +1,2 @@
 # Задача на стэк
-
-В данной задаче необходимо реализовать один стэк и стэк с минимумом (нельзя использовать std::stack). Получение минимума должно работать за константное время
+В данной задаче необходимо реализовать один стэк и стэк с минимумом (нельзя использовать std::stack). Получение минимума должно работать за константное время

task_02/src/main.cpp

@@ -1,3 +1,27 @@
 #include <iostream>
 
-int main() { return 0; }
+#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.pop();
+  stack.display();
+  std::cout << "\n";
+
+  int a = stack.peek();
+  std::cout << a << "\n";
+
+  int b = stack.min();
+  std::cout << "minimal element: " << b;
+  return 0;
+}

task_02/src/stack.cpp

@@ -1,21 +1,47 @@
 #include "stack.hpp"
 
-#include <algorithm>
+#include <iostream>
+#include <stdexcept>
+#include <vector>
 
-void Stack::Push(int value) { data_.push(value); }
+void Stack::Push(int element) {
+  arr.push_back(element);
+  if (min_stack.empty() || element <= min_stack.back()) {
+    min_stack.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.");
+  }
+  if (arr.back() == min_stack.back()) {
+    min_stack.pop_back();
+  }
+  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()); }
+int Stack::min() {
+  if (arr.empty()) {
+    throw std::out_of_range("Stack is empty. Cannot find min.");
+  }
+  return min_stack.back();
+}

task_02/src/stack.hpp

@@ -1,23 +1,24 @@
 #pragma once
 
-#include <stack>
 #include <vector>
 
 class Stack {
- public:
-  void Push(int value);
-  int Pop();
-
  private:
-  std::stack<int> data_;
-};
+  std::vector<int> arr;
+  std::vector<int> min_stack;
 
-class MinStack {
  public:
-  void Push(int value);
-  int Pop();
-  int GetMin();
+  void Push(int element);
 
- private:
-  std::vector<int> data_;
+  void pop();
+
+  int peek();
+
+  void display();
+
+  int min();
+
+  bool isEmpty() const { return arr.empty(); }
+
+  size_t size() const { return arr.size(); }
 };

task_02/src/test.cpp

@@ -1,42 +1,69 @@
-
 #include <gtest/gtest.h>
 
-#include <stack>
-
 #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);
 }

task_03/src/main.cpp

@@ -1,3 +1,13 @@
 #include <iostream>
+#include <vector>
 
-int main() { return 0; }
+#include "topology_sort.hpp"
+
+int main() {
+  std::vector<int> temps = {73, 74, 75, 71, 69, 72, 76, 73};
+  std::vector<int> result = TemperatureSorting(temps);
+
+  for (int i{0}; i < result.size(); ++i) {
+    std::cout << result[i] << " ";
+  }
+}

task_03/src/test.cpp

@@ -1,8 +1,35 @@
-
 #include <gtest/gtest.h>
 
+#include <vector>
+
 #include "topology_sort.hpp"
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+TEST(TopologyFuncTest, OrdinaryWeek) {
+  std::vector<int> temperatures = {73, 74, 75, 71, 69, 72, 76, 73};
+  std::vector<int> expected = {1, 1, 4, 2, 1, 1, 0, 0};
+  ASSERT_EQ(TemperatureSorting(temperatures), expected);
+}
+
+TEST(TopologyFuncTest, EmptyInput) {
+  std::vector<int> temperatures = {};
+  std::vector<int> expected = {};
+  ASSERT_EQ(TemperatureSorting(temperatures), expected);
+}
+
+TEST(TopologyFuncTest, SingleDay) {
+  std::vector<int> temperatures = {30};
+  std::vector<int> expected = {0};
+  ASSERT_EQ(TemperatureSorting(temperatures), expected);
+}
+
+TEST(TopologyFuncTest, IncreasingTemperatures) {
+  std::vector<int> temperatures = {10, 20, 30, 40};
+  std::vector<int> expected = {1, 1, 1, 0};
+  ASSERT_EQ(TemperatureSorting(temperatures), expected);
+}
+
+TEST(TopologyFuncTest, MixedTemperatures) {
+  std::vector<int> temperatures = {73, 74, 75, 71, 69, 72, 76, 73};
+  std::vector<int> expected = {1, 1, 4, 2, 1, 1, 0, 0};
+  ASSERT_EQ(TemperatureSorting(temperatures), expected);
 }

task_03/src/topology_sort.cpp

@@ -1 +1,19 @@
 #include "topology_sort.hpp"
+
+#include <stack>
+
+std::vector<int> TemperatureSorting(const std::vector<int>& temperatures) {
+  std::vector<int> result(temperatures.size(), 0);
+  std::stack<std::pair<int, int>> 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;
+}