Homework

sandbox/template/src/sem.cpp

@@ -0,0 +1,31 @@
+/*
+#include <iostream>
+#include <stdexcept>
+
+class Array {
+  // template < typename T, int Size> class Array {
+ public:
+  Array(int size) : size_(size), data_(new int(size)) {}
+  ~Array() { delete[] data_; }  // деструктор
+
+  int Size() { return size_; }
+  int operator{}(int index) { return data_[index]; }
+  int operator()(int index) {
+    if (index < 0 || index >= size_) {
+      throw std::out_of_range("oor");
+    }
+    return data_[index];
+  }
+
+ private:
+  const int *data_;
+  const int size_;
+}
+
+int main(){
+  Array a(10);
+  std::cout << "first: " << a[0];
+
+  return 0;
+}
+*/

task_01/src/median.hpp

@@ -0,0 +1,7 @@
+#include <algorithm>
+
+inline int median(int first_number, int second_number, int third_number) {
+  int mi{std::min(first_number, std::min(second_number, third_number))},
+      ma{std::max(first_number, std::max(second_number, third_number))};
+  return (first_number + second_number + third_number - ma - mi);
+}

task_01/src/test.cpp

@@ -1,5 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <sum.hpp>
-
-TEST(Test, Simple) { ASSERT_EQ(Sum(1, 2, 3), 6); }

task_02/src/max_in_vector.hpp

@@ -0,0 +1,10 @@
+#include <algorithm>
+#include <vector>
+
+inline int max_in_vector(const std::vector<int>& vec, int len) {
+  int ma{-10000000};
+  for (int i{0}; i < len; ++i) {
+    ma = std::max(ma, vec[i]);
+  }
+  return ma;
+}

task_02/src/test.cpp

@@ -1,5 +1,30 @@
 #include <gtest/gtest.h>
 
