tasks1-9

task_01/src/find_numbers.cpp

@@ -0,0 +1,26 @@
+#include "find_numbers.hpp"
+
+std::vector<int> FindNumberOfamount(std::vector<int> vec, int summa) {
+  if (vec.empty()) {
+    throw std::runtime_error("Vector is empty");
+  }
+  int start_iterator{0};
+  int end_iterator{vec.size() - 1};
+  std::vector<int> result;
+  while (true) {
+    if (vec[start_iterator] + vec[end_iterator] == summa) {
+      result.push_back(vec[start_iterator]);
+      result.push_back(vec[end_iterator]);
+      return result;
+    }
+    if (vec[start_iterator] + vec[end_iterator] < summa) {
+      start_iterator++;
+    }
+    if (vec[start_iterator] + vec[end_iterator] > summa) {
+      end_iterator--;
+    }
+    if (start_iterator == end_iterator) {
+      throw std::runtime_error("Sum not found");
+    }
+  }
+}

task_01/src/find_numbers.hpp

@@ -0,0 +1,9 @@
+#ifndef FIND_NUMBERS
+#define FIND_NUMBERS
+
+#include <stdexcept>
+#include <vector>
+
+std::vector<int> FindNumberOfamount(std::vector<int> vec, int summa);
+
+#endif  // FIND_NUMBERS

task_01/src/test.cpp

@@ -1,5 +1,30 @@
 #include <gtest/gtest.h>
+#include <vector>
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+#include "find_numbers.hpp"
+
+TEST(FindNumberOfamountTest, SimpleCase) {
+    std::vector<int> vec = {1, 2, 3, 4, 5};
+    int summa = 8;
+    std::vector<int> expected = {3, 5};
+    ASSERT_EQ(FindNumberOfamount(vec, summa), expected);
+}
+
+TEST(FindNumberOfamountTest, FirstAndLastElements) {
+    std::vector<int> vec = {1, 2, 3, 4, 5};
+    int summa = 6;
+    std::vector<int> expected = {1, 5};
+    ASSERT_EQ(FindNumberOfamount(vec, summa), expected);
+}
+
+TEST(FindNumberOfamountTest, NoPairFound) {
+    std::vector<int> vec = {1, 2, 3, 4, 5};
+    int summa = 10;
+    EXPECT_THROW(FindNumberOfamount(vec, summa), std::runtime_error);
+}
+
+TEST(FindNumberOfamountTest, EmptyVector) {
+    std::vector<int> vec;
+    int summa = 5;
+    EXPECT_THROW(FindNumberOfamount(vec, summa), std::runtime_error);
+}

task_02/src/stack.cpp

@@ -1,21 +0,0 @@
-#include "stack.hpp"
-
-#include <algorithm>
-
-void Stack::Push(int value) { data_.push(value); }
-
-int Stack::Pop() {
-  auto result = data_.top();
-  data_.pop();
-  return result;
-}
-
-void MinStack::Push(int value) { data_.push_back(value); }
-
-int MinStack::Pop() {
-  auto result = data_.back();
-  data_.pop_back();
-  return result;
-}
-
-int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); }

task_02/src/stack.hpp

@@ -1,23 +1,73 @@
-#pragma once
+#ifndef STACK_HPP
+#define STACK_HPP
 
-#include <stack>
+#include <stdexcept>
 #include <vector>
 
+template <typename T>
 class Stack {
+ private:
+  std::vector<T> data;
+
  public:
-  void Push(int value);
-  int Pop();
+  void Push(T value) { data.push_back(value); }
 
- private:
-  std::stack<int> data_;
+  void Pop() {
+    if (IsEmpty()) {
+      throw std::runtime_error("Stack is empty");
+    }
+    data.pop_back();
+  }
+
+  T Top() {
+    if (IsEmpty()) {
+      throw std::runtime_error("Stack is empty");
+    }
+    return data.back();
+  }
+
+  bool IsEmpty() { return data.empty(); }
 };
 
+template <typename T>
 class MinStack {
+ private:
+  std::vector<T> stack;
+  std::vector<T> minStack;
+
  public:
-  void Push(int value);
-  int Pop();
-  int GetMin();
+  void Push(T value) {
+    stack.push_back(value);
+    if (minStack.empty() || value <= minStack.back()) {
+      minStack.push_back(value);
+    }
+  }
 
- private:
-  std::vector<int> data_;
+  void Pop() {
+    if (stack.empty()) {
+      throw std::runtime_error("Stack is empty");
+    }
+    if (stack.back() == minStack.back()) {
+      minStack.pop_back();
+    }
+    stack.pop_back();
+  }
+
+  T Top() {
+    if (stack.empty()) {
+      throw std::runtime_error("Stack is empty");
+    }
+    return stack.back();
+  }
+
+  T FindMin() {
+    if (minStack.empty()) {
+      throw std::runtime_error("Stack is empty");
+    }
+    return minStack.back();
+  }
+
+  bool IsEmpty() { return stack.empty(); }
 };
+
+#endif  // STACK_HPP

task_02/src/test.cpp

@@ -1,42 +1,62 @@
-
 #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, BasicOperations) {
