Pogodaeva_homework

lib/src/util.cpp

@@ -1 +1,31 @@
 #include "util.hpp"
+
+std::vector<double> Smaller(double elem, const std::vector<double>& input) {
+  std::vector<double> smaller{};
+  for (auto i : input) {
+    if (i < elem) {
+      smaller.push_back(i);
+    }
+  }
+  return smaller;
+}
+
+std::vector<double> Bigger(double elem, const std::vector<double>& input) {
+  std::vector<double> bigger{};
+  for (auto i : input) {
+    if (i > elem) {
+      bigger.push_back(i);
+    }
+  }
+  return bigger;
+}
+
+std::vector<double> Eq(double elem, const std::vector<double>& input) {
+  std::vector<double> eq{};
+  for (auto i : input) {
+    if (i == elem) {
+      eq.push_back(i);
+    }
+  }
+  return eq;
+}

lib/src/util.hpp

@@ -0,0 +1,7 @@
+#include <vector>
+
+std::vector<double> Smaller(double elem, const std::vector<double>& input);
+
+std::vector<double> Bigger(double elem, const std::vector<double>& input);
+
+std::vector<double> Eq(double elem, const std::vector<double>& input);

task_01/src/task.cpp

@@ -0,0 +1,23 @@
+#include "task.hpp"
+
+#include <stdexcept>
+
+std::pair<int, int> SearchNumbers(int search_num,
+                                  const std::vector<int>& data) {
+  if (data.size() <= 1) {
+    throw std::invalid_argument("vector is too small");
+  }
+  size_t bottom{0};
+  size_t top{data.size() - 1};
+  while (bottom != top) {
+    if (data[bottom] + data[top] == search_num) {
+      std::pair<int, int> ans{data[bottom], data[top]};
+      return ans;
+    } else if (data[bottom] + data[top] > search_num) {
+      --top;
+    } else {
+      ++bottom;
+    }
+  }
+  throw std::invalid_argument("no suitable pair");
+}

task_01/src/task.hpp

@@ -0,0 +1,4 @@
+#include <utility>
+#include <vector>
+
+std::pair<int, int> SearchNumbers(int search_num, const std::vector<int>& data);

task_01/src/test.cpp

@@ -1,5 +1,48 @@
 #include <gtest/gtest.h>
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
-}
+#include "task.hpp"
+
+TEST(Task1, Simple) {
+  std::vector<int> data{1, 3, 4, 4, 7, 11};
+  std::pair<int, int> ans{3, 7};
+  ASSERT_EQ(SearchNumbers(10, data), ans);
+}
+
+TEST(Task1, FirstAndLast) {
+  std::vector<int> data{1, 2, 3, 4, 5, 99};
+  std::pair<int, int> ans{1, 99};
+  ASSERT_EQ(SearchNumbers(100, data), ans);
+}
+
+TEST(Task1, Negative) {
+  std::vector<int> data{-5, -3, 0, 1, 2, 8};
+  std::pair<int, int> ans{-3, 8};
+  ASSERT_EQ(SearchNumbers(5, data), ans);
+}
+
+TEST(Task1, Simple2) {
+  std::vector<int> data{10, 11, 12, 13, 14, 15};
+  std::pair<int, int> ans{10, 15};
+  ASSERT_EQ(SearchNumbers(25, data), ans);
+}
+
+TEST(Task1, SmallVector) {
+  std::vector<int> data{1, 2};
+  std::pair<int, int> ans{1, 2};
+  ASSERT_EQ(SearchNumbers(3, data), ans);
+}
+
+TEST(Task1, NoPair) {
+  std::vector<int> data{1, 2, 3, 4, 5};
+  ASSERT_THROW(SearchNumbers(100, data), std::invalid_argument);
+}
+
+TEST(Task1, Empty) {
+  std::vector<int> data;
+  ASSERT_THROW(SearchNumbers(10, data), std::invalid_argument);
+}
+
+TEST(Task1, SingleElementVector) {
+  std::vector<int> data{5};
+  ASSERT_THROW(SearchNumbers(5, data), std::invalid_argument);
+}

task_02/src/main.cpp

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

task_02/src/stack.hpp

@@ -1,23 +1,128 @@
 #pragma once
 
-#include <stack>
-#include <vector>
+#include <algorithm>
+#include <concepts>
 
+struct EmptyStackError : std::exception {
+  using std::exception::exception;
+};
+
+template <typename T>
+struct Node {
+  T value;
+  Node<T>* prev = nullptr;
+};
+
+template <typename T>
 class Stack {
  public:
-  void Push(int value);
-  int Pop();
+  Stack(){};
+  ~Stack() {
+    while (head != nullptr) {
+      Node<T>* old_head = head;
+      head = head->prev;
+      delete old_head;
+    }
+  }
+  void Push(T value);
+  T Pop();
 
  private:
-  std::stack<int> data_;
+  Node<T>* head = nullptr;
 };
 
+template <typename T>
+  requires(std::totally_ordered<T>)
 class MinStack {
  public:
-  void Push(int value);
-  int Pop();
-  int GetMin();
+  MinStack(){};
+  ~MinStack() {
+    while (head != nullptr) {
+      Node<T>* old_head = head;
+      Node<T>* old_head_min = head_min;
+
+      head = head->prev;
+      head_min = head_min->prev;
+
+      delete old_head;
+      delete old_head_min;
+    }
+  }
+  void Push(T value);
+  T Pop();
+  T const GetMin();
 
  private:
-  std::vector<int> data_;
+  Node<T>* head = nullptr;
+  Node<T>* head_min = nullptr;
 };
+
+template <typename T>
+void Stack<T>::Push(T value) {
+  if (!head) {
+    head = new Node<T>;
+    head->value = value;
+  } else {
+    Node<T>* new_head = new Node<T>;
+    new_head->prev = head;
+    new_head->value = value;
+    head = new_head;
+  }
+}
+
+template <typename T>
+T Stack<T>::Pop() {
+  if (head == nullptr) {
+    throw EmptyStackError();
+  }
+  Node<T>* del_node = head;
+  T val = head->value;
+  head = head->prev;
+  delete del_node;
+  return val;
+}
+
+template <typename T>
+  requires(std::totally_ordered<T>)
+void MinStack<T>::Push(T value) {
+  if (!head) {
+    head = new Node<T>;
+    head->value = value;
+    head_min = new Node<T>;
+    head_min->value = value;
+  } else {
+    Node<T>* new_head = new Node<T>;
+    Node<T>* new_head_min = new Node<T>;
+    new_head->prev = head;
+    new_head->value = value;
+    new_head_min->prev = head_min;
+    new_head_min->value = std::min(head_min->value, value);
+    head = new_head;
+    head_min = new_head_min;
+  }
+}
+
+template <typename T>
+  requires(std::totally_ordered<T>)
+T MinStack<T>::Pop() {
+  if (!head || !head_min) {
+    throw EmptyStackError();
+  }
+  Node<T>* del_node = head;
+  Node<T>* del_node_min = head_min;
+  T val = head->value;
+  head = head->prev;
+  head_min = head_min->prev;
+  delete del_node;
+  delete del_node_min;
+  return val;
+}
+
+template <typename T>
+  requires(std::totally_ordered<T>)
+T const MinStack<T>::GetMin() {
+  if (!head_min) {
+    throw EmptyStackError();
+  }
+  return head_min->value;
+}