Varinitsa

.github/workflows/tests.yaml

@@ -15,6 +15,7 @@ jobs:
     steps:
       - name: Install gtest manually
         run: sudo apt-get install libgtest-dev
+        run: sudo apt install libomp-dev
 
       - uses: actions/checkout@v3
 

lib/src/util.cpp

@@ -1 +1,24 @@
 #include "util.hpp"
+
+void MergeSort(std::vector<int>& array) {
+  int n = array.size();
+  std::vector<int> buffer(n);
+
+  for (int slice = 1; slice < n; slice *= 2) {
+    for (int left = 0; left < n; left += 2 * slice) {
+      int mid = std::min(left + slice, n);
+      int right = std::min(left + 2 * slice, n);
+
+      int i = left, j = mid;
+      int k = left;
+      while (i < mid && j < right) {
+        buffer[k++] = array[i] <= array[j] ? array[i++] : array[j++];
+      }
+      while (i < mid) buffer[k++] = array[i++];
+      while (j < right) buffer[k++] = array[j++];
+
+      std::copy(buffer.begin() + left, buffer.begin() + right,
+                array.begin() + left);
+    }
+  }
+}

lib/src/util.hpp

@@ -0,0 +1,3 @@
+#include <vector>
+
+void MergeSort(std::vector<int>& array);

sandbox/template/src/main.cpp

@@ -1,3 +1,41 @@
-#include <iostream>
+// #include <iostream>
+// #include <vector>
 
-int main() { return 0; }
+// void MergeSort(std ::vector<int>& array) {
+//   int i{0}, j{1};
+//   int slice{1};
+//   do {
+//     while (j <= array.size() - 1) {
+//       if (array[i] > array[j]) {
+//         iter_swap(array.begin() + i, array.begin() + j);
+
+//         ++j;
+//       } else
+//         ++i;
+//       if (j - i > slice) {
+//         i = j;
+//         j = i + slice;
+//       } else if (j == i) {
+//         i += 1;
+//         j = i + slice;
+//       }
+//     }
+//     slice *= 2;
+//     slice > array.size() ? j = array.size() - 1 : j = slice;
+//     i = 0;
+//     if (j == array.size() - 1) {
+//       if (i == 0) {
+//         return;
+//       }
+//     }
+//   } while (true);
+// }
+
+int main() {
+  //   std ::vector<int> unsort{3, 2, 4, 5, 1, 9, 7};
+  //   MergeSort(unsort);
+  //   for (int i = 0; i < unsort.size(); ++i) {
+  //     std ::cout << unsort[i] << " ";
+  //   }
+  //   std ::cout << std ::endl;
+}

sandbox/template/src/test.cpp

@@ -1,8 +1,8 @@
 
-#include <gtest/gtest.h>
+// #include <gtest/gtest.h>
 
-#include <stack>
+// #include <stack>
 
-#include "utils.hpp"
+// #include "utils.hpp"
 
-TEST(Template, Simple) { ASSERT_EQ(true, true); }
+// TEST(Template, Simple) { ASSERT_EQ(true, true); }

sandbox/template/src/utils.cpp

@@ -1 +1 @@
-#include "utils.hpp"
+// #include "utils.hpp"

sandbox/template/src/utils.hpp

@@ -1 +1 @@
-#pragma once
+// #pragma once

task_01/src/find.cpp

@@ -0,0 +1,20 @@
+#include "find.hpp"
+
+std ::vector<int> FindNums(int k, std ::vector<int> sequence) {
+  if (sequence.size() == 0) throw NoSumNum{};
+
+  std ::vector<int> answer;
+  unsigned long left_index{0};
+  unsigned long right_index{sequence.size() - 1};
+  while (left_index != right_index) {
+    if ((sequence[left_index] + sequence[right_index]) == k) {
+      answer.push_back(sequence[left_index]);
+      answer.push_back(sequence[right_index]);
+      return answer;
+    } else if (sequence[left_index] + sequence[right_index] > k)
+      --right_index;
+    else
+      ++left_index;
+  }
+  throw NoSumNum{};
+}

task_01/src/find.hpp

@@ -0,0 +1,8 @@
+#include <string>
+#include <vector>
+
+struct NoSumNum {
+  std ::string s{"no possible way to solve task"};
+};
+
+std ::vector<int> FindNums(int k, std ::vector<int> sequence);

task_01/src/main.cpp

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

task_01/src/test.cpp

@@ -1,5 +1,33 @@
 #include <gtest/gtest.h>
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include "find.hpp"
+
+TEST(FindNums, Simple) {
+  std ::vector<int> seq{1, 2, 3, 4, 5};
+  std ::vector<int> ans{FindNums(5, seq)};
+  ASSERT_EQ(5, ans[0] + ans[1]);
+}
+
+TEST(FindNums, Negative) {
+  std ::vector<int> seq{-100, -10, -9, -8, -1};
+  std ::vector<int> ans{FindNums(-9, seq)};
+  ASSERT_EQ(-9, ans[0] + ans[1]);
+}
+
+TEST(FindNums, WithZeros) {
+  std ::vector<int> seq{
+      -15, 0, 0, 2, 8,
+  };
+  std ::vector<int> ans{FindNums(10, seq)};
+  ASSERT_EQ(10, ans[0] + ans[1]);
+}
+
+TEST(FindNums, NoValue) {
+  std ::vector<int> seq{0, 0, 2, 8, -15};
+  EXPECT_THROW(FindNums(60, seq), NoSumNum);
+}
+
+TEST(FindNums, Empty) {
+  std ::vector<int> seq(0);
+  EXPECT_THROW(FindNums(60, seq), NoSumNum);
 }

