Б12-513 Береснев Даниил

task_01/src/main.cpp

@@ -1,3 +1,25 @@
 #include <iostream>
+#include <vector>
 
-int main() { return 0; }
+int main() {
+    int n, summ;
+    std::cin >> summ >> n;
+    std::vector<int> arr(n);
+    for (int i = 0; i < n; i++) {
+        std::cin >> arr[i];
+    }
+    int i = 0, j = arr.size() - 1;
+    while (i < j) {
+        int cur_summ = arr[i] + arr[j];
+        if (cur_summ == summ) {
+            std::cout << arr[i] << " " << arr[j];
+            return 0;
+        }
+        if (cur_summ < summ) {
+            i++;
+        } else {
+            j--;
+        }
+    }
+    std::cout << -1;
+}

task_01/src/solution.cpp

@@ -0,0 +1,24 @@
+#include "solution.hpp"
+
+// bool operator==(const Answer& lhs, const Answer& rhs) {
+//     if (!lhs.have_answer && !rhs.have_answer) {
+//         return true;
+//     }
+//     return lhs.have_answer == rhs.have_answer &&  lhs.lhs == rhs.lhs && lhs.rhs == rhs.rhs;
+// }
+
+Answer SumOfTwo(std::vector<int> arr, int summ) {
+    int i = 0, j = arr.size() - 1;
+    while (i < j) {
+        int cur_summ = arr[i] + arr[j];
+        if (cur_summ == summ) {
+            return Answer(arr[i], arr[j]);
+        }
+        if (cur_summ < summ) {
+            i++;
+        } else {
+            j--;
+        }
+    }
+    return Answer();
+}

task_01/src/solution.hpp

@@ -0,0 +1,16 @@
+#include <vector>
+
+struct Answer {
+    int lhs, rhs;
+    bool have_answer;
+    Answer(): have_answer(false) {}
+    Answer(int l, int r): lhs(l), rhs(r), have_answer(true) {}
+    bool operator==(const Answer other) {
+        if (!have_answer && !other.have_answer) {
+            return true;
+        }
+        return have_answer == other.have_answer && lhs == other.lhs && rhs == other.rhs;
+    }
+};
+
+Answer SumOfTwo(std::vector<int> arr, int summ);

task_01/src/test.cpp

@@ -1,5 +1,32 @@
 #include <gtest/gtest.h>
+#include "solution.hpp"
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+TEST(SumOfTwoTest, Simple) {
+  std::vector<int> array = {1, 3, 5, 6, 10, 23, 30};
+  ASSERT_EQ((SumOfTwo(array, 26) == Answer(3, 23)), true);
+  ASSERT_EQ((SumOfTwo(array, 16) == Answer(6, 10)), true);
+  ASSERT_EQ((SumOfTwo(array, 53) == Answer(23, 30)), true);
+  ASSERT_EQ((SumOfTwo(array, 4) == Answer(1, 3)), true);
+  std::vector<int> with_negative = {-12, -10, -4, 0, 2, 5, 10};
+  ASSERT_EQ((SumOfTwo(with_negative, -16) == Answer(-12, -4)), true);
+  ASSERT_EQ((SumOfTwo(with_negative, 0) == Answer(-10, 10)), true);
+  ASSERT_EQ((SumOfTwo(with_negative, 10) == Answer(0, 10)), true);
+}
+
+TEST(SumOfTwoTest, NoSolution) {
+  std::vector<int> array = {1, 4, 6, 10};
+  ASSERT_EQ((SumOfTwo(array, 100) == Answer()), true);
+  ASSERT_EQ((SumOfTwo(array, 6) == Answer()), true);
+  ASSERT_EQ((SumOfTwo({1}, 2)) == Answer(), true);
+}
+
+TEST(SumOfTwoTest, MoreSolutions) {
+  std::vector<int> two_sol = {1, 2, 4, 5};
+  Answer result = SumOfTwo(two_sol, 6);
+  bool check = (result == Answer(1, 5)) || (result == Answer(2, 4));
+  ASSERT_EQ(check, true);
+  std::vector<int> four_sol = {-10, 0, 1, 3, 4, 6, 7, 17};
+  result = SumOfTwo(four_sol, 7);
+  check = (result == Answer(-10, 17)) || (result == Answer(0, 7)) || (result == Answer(1, 6)) || (result == Answer(3, 4));
+  ASSERT_EQ(check, true);
 }

task_02/src/main.cpp

@@ -1,3 +1,13 @@
+#include "solution.hpp"
 #include <iostream>
 
-int main() { return 0; }
+int main() {
+    int n;
+    std::cin >> n;
+    std::vector<int> arr(n);
+    for (int i = 0; i < n; ++i) {
+        std::cin >> arr[i];
+    }
+
+    std::cout << FindBorder(arr);
+}

task_02/src/solution.cpp