+  Stack<int> s;
+  s.Push(1);
+  s.Push(2);
+  ASSERT_EQ(s.Top(), 2);
+  s.Pop();
+  ASSERT_EQ(s.Top(), 1);
+  s.Pop();
+  ASSERT_TRUE(s.IsEmpty());
 }
 
-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, EmptyStack) {
+  MinStack<int> s;
+  EXPECT_TRUE(s.IsEmpty());
+  EXPECT_THROW(s.Top(), std::runtime_error);
+  EXPECT_THROW(s.Pop(), std::runtime_error);
+}
+
+TEST(MinStackTest, BasicOperations) {
+  MinStack<int> s;
+  s.Push(3);
+  s.Push(5);
+  ASSERT_EQ(s.FindMin(), 3);
+  s.Push(2);
+  ASSERT_EQ(s.FindMin(), 2);
+  s.Pop();
+  ASSERT_EQ(s.FindMin(), 3);
+}
+
+TEST(MinStackTest, DuplicateMins) {
+  MinStack<int> s;
+  s.Push(2);
+  s.Push(2);
+  ASSERT_EQ(s.FindMin(), 2);
+  s.Pop();
+  ASSERT_EQ(s.FindMin(), 2);
+  s.Pop();
+  EXPECT_THROW(s.FindMin(), std::runtime_error);
+}
+
+TEST(MinStackTest, ComplexSequence) {
+  MinStack<int> s;
+  s.Push(5);
+  s.Push(3);
+  s.Push(7);
+  s.Push(1);
+  s.Push(2);
+
+  ASSERT_EQ(s.FindMin(), 1);
+  s.Pop();
+  ASSERT_EQ(s.FindMin(), 1);
+  s.Pop();
+  ASSERT_EQ(s.FindMin(), 3);
+  s.Pop();
+  ASSERT_EQ(s.FindMin(), 3);
+  s.Pop();
+  ASSERT_EQ(s.FindMin(), 5);
 }

task_03/src/find_days_to_warm.cpp

@@ -0,0 +1,37 @@
+#include "find_days_to_warm.hpp"
+
+#include <algorithm>
+#include <stack>
+#include <utility>
+#include <vector>
+
+std::vector<int> DaysToWarming(std::vector<int> temperature_list) {
+  if (temperature_list.size() == 0) {
+    return std::vector<int>{};
+  }
+
+  std::vector<int> days_to_warming;
+  std::stack<std::pair<int, int>> decreasing_stack;
+
+  int last_index{temperature_list.size() - 1};
+
+  decreasing_stack.push(
+      std::pair<int, int>(temperature_list[last_index], last_index));
+  for (int i{last_index}; i >= 0; i--) {
+    while (!decreasing_stack.empty() &&
+           temperature_list[i] >= decreasing_stack.top().first) {
+      decreasing_stack.pop();
+    }
+    if (decreasing_stack.empty()) {
+      days_to_warming.push_back(0);
+      decreasing_stack.push(std::pair<int, int>(temperature_list[i], i));
+    } else {
+      int previous_index = decreasing_stack.top().second;
+      decreasing_stack.push(std::pair<int, int>(temperature_list[i], i));
+      int current_index = decreasing_stack.top().second;
+      days_to_warming.push_back(previous_index - current_index);
+    }
+  }
+  std::reverse(days_to_warming.begin(), days_to_warming.end());
+  return days_to_warming;
+}

task_03/src/find_days_to_warm.hpp

@@ -0,0 +1,8 @@
+#ifndef TASK3_HPP
+#define TASK3_HPP
+
+#include <vector>
+
+std::vector<int> DaysToWarming(std::vector<int> temperature_list);
+
+#endif // TASK3_HPP

task_03/src/test.cpp

@@ -1,8 +1,41 @@
-
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include <vector>
+
+#include "find_days_to_warm.hpp"
+
+TEST(DaysToWarmingTest, NormalCase) {
+  std::vector<int> input = {73, 74, 75, 71, 69, 72, 76, 73};
+  std::vector<int> expected = {1, 1, 4, 2, 1, 1, 0, 0};
+  EXPECT_EQ(DaysToWarming(input), expected);
+}
+
+TEST(DaysToWarmingTest, NeverWarmer) {
+  std::vector<int> input = {5, 4, 3, 2, 1};
+  std::vector<int> expected = {0, 0, 0, 0, 0};
+  EXPECT_EQ(DaysToWarming(input), expected);
+}
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+TEST(DaysToWarmingTest, AlwaysWarmer) {
+  std::vector<int> input = {1, 2, 3, 4, 5};
+  std::vector<int> expected = {1, 1, 1, 1, 0};
+  EXPECT_EQ(DaysToWarming(input), expected);
 }
+
+TEST(DaysToWarmingTest, SameTemperatures) {
+  std::vector<int> input = {10, 10, 10, 10};
+  std::vector<int> expected = {0, 0, 0, 0};
+  EXPECT_EQ(DaysToWarming(input), expected);
+}
+
+TEST(DaysToWarmingTest, SingleDay) {
+  std::vector<int> input = {15};
+  std::vector<int> expected = {0};
+  EXPECT_EQ(DaysToWarming(input), expected);
+}
+
+TEST(DaysToWarmingTest, EmptyInput) {
+  std::vector<int> input = {};
+  std::vector<int> expected = {};
+  EXPECT_EQ(DaysToWarming(input), expected);
+}