task_02/src/stack.hpp

@@ -1,23 +1,70 @@
-#pragma once
-
-#include <stack>
+#include <concepts>
+#include <stdexcept>
 #include <vector>
 
+template <typename T>
+concept Comparable = requires(T a, T b) {
+  { a < b } -> std::convertible_to<bool>;
+};
+
+template <Comparable T>
 class Stack {
  public:
-  void Push(int value);
-  int Pop();
+  void Push(T k);
+  T Pop();
 
  private:
-  std::stack<int> data_;
+  std ::vector<T> _data;
 };
 
+template <Comparable T>
+void Stack<T>::Push(T k) {
+  _data.push_back(k);
+}
+
+template <Comparable T>
+T Stack<T>::Pop() {
+  if (_data.size() == 0) throw std::out_of_range("No data in stack");
+  T pop_val{_data.back()};
+  _data.pop_back();
+  return pop_val;
+}
+
+template <Comparable T>
 class MinStack {
  public:
-  void Push(int value);
-  int Pop();
-  int GetMin();
+  void Push(T k);
+  T Pop();
+  T GetMin();
 
  private:
-  std::vector<int> data_;
+  std ::vector<T> _data;
+  std ::vector<T> _min_data;
 };
+
+template <Comparable T>
+void MinStack<T>::Push(T k) {
+  if (_min_data.size() == 0)
+    _min_data.push_back(k);
+  else if (_min_data.back() > k)
+    _min_data.push_back(k);
+  else
+    _min_data.push_back(_min_data.back());
+  _data.push_back(k);
+}
+
+template <Comparable T>
+T MinStack<T>::Pop() {
+  if ((_data.size() == 0) || (_min_data.size() == 0))
+    throw std::out_of_range("No data in stack");
+  T pop_val{_data.back()};
+  _data.pop_back();
+  _min_data.pop_back();
+  return pop_val;
+}
+
+template <Comparable T>
+T MinStack<T>::GetMin() {
+  if (_min_data.size() == 0) throw std::out_of_range("No data in stack");
+  return _min_data.back();
+}

task_02/src/test.cpp

@@ -1,42 +1,66 @@
 
 #include <gtest/gtest.h>
 
-#include <stack>
-
 #include "stack.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 []
+  Stack<int> stack;
+  stack.Push(1);
+  ASSERT_EQ(stack.Pop(), 1);
+  stack.Push(1);
+  stack.Push(2);
+  ASSERT_EQ(stack.Pop(), 2);
+  ASSERT_EQ(stack.Pop(), 1);
+  stack.Push(1);
+  stack.Push(2);
+  ASSERT_EQ(stack.Pop(), 2);
+  stack.Push(3);
+  ASSERT_EQ(stack.Pop(), 3);
+  ASSERT_EQ(stack.Pop(), 1);
 }
 
 TEST(MinStackTest, Simple) {
-  MinStack stack;
-  stack.Push(1);  // Stack [1]
+  MinStack<int> stack;
+  stack.Push(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.Pop(), 1);
+  stack.Push(1);
+  stack.Push(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.Pop(), 2);
+  ASSERT_EQ(stack.Pop(), 1);
+  stack.Push(1);
+  stack.Push(2);
   ASSERT_EQ(stack.GetMin(), 1);
-  ASSERT_EQ(stack.Pop(), 2);  // Stack [1]
-  stack.Push(3);              // Stack [1, 3]
+  ASSERT_EQ(stack.Pop(), 2);
+  stack.Push(3);
   ASSERT_EQ(stack.GetMin(), 1);
-  ASSERT_EQ(stack.Pop(), 3);  // Stack [1]
-  ASSERT_EQ(stack.Pop(), 1);  // Stack []
+  ASSERT_EQ(stack.Pop(), 3);
+  ASSERT_EQ(stack.Pop(), 1);
+}
+
+TEST(Stack, Custom) {
+  Stack<int> stack;
+  stack.Push(10);
+  ASSERT_EQ(10, stack.Pop());
+
+  EXPECT_THROW(stack.Pop(), std::out_of_range);
+}
+
+TEST(MinStack, Custom) {
+  MinStack<int> stack;
+  stack.Push(10);
+  stack.Push(2);
+  stack.Push(17);
+  ASSERT_EQ(2, stack.GetMin());
+
+  stack.Pop();
+  stack.Pop();
+  stack.Pop();
+  EXPECT_THROW(stack.Pop(), std::out_of_range);
+
+  stack.Push(10);
+  stack.Push(10);
+  stack.Push(10);
+  ASSERT_EQ(10, stack.GetMin());
 }

task_03/src/main.cpp

@@ -1,3 +1,13 @@
 #include <iostream>
 
-int main() { return 0; }
+#include "warming_func.hpp"
+
+// void print(std::vector<int>& v) {
+//   for (auto c : v) std ::cout << c << " ";
+// }
+
+int main() {
+  // std ::vector<int> s{5, 7, 9, 3, 4, 0, 2, -1, 3};
+  // s = Warming(s);
+  // print(s);
+}