homework

task_01/task1/tests.cpp

@@ -0,0 +1,66 @@
+#include "two_sum.hpp"
+#include <cassert>
+#include <iostream>
+#include <vector>
+
+void runTests() {
+    {
+        std::vector<int> nums = {2, 7, 11, 15};
+        std::vector<int> result = twoSum(nums, 9);
+        assert((result == std::vector<int>{2, 7}));
+    }
+    {
+        std::vector<int> nums = {1, 2, 3, 4};
+        std::vector<int> result = twoSum(nums, 5);
+        assert((result == std::vector<int>{1, 4}));
+    }
+    {
+        std::vector<int> nums = {3, 3};
+        std::vector<int> result = twoSum(nums, 6);
+        assert((result == std::vector<int>{3, 3}));
+    }
+    {
+        std::vector<int> nums = {1, 2, 3, 4};
+        std::vector<int> result = twoSum(nums, 10);
+        assert(result.empty());
+    }
+    {
+        std::vector<int> nums;
+        std::vector<int> result = twoSum(nums, 5);
+        assert(result.empty());
+    }
+    {
+        std::vector<int> nums = {5};
+        std::vector<int> result = twoSum(nums, 5);
+        assert(result.empty());
+    }
+    {
+        std::vector<int> nums = {-4, -1, 0, 3, 5};
+        std::vector<int> result = twoSum(nums, -1);
+        assert((result == std::vector<int>{-4, 3}));
+    }
+    {
+        std::vector<int> nums = {10, 20, 30};
+        std::vector<int> result = twoSum(nums, 5);
+        assert(result.empty());
+    }
+    {
+        std::vector<int> nums = {1, 2, 3};
+        std::vector<int> result = twoSum(nums, 10);
+        assert(result.empty());
+    }
+    {
+        std::vector<int> nums = {1, 2, 3, 4, 5};
+        std::vector<int> result = twoSum(nums, 6);
+        assert((result == std::vector<int>{1, 5}));
+    }
+    {
+        std::vector<int> nums = {-5, -3, -2, 0, 1};
+        std::vector<int> result = twoSum(nums, -5);
+        assert((result == std::vector<int>{-5, 0}));
+    }
+}
+int main() {
+    runTests();
+    return 0;
+}

task_01/task1/two_sum.cpp

@@ -0,0 +1,22 @@
+#include "two_sum.hpp"
+
+std::vector<int> twoSum(const std::vector<int>& nums, int target) {
+    int left_index = 0;
+    int right_index = nums.size() - 1;
+
+    while (left_index < right_index) {
+        const int sum = nums[left_index] + nums[right_index];
+
+        if (sum == target) {
+            return {nums[left_index], nums[right_index]};
+        }
+        else if (sum < target) {
+            left_index++;
+        }
+        else {
+            right_index--;
+        }
+    }
+
+    return {};
+}

task_01/task1/two_sum.hpp

@@ -0,0 +1,8 @@
+#ifndef TWO_SUM_HPP
+#define TWO_SUM_HPP
+
+#include <vector>
+
+std::vector<int> twoSum(const std::vector<int>& nums, int target);
+
+#endif

task_02/task2/stack.cpp

@@ -0,0 +1,84 @@
+#include "stack.hpp"
+
+Stack::Stack() : capacity(10), _size(0) {
+    arr = new int[capacity];
+}
+
+Stack::~Stack() {
+    delete[] arr;
+}
+
+void Stack::resize(size_t newCapacity) {
+    int* newArr = new int[newCapacity];
+    for (size_t i = 0; i < _size; ++i) {
+        newArr[i] = arr[i];
+    }
+    delete[] arr;
+    arr = newArr;
+    capacity = newCapacity;
+}
+
+void Stack::push(int value) {
+    if (_size == capacity) {
+        resize(capacity * 2);
+    }
+    arr[_size++] = value;
+}
+
+void Stack::pop() {
+    if (empty()) {
+        throw std::out_of_range("empty");
+    }
+    --_size;
+}
+
+int Stack::top() const {
+    if (empty()) {
+        throw std::out_of_range("empty");
+    }
+    return arr[_size - 1];
+}
+
+bool Stack::empty() const {
+    return _size == 0;
+}
+
+size_t Stack::size() const {
+    return _size;
+}
+
+void MinStack::push(int value) {
+    dataStack.push(value);
+    if (minStack.empty() || value <= minStack.top()) {
+        minStack.push(value);
+    }
+}
+
+void MinStack::pop() {
+    if (dataStack.empty()) {
+        throw std::out_of_range("empty");
+    }
+    if (dataStack.top() == minStack.top()) {
+        minStack.pop();
+    }
+    dataStack.pop();
+}
+
+int MinStack::top() const {
+    return dataStack.top();
+}
+
+int MinStack::getMin() const {
+    if (minStack.empty()) {
+        throw std::out_of_range("empty");
+    }
+    return minStack.top();
+}
+
+bool MinStack::empty() const {
+    return dataStack.empty();
+}
+
+size_t MinStack::size() const {
+    return dataStack.size();
+}

task_02/task2/stack.hpp

@@ -0,0 +1,30 @@
+#include <stdexcept>
+
+class Stack {
+private:
+    int* arr;
+    size_t capacity;
+    size_t _size;
+    void resize(size_t newCapacity);
+public:
+    Stack();
+    ~Stack();
+    void push(int value);
+    void pop();
+    int top() const;
+    bool empty() const;
+    size_t size() const;
+};
+
+class MinStack {
+private:
+    Stack dataStack;
+    Stack minStack;
+public:
+    void push(int value);
+    void pop();
+    int top() const;
+    int getMin() const;
+    bool empty() const;
+    size_t size() const;
+};

task_02/task2/tests.cpp

@@ -0,0 +1,34 @@
+#include "stack.hpp"
+#include <cassert>
+
+int main() {
+    Stack s;
+    assert(s.empty());
+    s.push(1);
+    s.push(2);
+    assert(s.size() == 2);
+    assert(s.top() == 2);
+    s.pop();
+    assert(s.top() == 1);
+    s.pop();
+    assert(s.empty());
+
+    MinStack ms;
+    ms.push(3);
+    ms.push(2);
+    ms.push(5);
+    assert(ms.getMin() == 2);
+    ms.push(1);
+    assert(ms.getMin() == 1);
+    ms.pop();
+    assert(ms.getMin() == 2);
+    ms.pop();
+    assert(ms.top() == 2);
+    assert(ms.getMin() == 2);
+    ms.push(2);
+    ms.push(0);
+    ms.pop();
+    assert(ms.getMin() == 2);
+
+    return 0;
+}

task_03/task3/solution.cpp

@@ -0,0 +1,18 @@
+#include "solution.hpp"
+#include <stack>
+#include <vector>
+
+std::vector<int> dailyTemperatures(const std::vector<int>& temperatures) {
+    std::vector<int> result(temperatures.size(), 0);
+    std::stack<int> stack;
+
+    for (int i = 0; i < temperatures.size(); ++i) {
+        while (!stack.empty() && temperatures[i] > temperatures[stack.top()]) {
+            int idx = stack.top();
+            stack.pop();
+            result[idx] = i - idx;
+        }
+        stack.push(i);
+    }
+    return result;
+}