-TEST(Test, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include <vector>
+
+#include "max_in_vector.hpp"
+
+TEST(max_value, normal) {
+  std::vector<int> a{1, 2, 3, 4};
+  ASSERT_EQ(max_in_vector(a, 4), 4);
+}
+
+TEST(max_value, unsorted) {
+  std::vector<int> a{5, 16, 7, 48, 3, 13};
+  ASSERT_EQ(max_in_vector(a, 6), 48);
+}
+
+TEST(max_value, bellow_zero) {
+  std::vector<int> a{-1, -5, -6, -10, -3};
+  ASSERT_EQ(max_in_vector(a, 5), -1);
+}
+
+TEST(max_value, repeated) {
+  std::vector<int> a{1, 2, 2, 2, 2, 5, 5, 5};
+  ASSERT_EQ(max_in_vector(a, 8), 5);
+}
+
+TEST(max_value, all) {
+  std::vector<int> a{7, 0, -5, 13, 14, -48, 7, 18, 17, 1, -30};
+  ASSERT_EQ(max_in_vector(a, 11), 18);
 }

task_03/src/reverse.cpp

@@ -1,3 +1,9 @@
 #include "reverse.hpp"
 
-void Reverse(int *array, size_t len) {}
+void Reverse(std::vector<int> *array, size_t len) {
+  for (unsigned int i{0}; i < len / 2; ++i) {
+    int mem = (*array)[i];
+    (*array)[i] = (*array)[len - 1 - i];
+    (*array)[len - 1 - i] = mem;
+  }
+}

task_03/src/reverse.hpp

@@ -1,5 +1,5 @@
 #pragma once
-
 #include <cstddef>
+#include <vector>
 
-void Reverse(int *array, size_t len);
+void Reverse(std::vector<int> *array, size_t len);

task_03/src/test.cpp

@@ -1,6 +1,29 @@
-
 #include <gtest/gtest.h>
 
+#include <vector>
+
 #include "reverse.hpp"
 
-TEST(Reverse, Simple) {}
+TEST(Reverse, normal) {
+  std ::vector<int> a{1, 2, 3, 4};
+  std ::vector<int> b{4, 3, 2, 1};
+  std::vector<int> *pa = &a;
+  Reverse(pa, a.size());
+  ASSERT_EQ(a, b);
+}
+
+TEST(Reverse, bellow_zero) {
+  std ::vector<int> a{-5, -3, -10};
+  std ::vector<int> b{-10, -3, -5};
+  std::vector<int> *pa = &a;
+  Reverse(pa, a.size());
+  ASSERT_EQ(a, b);
+}
+
+TEST(Reverse, repeated) {
+  std ::vector<int> a{1, 1, 1, 1};
+  std ::vector<int> b{1, 1, 1, 1};
+  std::vector<int> *pa = &a;
+  Reverse(pa, a.size());
+  ASSERT_EQ(a, b);
+}

task_04/src/offseter.cpp

@@ -0,0 +1,15 @@
+#include "offsetter.hpp"
+
+void offsetter(std::vector<int> *array, size_t len, int n) {
+  std::vector<int> memory = (*array);
+  if (n >= len) {
+    n = n - len;
+  }
+  for (unsigned int i{0}; i < len; ++i) {
+    if (i < n) {
+      (*array)[i] = memory[len - n + i];
+    } else {
+      (*array)[i] = memory[i - n];
+    }
+  }
+}

task_04/src/offsetter.hpp

@@ -0,0 +1,4 @@
+#include <cstddef>
+#include <vector>
+
+void offsetter(std::vector<int> *array, size_t len, int n);

task_04/src/test.cpp

@@ -1,6 +1,88 @@
-
 #include <gtest/gtest.h>
 
-TEST(TopologySort, Simple) {
-  ASSERT_EQ(1, 1);  // Stack []
+#include <offsetter.hpp>
+
+TEST(task4, normal1) {
+  std ::vector<int> a{7, 32, 15, 0, 67, 1, 67, 90};
+  std ::vector<int> b{15, 0, 67, 1, 67, 90, 7, 32};
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 6);
+  ASSERT_EQ(a, b);
+}
+
+TEST(task4, cycle1) {
+  std ::vector<int> a{7, 32, 15, 0, 67, 1, 67, 90};
+  std ::vector<int> b{15, 0, 67, 1, 67, 90, 7, 32};
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 6);
+  ASSERT_EQ(a, b);
+}
+
+TEST(task4, cycle2) {
+  std ::vector<int> a{7, 32, 15, 0, 67, 1, 67, 90};
+  std ::vector<int> b{15, 0, 67, 1, 67, 90, 7, 32};
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 6);
+  ASSERT_EQ(a, b);
+}
+
+TEST(task4, normal2) {
+  std ::vector<int> a{5, 19, 4, 72, 85, 1, 4, 6};
+  std ::vector<int> b{1, 4, 6, 5, 19, 4, 72, 85};
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 11);
+  ASSERT_EQ(a, b);
+}
+
+TEST(task4, bellow_zero) {
+  std ::vector<int> a{-1, 3, 5, 10, -8};
+  std ::vector<int> b{10, -8, -1, 3, 5};
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 2);
+  ASSERT_EQ(a, b);
 }
+
+TEST(task4, big_test1) {
+  std ::vector<int> a{};
+  for (int i{0}; i < 100; ++i) a.push_back(11);
+  std ::vector<int> b = a;
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 1);
+  ASSERT_EQ(b, a);
+}
+
+TEST(task4, big_test2) {
+  std ::vector<int> a{};
+  for (int i{0}; i < 10000; ++i) a.push_back(11);
+  std ::vector<int> b = a;
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 100);
+  ASSERT_EQ(b, a);
+}
+
+TEST(task4, big_test3) {
+  std ::vector<int> a{};
+  for (int i{0}; i < 1000000; ++i) a.push_back(11);
+  std ::vector<int> b = a;
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 1000);
+  ASSERT_EQ(b, a);
+}
+
+TEST(task4, big_test4) {
+  std ::vector<int> a{};
+  for (int i{0}; i < 10000000; ++i) a.push_back(11);
+  std ::vector<int> b = a;
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 10000000);
+  ASSERT_EQ(b, a);
+}
+
+TEST(task4, big_test_final) {
+  std ::vector<int> a{};
+  for (int i{0}; i < 100000000; ++i) a.push_back(11);
+  std ::vector<int> b = a;
+  std::vector<int> *pa = &a;
+  offsetter(pa, a.size(), 1000000000);
+  ASSERT_EQ(b, a);
+}