@@ -0,0 +1,10 @@
+#include "solution.hpp"
+
+int FindBorder(std::vector<int> arr) {
+    for (int i = 0; i < arr.size() - 1; ++i) {
+        if (!arr[i] && arr[i + 1]) {
+            return i;
+        }
+    }
+    return -1;
+}

task_02/src/solution.hpp

@@ -0,0 +1,8 @@
+#ifndef SOLUTION_HPP
+#define SOLUTION_HPP
+
+#include <vector>
+
+int FindBorder(std::vector<int> arr);
+
+#endif

task_02/src/test.cpp

@@ -1,5 +1,21 @@
 #include <gtest/gtest.h>
+#include "solution.hpp"
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // placeholder
+TEST(FindBorderTest, Simple) {
+    std::vector<int> a = {0, 0, 0, 1, 1, 1, 1};
+    ASSERT_EQ(FindBorder(a), 2);
+
+    std::vector<int> b = {0, 1};
+    ASSERT_EQ(FindBorder(b), 0);
+
+    std::vector<int> c = {0, 0, 0, 0, 0, 0, 0, 1};
+    ASSERT_EQ(FindBorder(c), 6);
+
+    std::vector<int> d = {0, 1, 1, 1, 1};
+    ASSERT_EQ(FindBorder(d), 0);
+
+    std::vector<int> many = {0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1};
+    int ans = FindBorder(many);
+    bool check = ans < many.size() - 1 && !many[ans]  && many[ans + 1];
+    ASSERT_EQ(check, true);
 }

task_03/src/main.cpp

@@ -1,3 +1,10 @@
 #include <iostream>
+#include "solution.hpp"
 
-int main() { return 0; }
+int main() {
+    std::string s;
+    std::cin >> s;
+    for (const auto& el : ButtonPhone(s)) {
+        std::cout << el << " ";
+    }
+}

task_03/src/solution.cpp

@@ -0,0 +1,20 @@
+#include "solution.hpp"
+
+const std::vector<std::string> convert = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+
+void AddCombination(int index, const std::string& s, std::vector<std::string>& add, std::string current) {
+    if (index == s.size()) {
+        add.push_back(current);
+        return;
+    }
+    for (char c : convert[s[index] - '2']) {
+        std::string new_s = current + c;
+        AddCombination(index + 1, s, add, new_s);
+    }
+}
+
+std::vector<std::string> ButtonPhone(std::string s) {
+    std::vector<std::string> result;
+    AddCombination(0, s, result, "");
+    return result;
+}

task_03/src/solution.hpp

@@ -0,0 +1,4 @@
+#include <vector>
+#include <string>
+
+std::vector<std::string> ButtonPhone(std::string s);

task_03/src/test.cpp

@@ -1,4 +1,39 @@
 
 #include <gtest/gtest.h>
+#include "solution.hpp"
 
-TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); }
+TEST(ButtonPhoneTest, OneLetter) {
+    std::vector<std::string> expected1 = {"a", "b", "c"};
+    std::vector<std::string> res1 = ButtonPhone("2");
+    ASSERT_EQ(res1, expected1);
+
+    std::vector<std::string> expected2 = {"w", "x", "y", "z"};
+    std::vector<std::string> res2 = ButtonPhone("9");
+    ASSERT_EQ(res2, expected2);
+}
+
+TEST(ButtonPhoneTest, TwoLetters) {
+    std::vector<std::string> expected1 = {"pw", "px", "py", "pz", "qw", "qx", "qy", "qz", "rw", "rx", "ry", "rz", "sw", "sx", "sy", "sz"};
+    std::vector<std::string> res1 = ButtonPhone("79");
+    ASSERT_EQ(res1, expected1);
+
+    std::vector<std::string> expected2 = {"gg", "gh", "gi", "hg", "hh", "hi", "ig", "ih", "ii"};
+    std::vector<std::string> res2 = ButtonPhone("44");
+    ASSERT_EQ(res2, expected2);
+}
+
+TEST(ButtonPhoneTest, ThreeLetters) {
+    std::vector<std::string> expected1 = {"ajw", "ajx", "ajy", "ajz", "akw", "akx", "aky", "akz", "alw", "alx", "aly", "alz", "bjw", "bjx", "bjy", "bjz", "bkw", "bkx", "bky", "bkz", "blw", "blx", "bly", "blz", "cjw", "cjx", "cjy", "cjz", "ckw", "ckx", "cky", "ckz", "clw", "clx", "cly", "clz"};
+    std::vector<std::string> res1 = ButtonPhone("259");
+    ASSERT_EQ(res1, expected1);
+
+    std::vector<std::string> expected2 = {"ddd", "dde", "ddf", "ded", "dee", "def", "dfd", "dfe", "dff", "edd", "ede", "edf", "eed", "eee", "eef", "efd", "efe", "eff", "fdd", "fde", "fdf", "fed", "fee", "fef", "ffd", "ffe", "fff"};
+    std::vector<std::string> res2 = ButtonPhone("333");
+    ASSERT_EQ(res2, expected2);
+}
+
+TEST(ButtonPhoneTest, FourLetters) {
+    std::vector<std::string> expected = {"amwj", "amwk", "amwl", "amxj", "amxk", "amxl", "amyj", "amyk", "amyl", "amzj", "amzk", "amzl", "anwj", "anwk", "anwl", "anxj", "anxk", "anxl", "anyj", "anyk", "anyl", "anzj", "anzk", "anzl", "aowj", "aowk", "aowl", "aoxj", "aoxk", "aoxl", "aoyj", "aoyk", "aoyl", "aozj", "aozk", "aozl", "bmwj", "bmwk", "bmwl", "bmxj", "bmxk", "bmxl", "bmyj", "bmyk", "bmyl", "bmzj", "bmzk", "bmzl", "bnwj", "bnwk", "bnwl", "bnxj", "bnxk", "bnxl", "bnyj", "bnyk", "bnyl", "bnzj", "bnzk", "bnzl", "bowj", "bowk", "bowl", "boxj", "boxk", "boxl", "boyj", "boyk", "boyl", "bozj", "bozk", "bozl", "cmwj", "cmwk", "cmwl", "cmxj", "cmxk", "cmxl", "cmyj", "cmyk", "cmyl", "cmzj", "cmzk", "cmzl", "cnwj", "cnwk", "cnwl", "cnxj", "cnxk", "cnxl", "cnyj", "cnyk", "cnyl", "cnzj", "cnzk", "cnzl", "cowj", "cowk", "cowl", "coxj", "coxk", "coxl", "coyj", "coyk", "coyl", "cozj", "cozk", "cozl"};
+    std::vector<std::string> res = ButtonPhone("2695");
+    ASSERT_EQ(res, expected);
+}

