task01

task_01/src/get_terms.hpp

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+using namespace std;
+
+pair<int, int> get_terms(vector<int> v, int S) {
+  int N = v.size();
+
+  if (N == 0 || N == 1) return pair(-1, -1);
+
+  int l{0}, r{N - 1};
+
+  int s;
+  while (l != r) {
+    s = v[l] + v[r];
+    if (s == S) {
+      return pair(v[l], v[r]);
+    } else {
+      if (s > S)
+        --r;
+      else
+        ++l;
+    }
+  }
+
+  return pair(-1, -1);
+}

task_01/src/main.cpp

@@ -1,3 +1,34 @@
+#include <get_terms.hpp>
 #include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
 
-int main() { return 0; }
+using namespace std;
+
+int main() {
+  int S, N;
+  vector<int> v;
+  string line3, line1, line2;
+
+  getline(cin, line1);
+  getline(cin, line2);
+  getline(cin, line3);
+
+  S = stoi(line1);
+  N = stoi(line2);
+
+  istringstream is(line3);
+
+  int x;
+  while (is >> x) v.push_back(x);
+  pair<int, int> result = get_terms(v, S);
+  if (result == pair(-1, -1))
+    cout << -1 << endl;
+  else
+    cout << result.first << " " << result.second << endl;
+  /*
+  python3 ./scripts/run_cases.py --tasks task_01
+  */
+  return 0;
+}

task_01/src/test.cpp

@@ -1,5 +1,35 @@
 #include <gtest/gtest.h>
 
+#include <get_terms.hpp>
+#include <stdexcept>
+#include <vector>
+
 TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+  std::vector<int> v = {1, 2, 4};
+  std::vector<int> v1 = {2, 7, 11, 15};
+  std::vector<int> v2 = {3, 7, 12};
+  std::vector<int> v3 = {-67, -42, 0, 52, 108, 252};
+  std::vector<int> v4 = {2, 4};
+  ASSERT_EQ(get_terms(v, 52), std::make_pair(-1, -1));
+  ASSERT_EQ(get_terms(v, -52), std::make_pair(-1, -1));
+  ASSERT_EQ(get_terms(v, 0), std::make_pair(-1, -1));
+  ASSERT_EQ(get_terms(v1, 9), std::make_pair(2, 7));
+  ASSERT_EQ(get_terms(v2, 19), std::make_pair(7, 12));
+  ASSERT_EQ(get_terms(v3, 10), std::make_pair(-42, 52));
+  ASSERT_EQ(get_terms(v3, 1), std::make_pair(-1, -1));
+  ASSERT_EQ(get_terms(v4, 6), std::make_pair(2, 4));
+}
+
+TEST(Test, Empty) {
+  std::vector<int> v_empty = {};
+  ASSERT_EQ(get_terms(v_empty, 52), std::make_pair(-1, -1));
+  ASSERT_EQ(get_terms(v_empty, -52), std::make_pair(-1, -1));
+  ASSERT_EQ(get_terms(v_empty, 0), std::make_pair(-1, -1));
+}
+
+TEST(Test, Single) {
+  std::vector<int> v_single = {0};
+  ASSERT_EQ(get_terms(v_single, 52), std::make_pair(-1, -1));
+  ASSERT_EQ(get_terms(v_single, -52), std::make_pair(-1, -1));
+  ASSERT_EQ(get_terms(v_single, 0), std::make_pair(-1, -1));
 }

task_02/src/get_border_index.hpp

@@ -0,0 +1,22 @@
+#include <vector>
+
+using namespace std;
+
+int get_border_index(vector<int> v) {
+  int N = v.size();
+
+  if (v[1] == 1) return 0;
+  if (v[N - 2] == 0) return N - 2;
+
+  int left = 0, right = N - 1;
+
+  while (left + 1 < right) {
+    int mid = (left + right) / 2;
+
+    if (v[mid] == 1)
+      right = mid;
+    else
+      left = mid;
+  }
+  return left;
+}

task_02/src/main.cpp

@@ -1,3 +1,53 @@
+#include <get_border_index.hpp>
 #include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
 
-int main() { return 0; }
+using namespace std;
+
+int main() {
+  int N;
+  vector<int> v;
+  string line1, line2;
+
+  getline(cin, line1);
+  getline(cin, line2);
+
+  N = stoi(line1);
+
+  istringstream is(line2);
+  int x;
+  while (is >> x) v.push_back(x);
+
+  cout << get_border_index(v) << endl;
+  /*
+  if (v[1] == 1) cout << 0 << endl;
+  else if (v[N-2] == 0) cout << N-2 << endl;
+  else
+  {
+      int i{(N-1)/2};
+      while (v[i] != 0 && v[i+1] != 1)
+      {
+          if (v[i] == 0)
+          {
+              if (i+1 < v.size() && v[i+1] == 1)
+              {
+                  cout << i << endl;
+                  break;
+              }
+              i = (N-1 - i)/2;
+          } else
+          {
+              if (i-1 >= 0  && v[i-1] == 0)
+              {
+                  cout << i-1 << endl;
+                  break;
+              }
+              i /= 2;
+          }
+      }
+  };
+  */
+  return 0;
+}

task_02/src/test.cpp

@@ -1,5 +1,34 @@
 #include <gtest/gtest.h>
 
+#include <get_border_index.hpp>
+
 TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // placeholder
