Homework all done

task_01/src/task_01.cpp

@@ -0,0 +1,17 @@
+#include "task_01.hpp"
+
+std::vector<int> FindTwoNums(int target, const std::vector<int>& arr) {
+  int left = 0;
+  int right = arr.size() - 1;
+  while (left < right) {
+    int sum = arr[left] + arr[right];
+    if (sum == target) {
+      return {arr[left], arr[right]};
+    } else if (sum < target) {
+      ++left;
+    } else {
+      --right;
+    }
+  }
+  return {};
+};

task_01/src/task_01.hpp

@@ -0,0 +1,4 @@
+#pragma once
+#include <vector>
+
+std::vector<int> FindTwoNums(int target, const std::vector<int>& arr);

task_01/src/test.cpp

@@ -1,5 +1,39 @@
 #include <gtest/gtest.h>
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include <algorithm>
+#include <stdexcept>
+#include <vector>
+
+#include "task_01.hpp"
+
+TEST(FindTwoNumsTest, BasicMatch) {
+  std::vector<int> arr = {1, 2, 3, 4, 6};
+  auto result = FindTwoNums(7, arr);
+  std::sort(result.begin(), result.end());
+  ASSERT_EQ(result, std::vector<int>({1, 6}));
+}
+
+TEST(FindTwoNumsTest, MultiplePairsPossible) {
+  std::vector<int> arr = {1, 2, 3, 4, 4, 5};
+  auto result = FindTwoNums(8, arr);
+  ASSERT_EQ(result[0] + result[1], 8);
+}
+
+TEST(FindTwoNumsTest, NoSolution) {
+  std::vector<int> arr = {1, 2, 3};
+  ASSERT_EQ(FindTwoNums(10, arr), std::vector<int>{});
+}
+
+TEST(FindTwoNumsTest, NegativeNumbers) {
+  std::vector<int> arr = {-5, -2, 0, 3, 7, 9};
+  auto result = FindTwoNums(4, arr);
+  std::sort(result.begin(), result.end());
+  ASSERT_EQ(result, std::vector<int>({-5, 9}));
+}
+
+TEST(FindTwoNumsTest, SameElementTwice) {
+  std::vector<int> arr = {1, 2, 4, 4, 5, 6};
+  auto result = FindTwoNums(8, arr);
+  std::sort(result.begin(), result.end());
+  ASSERT_EQ(result, std::vector<int>({2, 6}));
 }

task_02/src/stack.hpp

@@ -1,23 +1,117 @@
 #pragma once
 
-#include <stack>
+#include <stdexcept>
 #include <vector>
 
+template <typename T>
 class Stack {
  public:
-  void Push(int value);
-  int Pop();
+  Stack(){};
+  Stack(std::vector<T> vec) {
+    for (auto val : vec) {
+      push(val);
+    }
+  }
+  void Push(T value) { data_.push_back(value); }
+  T Pop() {
+    if (data_.empty()) {
+      throw std::runtime_error("Stack is empty.");
+    }
+    T result = data_.back();
+    data_.pop_back();
+    return result;
+  }
+
+  int Size() { return data_.size(); }
+
+  bool IsEmpty() { return data_.empty(); }
 
  private:
-  std::stack<int> data_;
+  std::vector<T> data_;
 };
 
+template <typename T>
 class MinStack {
  public:
-  void Push(int value);
-  int Pop();
-  int GetMin();
+  MinStack(){};
+  MinStack(std::vector<T> vec) {
+    for (auto val : vec) {
+      push(val);
+    }
+  }
+  void Push(T value) {
+    data_.push_back(value);
+    if (data_mins_.size() == 0 || value <= data_mins_.back()) {
+      data_mins_.push_back(value);
+    } else {
+      data_mins_.push_back(data_mins_.back());
+    }
+  }
+  T Pop() {
+    if (data_.empty()) {
+      throw std::runtime_error("Stack is empty.");
+    }
+    T result = data_.back();
+    data_.pop_back();
+    data_mins_.pop_back();
+    return result;
+  }
+
+  T GetMin() {
+    if (data_mins_.size() == 0) {
+      throw std::runtime_error("Пустой стек - нет минимума");
+    }
+    return data_mins_.back();
+  }
+
+  int Size() { return data_.size(); }
+
+  bool IsEmpty() { return data_.empty(); }
 
  private:
-  std::vector<int> data_;
+  std::vector<T> data_;
+  std::vector<T> data_mins_;
 };
+
+template <typename T>
+class MaxStack {
+ public:
+  MaxStack(){};
+  MaxStack(std::vector<T> vec) {
+    for (auto val : vec) {
+      push(val);
+    }
+  }
+  void Push(T value) {
+    data_.push_back(value);
+    if (data_maxs.size() == 0 || value >= data_maxs.back()) {
+      data_maxs.push_back(value);
+    } else {
+      data_maxs.push_back(data_maxs.back());
+    }
+  }
+  T Pop() {
+    if (data_.empty()) {
+      throw std::runtime_error("Stack is empty.");
+    }
+    T result = data_.back();
+    data_.pop_back();
+    data_maxs.pop_back();
+    return result;
+  }
+
+  T GetMax() {
+    if (data_maxs.size() == 0) {
+      throw std::runtime_error("Пустой стек - нет минимума");
+    }
+    return data_maxs.back();
+  }
+
+  int Size() { return data_.size(); }
+
+  bool IsEmpty() { return data_.empty(); }
+
+ private:
+  std::vector<T> data_;
+  std::vector<T> data_maxs;
+};

task_02/src/test.cpp

