task_01

.gitignore

@@ -12,4 +12,6 @@ _deps
 
 .cache/*
 .vscode/*
-build/*
+build/*
+.clang-format
+.gitignore

task_01/src/main.cpp

@@ -1,3 +1,23 @@
 #include <iostream>
 
-int main() { return 0; }
+#include "searching_sum.hpp"
+
+/*
+Формат ввода:
+  В первой строке ввода через пробел подаётся 2 целых числа:
+    sum - заданное число, n - длина массива чисел
+  В следующей строке подаются n целых чисел - элемента массива
+
+Формат вывода:
+  В одной строке через пробел выводятся два числа - индексы элементов данного
+  массива, дающие в сумме sum
+*/
+int main() {
+  int sum = 0, n = 0;
+  std::cin >> sum >> n;
+  std::vector<int> arr(n);
+  for (int i = 0; i < n; ++i) std::cin >> arr[i];
+  std::pair<int, int> answer = SearchingSum(sum, arr);
+  std::cout << answer.first << " " << answer.second << std::endl;
+  return 0;
+}

task_01/src/searching_sum.cpp

@@ -0,0 +1,15 @@
+#include "searching_sum.hpp"
+
+/*
+Алгоритм для нахождения в массиве чисел, дающих в сумме заданное число
+Ассимптотика алгоритма - O(n), затраты по памяти - O(n)
+*/
+std::pair<int, int> SearchingSum(int sum, std::vector<int> arr) {
+  std::pair<int, int> ans = {0, arr.size() - 1};
+  while (ans.first < ans.second) {
+    if (arr[ans.first] + arr[ans.second] == sum) return ans;
+    if (arr[ans.first] + arr[ans.second] < sum) ++ans.first;
+    if (arr[ans.first] + arr[ans.second] > sum) --ans.second;
+  }
+  return {-1, -1};
+}

task_01/src/searching_sum.hpp

@@ -0,0 +1,9 @@
+#ifndef SEARCHING_SUM
+#define SEARCHING_SUM
+
+#include <map>
+#include <vector>
+
+std::pair<int, int> SearchingSum(int sum, std::vector<int> arr);
+
+#endif  // SEARCHING_SUM

task_01/src/test.cpp

@@ -1,8 +1,36 @@
 
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include "searching_sum.hpp"
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+TEST(SearchingSum, Simple) {
+  int sum1 = 10;
+  std::vector<int> arr1 = {1, 3, 4, 7, 14};
+  std::pair<int, int> ans1 = {1, 3};
+  ASSERT_EQ(ans1, SearchingSum(sum1, arr1));
+
+  int sum2 = 19;
+  std::vector<int> arr2 = {1, 2, 5, 5, 6, 7, 8, 9, 14};
+  std::pair<int, int> ans2 = {2, 8};
+  ASSERT_EQ(ans2, SearchingSum(sum2, arr2));
+
+  int sum3 = 8;
+  std::vector<int> arr3 = {};
+  std::pair<int, int> ans3 = {-1, -1};
+  ASSERT_EQ(ans3, SearchingSum(sum3, arr3));
+
+  int sum4 = -1;
+  std::vector<int> arr4 = {-7, -5, 0, 1, 3, 4, 6};
+  std::pair<int, int> ans4 = {0, 6};
+  ASSERT_EQ(ans4, SearchingSum(sum4, arr4));
+
+  int sum5 = 0;
+  std::vector<int> arr5 = {1, 2, 5, 5, 6, 7, 8, 9, 14};
+  std::pair<int, int> ans5 = {-1, -1};
+  ASSERT_EQ(ans5, SearchingSum(sum5, arr5));
+
+  int sum6 = 2;
+  std::vector<int> arr6 = {2};
+  std::pair<int, int> ans6 = {-1, -1};
+  ASSERT_EQ(ans6, SearchingSum(sum6, arr6));
 }

task_02/src/stack.hpp

@@ -1,23 +1,99 @@
 #pragma once
 
-#include <stack>
-#include <vector>
+#include <memory>
+#include <stdexcept>
 
+/// @brief Элемент стека
+template <typename T>
+struct Element {
+  explicit Element(T data, const std::shared_ptr<Element>& next)
+      : data_(data), next_(next) {}
+
+  T data_;
+  std::shared_ptr<Element> next_;
+};
+
+/// @brief Cтек
+/// @tparam Т Тип данных
+template <typename T>
 class Stack {
  public:
-  void Push(int value);
-  int Pop();
+  explicit Stack() : top_(nullptr), size_{0} {}
+
+  std::size_t Size() const;
+  virtual void Push(T data);
+  virtual T Pop();
+  virtual T Top() const;
 
  private:
-  std::stack<int> data_;
+  std::size_t size_;
+  std::shared_ptr<Element<T>> top_;
 };
 
