Kirpichev's Homework

task_01/src/sum_two_num.cpp

@@ -0,0 +1,21 @@
+#include "sum_two_num.h"
+
+#include <iostream>
+
+void FindSumTwoNum(std::vector<int>& vec, int len, int num) {
+  int left = 0;
+  int right = len - 1;
+
+  while (left < right) {
+    int sum = vec[left] + vec[right];
+    if (right - left == 0) std::cout << "There are no necessary numbers";
+    if (sum == num) {
+      std::cout << vec[left] << "+" << vec[right] << "=" << num;
+      break;
+    }
+    if (sum < num)
+      ++left;
+    else
+      --right;
+  }
+}

task_01/src/sum_two_num.h

@@ -0,0 +1,3 @@
+#include <vector>
+
+void FindSumTwoNum(std::vector<int>& vec, int len, int num);

task_01/src/test.cpp

@@ -1,5 +1,48 @@
 #include <gtest/gtest.h>
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include <sstream>
+#include <string>
+
+#include "sum_two_num.h"
+
+static std::string captureOutput(std::vector<int>& vec, int len, int num) {
+  std::stringstream buffer;
+  std::streambuf* old = std::cout.rdbuf(buffer.rdbuf());
+
+  FindSumTwoNum(vec, len, num);
+
+  std::cout.rdbuf(old);
+  return buffer.str();
+}
+
+TEST(SumTwoNum, Simple) {
+  std::vector<int> vec = {1, 2, 3, 4, 6, 8};
+  std::string output = captureOutput(vec, 6, 6);
+  EXPECT_TRUE(output == "2+4=6" ||
+              output == "There are no necessary numbers 2+4=6");
+}
+
+TEST(SumTwoNum, NoPairFound) {
+  std::vector<int> vec = {1, 2, 3, 4, 6, 8};
+  std::string output = captureOutput(vec, 6, 20);
+  EXPECT_TRUE(output.empty() || output == "There are no necessary numbers");
+}
+
+TEST(SumTwoNum, EmptyInput) {
+  std::vector<int> vec = {};
+  std::string output = captureOutput(vec, 0, 5);
+  EXPECT_TRUE(output.empty() || output == "There are no necessary numbers");
+}
+
+TEST(SumTwoNum, SingleElement) {
+  std::vector<int> vec = {5};
+  std::string output = captureOutput(vec, 1, 5);
+  EXPECT_TRUE(output == "There are no necessary numbers" || output.empty());
+}
+
+TEST(SumTwoNum, EdgeCase) {
+  std::vector<int> vec = {3, 5};
+  std::string output = captureOutput(vec, 2, 8);
+  EXPECT_TRUE(output == "3+5=8" ||
+              output == "There are no necessary numbers 3+5=8");
 }

task_03/src/test.cpp

@@ -1,8 +1,36 @@
 
 #include <gtest/gtest.h>
 
+#include <vector>
+
 #include "topology_sort.hpp"
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+TEST(TopologyFuncTest, OrdinaryWeek) {
+  std::vector<int> temperatures = {73, 74, 75, 71, 69, 72, 76, 73};
+  std::vector<int> expected = {1, 1, 4, 2, 1, 1, 0, 0};
+  ASSERT_EQ(TopologySort(temperatures), expected);
+}
+
+TEST(TopologyFuncTest, EmptyInput) {
+  std::vector<int> temperatures = {};
+  std::vector<int> expected = {};
+  ASSERT_EQ(TopologySort(temperatures), expected);
+}
+
+TEST(TopologyFuncTest, SingleDay) {
+  std::vector<int> temperatures = {30};
+  std::vector<int> expected = {0};
+  ASSERT_EQ(TopologySort(temperatures), expected);
+}
+
+TEST(TopologyFuncTest, IncreasingTemperatures) {
+  std::vector<int> temperatures = {10, 20, 30, 40};
+  std::vector<int> expected = {1, 1, 1, 0};
+  ASSERT_EQ(TopologySort(temperatures), expected);
 }
+
+TEST(TopologyFuncTest, MixedTemperatures) {
+  std::vector<int> temperatures = {73, 74, 75, 71, 69, 72, 76, 73};
+  std::vector<int> expected = {1, 1, 4, 2, 1, 1, 0, 0};
+  ASSERT_EQ(TopologySort(temperatures), expected);
+}

task_03/src/topology_sort.cpp

@@ -1 +1,19 @@
 #include "topology_sort.hpp"
+
+#include <stack>
+
+std::vector<int> TopologySort(const std::vector<int>& temperatures) {
+  std::vector<int> result(temperatures.size(), 0);
+  std::stack<std::pair<int, int>> s;
+
+  for (int i{0}; i < temperatures.size(); ++i) {
+    while (!s.empty() && temperatures[i] > s.top().first) {
+      int prev_index = s.top().second;
+      result[prev_index] = i - prev_index;
+      s.pop();
+    }
+    s.push({temperatures[i], i});
+  }
+
+  return result;
+}