+  vector<int> v1{0, 1};
+  vector<int> v2{0, 0, 0, 1, 1};
+  vector<int> v3{0, 0, 0, 0, 0, 1};
+  vector<int> v4{0, 1, 1, 1, 1};
+  vector<int> v5{0, 0, 1, 1, 1, 1};
+  vector<int> v6{0, 0, 0, 1};
+  vector<int> v7{0, 0, 1};
+  vector<int> v8{0, 1, 1};
+  vector<int> v9{0, 0, 0, 0, 1, 1, 1};
+  vector<int> v10{0, 0, 0, 0, 0, 0, 0, 0, 1};
+  vector<int> v11{0, 0, 0, 0, 1};
+  vector<int> v12{0, 0, 1, 1};
+  vector<int> v13{0, 1, 1, 1};
+  vector<int> v14{0, 1, 0, 1, 0, 1, 0, 1};
+
+  ASSERT_EQ(get_border_index(v1), 0);
+  ASSERT_EQ(get_border_index(v2), 2);
+  ASSERT_EQ(get_border_index(v3), 4);
+  ASSERT_EQ(get_border_index(v4), 0);
+  ASSERT_EQ(get_border_index(v5), 1);
+  ASSERT_EQ(get_border_index(v6), 2);
+  ASSERT_EQ(get_border_index(v7), 1);
+  ASSERT_EQ(get_border_index(v8), 0);
+  ASSERT_EQ(get_border_index(v9), 3);
+  ASSERT_EQ(get_border_index(v10), 7);
+  ASSERT_EQ(get_border_index(v11), 3);
+  ASSERT_EQ(get_border_index(v12), 1);
+  ASSERT_EQ(get_border_index(v13), 0);
 }

task_03/src/get_combinations.hpp

@@ -0,0 +1,40 @@
+#include <string>
+#include <vector>
+
+using namespace std;
+
+const vector<string> v_s{"abc", "def",  "ghi", "jkl",
+                         "mno", "pqrs", "tuv", "wxyz"};
+constexpr int shift = 2;
+
+void get_small_combination(vector<int> nums, int i, string s,
+                           vector<string> &result) {
+  if (i == nums.size()) {
+    result.push_back(s);
+    return;
+  }
+
+  string s_new;
+  for (char c : v_s[nums[i] - shift]) {
+    s_new = s + c;
+    get_small_combination(nums, i + 1, s_new, result);
+  }
+}
+
+vector<string> get_combinations(string digits) {
+  vector<int> nums;
+  for (char c : digits) {
+    if (c >= '2' && c <= '9') {
+      nums.push_back(c - '0');
+    }
+  }
+  vector<string> result;
+
+  if (nums.empty()) return result;
+
+  string s;
+  int i = 0;
+
+  get_small_combination(nums, i, s, result);
+  return result;
+}

task_03/src/main.cpp

@@ -1,3 +1,15 @@
+#include <get_combinations.hpp>
 #include <iostream>
+#include <string>
+#include <vector>
 
-int main() { return 0; }
+using namespace std;
+
+int main() {
+  string digits;
+  getline(cin, digits);
+
+  vector<string> result = get_combinations(digits);
+
+  for (string str : result) cout << str << " ";
+}

task_03/src/test.cpp

@@ -1,4 +1,14 @@
-
 #include <gtest/gtest.h>
 
+#include <vector>
+
+#include "get_combinations.hpp"
+
+using namespace std;
+
 TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); }
+
+TEST(TopologySort, Single) {
+  ASSERT_EQ(get_combinations("2"), 1);
+  ASSERT_EQ(get_combinations("1"), "");
+}

task_04/src/stack.cpp

@@ -1,21 +1,26 @@
 #include "stack.hpp"
 
-#include <algorithm>
-
-void Stack::Push(int value) { data_.push(value); }
+void Stack::Push(int value) { stack_.push_back(value); }
 
 int Stack::Pop() {
-  auto result = data_.top();
-  data_.pop();
+  auto result = stack_.back();
+  stack_.pop_back();
   return result;
 }
 
-void MinStack::Push(int value) { data_.push_back(value); }
+void MinStack::Push(int value) {
+  stack_.push_back(value);
+  if (min_stack_.size() == 0 || value < min_stack_.back())
+    min_stack_.push_back(value);
+  else
+    min_stack_.push_back(min_stack_.back());
+}
 
 int MinStack::Pop() {
-  auto result = data_.back();
-  data_.pop_back();
+  auto result = stack_.back();
+  stack_.pop_back();
+  min_stack_.pop_back();
   return result;
 }
 
-int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); }
+int MinStack::GetMin() { return min_stack_.back(); }

task_04/src/stack.hpp

@@ -9,7 +9,7 @@ class Stack {
   int Pop();
 
  private:
-  std::stack<int> data_;
+  std::vector<int> stack_;
 };
 
 class MinStack {
@@ -19,5 +19,6 @@ class MinStack {
   int GetMin();
 
  private:
-  std::vector<int> data_;
+  std::vector<int> stack_;
+  std::vector<int> min_stack_;
 };

task_05/src/main.cpp

@@ -1,3 +1,20 @@
 #include <iostream>
+#include <vector>
 
-int main() { return 0; }
+#include "topology_sort.hpp"
+
+using namespace std;
+
+int main() {
+  int N;
+  cin >> N;
+  vector<int> v;
+
+  for (int i = 0; i < N; ++i) {
+    int n;
+    cin >> n;
+    v.push_back(n);
+  }
+  vector<int> v2 = temperature_rise(v);
+  for (int t : v2) cout << t << " ";
+}