@@ -6,7 +6,7 @@
 #include "stack.hpp"
 
 TEST(StackTest, Simple) {
-  Stack stack;
+  Stack<int> stack;
   stack.Push(1);              // Stack [1]
   ASSERT_EQ(stack.Pop(), 1);  // Stack []
   stack.Push(1);              // Stack [1]
@@ -22,7 +22,7 @@ TEST(StackTest, Simple) {
 }
 
 TEST(MinStackTest, Simple) {
-  MinStack stack;
+  MinStack<int> stack;
   stack.Push(1);  // Stack [1]
   ASSERT_EQ(stack.GetMin(), 1);
   ASSERT_EQ(stack.Pop(), 1);  // Stack []
@@ -39,4 +39,111 @@ TEST(MinStackTest, Simple) {
   ASSERT_EQ(stack.GetMin(), 1);
   ASSERT_EQ(stack.Pop(), 3);  // Stack [1]
   ASSERT_EQ(stack.Pop(), 1);  // Stack []
+}
+
+// ------------------------- Stack ----------------------------
+
+TEST(StackTest, BasicPushPop) {
+  Stack<int> s;
+  s.Push(1);
+  s.Push(2);
+  EXPECT_EQ(s.Pop(), 2);
+  EXPECT_EQ(s.Pop(), 1);
+}
+
+TEST(StackTest, IsEmptyInitially) {
+  Stack<int> s;
+  EXPECT_TRUE(s.IsEmpty());
+  EXPECT_EQ(s.Size(), 0);
+}
+
+TEST(StackTest, SizeIncreasesAndDecreases) {
+  Stack<int> s;
+  s.Push(1);
+  s.Push(2);
+  EXPECT_EQ(s.Size(), 2);
+  s.Pop();
+  EXPECT_EQ(s.Size(), 1);
+}
+
+TEST(StackTest, PopFromEmptyStackThrows) {
+  Stack<int> s;
+  EXPECT_THROW(s.Pop(), std::runtime_error);
+}
+
+// ------------------------- MinStack ----------------------------
+
+TEST(MinStackTest, GetMinBasic) {
+  MinStack<int> s;
+  s.Push(5);
+  s.Push(3);
+  s.Push(7);
+  EXPECT_EQ(s.GetMin(), 3);
+  s.Pop();  // pop 7
+  EXPECT_EQ(s.GetMin(), 3);
+  s.Pop();  // pop 3
+  EXPECT_EQ(s.GetMin(), 5);
+}
+
+TEST(MinStackTest, IsEmptyInitially) {
+  MinStack<int> s;
+  EXPECT_TRUE(s.IsEmpty());
+  EXPECT_EQ(s.Size(), 0);
+}
+
+TEST(MinStackTest, SizeWorksCorrectly) {
+  MinStack<int> s;
+  s.Push(10);
+  s.Push(20);
+  EXPECT_EQ(s.Size(), 2);
+  s.Pop();
+  EXPECT_EQ(s.Size(), 1);
+}
+
+TEST(MinStackTest, PopFromEmptyStackThrows) {
+  MinStack<int> s;
+  EXPECT_THROW(s.Pop(), std::runtime_error);
+}
+
+TEST(MinStackTest, GetMinFromEmptyThrows) {
+  MinStack<int> s;
+  EXPECT_THROW(s.GetMin(), std::runtime_error);
+}
+
+// ------------------------- MaxStack ----------------------------
+
+TEST(MaxStackTest, GetMaxBasic) {
+  MaxStack<int> s;
+  s.Push(1);
+  s.Push(3);
+  s.Push(2);
+  EXPECT_EQ(s.GetMax(), 3);
+  s.Pop();  // pop 2
+  EXPECT_EQ(s.GetMax(), 3);
+  s.Pop();  // pop 3
+  EXPECT_EQ(s.GetMax(), 1);
+}
+
+TEST(MaxStackTest, IsEmptyInitially) {
+  MaxStack<int> s;
+  EXPECT_TRUE(s.IsEmpty());
+}
+
+TEST(MaxStackTest, PopFromEmptyThrows) {
+  MaxStack<int> s;
+  EXPECT_THROW(s.Pop(), std::runtime_error);
+}
+
+TEST(MaxStackTest, GetMaxFromEmptyThrows) {
+  MaxStack<int> s;
+  EXPECT_THROW(s.GetMax(), std::runtime_error);
+}
+
+TEST(MaxStackTest, SizeWorksCorrectly) {
+  MaxStack<int> s;
+  EXPECT_EQ(s.Size(), 0);
+  s.Push(42);
+  EXPECT_EQ(s.Size(), 1);
+  s.Pop();
+  EXPECT_EQ(s.Size(), 0);
 }

task_03/src/days_untill_warmer.cpp

@@ -0,0 +1,23 @@
+#include "days_untill_warmer.hpp"
+
+#include <stdexcept>
+
+std::vector<int> DaysUntilWarmer(const std::vector<int>& temperatures) {
+  int n = temperatures.size();
+  if (n == 0) {
+    throw std::runtime_error("Empty array");
+  }
+  std::vector<int> result(n, 0);
+  std::stack<int> st;
+
+  for (int i = 0; i < n; ++i) {
+    while (!st.empty() && temperatures[i] > temperatures[st.top()]) {
+      int prev_index = st.top();
+      st.pop();
+      result[prev_index] = i - prev_index;
+    }
+    st.push(i);
+  }
+
+  return result;
+}

task_03/src/days_untill_warmer.hpp

@@ -0,0 +1,5 @@
+#pragma once
+#include <stack>
+#include <vector>
+
+std::vector<int> DaysUntilWarmer(const std::vector<int>& temperatures);