Mathew_tasks

task_01/src/test.cpp

@@ -1,8 +1,22 @@
-
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include <vector>
+
+#include "utils.h"
+
+TEST(main, Simple) {
+  ASSERT_EQ(Task1(9, std::vector<int>{1, 2, 4, 5, 6, 8, 10, 12}),
+            (std::pair<int, int>{1, 8}));
+
+  ASSERT_EQ(Task1(39, std::vector<int>{1, 2, 4, 5, 6, 9, 10, 35}),
+            (std::pair<int, int>{4, 35}));
+
+  ASSERT_EQ(Task1(14, std::vector<int>{1, 2, 4, 5, 6, 8, 10, 12}),
+            (std::pair<int, int>{2, 12}));
+
+  ASSERT_EQ(Task1(1338, std::vector<int>{10, 20, 40, 50, 60, 87, 100, 1278}),
+            (std::pair<int, int>{60, 1278}));
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+  ASSERT_EQ(Task1(22, std::vector<int>{10, 10, 11, 11, 12, 15}),
+            (std::pair<int, int>{10, 12}));
+}

task_01/src/utils.cpp

@@ -0,0 +1,11 @@
+#include "utils.h"
+
+std::pair<int, int> Task1(int number, std::vector<int> array_of_numbers) {
+  int i = 0;
+  int j = array_of_numbers.size() - 1;
+  while (array_of_numbers[i] + array_of_numbers[j] != number) {
+    if (array_of_numbers[i] + array_of_numbers[j] < number) i++;
+    if (array_of_numbers[i] + array_of_numbers[j] > number) j--;
+  }
+  return {array_of_numbers[i], array_of_numbers[j]};
+}

task_01/src/utils.h

@@ -0,0 +1,3 @@
+#include <vector>
+
+std::pair<int, int> Task1(int, std::vector<int>);

task_02/src/stack.cpp

@@ -2,20 +2,48 @@
 
 #include <algorithm>
 
-void Stack::Push(int value) { data_.push(value); }
+void Stack::Push(int value) { elements_.push_back(value); }
 
 int Stack::Pop() {
-  auto result = data_.top();
-  data_.pop();
+  if (elements_.size() == 0) {
+    throw std::out_of_range("Stack is empty");
+  }
+  int result = elements_.back();
+  elements_.pop_back();
   return result;
 }
 
-void MinStack::Push(int value) { data_.push_back(value); }
+int Stack::Size() { return elements_.size(); }
+
+int Stack::Top() {
+  if (elements_.size() == 0) {
+    throw std::out_of_range("Stack is empty");
+  }
+  return elements_.back();
+}
+
+///////////////////
+
+void MinStack::Push(int value) {
+  main_stack_.Push(value);
+  if (min_stack_.Size() && min_stack_.Top() > value) {
+    min_stack_.Push(value);
+  }
+  if (min_stack_.Size() == 0) {
+    min_stack_.Push(value);
+  }
+}
 
 int MinStack::Pop() {
-  auto result = data_.back();
-  data_.pop_back();
-  return result;
+  if (main_stack_.Size() && min_stack_.Size() &&
+      main_stack_.Top() == min_stack_.Top()) {
+    min_stack_.Pop();
+  }
+  return main_stack_.Pop();
 }
 
-int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); }
+int MinStack::GetMin() { return min_stack_.Top(); }
+
+int MinStack::Top() { return main_stack_.Top(); }
+
+int MinStack::Size() { return main_stack_.Size(); }

task_02/src/stack.hpp

@@ -7,17 +7,22 @@ class Stack {
  public:
   void Push(int value);
   int Pop();
+  int Top();
+  int Size();
 
  private:
-  std::stack<int> data_;
+  std::vector<int> elements_;
 };
 
 class MinStack {
  public:
   void Push(int value);
   int Pop();
+  int Top();
   int GetMin();
+  int Size();
 
  private:
-  std::vector<int> data_;
+  Stack main_stack_;
+  Stack min_stack_;
 };

task_02/src/test.cpp

@@ -7,36 +7,26 @@
 
 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 []
+  stack.Push(1);
+  ASSERT_EQ(stack.Pop(), 1);
+  ASSERT_EQ(stack.Size(), 0);
+  EXPECT_THROW(stack.Top(), std::out_of_range);
+  EXPECT_THROW(stack.Pop(), std::out_of_range);
+  stack.Push(3);
+  stack.Push(-1);
+  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 []
+  stack.Push(1);
+  ASSERT_EQ(stack.Pop(), 1);
+  ASSERT_EQ(stack.Size(), 0);
+  EXPECT_THROW(stack.Top(), std::out_of_range);
+  EXPECT_THROW(stack.Pop(), std::out_of_range);
+  EXPECT_THROW(stack.GetMin(), std::out_of_range);
+  stack.Push(-2);
+  stack.Push(5);
+  ASSERT_EQ(stack.Top(), 5);
+  ASSERT_EQ(stack.GetMin(), -2);
 }

task_03/src/test.cpp

@@ -1,8 +1,21 @@
 
 #include <gtest/gtest.h>
 