task_04/src/min_stack.cpp

@@ -0,0 +1,40 @@
+#include "min_stack.hpp"
+
+MinStack::MinStack() {
+    head = nullptr;
+}
+
+void MinStack::Push(int value) {
+    MinNode *node = new MinNode();
+    node->value = value;
+    node->min = std::min(value, GetMin());
+    node->prev = head;
+    head = node;
+}
+
+int MinStack::Pop() {
+    if (!head) {
+        return -1;
+    }
+    int value = head->value;
+    MinNode *temp = head->prev;
+    delete head;
+    head = temp;
+    return value;
+}
+
+int MinStack::GetMin() {
+    if (!head) {
+        return 1e9;
+    }
+    return head->min;
+}
+
+MinStack::~MinStack() {
+    MinNode* tmp = head;
+    while (tmp) {
+        MinNode* pr = tmp->prev;
+        delete tmp;
+        tmp = pr;
+    }
+}

task_04/src/min_stack.hpp

@@ -0,0 +1,17 @@
+#include <algorithm>
+
+class MinStack {
+public:
+    void Push(int value);
+    int Pop();
+    int GetMin();
+    MinStack();
+    ~MinStack();
+private:
+    struct MinNode {
+        int value;
+        int min;
+        MinNode *prev;
+    };
+    MinNode *head;
+};

task_04/src/stack.cpp

@@ -1,21 +1,32 @@
 #include "stack.hpp"
 
-#include <algorithm>
+Stack::Stack() {
+    head = nullptr;
+}
 
-void Stack::Push(int value) { data_.push(value); }
+void Stack::Push(int value) {
+    Node *node = new Node();
+    node->value = value;
+    node->prev = head;
+    head = node;
+}
 
 int Stack::Pop() {
-  auto result = data_.top();
-  data_.pop();
-  return result;
+    if (!head) {
+        return -1;
+    }
+    int value = head->value;
+    Node *temp = head->prev;
+    delete head;
+    head = temp;
+    return value;
 }
 
-void MinStack::Push(int value) { data_.push_back(value); }
-
-int MinStack::Pop() {
-  auto result = data_.back();
-  data_.pop_back();
-  return result;
+Stack::~Stack() {
+    Node* tmp = head;
+    while (tmp) {
+        Node* pr = tmp->prev;
+        delete tmp;
+        tmp = pr;
+    }
 }
-
-int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); }

task_04/src/stack.hpp

@@ -1,23 +1,14 @@
-#pragma once
-
-#include <stack>
-#include <vector>
-
 class Stack {
- public:
-  void Push(int value);
-  int Pop();
-
- private:
-  std::stack<int> data_;
-};
-
-class MinStack {
- public:
-  void Push(int value);
-  int Pop();
-  int GetMin();
-
- private:
-  std::vector<int> data_;
-};
+public:
+    void Push(int value);
+    int Pop();
+    Stack();
+    ~Stack();
+private:
+    struct Node {
+        int value;
+        int min;
+        Node *prev;
+    };
+    Node *head;
+};