homework 2

lib/src/util.hpp

@@ -0,0 +1,29 @@
+#include <functional>
+#include <random>
+#include <vector>
+
+template <typename T>
+static std::size_t Partition(std::vector<T>& data, std::size_t left,
+                             std::size_t right) {
+  std::function<std::size_t(std::size_t, std::size_t)> RandomPivotIndex =
+      [&](std::size_t left, std::size_t right) {
+        std::random_device rd;
+        std::mt19937 gen(rd());
+        std::uniform_int_distribution<> dis(left, right);
+        return dis(gen);
+      };
+
+  std::size_t pivot_index = RandomPivotIndex(left, right);
+  std::swap(data[pivot_index], data[right]);
+  std::size_t index = left;
+
+  for (std::size_t i = left; i < right; i++) {
+    if (data[i] < data[right]) {
+      std::swap(data[i], data[index]);
+      index++;
+    }
+  }
+
+  std::swap(data[right], data[index]);
+  return index;
+}

task_02/src/list_stack.cpp

@@ -0,0 +1 @@
+#include "list_stacks.hpp"

task_02/src/list_stacks.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <list>
+#include <stdexcept>
+
+template <typename T>
+class Stack final {
+ public:
+  constexpr Stack() noexcept {}
+  Stack(const Stack& other) : list_(other.list_) {}
+  Stack(Stack&& other) : list_(std::move(other.list_)) { other.list_.clear(); }
+  Stack(const std::initializer_list<T>& init_list) : list_(init_list) {}
+
+  ~Stack() = default;
+
+  void Push(const T& value) { list_.push_back(value); }
+  void Pop() {
+    if (Empty()) throw std::underflow_error("Stack is empty!");
+    list_.pop_back();
+  }
+
+  T& Top() {
+    if (Empty()) throw std::underflow_error("Stack is empty!");
+    return list_.back();
+  }
+  bool Empty() { return list_.empty(); }
+  std::size_t Size() { return list_.size(); }
+
+ private:
+  std::list<T> list_;
+};
+
+template <typename T>
+class StackMin final {
+ public:
+  constexpr StackMin() noexcept {}
+  StackMin(const StackMin& other) : list_(other.list_) {}
+  StackMin(StackMin&& other) : list_(other.list_) { other.list_.clear(); }
+  StackMin(const std::initializer_list<T>& init_list_) : list_(init_list_) {}
+
+  ~StackMin() = default;
+
+  void Push(const T& value) {
+    if (min_stack.Empty() || min_stack.Top() > value) min_stack.Push(value);
+    list_.push_back(value);
+  }
+  void Pop() {
+    if (Empty()) throw std::underflow_error("Stack is empty!");
+    if (min_stack.Top() == list_.back()) min_stack.Pop();
+    list_.pop_back();
+  }
+
+  T& Top() {
+    if (Empty()) throw std::underflow_error("Stack is empty!");
+    return list_.back();
+  }
+  bool Empty() { return list_.empty(); }
+  std::size_t Size() { return list_.size(); }
+
+  T& Min() { return min_stack.Top(); }
+
+ private:
+  std::list<T> list_;
+  Stack<T> min_stack;
+};

task_02/src/test.cpp

@@ -2,41 +2,62 @@
 #include <gtest/gtest.h>
 
 #include <stack>
+#include <stdexcept>
 
-#include "stack.hpp"
+#include "list_stacks.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, test1) {
+  Stack<int> stack;
+  stack.Push(1);
+  stack.Pop();
+  EXPECT_THROW(stack.Pop(), std::underflow_error);
+  stack.Push(1);
+  stack.Push(2);
+  ASSERT_EQ(stack.Top(), 2);
+  ASSERT_EQ(stack.Top(), 2);
+  stack.Push(1000);
+  stack.Push(21412);
+  stack.Pop();
+  stack.Pop();
+  stack.Pop();
+  stack.Pop();
+  EXPECT_THROW(stack.Pop(), std::underflow_error);
+  EXPECT_THROW(stack.Top(), std::underflow_error);
+  stack.Push(1);
+  stack.Push(3);
+  ASSERT_EQ(stack.Top(), 3);
+  stack.Pop();
+  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 []
+TEST(MinStackTest, test2) {
+  StackMin<int> stack;
+  stack.Push(1);
+  stack.Pop();
+  EXPECT_THROW(stack.Pop(), std::underflow_error);
+  stack.Push(1);
+  stack.Push(2);
+  ASSERT_EQ(stack.Top(), 2);
+  ASSERT_EQ(stack.Top(), 2);
+  stack.Push(1000);
+  stack.Push(21412);
+  ASSERT_EQ(stack.Min(), 1);
+  stack.Pop();
+  stack.Pop();
+  stack.Pop();
+  stack.Pop();
+  EXPECT_THROW(stack.Min(), std::underflow_error);
+  EXPECT_THROW(stack.Pop(), std::underflow_error);
+  EXPECT_THROW(stack.Top(), std::underflow_error);
+  stack.Push(1);
+  stack.Push(3);
+  ASSERT_EQ(stack.Top(), 3);
+  stack.Pop();
+  ASSERT_EQ(stack.Top(), 1);
+  stack.Push(-10);
+  stack.Push(-102410);
+  stack.Push(10432140);
+  stack.Push(0);
+  stack.Push(-1010);
+  ASSERT_EQ(stack.Min(), -102410);
 }

task_03/src/temperature.cpp

@@ -0,0 +1,14 @@
+#include "temperature.hpp"
+
+std::vector<int> TemperatureCounter(std::vector<double> temps) {
+  std::stack<Day> days;
+  std::vector<int> result(temps.size(), 0);
+  for (int i = 0; i < temps.size(); i++) {
+    while (!days.empty() && days.top().value < temps[i]) {
+      result[days.top().index] = i - days.top().index;
+      days.pop();
+    }
+    days.push(Day(i, temps[i]));
+  }
+  return result;
+}

task_03/src/temperature.hpp

@@ -0,0 +1,11 @@
+#pragma once
+#include <stack>
+#include <vector>
+
+struct Day {
+  int index;
+  double value;
+  Day(int index, double value) : index(index), value(value) {}
+};
+
+std::vector<int> TemperatureCounter(std::vector<double> temps);

task_03/src/test.cpp

@@ -1,8 +1,18 @@
 
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include "temperature.hpp"
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+TEST(TemperatureCnt, Simple) {
+  ASSERT_EQ(TemperatureCounter(std::vector<double>{5.8, 7.2, 4.1, 5.999}),
+            (std::vector<int>{1, 0, 1, 0}));
+  ASSERT_EQ(
+      TemperatureCounter(std::vector<double>{5.99, 12, 4, 9.1, 5.15, 4, 2}),
+      (std::vector<int>{1, 0, 1, 0, 0, 0, 0}));
+  ASSERT_EQ(
+      TemperatureCounter(std::vector<double>{2, 6, 17.512512, 7, 3, 4.412151}),
+      (std::vector<int>{1, 1, 0, 0, 1, 0}));
+  ASSERT_EQ(TemperatureCounter(std::vector<double>{}), std::vector<int>{});
+  ASSERT_EQ(TemperatureCounter(std::vector<double>{2, 6, 5, 4, 3, 7}),
+            (std::vector<int>{1, 4, 3, 2, 1, 0}));
+}