+#include <vector>
+
 #include "topology_sort.hpp"
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+TEST(DaysUntilWarmer, MultipleCases) {
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{73, 74, 75, 71, 69, 72, 76, 73}),
+            (std::vector<int>{1, 1, 4, 2, 1, 1, 0, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{30, 40, 50, 60}),
+            (std::vector<int>{1, 1, 1, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{30, 60, 90, 70, 80, 40, 30}),
+            (std::vector<int>{1, 1, 0, 1, 0, 0, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{55, 55, 55, 55, 55}),
+            (std::vector<int>{0, 0, 0, 0, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{76, 75, 74, 73, 72, 71, 70}),
+            (std::vector<int>{0, 0, 0, 0, 0, 0, 0}));
+  ASSERT_EQ(DaysUntilWarmer(std::vector<int>{75, 72, 71, 70, 74, 76}),
+            (std::vector<int>{5, 3, 2, 1, 1, 0}));
 }

task_03/src/topology_sort.cpp

@@ -1 +1,17 @@
 #include "topology_sort.hpp"
+
+std::vector<int> DaysUntilWarmer(std::vector<int> temperature) {
+  std::vector<int> result(temperature.size(), 0);
+  std::stack<int> index;
+
+  for (int i = 0; i < temperature.size(); ++i) {
+    while (!index.empty() && temperature[index.top()] < temperature[i]) {
+      int current_index = index.top();
+      index.pop();
+      result[current_index] = i - current_index;
+    }
+    index.push(i);
+  }
+
+  return result;
+}

task_03/src/topology_sort.hpp

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

task_04/src/heap.cpp

@@ -0,0 +1,57 @@
+#include "heap.hpp"
+
+void Heap::SiftUp(int i) {
+  int half_i = i / 2;
+  while (elements[i] < elements[half_i]) {
+    std::swap(elements[i], elements[half_i]);
+    i /= 2;
+    half_i /= 2;
+  }
+}
+
+void Heap::SiftDown(int i) {
+  int leftChildIndex = 2 * i;
+  int rightChildIndex = 2 * i + 1;
+  while (leftChildIndex < n) {
+    int j = -1;
+    if (elements[leftChildIndex] < elements[i]) {
+      j = leftChildIndex;
+    }
+    if (rightChildIndex < n && elements[rightChildIndex] < elements[i] &&
+        (j == -1 || elements[leftChildIndex] > elements[rightChildIndex])) {
+      j = rightChildIndex;
+    }
+    if (j == -1)
+      break;
+    else {
+      std::swap(elements[i], elements[j]);
+      leftChildIndex = 2 * j;
+      rightChildIndex = 2 * j + 1;
+    }
+  }
+}
+
+int Heap::Size() { return elements.size(); }
+
+int Heap::GetMin() {
+  if (elements.size() == 0) {
+    throw std::out_of_range("Heap is empty");
+  }
+  return elements[0];
+}
+
+void Heap::Insert(int x) {
+  elements.push_back(x);
+  n++;
+  SiftUp(n - 1);
+}
+
+void Heap::ExtractMin() {
+  if (elements.size() == 0) {
+    throw std::out_of_range("Heap is empty");
+  }
+  elements[0] = elements[n - 1];
+  elements.erase(elements.begin() + n - 1);
+  n--;
+  SiftDown(0);
+}

task_04/src/heap.hpp

@@ -0,0 +1,16 @@
+#include <iostream>
+#include <vector>
+
+class Heap {
+ public:
+  void SiftUp(int i);
+  void SiftDown(int i);
+  void Insert(int x);
+  int GetMin();
+  void ExtractMin();
+  int Size();
+
+ private:
+  std::vector<int> elements;
+  int n = 0;
+};

task_04/src/test.cpp

@@ -1,6 +1,27 @@
 
 #include <gtest/gtest.h>
 
+#include "heap.hpp"
+
 TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+  Heap heap;
+
+  EXPECT_THROW(heap.ExtractMin(), std::out_of_range);
+  EXPECT_THROW(heap.GetMin(), std::out_of_range);
+
+  heap.Insert(-1);
+
+  heap.ExtractMin();
+  EXPECT_THROW(heap.ExtractMin(), std::out_of_range);
+
+  ASSERT_EQ(heap.Size(), 0);
+  heap.Insert(5);
+  ASSERT_EQ(heap.GetMin(), 5);
+  heap.Insert(3);
+  heap.Insert(1);
+  heap.Insert(7);
+  heap.Insert(-2);
+  heap.ExtractMin();
+  ASSERT_EQ(heap.Size(), 4);
+  ASSERT_EQ(heap.GetMin(), 1);
+}

task_05/src/sort.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <vector>
+
+std::vector<int> Merge(const std::vector<int>& left,
+                       const std::vector<int>& right) {
+  std::vector<int> result;
+  int i = 0, j = 0;
+
+  while (i < left.size() && j < right.size()) {
+    if (left[i] <= right[j]) {
+      result.push_back(left[i]);
+      ++i;
+    } else {
+      result.push_back(right[j]);
+      ++j;
+    }
+  }
+
+  while (i < left.size()) {
+    result.push_back(left[i]);
+    ++i;
+  }
+
+  while (j < right.size()) {
+    result.push_back(right[j]);
+    ++j;
+  }
+
+  return result;
+}
+
+std::vector<int> MergeSort(std::vector<int> arr) {
+  if (arr.size() <= 1) {
+    return arr;
+  }
+
+  int mid = arr.size() / 2;
+  std::vector<int> left(arr.begin(), arr.begin() + mid);
+  std::vector<int> right(arr.begin() + mid, arr.end());
+
+  return Merge(MergeSort(left), MergeSort(right));
+}