Homework 2

sandbox/template/src/main.cpp

@@ -1,3 +1,6 @@
 #include <iostream>
 
-int main() { return 0; }
+int main() {
+  std::cout << "Hello world!";
+  return 0;
+}

task_01/README.md

@@ -1,3 +1,3 @@
 # Задача 1
 
-Дано целое число и отсортированый массив целых чисел, нужно найти 2 числа из массива которые в сумме дадут заданное число
+Дано целое число и массив целых чисел, нужно найти 2 числа из массива которые в сумме дадут заданное число

task_01/src/main.cpp

@@ -1,3 +1,22 @@
 #include <iostream>
 
-int main() { return 0; }
+#include "solution.h"
+
+int main() {
+  int sum, arr_size, t;
+  std::vector<int> input_vector;
+  std::unordered_map<int, int> indices_map;  // keeps array numbers as keys and
+                                             // indices as values behind keys
+
+  std::cin >> sum >> arr_size;
+
+  for (int i = 0; i < arr_size; i++) {
+    std::cin >> t;
+    input_vector.push_back(t);
+  }
+
+  std::pair<int, int> sol = solution(sum, input_vector);
+  std::cout << sol.first << ' ' << sol.second;
+
+  return 0;
+}

task_01/src/solution.h

@@ -0,0 +1,41 @@
+#include <unordered_map>
+#include <vector>
+
+/*
+
+Output - indices of two numbers, which sum is equal to needed number, if there's
+no such numbers, the output is "-1 -1"
+
+Input:
+
+10
+10
+-2 2 3 3 5 8 11 13 14 15
+
+Output:
+
+1 5
+
+*/
+
+// Solution below has a time complexity of O(n) and memory complexity of O(n)
+
+std::pair<int, int> solution(int sum, std::vector<int> v) {
+  std::unordered_map<int, int> indices_map;  // keeps array numbers as keys and
+                                             // indices as values behind keys
+
+  for (int i = 0; i < v.size(); i++) {
+    if (indices_map.find(sum - v[i]) !=
+        indices_map
+            .end()) {  // if key "number - t" exists, we have found the solution
+      return {indices_map[sum - v[i]], i};
+    }
+
+    if (indices_map.find(v[i]) == indices_map.end())
+      indices_map[v[i]] =
+          i;  // We only add keys that weren't in the map before (that
+              // way we get the least possible sum of i and j)
+  }
+
+  return {-1, -1};  // in case there are no such numbers
+}

task_01/src/test.cpp

@@ -1,8 +1,39 @@
 
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include "solution.h"
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+TEST(solution, simple) {
+  std::vector<int> v1 = {-2, 2, 3, 3, 5, 9, 11, 13, 14, 15};
+  std::pair<int, int> p1 = {-1, -1};
+  ASSERT_EQ(p1, solution(10, v1));
+
+  std::vector<int> v2 = {-2, 2, 3, 3, 5, 8, 11, 13, 14, 15};
+  std::pair<int, int> p2 = {1, 5};
+  ASSERT_EQ(p2, solution(10, v2));
+
+  std::vector<int> v3 = {};
+  std::pair<int, int> p3 = {-1, -1};
+  ASSERT_EQ(p3, solution(0, v3));
+
+  std::vector<int> v4 = {1};
+  std::pair<int, int> p4 = {-1, -1};
+  ASSERT_EQ(p4, solution(1, v4));
+
+  std::vector<int> v5 = {1, 2};
+  std::pair<int, int> p5 = {0, 1};
+  ASSERT_EQ(p5, solution(3, v5));
+
+  // if there are multiple solutions, the algorithm
+  // will pick the one, in which sum of i and j is the least,
+  // where i and j are indices of numbers, which sum is equal to needed number
+  std::vector<int> v6 = {1, 1, 1, 1, 1, 1, 1, 1, 1};
+  std::pair<int, int> p6 = {0, 1};
+  ASSERT_EQ(p6, solution(2, v6));
+
+  // in case there are multiple solutions in which i+j is the least,
+  // the algorithm will pick the one, in which i is greater
+  std::vector<int> v7 = {1, 2, 1, 1, 4, 5, 1, 1, 1};
+  std::pair<int, int> p7 = {1, 4};
+  ASSERT_EQ(p7, solution(6, v7));
+}

task_02/src/stack.hpp

@@ -1,23 +1,122 @@
 #pragma once
 
+#include <algorithm>
 #include <stack>
+#include <stdexcept>
 #include <vector>
 
