task 2-4

Author: dalnoboy75

task_01/src/test.cpp

@@ -1,7 +1,7 @@
 
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include "utils.hpp"
 
 TEST(TopologySort, Simple) {
   ASSERT_EQ(1, 1);  // Stack []

task_01/src/topology_sort.cpp

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

task_01/src/utils.cpp

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

task_01/src/topology_sort.hpp renamed to task_01/src/utils.hpp

@@ -2,20 +2,36 @@
 
 #include <algorithm>
 
-void Stack::Push(int value) { data_.push(value); }
+void Stack::Push(int value) {
+  Node* t = new Node();
+  t->value_ = value;
+  if (this->top_ == nullptr) {
+    this->top_ = t;
+  } else {
+    t->prev_ = this->top_;
+    this->top_ = t;
+  }
+}
 
 int Stack::Pop() {
-  auto result = data_.top();
-  data_.pop();
-  return result;
+  Node* t = this->top_;
+  this->top_ = this->top_->prev_;
+  return t->value_;
 }
 
-void MinStack::Push(int value) { data_.push_back(value); }
+Node* Stack::Top() { return this->top_; }
+void MinStack::Push(int value) {
+  if (s_.Top() == nullptr) {
+    m_.Push(value);
+  } else {
+    m_.Push(std::min(value, s_.Top()->value_));
+  }
+  s_.Push(value);
+}
 
 int MinStack::Pop() {
-  auto result = data_.back();
-  data_.pop_back();
-  return result;
+  int t = m_.Pop();
+  return s_.Pop();
 }
 
-int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); }
+int MinStack::GetMin() { return m_.Top()->value_; }

task_02/src/main.cpp

@@ -1,23 +1,23 @@
 #pragma once
 
-#include <stack>
-#include <vector>
+struct Node {
+  int value_ = 0;
+  Node* prev_ = nullptr;
+};
 
-class Stack {
- public:
+struct Stack {
   void Push(int value);
   int Pop();
+  Node* Top();
 
- private:
-  std::stack<int> data_;
+  Node* top_ = nullptr;
 };
 
-class MinStack {
- public:
+struct MinStack {
   void Push(int value);
   int Pop();
   int GetMin();
 
- private:
-  std::vector<int> data_;
+  Stack s_;
+  Stack m_;
 };

task_02/src/stack.cpp

@@ -0,0 +1,23 @@
+#include "temp_up_days.hpp"
+
+#include <stack>
+
+std::vector<int> TempUpDayCounter(std::vector<int> temps) {
+  std::stack<Day> days;
+  std::vector<int> result(temps.size(), 0);
+  for (int i = 0; i < temps.size(); i++) {
+    Day d;
+    d.index_ = i;
+    d.temp_ = temps[i];
+    while (!days.empty()) {
+      if (days.top().temp_ < d.temp_) {
+        result[days.top().index_] = d.index_ - days.top().index_;
+        days.pop();
+      } else {
+        break;
+      }
+    }
+    days.push(d);
+  }
+  return result;
+}

task_02/src/stack.hpp

@@ -0,0 +1,9 @@
+#pragma once
+#include <vector>
+
+struct Day {
+  int index_;
+  int temp_;
+};
+
+std::vector<int> TempUpDayCounter(std::vector<int> temps);

task_03/src/temp_up_days.cpp

@@ -1,8 +1,13 @@
 
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include "temp_up_days.hpp"
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+TEST(TempUpDays, Simple) {
+  ASSERT_EQ(TempUpDayCounter(std::vector<int>{5, 7, 4, 5}),
+            (std::vector<int>{1, 0, 1, 0}));
+  ASSERT_EQ(TempUpDayCounter(std::vector<int>{5, 12, 4, 9, 5, 4, 2}),
+            (std::vector<int>{1, 0, 1, 0, 0, 0, 0}));
+  ASSERT_EQ(TempUpDayCounter(std::vector<int>{2, 6, 17, 7, 3, 4}),
+            (std::vector<int>{1, 1, 0, 0, 1, 0}));
 }

task_03/src/temp_up_days.hpp

@@ -0,0 +1,44 @@
+#include "heap.hpp"
+
+#include <vector>
+
+void Heap::SiftUp(int index) {
+  while (heap_[index] < heap_[(index - 1) / 2]) {
+    std::swap(heap_[index], heap_[(index - 1) / 2]);
+    index = (index - 1) / 2;
+  }
+}
+
+void Heap::SiftDown(int index) {
+  while (2 * index + 1 < heap_.size()) {
+    int l = 2 * index + 1, r = 2 * index + 2;
+    int j = l;
+    if (r < heap_.size() && heap_[r] < heap_[l]) {
+      j = r;
+    }
+    if (heap_[index] < heap_[j]) {
+      break;
+    }
+    std::swap(heap_[index], heap_[j]);
+    index = j;
+  }
+}
+
+int Heap::Min() { return heap_[0]; }
+
+void Heap::Insert(int value) {
+  heap_.push_back(value);
+  this->SiftUp(heap_.size() - 1);
+}
+
+void Heap::Build(std::vector<int> data) {
+  for (auto x : data) {
+    this->Insert(x);
+  }
+}
+
+int FindMin(std::vector<int> data) {
+  Heap heap;
+  heap.Build(data);
+  return heap.Min();
+}

task_03/src/test.cpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <vector>
+struct Heap {
+  void SiftUp(int index);
+  void SiftDown(int index);
+  int Min();
+  void Insert(int value);
+  void Build(std::vector<int> data);
+
+  std::vector<int> heap_;
+};
+
+int FindMin(std::vector<int> data);

task_03/src/topology_sort.cpp

@@ -1,6 +1,9 @@
-
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include "heap.hpp"
+
+TEST(HeapMin, Simple) {
+  ASSERT_EQ(FindMin(std::vector<int>{4, 5, 16, 3, 6}), 3);
+  ASSERT_EQ(FindMin(std::vector<int>{29, 25, 10, 13, 14, 23, 4, 6}), 4);
+  ASSERT_EQ(FindMin(std::vector<int>{29, 17, 16, 27, 6, 11}), 6);
 }