-class MinStack {
+/// @brief Стек с минимумом
+/// @tparam T Тип данных
+template <typename T>
+class MinStack : public Stack<T> {
  public:
-  void Push(int value);
-  int Pop();
-  int GetMin();
+  explicit MinStack() : Stack<T>(), minimums_stack_() {}
+
+  void Push(T data) override;
+  T Pop() override;
+  T GetMin() const;
 
  private:
-  std::vector<int> data_;
+  Stack<T> minimums_stack_;
+  std::size_t size_;
+  std::shared_ptr<Element<T>> top_;
 };
+
+template <typename T>
+std::size_t Stack<T>::Size() const {
+  return size_;
+}
+
+template <typename T>
+void Stack<T>::Push(T data) {
+  top_ = std::make_shared<Element<T>>(data, top_);
+  size_++;
+}
+
+template <typename T>
+T Stack<T>::Pop() {
+  if (size_ == 0) throw std::runtime_error("Stack is empty");
+  T removed_value = top_->data_;
+  top_ = std::move(top_->next_);
+  size_--;
+  return removed_value;
+}
+
+template <typename T>
+T Stack<T>::Top() const {
+  if (size_ == 0) throw std::runtime_error("Stack is empty");
+  return top_->data_;
+}
+
+template <typename T>
+void MinStack<T>::Push(T data) {
+  top_ = std::make_shared<Element<T>>(data, top_);
+  size_++;
+  if (minimums_stack_.Size() > 0 && data > minimums_stack_.Top())
+    minimums_stack_.Push(minimums_stack_.Top());
+  else
+    minimums_stack_.Push(data);
+}
+
+template <typename T>
+T MinStack<T>::Pop() {
+  if (size_ == 0) throw std::runtime_error("Stack is empty");
+  T removed_value = top_->data_;
+  top_ = std::move(top_->next_);
+  size_--;
+  minimums_stack_.Pop();
+  return removed_value;
+}
+
+template <typename T>
+T MinStack<T>::GetMin() const {
+  return minimums_stack_.Top();
+}

task_02/src/test.cpp

@@ -1,12 +1,11 @@
-
 #include <gtest/gtest.h>
 
 #include <stack>
 
 #include "stack.hpp"
 
 TEST(StackTest, Simple) {
-  Stack stack;
+  Stack<int> stack;
   stack.Push(1);              // Stack [1]
   ASSERT_EQ(stack.Pop(), 1);  // Stack []
   stack.Push(1);              // Stack [1]
@@ -22,7 +21,7 @@ TEST(StackTest, Simple) {
 }
 
 TEST(MinStackTest, Simple) {
-  MinStack stack;
+  MinStack<int> stack;
   stack.Push(1);  // Stack [1]
   ASSERT_EQ(stack.GetMin(), 1);
   ASSERT_EQ(stack.Pop(), 1);  // Stack []

task_03/src/days_amount_before_warming.cpp

@@ -0,0 +1,19 @@
+#include "days_amount_before_warming.h"
+
+#include <stack>
+
+std::vector<std::size_t> DaysAmountBeforeWarming(
+    std::vector<int> temperatures) {
+  std::vector<std::size_t> result(temperatures.size());
+  std::stack<std::size_t> remaining_days;
+  for (std::size_t i = 0; i < temperatures.size(); ++i) {
+    result[i] = 0;
+    while (!remaining_days.empty() &&
+           temperatures[i] > temperatures[remaining_days.top()]) {
+      result[remaining_days.top()] = i - remaining_days.top();
+      remaining_days.pop();
+    }
+    remaining_days.push(i);
+  }
+  return result;
+}

task_03/src/days_amount_before_warming.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <vector>
+
+std::vector<std::size_t> DaysAmountBeforeWarming(std::vector<int> temperatures);

task_03/src/test.cpp

@@ -1,8 +1,31 @@
-
 #include <gtest/gtest.h>
 
-#include "topology_sort.hpp"
+#include "days_amount_before_warming.h"
+
+TEST(Temperature, Simple) {
+  std::vector<size_t> days_data_1 = DaysAmountBeforeWarming({1, 2, 3, 4, 5});
+  std::vector<size_t> answer_1 = {1, 1, 1, 1, 0};
+
+  ASSERT_EQ(days_data_1, answer_1);
+
+  std::vector<size_t> days_data_2 = DaysAmountBeforeWarming({5});
+  std::vector<size_t> answer_2 = {0};
+
+  ASSERT_EQ(days_data_2, answer_2);
+
+  std::vector<size_t> days_data_3 = DaysAmountBeforeWarming({});
+  std::vector<size_t> answer_3 = {};
+
+  ASSERT_EQ(days_data_3, answer_3);
+
+  std::vector<size_t> days_data_4 =
+      DaysAmountBeforeWarming({-1, -1, 2, 2, -5, 3, 4, 1});
+  std::vector<size_t> answer_4 = {2, 1, 3, 2, 1, 1, 0, 0};
+
+  ASSERT_EQ(days_data_4, answer_4);
+
+  std::vector<size_t> days_data_5 = DaysAmountBeforeWarming({6, 5, 4, 3, 2, 1});
+  std::vector<size_t> answer_5 = {0, 0, 0, 0, 0, 0};
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+  ASSERT_EQ(days_data_5, answer_5);
 }