Курсовая работа

Part2/4Lab/Kursov.cpp

@@ -0,0 +1,184 @@
+#include <time.h>
+#include <chrono>
+#include <fstream>
+#include <string>
+#include <set>
+#include <vector>
+#include <iterator>
+#include <algorithm>
+#include <iostream>
+
+using namespace std;
+using MySet = set<int>;
+using MyIt = set<int>::iterator;
+using MySeq = vector<MyIt>;
+const int lim = 16;
+
+class MyCont {
+    int power;
+    char tag;
+    MySet setA;
+    MySeq Sequence;
+    MyCont& operator = (const MyCont&) = delete;
+    MyCont& operator = (MyCont&&) = delete;
+
+public:
+    MyCont(int, char);
+    MyCont(const MyCont&);
+    MyCont(MyCont&&);
+    MyCont& operator |= (const MyCont&);
+    MyCont operator | (const MyCont& rgt) const{
+        MyCont result(*this); return (result |= rgt);
+    }
+
+    MyCont& operator -= (const MyCont&);
+    MyCont operator - (const MyCont& rgt) const {
+        MyCont result(*this); return (result -= rgt);
+    }
+    MyCont& operator ^= (const MyCont&);
+    MyCont operator ^ (const MyCont& rgt) const
+    {
+        MyCont result(*this); return (result ^= rgt);
+    }
+    void Merge(const MyCont&);
+    void Concat(const MyCont& rgt);
+    void Subst(const MyCont&, size_t);
+    void Change(const MyCont&, size_t);
+    void Show() const;
+    size_t Power() const { return Sequence.size(); }
+
+};
+
+MyCont::MyCont(int p, char t = 'R') : power(p), tag(t) {
+    for (int i = 0; i < power; ++i){
+        Sequence.push_back(setA.insert(rand() % lim).first);
+    }
+}
+
+MyCont::MyCont(MyCont&& source) //Копия "с переносом"
+        : power(source.power), tag(source.tag),
+          setA(move(source.setA)), Sequence(move(source.Sequence)) { }
+
+MyCont::MyCont(const MyCont& source) //Конструктор копии
+        : power(source.power), tag(source.tag) {
+    for (auto x : source.setA) Sequence.push_back(setA.insert(x).first);
+}
+
+void MyCont::Show() const {
+    using std::cout;
+    cout << "\n" << tag << ": ";
+    for (auto x : setA) cout << x << " "; //Выдача множества
+    cout << "\n < ";
+    for (auto x : Sequence) cout << *x << " "; //Выдача последовательности
+    cout << ">";
+}
+
+MyCont& MyCont::operator -= (const MyCont& rgt) { //Разность мн-в
+    MySet temp;
+    MySeq stemp;
+    for (auto x : setA)
+        if (rgt.setA.find(x) == rgt.setA.end())
+            stemp.push_back(temp.insert(x).first);
+    temp.swap(setA);
+    stemp.swap(Sequence);
+    return *this;
+}
+
+MyCont& MyCont::operator |= (const MyCont& rgt) { //Объединение
+    for (auto x : rgt.setA) Sequence.push_back(setA.insert(x).first);
+    return *this;
+}
+
+void MyCont::Merge(const MyCont& rgt) { //Слияние
+    using std::sort;
+    MySeq temp(rgt.Sequence), res;
+    auto le = [](MyIt a, MyIt b)->bool { return *a < *b; };//Критерий
+    sort(Sequence.begin(), Sequence.end(), le);
+    sort(temp.begin(), temp.end(), le);
+    std::merge(Sequence.begin(), Sequence.end(), temp.begin(), temp.end(),
+               std::back_inserter(res), le); //Слияние для последовательностей...
+    setA.insert(rgt.setA.begin(), rgt.setA.end()); //... и объединение множеств
+    Sequence.swap(res);
+}
+
+void MyCont::Concat(const MyCont& rgt) { //Сцепление
+    for (auto x : rgt.Sequence) Sequence.push_back(setA.insert(*x).first);
+}
+
+void MyCont::Subst(const MyCont& rgt, size_t p) { //Подстановка
+    if (p >= Power()) Concat(rgt);
+    else {
+        MySeq stemp(Sequence.begin(), Sequence.begin() + p); //Начало
+        std::copy(rgt.Sequence.begin(), rgt.Sequence.end(), back_inserter(stemp)); //Вставка
+        std::copy(Sequence.begin() + p, Sequence.end(), back_inserter(stemp)); //Окончание
+        MySet temp;
+        Sequence.clear();
+        for (auto x : stemp) Sequence.push_back(temp.insert(*x).first);
+        setA.swap(temp);
+    }
+
+}
+
+void MyCont::Change(const MyCont& rgt, size_t p) { //Замена
+    if (p >= Power()) Concat(rgt);
+    else {
+        MySeq stemp(Sequence.begin(), Sequence.begin() + p); //Начало
+        std::copy(rgt.Sequence.begin(), rgt.Sequence.end(), back_inserter(stemp));
+        //Замена
+        size_t q = p + rgt.Power();
+        if (q < Power())
+            std::copy(Sequence.begin() + q, Sequence.end(), back_inserter(stemp));
+        //Окончание
+        MySet temp;
+        Sequence.clear();
+        for (auto x : stemp) Sequence.push_back(temp.insert(*x).first);
+        setA.swap(temp);
+
+    }
+
+}
+
+int main() {
+    using namespace std::chrono;
+    setlocale(LC_ALL, "Russian");
+    srand((unsigned int)7); //Пока здесь константа, данные повторяются
+    // srand((unsigned int)time(nullptr)); //Разблокировать для случайных данных
+    auto rand = [](int d) { return std::rand() % d; }; //Лямбда-функция!
+    ofstream fout;
+    fout.open("in.txt");
+
+    for (int p = 10; p < 5000; p += 10) {
+        int middle_power = 0, set_count = 0;
+        auto Used = [&](MyCont& t) { middle_power += t.Power(); ++set_count; };
+
+        MyCont A(p, 'A');
+        MyCont B(p, 'B');
+        MyCont C(p, 'C');
+        MyCont D(p, 'D');
+        MyCont E(p, 'E');
+        MyCont F(p, 'F');
+        MyCont G(p, 'G');
+        MyCont H(p, 'H');
+        MyCont R(p);
+
+        auto t1 = std::chrono::high_resolution_clock::now();
+        A | B; Used(A); Used(B);
+        C | D; Used(C); Used(D);
+        (A | B) - (C | D); Used(A); Used(B); Used(C); Used(D);
+        ((A | B) - (C | D)) | E; Used(A); Used(B); Used(C); Used(D); Used(E);
+        R.Merge(E); Used(R); Used(E);
+        int c = rand(R.Power());
+        R.Subst(G, c); Used(R); Used(G);
+        c = rand(R.Power());
+        R.Change(H, c); Used(R); Used(H);
+        auto t2 = std::chrono::high_resolution_clock::now();
+        auto dt = duration_cast<duration<double>>(t2 - t1);
+        middle_power /= set_count;
+        fout << middle_power << ' ' << dt.count() << endl;
+    }
+    cout << "The end\n";
+    fout.close();
+    std::cin.get();
+    return 0;
+}
+

Part2/4Lab/README.md

@@ -0,0 +1,4 @@
+# Курсовая работа
+На основе программы, составленной по лабораторной работе №3, выполнить статистический эксперимент по измерению фактической временной сложности алгоритма обработки данных, провести анализ.
+## Полезные ссылки
+RG41: https://bit.ly/3m9Hcio