task_03/src/topology_sort.hpp

@@ -1 +1,4 @@
 #pragma once
+#include <vector>
+
+std::vector<int> TopologySort(const std::vector<int>& temperatures);

task_04/src/main.cpp

@@ -1,3 +1,5 @@
 #include <iostream>
 
+// Задача на жадный алгоритмы, которые мы будем проходить в следующем семестре
+// Разрешили не делать
 int main() { return 0; }

task_04/src/test.cpp

@@ -1,6 +1,9 @@
 
 #include <gtest/gtest.h>
 
+// Задача на жадный алгоритмы, которые мы будем проходить в следующем семестре
+// Разрешили не делать
+
 TEST(TopologySort, Simple) {
   ASSERT_EQ(1, 1);  // Stack []
 }

task_05/src/bubble_sort.cpp

@@ -0,0 +1,14 @@
+#include "bubble_sort.hpp"
+
+void BubbleSort(std::vector<int>& vec) {
+  int n = vec.size();
+
+  while (n > 1) {
+    for (size_t j = 0; j < n - 1; j++) {
+      if (vec[j] > vec[j + 1]) {
+        std::swap(vec[j], vec[j + 1]);
+      }
+    }
+    n--;
+  }
+}

task_05/src/bubble_sort.hpp

@@ -0,0 +1,18 @@
+/*                                                       Сортировка пузырьком
+Выполняется некоторое количество проходов по массиву — начиная от начала
+массива, перебираются пары соседних элементов массива. Если 1-й элемент пары
+больше 2-го, элементы переставляются (выполняется обмен). Пары элементов массива
+перебираются (проходы по массиву повторяются) либо (n - 1) раз либо до тех пор,
+пока на очередном проходе не обнаружится, что более не требуется выполнять
+перестановки (обмены) (массив отсортирован). При каждом проходе алгоритма по
+внутреннему циклу очередной наибольший элемент массива ставится на своё место в
+конце массива рядом с предыдущим «наибольшим элементом», а наименьший элемент
+перемещается на одну позицию к началу массива (как бы «всплывает» до нужной
+позиции, как пузырёк в воде — откуда и название алгоритма).
+*/
+
+// В худшем и среднем случае O( n^2 ). В лучшем случае O( n )
+
+#include <vector>
+
+void BubbleSort(std::vector<int>& vec);

task_05/src/insertion_sort.cpp

@@ -0,0 +1,17 @@
+#include "insertion_sort.hpp"
+
+void InsertionSort(std::vector<int>& vec) {
+  int n = vec.size();
+
+  for (size_t i = 0; i < n; i++) {
+    for (size_t j = i; j > 0; j--) {
+      if (vec[j] < vec[j - 1]) {
+        std::swap(vec[j], vec[j - 1]);
+        continue;
+      }
+      if (vec[j] >= vec[j - 1]) {
+        break;
+      }
+    }
+  }
+}

task_05/src/insertion_sort.hpp

@@ -0,0 +1,11 @@
+/*                                          Сортировка вставкой
+Aлгоритм сортировки, в котором элементы входной последовательности
+просматриваются по одному, и каждый новый поступивший элемент размещается в
+подходящее место среди ранее упорядоченных элементов
+*/
+
+// В худшем и среднем случае O( n^2 ). В лучшем случае O( n )
+
+#include <vector>
+
+void InsertionSort(std::vector<int>& vec);

task_05/src/merge_sort.cpp

@@ -0,0 +1,49 @@
+#include "merge_sort.hpp"
+
+int Mmax(int a, int b) { return a >= b ? a : b; }
+int Mmin(int a, int b) { return a <= b ? a : b; }
+
+std::vector<int> Sslice(const std::vector<int>& vector, const size_t from,
+                        const size_t to) {
+  if (from < to)
+    return std::vector<int>{vector.begin() + from, vector.begin() + to};
+  else
+    return std::vector<int>{};
+}
+
+std::vector<int> Merge(std::vector<int>& left, std::vector<int>& right) {
+  std::vector<int> nw;
+  size_t i_l = 0;
+  size_t i_r = 0;
+  size_t size_l = left.size();
+  size_t size_r = right.size();
+  while (i_l < size_l && i_r < size_r) {
+    if (left[i_l] < right[i_r]) {
+      nw.push_back(left[i_l]);
+      ++i_l;
+    } else {
+      nw.push_back(right[i_r]);
+      ++i_r;
+    }
+  }
+  if (i_l >= size_l) {
+    for (size_t i = i_r; i < size_r; ++i) nw.push_back(right[i]);
+    return nw;
+  }
+  if (i_r >= size_r) {
+    for (size_t i = i_l; i < size_l; ++i) nw.push_back(left[i]);
+    return nw;
+  }
+  return nw;
+}
+void MergeSort(std::vector<int>& vec) {
+  int n = vec.size();
+  if (n <= 1) return;
+  std::vector<int> left = Sslice(vec, 0, n / 2);
+  std::vector<int> right = Sslice(vec, n / 2, n);
+
+  MergeSort(left);
+  MergeSort(right);
+
+  vec = Merge(left, right);
+}