-class Stack {
+// check if type comparasion operators are defined for a class
+template <typename CutsomType>
+concept comparable = requires(CutsomType a, CutsomType b) {
+  a < b;
+  a <= b;
+  a == b;
+  a >= b;
+  a > b;
+  a != b;
+};
+
+// simple structure, helps to form a linked list
+template <typename CutsomType>
+struct Node {
+  Node() : prev{nullptr}, data{}, next{nullptr} {}
+  Node(CutsomType data_) : prev{nullptr}, data{data_}, next{nullptr} {}
+  void AddNode(CutsomType data_);
+  Node* next;
+  Node* prev;
+  CutsomType data;
+};
+
+// method, that allows to add a node with a value to an existing one
+template <typename CutsomType>
+void Node<CutsomType>::AddNode(CutsomType data_) {
+  next = new Node(data_);
+  next->prev = this;
+}
+
+// data structure that can store and retrieve data in such fashion:
+// last element inserted will be retrieved first (last in first out (LIFO))
+// insertion, deletion and retrieval has time complexity of O(1)
+template <typename CutsomType>
+class MyStack {
  public:
-  void Push(int value);
-  int Pop();
+  MyStack() : top_{nullptr} {}
+
+  // insert an element at the top of the stack
+  void Push(CutsomType value);
+
+  // retrieve last inserted element
+  CutsomType Top();
+  // retrieve last inserted element and delete it from the stack
+  CutsomType Pop();
+  // check if stack is empty
+  bool Empty() const { return top_ == nullptr; }
 
  private:
-  std::stack<int> data_;
+  Node<CutsomType>* top_;
 };
 
+template <typename CutsomType>
+void MyStack<CutsomType>::Push(CutsomType value) {
+  if (top_ == nullptr)
+    top_ = new Node(value);
+  else {
+    top_->AddNode(value);
+    top_ = top_->next;
+  }
+}
+
+template <typename CutsomType>
+CutsomType MyStack<CutsomType>::Top() {
+  if (top_ == nullptr) throw std::runtime_error("out_of_range\n");
+  return top_->data;
+}
+
+template <typename CutsomType>
+CutsomType MyStack<CutsomType>::Pop() {
+  if (top_ == nullptr) throw std::runtime_error("out_of_range\n");
+  Node<CutsomType>* temp = top_->prev;
+  CutsomType val = top_->data;
+  delete top_;
+  top_ = temp;
+  return val;
+}
+
+template <comparable CutsomType>
 class MinStack {
  public:
-  void Push(int value);
-  int Pop();
-  int GetMin();
+  // insert an element at the top of the stack
+  void Push(CutsomType value);
+  // retrieve last inserted element and delete it from the stack
+  CutsomType Pop();
+  // retrieve minimal element
+  CutsomType Min();
+  // retrieve last inserted element
+  CutsomType Top();
 
  private:
-  std::vector<int> data_;
+  MyStack<std::pair<CutsomType, CutsomType>> stack;
 };
+
+template <comparable CutsomType>
+void MinStack<CutsomType>::Push(CutsomType value) {
+  if (stack.Empty())
+    stack.Push({value, value});
+  else
+    stack.Push({value, std::min(value, stack.Top().second)});
+}
+
+template <comparable CutsomType>
+CutsomType MinStack<CutsomType>::Pop() {
+  return stack.Pop().first;
+}
+
+template <comparable CutsomType>
+CutsomType MinStack<CutsomType>::Min() {
+  return stack.Top().second;
+}
+
+template <comparable CutsomType>
+CutsomType MinStack<CutsomType>::Top() {
+  return stack.Top().first;
+}

task_02/src/test.cpp

@@ -2,11 +2,20 @@
 #include <gtest/gtest.h>
 
 #include <stack>
+#include <stdexcept>
 
 #include "stack.hpp"
 
+TEST(EmptyStack, Simple) {
+  MyStack<int> stack;
+  EXPECT_THROW(stack.Top(), std::runtime_error);
+  EXPECT_THROW(stack.Pop(), std::runtime_error);
+  stack.Push(1);
+  EXPECT_NO_THROW(stack.Pop());
+}
+
 TEST(StackTest, Simple) {
-  Stack stack;
+  MyStack<int> stack;
   stack.Push(1);              // Stack [1]
   ASSERT_EQ(stack.Pop(), 1);  // Stack []
   stack.Push(1);              // Stack [1]
@@ -22,21 +31,27 @@ TEST(StackTest, Simple) {
 }
 
 TEST(MinStackTest, Simple) {
-  MinStack stack;
+  MinStack<int> stack;
   stack.Push(1);  // Stack [1]
-  ASSERT_EQ(stack.GetMin(), 1);
+  ASSERT_EQ(stack.Min(), 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.Min(), 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.Min(), 1);
   ASSERT_EQ(stack.Pop(), 2);  // Stack [1]
   stack.Push(3);              // Stack [1, 3]
-  ASSERT_EQ(stack.GetMin(), 1);
+  ASSERT_EQ(stack.Min(), 1);
   ASSERT_EQ(stack.Pop(), 3);  // Stack [1]
   ASSERT_EQ(stack.Pop(), 1);  // Stack []
+}
+
+TEST(StackTest, Empty) {
+  MyStack<int> stack;
+  EXPECT_THROW(stack.Top(), std::runtime_error);
+  EXPECT_THROW(stack.Pop(), std::runtime_error);
 }

task_03/src/test.cpp

@@ -1,8 +1,33 @@
-
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include <cstddef>
+
+#include "weather.h"
+
+TEST(weather, Simple) {
+  std::vector<size_t> data_vector_1 = weather_algorithm({1, 2, 3, 4, 5});
+  std::vector<size_t> assert_vector_1 = {1, 1, 1, 1, 0};
+
+  ASSERT_EQ(data_vector_1, assert_vector_1);
+
+  std::vector<size_t> data_vector_2 = weather_algorithm({5});
+  std::vector<size_t> assert_vector_2 = {0};
+
+  ASSERT_EQ(data_vector_2, assert_vector_2);
+
+  std::vector<size_t> data_vector_3 = weather_algorithm({});
+  std::vector<size_t> assert_vector_3 = {};
+
+  ASSERT_EQ(data_vector_3, assert_vector_3);
+
+  std::vector<size_t> data_vector_4 =
+      weather_algorithm({-1, -1, 2, 2, -5, 3, 4, 1});
+  std::vector<size_t> assert_vector_4 = {2, 1, 3, 2, 1, 1, 0, 0};
+
+  ASSERT_EQ(data_vector_4, assert_vector_4);
+
+  std::vector<size_t> data_vector_5 = weather_algorithm({6, 5, 4, 3, 2, 1});
+  std::vector<size_t> assert_vector_5 = {0, 0, 0, 0, 0, 0};
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+  ASSERT_EQ(data_vector_5, assert_vector_5);
 }