restruct folders and base approach

README.md

@@ -2,8 +2,13 @@
 
 Итого:
 
-1. Сортировка вставками.
-2. Нахождение наибольшего общего делителя.
-3. Нахождение все простых множителей заданного числа. (в работе)
-4. Сортировка слиянием. (в работе)
-5. Возведение в степень.
+В работе (tmp):
+- Нахождение все простых множителей заданного числа.
+- Сортировка слиянием.
+- Сортировка вставками.
+- Нахождение наибольшего общего делителя.
+- Возведение в степень.
+- Проверка на простоту числа.
+- Нахождение всех простых числе до заданного.
+
+Рассмотрены

bin/main.cpp

@@ -1,50 +1,50 @@
 #include <hack/logger/logger.hpp>
 
-#include "base/insertion_sort.hpp"
-#include "base/merge_sort.hpp"
-#include "base/merge_sort.v2.hpp"
-
-#include "numbers/gcd.hpp"
-#include "numbers/prime_factors.hpp"
-#include "numbers/pow.hpp"
-#include "numbers/is_prime.hpp"
+#include "sort/insertion.hpp"
 
 auto main() -> int
 {
   {
-    hack::log()(alg::is_prime(2));
-    return 1;
-  }
-
-  {
-    hack::log()(alg::pow(3.0, 2), alg::pow(3.0, 3));
-  }
-  
-  {
-    std::vector<int> v { 5, 4, 1, 5, 6 };
-    alg::insertion_sort(v);
+    std::vector<int> v { 5, 4, 1, 3, 6, 9, 7, 2, 8, 0, 10 };
+    // alg::sort::insertion(v, 0, v.size() - 1);
+    alg::sort::insertion(v);
     hack::log()(v);
+    return 0;
   }
 
-  {
-    std::vector<int> v { 16, 7, 10, 1, 5, 11, 3, 8, 14, 4, 2, 12, 6, 13, 9, 15 };
-    alg_v2::merge_sort(v);
-    hack::log()(v);
-  }
-
-  {
-    hack::log()(alg::gcd(4851, 3003));
-    hack::log()(alg::gcd(64, 28));
-  }
-
-  {
-    hack::log()(alg::prime_factors_v1(127));
-    hack::log()(alg::prime_factors_v1(128));
-    hack::log()(alg::prime_factors_v1(130));
-
-    hack::log()(alg::prime_factors_v2(127));
-    hack::log()(alg::prime_factors_v2(128));
-    hack::log()(alg::prime_factors_v2(130));
-  }
+  // {
+  //   hack::log()(alg::find_primes(50));
+  //   return 1;
+  // }
+  //
+  // {
+  //   hack::log()(alg::is_prime(2));
+  // }
+  //
+  // {
+  //   hack::log()(alg::pow(3.0, 2), alg::pow(3.0, 3));
+  // }
+  // 
+  //
+  // {
+  //   std::vector<int> v { 16, 7, 10, 1, 5, 11, 3, 8, 14, 4, 2, 12, 6, 13, 9, 15 };
+  //   alg_v2::merge_sort(v);
+  //   hack::log()(v);
+  // }
+  //
+  // {
+  //   hack::log()(alg::gcd(4851, 3003));
+  //   hack::log()(alg::gcd(64, 28));
+  // }
+  //
+  // {
+  //   hack::log()(alg::prime_factors_v1(127));
+  //   hack::log()(alg::prime_factors_v1(128));
+  //   hack::log()(alg::prime_factors_v1(130));
+  //
+  //   hack::log()(alg::prime_factors_v2(127));
+  //   hack::log()(alg::prime_factors_v2(128));
+  //   hack::log()(alg::prime_factors_v2(130));
+  // }
 }
 

src/base/insertion_sort.hpp

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <hack/logger/logger.hpp>
-
-// Сортировка вставкой
-// Эффективна на мелких массивах. Сложнгость O(N^2)
-namespace alg
-{
-  inline void insertion_sort(std::vector<int>& v)
-  {
-    for (std::size_t i = 1; i < v.size(); ++i)
-    {
-      auto key = v[i];
-      auto j = i;
-
-      while (j > 0 && v[j - 1] > key)
-      {
-        v[j] = v[j - 1];
-        --j;
-      }
-      v[j] =  key;
-    }
-  }
-}
-

src/meson.build

@@ -1,9 +1,6 @@
 inc += include_directories('.')
 
 headers = [
-  'base/insertion_sort.hpp',
-  'numbers/gcd.hpp',
-  'numbers/prime_factors.hpp'
 ]
 
 sources = [ 
@@ -17,9 +14,9 @@ lib = library(
   cpp_args: args
 )
 
-dsp_sdk_dep = declare_dependency(
+alg_dep = declare_dependency(
   include_directories: inc, 
   link_with: lib 
 )
 
-deps += dsp_sdk_dep
+deps += alg_dep

src/sort/insertion.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <vector>
+
+/*
+ Сортировка вставками.
+ Для небольших массивов стабильна и является самой быстрой. Её можно использовать
+ как вспомогательную при реализации других сортировок.
+
+ Сортировка стабильна, если равные элементы сохраняют свой первоначальный порядок относительно друг друга.
+ 
+ Смысл следующий: Считаем что элемент с индексом 0 является как бы массивом(1) с уже отсотрированным элементом.
+ И далее, каждый появляющийся элемент мы сравниваем с элементом из массива(1) и если он меньше, то перемещаем его дальше вглубь массива(1)
+ При удачном раскладе и небольших данных работает
+
+ В наихудшем случае сложность алгоритма = O(N^2). Т.к. нам нужно будет пробежаться по каждому элементу из масива массивов
+
+ ДОПИСАТЬ ТЕКСТ ДАЛЬШЕ ПРО НАИЛУЧШИЙ И СРЕДНИЙ СЛУЧАЙ
+ */
+namespace alg::sort
+{
+  template<typename Item>
+  void insertion(std::vector<Item>& v, std::size_t left, std::size_t right)
+  {
+    for (std::size_t i = left + 1; i <= right; ++i)
+    {
+      Item e = v[i];
+      std::size_t j = i;
+      while (j > left && e < v[j - 1])
+      {
+        v[j] = v[j - 1];
+        --j;
+      }
+      v[j] = e;
+    }
+  }
+
+  template<typename Item>
+  void insertion(std::vector<Item>& v)
+  {
+    insertion(v, 0, v.size() - 1);
+  }
+}

src/tmp/numbers/find_primes.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <vector>
+
+// находит все простые числа от 0 до n
+namespace alg
+{
+  inline std::vector<int> find_primes(int n)
+  {
+    std::vector<int> r;
+    std::vector<bool> is_prime(n + 1, true);
+
+    // 0 и 1 не являются простыми числами
+    is_prime[0] = is_prime[1] = false;
+
+    // Исключаем все чётные числа, кроме 2
+    for (int i = 4; i <= n; i += 2) is_prime[i] = false;
+
+    // Перебираем только нечётные числа, начиная с 3
+    for (int p = 3; p * p <= n; p += 2) 
+      if (is_prime[p]) 
+        for (int i = p * p; i <= n; i += 2 * p) is_prime[i] = false;
+
+    for (int p = 3; p <= n; p += 2) 
+      if (is_prime[p]) r.push_back(p);
+
+    return r;
+  }
+}
+