task_05/src/merge_sort.hpp

@@ -0,0 +1,35 @@
+/*                                                                Сортировка
+слиянием
+
+1. Сортируемый массив разбивается на две части примерно одинакового размера;
+2. Каждая из получившихся частей сортируется отдельно, например — тем же самым
+алгоритмом;
+3. Два упорядоченных массива половинного размера соединяются в один.
+1.1. — 2.1. Рекурсивное разбиение задачи на меньшие происходит до тех пор, пока
+размер массива не достигнет единицы (любой массив длины 1 можно считать
+упорядоченным).
+
+3.1. Соединение двух упорядоченных массивов в один.
+Основную идею слияния двух отсортированных массивов можно объяснить на следующем
+примере. Пусть мы имеем два уже отсортированных по возрастанию подмассива.
+Тогда: 3.2. Слияние двух подмассивов в третий результирующий массив. На каждом
+шаге мы берём меньший из двух первых элементов подмассивов и записываем его в
+результирующий массив. Счётчики номеров элементов результирующего массива и
+подмассива, из которого был взят элемент, увеличиваем на 1. 3.3. «Прицепление»
+остатка. Когда один из подмассивов закончился, мы добавляем все оставшиеся
+элементы второго подмассива в результирующий массив.
+*/
+
+// Всегда (и в среднем, и в худшем, и в лучшем случае) O(n*log(n))
+
+#include <vector>
+
+int Mmax(int a, int b);
+int Mmin(int a, int b);
+
+std::vector<int> Sslice(const std::vector<int>& vector, const size_t from,
+                        const size_t to);
+
+std::vector<int> Merge(std::vector<int>& left, std::vector<int>& right);
+
+void MergeSort(std::vector<int>& vec);

task_05/src/q_sort.cpp

@@ -0,0 +1,35 @@
+#include "q_sort.hpp"
+
+#include <algorithm>
+#include <cstdlib>
+
+int Partition(std::vector<int> &arr, int low, int high) {
+  int pivot_index = low + rand() % (high - low + 1);
+  int pivot = arr[pivot_index];
+
+  std::swap(arr[pivot_index], arr[high]);
+
+  int i = low;  // Указатель на место для следующего меньшего элемента
+
+  for (int j = low; j < high; j++) {
+    if (arr[j] <= pivot) {
+      std::swap(arr[i], arr[j]);
+      i++;
+    }
+  }
+  // Возвращаем опорный элемент на правильную позицию
+  std::swap(arr[i], arr[high]);
+  return i;
+}
+
+void QSortWithI(std::vector<int> &arr, int low, int high) {
+  if (low < high) {
+    // pi - индекс разделения, arr[pi] теперь на правильном месте
+    int pi = Partition(arr, low, high);
+
+    QSortWithI(arr, low, pi - 1);
+    QSortWithI(arr, pi + 1, high);
+  }
+}
+
+void QSort(std::vector<int> &arr) { QSortWithI(arr, 0, arr.size() - 1); }

task_05/src/q_sort.hpp

@@ -0,0 +1,11 @@
+/*
+Добавил другой вариант быстрой сортировки
+*/
+
+#include <vector>
+
+int Partition(std::vector<int>& arr, int low, int high);
+
+void QSortWithI(std::vector<int>& arr, int low, int high);
+
+void QSort(std::vector<int>& arr);

task_05/src/quick_sort.cpp

@@ -0,0 +1,30 @@
+#include "quick_sort.hpp"
+
+void QuickSortWithI(std::vector<int>& vec, int first, int last) {
+  if (last - first <= 0) return;
+  int index_big = last + 1;
+  for (size_t i = first + 1; i <= last; ++i) {
+    if (vec[i] > vec[first]) {
+      if (index_big != last + 1) continue;
+      index_big = i;
+    } else {
+      if (index_big == last + 1)
+        continue;
+      else {
+        int tmp = vec[index_big];
+        vec[index_big] = vec[i];
+        vec[i] = tmp;
+        index_big++;
+      }
+    }
+  }
+  int tmp = vec[index_big - 1];
+  vec[index_big - 1] = vec[first];
+  vec[first] = tmp;
+  QuickSortWithI(vec, first, index_big - 2);
+  QuickSortWithI(vec, index_big, last);
+}
+
+void QuickSort(std::vector<int>& vec) {
+  QuickSortWithI(vec, 0, vec.size() - 1);
+}