Update 'Part2/4Lab/README.md'

Добавление ссылки на таблицу

Part1/Lab1/Mashinnoe/Lab1_1.cpp

@@ -0,0 +1,255 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <Windows.h>
+#include <cstdio>
+#include <time.h>
+#include <iomanip>
+using namespace std;
+
+const char universum[] = "ABCDEFGHIJKMNLOPQRSTUVWXYZ";
+const char filename[] = "Test_result.txt";
+const int length = 26;
+const int durationCoeff = 1000000;
+int customTestAmount = 0;
+char stringA[length], stringB[length], stringC[length], stringD[length];
+unsigned int vectorA, vectorB, vectorC, vectorD, vectorF;
+
+
+void setupConsole()
+{
+	setlocale(LC_ALL, "Russian");
+	SetConsoleOutputCP(1251);
+	SetConsoleCP(1251);
+	cout << fixed;
+	cout << setprecision(7);
+}
+
+void outputGreeting()
+{
+	cout << "Программа рассчитывает значение множества F согласно следующим законам - " << endl;
+	cout << "F = D && (A || B) && !C, что равносильно F = D*(A + B) - C." << endl;
+	cout << "Универсум: " << universum << endl;
+}
+
+void input()
+{
+	cout << endl;
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Введите множество A: ";
+	cin >> stringA;
+	cout << "Введите множество B: ";
+	cin >> stringB;
+	cout << "Введите множество C: ";
+	cin >> stringC;
+	cout << "Введите множество D: ";
+	cin >> stringD;
+
+	cout << endl;
+}
+
+bool isCorrectSymbol(char symbol)
+{
+	return ((symbol >= universum[0] && symbol <= universum[length - 1]) || symbol == '\0') ? 1 : 0;
+}
+
+bool isStringCorrect(char* string)
+{
+	for (int i = 0; i < length && string[i] != '\0'; i++)
+		if (!isCorrectSymbol(string[i]))
+			return 0;
+	return 1;
+}
+
+int memberToIndex(char member)
+{
+	return member - universum[0];
+}
+
+char indexToMember(int number)
+{
+	return number + universum[0];
+}
+
+unsigned int vectorFromString(const char string[])
+{
+	int vector = 0;
+	for (int i = 0; string[i]; ++i)
+		vector |= (1 << memberToIndex(string[i]));
+	return vector;
+};
+
+void convertSets()
+{
+	vectorA = vectorFromString(stringA);
+	vectorB = vectorFromString(stringB);
+	vectorC = vectorFromString(stringC);
+	vectorD = vectorFromString(stringD);
+}
+
+void calculateAnswer()
+{
+	vectorF = vectorD & (vectorA | vectorB) & ~vectorC;
+}
+
+void outputSetToConsole(int vector)
+{
+	for (int i = 0, k = 0; i < length; ++i)
+		if ((vector >> i) & 1)
+			cout << indexToMember(i);
+}
+
+void outputSetToFile(int vector, ofstream& output)
+{
+	for (int i = 0, k = 0; i < length; ++i)
+		if ((vector >> i) & 1)
+			output << indexToMember(i);
+}
+
+bool isSetEmpty(int vector)
+{
+	if (vector == 0)
+		return 1;
+	else return 0;
+}
+
+void outputAnswer()
+{
+	cout << "Ответ: F = ";
+	if (isSetEmpty(vectorF))
+		cout << "пустое множество";
+	else
+		outputSetToConsole(vectorF);
+	cout << endl;
+}
+
+double calulateDuration()
+{
+	double firstPoint, lastPoint, duration = 0;
+	for (int i = 0; i < durationCoeff; i++)
+	{
+		firstPoint = clock();
+		calculateAnswer();
+		lastPoint = clock();
+		duration += lastPoint - firstPoint;
+	}
+	return duration / durationCoeff;
+}
+
+void outputDuration()
+{
+	cout << endl;
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Временная сложность алгоритма - O(1), постоянное время" << endl;
+	cout << "На выполнение алгоритма уходит " << calulateDuration() << " секунд." << endl;
+	cout << endl;
+}
+
+float factorial(int number)
+{
+	float factorial = 1;
+	for (int i = 1; i <= number; i++)
+		factorial *= i;
+	return factorial;
+}
+
+int randomInt(int max)
+{
+	return rand() % (max + 1);
+}
+
+unsigned int randomVector(long long max)
+{
+	return (rand() * 2 + randomInt(1)) * (rand() * 2 + randomInt(3));
+}
+
+void fillVectors()
+{
+	unsigned int maxVector = pow(2, length) - 1;
+	for (int i = 0; i < length; i++)
+	{
+		vectorA = randomVector(maxVector);
+		vectorB = randomVector(maxVector);
+		vectorC = randomVector(maxVector);
+		vectorD = randomVector(maxVector);
+	}
+}
+
+void badInputLoop()
+{
+	while (cin.fail() || customTestAmount < 0)
+	{
+		cout << "Неправильный ввод, повторите еще раз:" << endl;
+		cin.clear();
+		cin.ignore(32767, '\n');
+		cin >> customTestAmount;
+	}
+}
+
+void testInfo()
+{
+	cout << setprecision(0);
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Из 26 символов может быть составлено " << factorial(length) << " перестановок" << endl;
+	cout << "Сколько программа должна проделать тестов со случайными комбинациями?" << endl;
+	cin >> customTestAmount;
+	badInputLoop();
+	if (customTestAmount > 0)
+		cout << "Отчеты будут выведены в файл " << filename << endl;
+	else cout << "Тесты не будут проделаны" << endl;
+}
+
+void outputTestAnswer(ofstream& output)
+{
+	if (isSetEmpty(vectorF))
+		output << "пустое множество";
+	else
+		outputSetToFile(vectorF, output);
+}
+
+void executeTest()
+{
+	ofstream output;
+	output.open(filename);
+	for (int i = 0; i < customTestAmount; i++)
+	{
+		fillVectors();
+		vectorF = 0;
+		output << "Множество A: ";
+		outputSetToFile(vectorA, output);
+		output << endl;
+		output << "Множество B: ";
+		outputSetToFile(vectorB, output);
+		output << endl;
+		output << "Множество C: ";
+		outputSetToFile(vectorC, output);
+		output << endl;
+		output << "Множество D: ";
+		outputSetToFile(vectorD, output);
+		output << endl;
+		calculateAnswer();
+		output << "Ответ: F = ";
+		outputTestAnswer(output);
+		output << endl;
+		output << '*' << endl;
+	}
+	output.close();
+}
+
+int main()
+{
+	setupConsole();
+	outputGreeting();
+	input();
+	while (!isStringCorrect(stringA) || !isStringCorrect(stringB) || !isStringCorrect(stringC) || !isStringCorrect(stringD))
+	{
+		cout << "Некорректный ввод" << endl;
+		input();
+	}
+	convertSets();
+	calculateAnswer();
+	outputAnswer();
+	outputDuration();
+	testInfo();
+	executeTest();
+}

Part1/Lab1/Mashinnoe/Test_result.txt

@@ -0,0 +1,60 @@
+Множество A: CDEHJKMNOTUVWYZ
+Множество B: CDEFGHJMQRSUVX
+Множество C: ACDEJNOPSUVWY
+Множество D: BEFGHJKLMNOPRTUVYZ
+Ответ: F = FGHKMRTZ
+*
+Множество A: CEFILMRSWY
+Множество B: BCFIJKNOPRSTVWY
+Множество C: BDEFIJKMOPQTUXYZ
+Множество D: CHLMNSUYZ
+Ответ: F = CLNS
+*
+Множество A: ABCEFGIJKNOQRTUVXYZ
+Множество B: GHINPRSXYZ
+Множество C: BCHJMNPQRSVWXZ
+Множество D: DEGLMNOPQWYZ
+Ответ: F = EGOY
+*
+Множество A: AHIJKMNOPQRSU
+Множество B: BEFGHIMNOQRSTVWXZ
+Множество C: BDEHIJKLOUVXY
+Множество D: BCDEFLNQSUVWXY
+Ответ: F = FNQSW
+*
+Множество A: AEFGJLNPVX
+Множество B: BFJNOQRTVXY
+Множество C: EFIJKMNOQRUXYZ
+Множество D: MNPRT
+Ответ: F = PT
+*
+Множество A: BCDEFHMOPRSTUX
+Множество B: DEIKPQRTVWZ
+Множество C: BCFJKMNOPRSXYZ
+Множество D: DHIKLOPQTY
+Ответ: F = DHIQT
+*
+Множество A: ABDGIJKMSVWXZ
+Множество B: CIMNOPQRSUVW
+Множество C: BCDFIKNSTUVWY
+Множество D: CGHIJLMRSUWXYZ
+Ответ: F = GJMRXZ
+*
+Множество A: ABDEHIRSTUWZ
+Множество B: ABDGIJLOSTUZ
+Множество C: ACEFHLOPTUWX
+Множество D: CIKNOPQZ
+Ответ: F = IZ
+*
+Множество A: CDEIJLMOQSTUWYZ
+Множество B: CFJKLMNOQTUVWXZ
+Множество C: AEJKMPRSWZ
+Множество D: ABFHIKLMORTY
+Ответ: F = FILOTY
+*
+Множество A: AHJLMNUVXYZ
+Множество B: BFHIJKLNORTVYZ
+Множество C: FGJKLNPRSWX
+Множество D: CHINPQRSTUV
+Ответ: F = HITUV
+*

Part1/Lab1/Massiv_simv/Lab1_3.cpp

@@ -0,0 +1,288 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <Windows.h>
+#include <cstdio>
+#include <time.h>
+#include <iomanip>
+using namespace std;
+
+const char universum[] = "ABCDEFGHIJKMNLOPQRSTUVWXYZ";
+const char filename[] = "Test_result.txt";
+const int length = 26;
+const int durationCoeff = 1000000;
+int customTestAmount = 0;
+char stringA[length], stringB[length], stringC[length], stringD[length];
+char vectorA[length], vectorB[length], vectorC[length], vectorD[length], vectorF[length];
+
+
+void setupConsole()
+{
+	setlocale(LC_ALL, "Russian");
+	SetConsoleOutputCP(1251);
+	SetConsoleCP(1251);
+	cout << fixed << setprecision(7);
+}
+
+void outputGreeting()
+{
+	cout << "Программа рассчитывает значение множества F согласно следующим законам - " << endl;
+	cout << "F = D && (A || B) && !C, что равносильно F = D*(A + B) - C." << endl;
+	cout << "Универсум: " << universum << endl;
+}
+
+void input()
+{
+	cout << endl;
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Введите множество A: ";
+	cin >> stringA;
+	cout << "Введите множество B: ";
+	cin >> stringB;
+	cout << "Введите множество C: ";
+	cin >> stringC;
+	cout << "Введите множество D: ";
+	cin >> stringD;
+
+	cout << endl;
+}
+
+bool isCorrectSymbol(char symbol)
+{
+	return ((symbol >= universum[0] && symbol <= universum[length - 1]) || symbol == '\0') ? 1 : 0;
+}
+
+bool isStringCorrect(char* string)
+{
+	for (int i = 0; i < length && string[i] != '\0'; i++)
+		if (!isCorrectSymbol(string[i]))
+			return 0;
+	return 1;
+}
+
+int memberToIndex(char member)
+{
+	return member - universum[0];
+}
+
+char indexToMember(int number)
+{
+	return number + universum[0];
+}
+
+void vectorFromString(char* vector, const char string[])
+{
+	for (int i = 0; string[i]; i++) {
+		int j = 0;
+		for (j = 0; j < i; j++) {
+			if (memberToIndex(string[i]) < memberToIndex(vector[j])) {
+				for (int k = i + 1; k > j; k--) {
+					vector[k] = vector[k - 1];
+				}
+				break;
+			}
+			if (memberToIndex(string[i]) == memberToIndex(vector[j])) {
+				j = -1;
+				break;
+			}
+		}
+		if(j != -1) vector[j] = string[i];
+	}
+};
+
+void convertSets()
+{
+	vectorFromString(vectorA, stringA);
+	vectorFromString(vectorB, stringB);
+	vectorFromString(vectorC, stringC);
+	vectorFromString(vectorD, stringD);
+}
+
+void calculateAnswer()
+{
+	for (int i = 0; vectorA[i]; i++)
+		vectorF[i] = vectorA[i];
+
+	int j = 0;
+	for (int i = 0; vectorB[i]; i++) {
+		while (j < strlen(vectorF) && memberToIndex(vectorB[i]) > memberToIndex(vectorF[j])) j++;
+		if (memberToIndex(vectorB[i]) != memberToIndex(vectorF[j])) {
+			for (int k = strlen(vectorF); k >= j; k--) vectorF[k + 1] = vectorF[k];
+			vectorF[j] = vectorB[i];
+		}
+	}
+
+	j = 0;
+	for (int i = 0; vectorC[i]; i++) {
+		while (j < strlen(vectorF) && memberToIndex(vectorC[i]) > memberToIndex(vectorF[j])) j++;
+		if (memberToIndex(vectorC[i]) == memberToIndex(vectorF[j])) {
+			for (int k = j; k < strlen(vectorF); k++) vectorF[k] = vectorF[k + 1];
+		}
+	}
+
+	j = 0;
+	for (int i = 0; vectorD[i]; i++) {
+		while (j < strlen(vectorF) && memberToIndex(vectorD[i]) > memberToIndex(vectorF[j])) {
+			for (int k = j; k < strlen(vectorF); k++) vectorF[k] = vectorF[k + 1];
+		}
+		if (memberToIndex(vectorD[i]) == memberToIndex(vectorF[j])) j++;
+	}
+	for (j; j < strlen(vectorF); j++) {
+		vectorF[j] = '\0';
+	}
+}
+
+void outputSetToConsole(char* vector)
+{
+	for (int i = 0; vector[i]; i++)
+		cout << vector[i];
+}
+
+void outputSetToFile(char* vector, ofstream& output)
+{
+	for (int i = 0; vector[i]; i++)
+		output << vector[i];
+}
+
+bool isSetEmpty(char* vector)
+{
+	return (vector[0] == '\0') ? true : false;
+}
+
+void outputAnswer()
+{
+	cout << "Ответ: F = ";
+	if (isSetEmpty(vectorF))
+		cout << "пустое множество";
+	else
+		outputSetToConsole(vectorF);
+	cout << endl;
+}
+
+double calulateDuration()
+{
+	double firstPoint, lastPoint, duration = 0;
+	for (int i = 0; i < durationCoeff; i++)
+	{
+		firstPoint = clock();
+		calculateAnswer();
+		lastPoint = clock();
+		duration += lastPoint - firstPoint;
+	}
+	return duration / durationCoeff;
+}
+
+void outputDuration()
+{
+	cout << endl;
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Временная сложность алгоритма - O(1), постоянное время" << endl;
+	cout << "На выполнение алгоритма уходит " << calulateDuration() << " секунд." << endl;
+	cout << endl;
+}
+
+float factorial(int number)
+{
+	float factorial = 1;
+	for (int i = 1; i <= number; i++)
+		factorial *= i;
+	return factorial;
+}
+
+bool randomVector()
+{
+	return rand() % 2;
+}
+
+void fillVectors()
+{
+	for (int i = 0; i < length; i++) {
+		vectorA[i] = '\0';
+		vectorB[i] = '\0';
+		vectorC[i] = '\0';
+		vectorD[i] = '\0';
+	}
+	for (int i = 0; i < length; i++) {
+		if (randomVector()) vectorA[strlen(vectorA)] = indexToMember(i);
+		if (randomVector()) vectorB[strlen(vectorB)] = indexToMember(i);
+		if (randomVector()) vectorC[strlen(vectorC)] = indexToMember(i);
+		if (randomVector()) vectorD[strlen(vectorD)] = indexToMember(i);
+	}
+}
+
+void clearAnswerVector()
+{
+	for (int i = 0; i < strlen(vectorF); i++)
+		vectorF[i] = '\0';
+}
+
+void badInputLoop()
+{
+	while (cin.fail() || customTestAmount < 0)
+	{
+		cout << "Неправильный ввод, повторите еще раз:" << endl;
+		cin.clear();
+		cin.ignore(32767, '\n');
+		cin >> customTestAmount;
+	}
+}
+
+void testInfo()
+{
+	cout << setprecision(0);
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Из 26 символов может быть составлено " << factorial(length) << " перестановок" << endl;
+	cout << "Сколько программа должна проделать тестов со случайными комбинациями?" << endl;
+	cin >> customTestAmount;
+	badInputLoop();
+	if (customTestAmount > 0)
+		cout << "Отчеты будут выведены в файл " << filename << endl;
+	else cout << "Тесты не будут проделаны" << endl;
+}
+
+void executeTest()
+{
+	ofstream output;
+	output.open(filename);
+	for (int i = 0; i < customTestAmount; i++)
+	{
+		fillVectors();
+		clearAnswerVector();
+		output << "Множество A: ";
+		outputSetToFile(vectorA, output);
+		output << endl;
+		output << "Множество B: ";
+		outputSetToFile(vectorB, output);
+		output << endl;
+		output << "Множество C: ";
+		outputSetToFile(vectorC, output);
+		output << endl;
+		output << "Множество D: ";
+		outputSetToFile(vectorD, output);
+		output << endl;
+		calculateAnswer();
+		output << "Ответ: F = ";
+		outputSetToFile(vectorF, output);
+		output << endl;
+		output << '*' << endl;
+	}
+	output.close();
+}
+
+int main()
+{
+	setupConsole();
+	outputGreeting();
+	input();
+	while (!isStringCorrect(stringA) || !isStringCorrect(stringB) || !isStringCorrect(stringC) || !isStringCorrect(stringD))
+	{
+		cout << "Некорректный ввод" << endl;
+		input();
+	}
+	convertSets();
+	calculateAnswer();
+	outputAnswer();
+	outputDuration();
+	testInfo();
+	executeTest();
+}

Part1/Lab1/Massiv_simv/Test_result.txt

@@ -0,0 +1,60 @@
+Множество A: ABDEFIJKLMOUWZ
+Множество B: ADHJKNOPSTUXZ
+Множество C: CDEGHIJLMNOTXYZ
+Множество D: CDFKLNRWY
+Ответ: F = FKW
+*
+Множество A: BDFGHIJKLTVY
+Множество B: DFIJKNOPSVWXZ
+Множество C: ABDEFIJKMPQTWXYZ
+Множество D: BCIJNOPRTVWY
+Ответ: F = NOV
+*
+Множество A: CDGNOPSTVWYZ
+Множество B: ABCDIJKLPQTUVXY
+Множество C: BCGJMPQRSWZ
+Множество D: CDFGIMORSTWY
+Ответ: F = DIOTY
+*
+Множество A: BCDFHJMOPRVWYZ
+Множество B: ACDEGHNPRSUVXYZ
+Множество C: ABDHJKLMSUWZ
+Множество D: ABCFGHILNPRVY
+Ответ: F = CFGNPRVY
+*
+Множество A: ABCEGHIKLMPRSUX
+Множество B: COUXZ
+Множество C: ABEFIQRSTUWX
+Множество D: ABFGIKMNOPQRUWYZ
+Ответ: F = GKMOPZ
+*
+Множество A: BDEGHIKMNOPSTVY
+Множество B: ABCEIJKNRSUVZ
+Множество C: BCDEFGKLMNQRSTUVWXY
+Множество D: JKMNOQRUWXZ
+Ответ: F = JOZ
+*
+Множество A: BFGHIKLNOPQRUVWZ
+Множество B: BEHJLMPRSVWX
+Множество C: ABCIJMOPQRTXY
+Множество D: BCDEGILMNOQSVWY
+Ответ: F = EGLNSVW
+*
+Множество A: BDFGKLMNPTVXZ
+Множество B: ADFJKLNSXYZ
+Множество C: ACDEFGHJMNQSTUWX
+Множество D: ABHIJKLMNQRTUVW
+Ответ: F = BKLV
+*
+Множество A: BDGHJLNPQRTVWYZ
+Множество B: BGHJQTUVWZ
+Множество C: CHKLMPUXZ
+Множество D: BCDFGMOQRSTUWYZ
+Ответ: F = BDGQRTWY
+*
+Множество A: ABCEGHJLMQRTUVXZ
+Множество B: ACFGILMNRVWX
+Множество C: BFHIJMOQUWY
+Множество D: BCFJLMNOPSVY
+Ответ: F = CLNV
+*

Part1/Lab1/Spiski/Lab1_2.cpp

@@ -0,0 +1,376 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <Windows.h>
+#include <cstdio>
+#include <time.h>
+#include <iomanip>
+
+struct Set {
+	char el;
+	Set* next;
+	Set(char e, Set* n = nullptr) : el(e), next(n) { }
+	~Set() { delete next; }
+};
+
+using namespace std;
+
+const char universum[] = "ABCDEFGHIJKMNLOPQRSTUVWXYZ";
+const char filename[] = "Test_result.txt";
+const int length = 26;
+const int durationCoeff = 1000000;
+int customTestAmount = 0;
+char stringA[length], stringB[length], stringC[length], stringD[length];
+Set *vectorA = nullptr, *vectorB = nullptr, *vectorC = nullptr, *vectorD = nullptr, *vectorF = nullptr;
+
+
+void setupConsole()
+{
+	setlocale(LC_ALL, "Russian");
+	SetConsoleOutputCP(1251);
+	SetConsoleCP(1251);
+	cout << fixed << setprecision(7);
+}
+
+void outputGreeting()
+{
+	cout << "Ïðîãðàììà ðàññ÷èòûâàåò çíà÷åíèå ìíîæåñòâà F ñîãëàñíî ñëåäóþùèì çàêîíàì - " << endl;
+	cout << "F = D && (A || B) && !C, ÷òî ðàâíîñèëüíî F = D*(A + B) - C." << endl;
+	cout << "Óíèâåðñóì: " << universum << endl;
+}
+
+void input()
+{
+	cout << endl;
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Ââåäèòå ìíîæåñòâî A: ";
+	cin >> stringA;
+	cout << "Ââåäèòå ìíîæåñòâî B: ";
+	cin >> stringB;
+	cout << "Ââåäèòå ìíîæåñòâî C: ";
+	cin >> stringC;
+	cout << "Ââåäèòå ìíîæåñòâî D: ";
+	cin >> stringD;
+
+	cout << endl;
+}
+
+bool isCorrectSymbol(char symbol)
+{
+	return ((symbol >= universum[0] && symbol <= universum[length - 1]) || symbol == '\0') ? 1 : 0;
+}
+
+bool isStringCorrect(char* string)
+{
+	for (int i = 0; i < length && string[i] != '\0'; i++)
+		if (!isCorrectSymbol(string[i]))
+			return 0;
+	return 1;
+}
+
+int memberToIndex(char member)
+{
+	return member - universum[0];
+}
+
+char indexToMember(int number)
+{
+	return number + universum[0];
+}
+
+Set* vectorFromString(Set* vector, const char string[])
+{
+	Set* p = vector;
+	for (int i = 0; string[i]; i++) {
+		if (p) {
+			p = vector;
+			if (memberToIndex(vector->el) > memberToIndex(string[i])) {
+				p = new Set(string[i], vector);
+				vector = p;
+			}
+			else {
+				while (p->next && memberToIndex(p->next->el) < memberToIndex(string[i])) p = p->next;
+				if (p->next) p->next = new Set(string[i], p->next);
+				else {
+					if (memberToIndex(p->el) < memberToIndex(string[i])) p->next = new Set(string[i]);
+					else {
+						if (memberToIndex(p->el) != memberToIndex(string[i])) {
+							p->next = new Set(string[i], p->next);
+						}
+					}
+				}
+
+			}
+		}
+		else {
+			vector = new Set(string[i]);
+			p = vector;
+		}
+	}
+	return vector;
+}
+
+void convertSets()
+{
+	vectorA = vectorFromString(vectorA, stringA);
+	vectorB = vectorFromString(vectorB, stringB);
+	vectorC = vectorFromString(vectorC, stringC);
+	vectorD = vectorFromString(vectorD, stringD);
+}
+
+void calculateAnswer()
+{
+	Set* pF = vectorF;
+	for (Set* pA = vectorA; pA; pA = pA->next) {
+		if (pF) {
+			pF->next = new Set(pA->el);
+			pF = pF->next;
+		}
+		else {
+			pF = new Set(pA->el);
+			vectorF = pF;
+		}
+	}
+	pF = vectorF;
+	for (Set* pB = vectorB; pB; pB = pB->next) {
+		if (pF) {
+			while (pF->next && memberToIndex(pF->next->el) < memberToIndex(pB->el)) pF = pF->next;
+			if (!pF->next || memberToIndex(pF->next->el) != memberToIndex(pB->el)) {
+				if (pF == vectorF) {
+					if (memberToIndex(pB->el) <= memberToIndex(pF->el)) {
+						pF = new Set(pB->el, vectorF);
+						vectorF = pF;
+					}
+				}
+				else {
+					pF->next = new Set(pB->el, pF->next);
+					pF = pF->next;
+				}
+			}
+		}
+		else {
+			pF = new Set(pB->el);
+			vectorF = pF;
+		}
+	}
+	pF = vectorF;
+	for (Set* pC = vectorC; pC && pF; pC = pC->next) {
+		if (memberToIndex(pF->el) == memberToIndex(pC->el) && pF == vectorF) {
+			vectorF = pF->next;
+			pF = pF->next;
+		}
+		while (pF && pF->next && memberToIndex(pF->next->el) < memberToIndex(pC->el)) pF = pF->next;
+		if (pF && pF->next && memberToIndex(pF->next->el) == memberToIndex(pC->el)) pF->next = pF->next->next;
+	}
+	pF = vectorF;
+	Set* last = nullptr;
+	for (Set* pD = vectorD; pD; pD = pD->next) {
+		while (pF && memberToIndex(pF->el) < memberToIndex(pD->el)) pF = pF->next;
+		if (pF && memberToIndex(pF->el) == memberToIndex(pD->el)) {
+			if (last == nullptr) {
+				last = pF;
+				vectorF = pF;
+			}
+			else {
+				last->next = pF;
+				last = pF;
+			}
+		}
+	}
+	if(pF) last->next = nullptr;
+}
+
+void outputSetToConsole(Set* vector)
+{
+	for (Set* p = vector; p; p = p->next)
+		cout << p->el;
+}
+
+void outputSetToFile(Set* vector, ofstream& output)
+{
+	for (Set* p = vector; p; p = p->next)
+		output << p->el;
+}
+
+bool isSetEmpty(Set* vector)
+{
+	return vector ? 0 : 1;
+}
+
+void outputAnswer()
+{
+	cout << "Îòâåò: F = ";
+	if (isSetEmpty(vectorF))
+		cout << "ïóñòîå ìíîæåñòâî";
+	else
+		outputSetToConsole(vectorF);
+	cout << endl;
+}
+
+double calulateDuration()
+{
+	double firstPoint, lastPoint, duration = 0;
+	for (int i = 0; i < durationCoeff; i++)
+	{
+		firstPoint = clock();
+		calculateAnswer();
+		lastPoint = clock();
+		duration += lastPoint - firstPoint;
+	}
+	return duration / durationCoeff;
+}
+
+void outputDuration()
+{
+	cout << endl;
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Âðåìåííàÿ ñëîæíîñòü àëãîðèòìà - O(1), ïîñòîÿííîå âðåìÿ" << endl;
+	cout << "Íà âûïîëíåíèå àëãîðèòìà óõîäèò " << calulateDuration() << " ñåêóíä." << endl;
+	cout << endl;
+}
+
+float factorial(int number)
+{
+	float factorial = 1;
+	for (int i = 1; i <= number; i++)
+		factorial *= i;
+	return factorial;
+}
+
+bool randomVector()
+{
+	return rand() % 2;
+}
+
+void fillVectors()
+{
+	Set* pA = vectorA, * pB = vectorB, * pC = vectorC, * pD = vectorD;
+	for (int i = 0; i < length; i++)
+	{
+		if (randomVector()) {
+			if (pA) {
+				pA->next = new Set(indexToMember(i));
+				pA = pA->next;
+			}
+			else {
+				vectorA = new Set(indexToMember(i));
+				pA = vectorA;
+			}
+		}
+		if (randomVector()) {
+			if (pB) {
+				pB->next = new Set(indexToMember(i));
+				pB = pB->next;
+			}
+			else {
+				vectorB = new Set(indexToMember(i));
+				pB = vectorB;
+			}
+		}
+		if (randomVector()) {
+			if (pC) {
+				pC->next = new Set(indexToMember(i));
+				pC = pC->next;
+			}
+			else {
+				vectorC = new Set(indexToMember(i));
+				pC = vectorC;
+			}
+		}
+		if (randomVector()) {
+			if (pD) {
+				pD->next = new Set(indexToMember(i));
+				pD = pD->next;
+			}
+			else {
+				vectorD = new Set(indexToMember(i));
+				pD = vectorD;
+			}
+		}
+	}
+}
+
+void clearAnswerVector()
+{
+	delete vectorA;
+	vectorA = nullptr;
+	delete vectorB;
+	vectorB = nullptr;
+	delete vectorC;
+	vectorC = nullptr;
+	delete vectorD;
+	vectorD = nullptr;
+	delete vectorF;
+	vectorF = nullptr;
+}
+
+void badInputLoop()
+{
+	while (cin.fail() || customTestAmount < 0)
+	{
+		cout << "Íåïðàâèëüíûé ââîä, ïîâòîðèòå åùå ðàç:" << endl;
+		cin.clear();
+		cin.ignore(32767, '\n');
+		cin >> customTestAmount;
+	}
+}
+
+void testInfo()
+{
+	cout << setprecision(0);
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Èç 26 ñèìâîëîâ ìîæåò áûòü ñîñòàâëåíî " << factorial(length) << " ïåðåñòàíîâîê" << endl;
+	cout << "Ñêîëüêî ïðîãðàììà äîëæíà ïðîäåëàòü òåñòîâ ñî ñëó÷àéíûìè êîìáèíàöèÿìè?" << endl;
+	cin >> customTestAmount;
+	badInputLoop();
+	if (customTestAmount > 0)
+		cout << "Îò÷åòû áóäóò âûâåäåíû â ôàéë " << filename << endl;
+	else cout << "Òåñòû íå áóäóò ïðîäåëàíû" << endl;
+}
+
+void executeTest()
+{
+	ofstream output;
+	output.open(filename);
+	for (int i = 0; i < customTestAmount; i++)
+	{
+		clearAnswerVector();
+		fillVectors();
+		output << "Ìíîæåñòâî A: ";
+		outputSetToFile(vectorA, output);
+		output << endl;
+		output << "Ìíîæåñòâî B: ";
+		outputSetToFile(vectorB, output);
+		output << endl;
+		output << "Ìíîæåñòâî C: ";
+		outputSetToFile(vectorC, output);
+		output << endl;
+		output << "Ìíîæåñòâî D: ";
+		outputSetToFile(vectorD, output);
+		output << endl;
+		calculateAnswer();
+		output << "Îòâåò: F = ";
+		outputSetToFile(vectorF, output);
+		output << endl;
+		output << '*' << endl;
+	}
+	output.close();
+}
+
+int main()
+{
+	setupConsole();
+	outputGreeting();
+	input();
+	while (!isStringCorrect(stringA) || !isStringCorrect(stringB) || !isStringCorrect(stringC) || !isStringCorrect(stringD))
+	{
+		cout << "Íåêîððåêòíûé ââîä" << endl;
+		input();
+	}
+	convertSets();
+	calculateAnswer();
+	outputAnswer();
+	outputDuration();
+	testInfo();
+	executeTest();
+}

Part1/Lab1/Spiski/Test_result.txt

@@ -0,0 +1,60 @@
+Множество A: ABDEFIJKLMOUWZ
+Множество B: ADHJKNOPSTUXZ
+Множество C: CDEGHIJLMNOTXYZ
+Множество D: CDFKLNRWY
+Ответ: F = FKW
+*
+Множество A: BDFGHIJKLTVY
+Множество B: DFIJKNOPSVWXZ
+Множество C: ABDEFIJKMPQTWXYZ
+Множество D: BCIJNOPRTVWY
+Ответ: F = NOV
+*
+Множество A: CDGNOPSTVWYZ
+Множество B: ABCDIJKLPQTUVXY
+Множество C: BCGJMPQRSWZ
+Множество D: CDFGIMORSTWY
+Ответ: F = DIOTY
+*
+Множество A: BCDFHJMOPRVWYZ
+Множество B: ACDEGHNPRSUVXYZ
+Множество C: ABDHJKLMSUWZ
+Множество D: ABCFGHILNPRVY
+Ответ: F = CFGNPRVY
+*
+Множество A: ABCEGHIKLMPRSUX
+Множество B: COUXZ
+Множество C: ABEFIQRSTUWX
+Множество D: ABFGIKMNOPQRUWYZ
+Ответ: F = GKMOPZ
+*
+Множество A: BDEGHIKMNOPSTVY
+Множество B: ABCEIJKNRSUVZ
+Множество C: BCDEFGKLMNQRSTUVWXY
+Множество D: JKMNOQRUWXZ
+Ответ: F = OZ
+*
+Множество A: BFGHIKLNOPQRUVWZ
+Множество B: BEHJLMPRSVWX
+Множество C: ABCIJMOPQRTXY
+Множество D: BCDEGILMNOQSVWY
+Ответ: F = EGLNSVW
+*
+Множество A: BDFGKLMNPTVXZ
+Множество B: ADFJKLNSXYZ
+Множество C: ACDEFGHJMNQSTUWX
+Множество D: ABHIJKLMNQRTUVW
+Ответ: F = BKLV
+*
+Множество A: BDGHJLNPQRTVWYZ
+Множество B: BGHJQTUVWZ
+Множество C: CHKLMPUXZ
+Множество D: BCDFGMOQRSTUWYZ
+Ответ: F = DGQRTWY
+*
+Множество A: ABCEGHJLMQRTUVXZ
+Множество B: ACFGILMNRVWX
+Множество C: BFHIJMOQUWY
+Множество D: BCFJLMNOPSVY
+Ответ: F = CLNV
+*

Part1/Lab1/Vector_bit/Lab1.cpp

@@ -0,0 +1,246 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <Windows.h>
+#include <cstdio>
+#include <time.h>
+#include <iomanip>
+using namespace std;
+
+const char universum[] = "ABCDEFGHIJKMNLOPQRSTUVWXYZ";
+const char filename[] = "Test_result.txt";
+const int length = 26;
+const int durationCoeff = 1000000;
+int customTestAmount = 0;
+char stringA[length], stringB[length], stringC[length], stringD[length];
+bool vectorA[length], vectorB[length], vectorC[length], vectorD[length], vectorF[length];
+
+
+void setupConsole()
+{
+	setlocale(LC_ALL, "Russian");
+	SetConsoleOutputCP(1251);
+	SetConsoleCP(1251);
+	cout << fixed << setprecision(7);
+}
+
+void outputGreeting()
+{
+	cout << "Программа рассчитывает значение множества F согласно следующим законам - " << endl;
+	cout << "F = D && (A || B) && !C, что равносильно F = D*(A + B) - C." << endl;
+	cout << "Универсум: " << universum << endl;
+}
+
+void input()
+{
+	cout << endl;
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Введите множество A: ";
+	cin >> stringA;
+	cout << "Введите множество B: ";
+	cin >> stringB;
+	cout << "Введите множество C: ";
+	cin >> stringC;
+	cout << "Введите множество D: ";
+	cin >> stringD;
+
+	cout << endl;
+}
+
+bool isCorrectSymbol(char symbol)
+{
+	return ((symbol >= universum[0] && symbol <= universum[length - 1]) || symbol == '\0') ? 1 : 0;
+}
+
+bool isStringCorrect(char* string)
+{
+	for (int i = 0; i < length && string[i] != '\0'; i++)
+		if (!isCorrectSymbol(string[i]))
+			return 0;
+	return 1;
+}
+
+int memberToIndex(char member)
+{
+	return member - universum[0];
+}
+
+char indexToMember(int number)
+{
+	return number + universum[0];
+}
+
+void vectorFromString(bool* vector, const char string[])
+{
+	for (int i = 0; string[i]; i++)
+		vector[memberToIndex(string[i])] = 1;
+};
+
+void convertSets()
+{
+	vectorFromString(vectorA, stringA);
+	vectorFromString(vectorB, stringB);
+	vectorFromString(vectorC, stringC);
+	vectorFromString(vectorD, stringD);
+}
+
+void calculateAnswer()
+{
+	for (int i = 0; i < length; i++)
+		vectorF[i] = vectorD[i] && (vectorA[i] || vectorB[i]) && !vectorC[i];
+}
+
+void outputSetToConsole(bool* vector)
+{
+	for (int i = 0; i < length; ++i)
+		if (vector[i])
+			cout << indexToMember(i);
+}
+
+void outputSetToFile(bool* vector, ofstream& output)
+{
+	for (int i = 0; i < length; ++i)
+		if (vector[i])
+			output << indexToMember(i);
+}
+
+bool isSetEmpty(bool* vector)
+{
+	for (int i = 0; i < length; i++)
+		if (vector[i] == 1)
+			return 0;
+	return 1;
+}
+
+void outputAnswer()
+{
+	cout << "Ответ: F = ";
+	if (isSetEmpty(vectorF))
+		cout << "пустое множество";
+	else
+		outputSetToConsole(vectorF);
+	cout << endl;
+}
+
+double calulateDuration()
+{
+	double firstPoint, lastPoint, duration = 0;
+	for (int i = 0; i < durationCoeff; i++)
+	{
+		firstPoint = clock();
+		calculateAnswer();
+		lastPoint = clock();
+		duration += lastPoint - firstPoint;
+	}
+	return duration / durationCoeff;
+}
+
+void outputDuration()
+{
+	cout << endl;
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Временная сложность алгоритма - O(1), постоянное время" << endl;
+	cout << "На выполнение алгоритма уходит " << calulateDuration() << " секунд." << endl;
+	cout << endl;
+}
+
+float factorial(int number)
+{
+	float factorial = 1;
+	for (int i = 1; i <= number; i++)
+		factorial *= i;
+	return factorial;
+}
+
+bool randomVector()
+{
+	return rand() % 2;
+}
+
+void fillVectors()
+{
+	for (int i = 0; i < length; i++)
+	{
+		vectorA[i] = randomVector();
+		vectorB[i] = randomVector();
+		vectorC[i] = randomVector();
+		vectorD[i] = randomVector();
+	}
+}
+
+void clearAnswerVector()
+{
+	for (int i = 0; i < length; i++)
+		vectorF[i] = 0;
+}
+
+void badInputLoop()
+{
+	while (cin.fail() || customTestAmount < 0)
+	{
+		cout << "Неправильный ввод, повторите еще раз:" << endl;
+		cin.clear();
+		cin.ignore(32767, '\n');
+		cin >> customTestAmount;
+	}
+}
+
+void testInfo()
+{
+	cout << setprecision(0);
+	cout << "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << endl;
+	cout << "Из 26 символов может быть составлено " << factorial(length) << " перестановок" << endl;
+	cout << "Сколько программа должна проделать тестов со случайными комбинациями?" << endl;
+	cin >> customTestAmount;
+	badInputLoop();
+	if (customTestAmount > 0)
+		cout << "Отчеты будут выведены в файл " << filename << endl;
+	else cout << "Тесты не будут проделаны" << endl;
+}
+
+void executeTest()
+{
+	ofstream output;
+	output.open(filename);
+	for (int i = 0; i < customTestAmount; i++)
+	{
+		fillVectors();
+		clearAnswerVector();
+		output << "Множество A: ";
+		outputSetToFile(vectorA, output);
+		output << endl;
+		output << "Множество B: ";
+		outputSetToFile(vectorB, output);
+		output << endl;
+		output << "Множество C: ";
+		outputSetToFile(vectorC, output);
+		output << endl;
+		output << "Множество D: ";
+		outputSetToFile(vectorD, output);
+		output << endl;
+		calculateAnswer();
+		output << "Ответ: F = ";
+		outputSetToFile(vectorF, output);
+		output << endl;
+		output << '*' << endl;
+	}
+	output.close();
+}
+
+int main()
+{
+	setupConsole();
+	outputGreeting();
+	input();
+	while (!isStringCorrect(stringA) || !isStringCorrect(stringB) || !isStringCorrect(stringC) || !isStringCorrect(stringD))
+	{
+		cout << "Некорректный ввод" << endl;
+		input();
+	}
+	convertSets();
+	calculateAnswer();
+	outputAnswer();
+	outputDuration();
+	testInfo();
+	executeTest();
+}

Part1/Lab1/Vector_bit/Test_result.txt

@@ -0,0 +1,72 @@
+Множество A: ABDEFIJKLMOUWZ
+Множество B: ADHJKNOPSTUXZ
+Множество C: CDEGHIJLMNOTXYZ
+Множество D: CDFKLNRWY
+Ответ: F = FKW
+*
+Множество A: BDFGHIJKLTVY
+Множество B: DFIJKNOPSVWXZ
+Множество C: ABDEFIJKMPQTWXYZ
+Множество D: BCIJNOPRTVWY
+Ответ: F = NOV
+*
+Множество A: CDGNOPSTVWYZ
+Множество B: ABCDIJKLPQTUVXY
+Множество C: BCGJMPQRSWZ
+Множество D: CDFGIMORSTWY
+Ответ: F = DIOTY
+*
+Множество A: BCDFHJMOPRVWYZ
+Множество B: ACDEGHNPRSUVXYZ
+Множество C: ABDHJKLMSUWZ
+Множество D: ABCFGHILNPRVY
+Ответ: F = CFGNPRVY
+*
+Множество A: ABCEGHIKLMPRSUX
+Множество B: COUXZ
+Множество C: ABEFIQRSTUWX
+Множество D: ABFGIKMNOPQRUWYZ
+Ответ: F = GKMOPZ
+*
+Множество A: BDEGHIKMNOPSTVY
+Множество B: ABCEIJKNRSUVZ
+Множество C: BCDEFGKLMNQRSTUVWXY
+Множество D: JKMNOQRUWXZ
+Ответ: F = JOZ
+*
+Множество A: BFGHIKLNOPQRUVWZ
+Множество B: BEHJLMPRSVWX
+Множество C: ABCIJMOPQRTXY
+Множество D: BCDEGILMNOQSVWY
+Ответ: F = EGLNSVW
+*
+Множество A: BDFGKLMNPTVXZ
+Множество B: ADFJKLNSXYZ
+Множество C: ACDEFGHJMNQSTUWX
+Множество D: ABHIJKLMNQRTUVW
+Ответ: F = BKLV
+*
+Множество A: BDGHJLNPQRTVWYZ
+Множество B: BGHJQTUVWZ
+Множество C: CHKLMPUXZ
+Множество D: BCDFGMOQRSTUWYZ
+Ответ: F = BDGQRTWY
+*
+Множество A: ABCEGHJLMQRTUVXZ
+Множество B: ACFGILMNRVWX
+Множество C: BFHIJMOQUWY
+Множество D: BCFJLMNOPSVY
+Ответ: F = CLNV
+*
+Множество A: DEFHKTWXYZ
+Множество B: ABCGIMOPRSVW
+Множество C: DFJNQTWYZ
+Множество D: FJKNOPQSVWZ
+Ответ: F = KOPSV
+*
+Множество A: BCEFJKLOPTWY
+Множество B: AEFHKLPQUVW
+Множество C: BCDEGKLMNOWX
+Множество D: ADGJKLMORSVWYZ
+Ответ: F = AJVY
+*

Part1/Lab2/Lab2.cpp

@@ -0,0 +1,26 @@
+#include <string.h> 
+#include <stdlib.h> 
+#include <time.h> 
+#include <iostream> 
+using namespace std;
+#include "Set4.h" 
+int Set::N = 26, Set::cnt = 0; // Îïðåäåëåíèå ñòàòè÷åñêèõ ÷ëåíîâ êëàññà
+const long q0 = 100000; // Êîëè÷åñòâî ïîâòîðåíèé öèêëà âðåìåíè
+int main()
+{
+	srand(time(nullptr));
+	Set A('A'), B('B'), C('C'), D('D'), E; //A, B, C, D ãåíåðèðóþòñÿ. E — ïóñòîå ìí-âî
+	clock_t begin = clock();
+	for (long q = 0; q < q0; ++q)
+	{
+		E = D & (A | B) & ~C;
+		//E = ~A;
+	}
+	clock_t end = clock();
+	E.Show();
+	cout << " Middle power =" <<
+		(A.power() + B.power() + C.power() + D.power() + E.power()) / 5 <<
+		" Time=" << end - begin << " / " << q0 << endl;
+	cin.get();
+	return 0;
+}

Part1/Lab2/Set1.h

@@ -0,0 +1,118 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <Windows.h>
+#include <cstdio>
+#include <time.h>
+
+using namespace std;
+
+class Set {
+private:
+	static int N, cnt; // ìîùíîñòü óíèâåðñóìà è ñ÷åò÷èê ìíîæåñòâ
+	int n; // ìîùíîñòü ìíîæåñòâà
+	char S, * A; // òåã è ïàìÿòü äëÿ ìíîæåñòâà
+public:
+	Set operator | (const Set&) const; // îáúåäèíåíèå
+	Set& operator |= (const Set&);
+	Set operator & (const Set&) const; // ïåðåñå÷åíèå
+	Set& operator &= (const Set&);
+	Set operator ~ () const; // äîïîëíåíèå äî óíèâåðñóìà
+	void Show(); // âûâîä ìíîæåñòâà íà ýêðàí
+	int power() { return n; } // ïîëó÷åíèå ìîùíîñòè
+	Set(char);
+	// êîíñòðóêòîð ìíîæåñòâà
+	Set(); // åùå êîíñòðóêòîð — ïî óìîë÷àíèþ
+	Set(const Set&); // êîíñòðóêòîð êîïèè
+	Set(Set&&); // ïåðåìåùàþùèé êîíñòðóêòîð (C++11) 
+	Set operator = (const Set&); // îïåðàòîð ïðèñâàèâàíèÿ
+	Set operator = (Set&&); //ïðèñâàèâàíèå ñ ïåðåìåùåíèåì (C++11) 
+	~Set() { delete[] A; } // äåñòðóêòîð
+};
+
+Set::Set() : n(0), S('A' + cnt++), A(new char[N + 1]) { A[0] = 0; }
+
+Set::Set(char) : S('A' + cnt++), n(0), A(new char[N + 1]) {
+	for (int i = 0; i < N; i++)
+		if (rand() % 2) A[n++] = i + 'A';
+	A[n] = 0;
+	cout << '\n' << S << " = [" << A << "]";
+}
+
+Set::Set(const Set& B) : S('A' + cnt++), n(B.n), A(new char[N + 1]) {
+	char* dst(A), * src(B.A); // Èíèöèàëèçàöèÿ àäðåñîâ/ñ÷åò÷èêîâ
+	while (*dst++ = *src++); // Êîïèðîâàíèå ñèìâîëîâ äî îáíàðóæåíèÿ 0 
+}
+
+Set Set:: operator= (const Set& B) {
+	if (this != &B) {
+		char* dst(A), * src(B.A); n = B.n;
+
+		while (*dst++ = *src++); S = 'A' + cnt++;
+	}
+	return *this;
+}
+
+Set& Set :: operator &= (const Set& B)
+{
+	Set C(*this);
+	n = 0;
+	for (int i = 0; i < C.n; ++i) {
+		for (int j = 0; j < B.n; ++j)
+			if (C.A[i] == B.A[j]) A[n++] = C.A[i];
+	}
+	A[n] = 0; // Îãðàíè÷èòåëü ñòðîêè
+	return *this;
+}
+
+Set Set :: operator & (const Set& B) const
+{
+	Set C(*this);
+	return std::move(C &= B);
+}
+
+Set& Set :: operator |= (const Set& B)
+{
+	for (int i = 0; i < B.n; ++i) {
+		bool f = true;
+		for (int j = 0; j < n; ++j)
+			if (B.A[i] == A[j]) f = false;
+		if (f) A[n++] = B.A[i];
+	}
+	A[n] = 0; return *this;
+}
+
+Set Set :: operator | (const Set& B) const
+{
+	Set C(*this);
+	return std::move(C |= B);
+}
+
+Set Set :: operator ~ () const
+{
+	Set C;
+	for (char c = 'A'; c <= 'Z'; ++c) { // Öèêë ïî óíèâåðñóìó
+		bool f = true;
+		for (int j = 0; j < n; ++j)
+			if (c == A[j]) { f = false; break; }
+		if (f) C.A[C.n++] = c;
+	}
+	C.A[C.n] = 0;
+	return std::move(C);
+}
+
+Set::Set(Set&& B) : S('A' + cnt++), n(B.n), A(B.A)
+{
+	B.A = nullptr;
+} // Êîïèðîâàíèå ñ ïåðåíîñîì
+
+Set Set:: operator = (Set&& B) // Ïðèñâàèâàíèå ñ ïåðåíîñîì
+{
+	if (this != &B)
+	{
+		n = B.n; A = B.A; S = 'A' + cnt++; B.A = nullptr;
+	}
+	return *this;
+}
+
+void Set::Show() { cout << '\n' << S << " = [" << A << "]"; }

Part1/Lab2/Set2.h

@@ -0,0 +1,122 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <Windows.h>
+#include <cstdio>
+#include <time.h>
+
+using namespace std;
+
+
+class Set {
+private:
+	static int N, cnt; // ìîùíîñòü óíèâåðñóìà è ñ÷åò÷èê ìíîæåñòâ
+	int n; // ìîùíîñòü ìíîæåñòâà
+	char S; // òåã è ïàìÿòü äëÿ ìíîæåñòâà
+	bool* A;
+public:
+	Set operator | (const Set&) const; // îáúåäèíåíèå
+	Set& operator |= (const Set&);
+	Set operator & (const Set&) const; // ïåðåñå÷åíèå
+	Set& operator &= (const Set&);
+	Set operator ~ () const; // äîïîëíåíèå äî óíèâåðñóìà
+	void Show(); // âûâîä ìíîæåñòâà íà ýêðàí
+	int power() { return n; } // ïîëó÷åíèå ìîùíîñòè
+	Set(char);// êîíñòðóêòîð ìíîæåñòâà
+	Set(); // åùå êîíñòðóêòîð — ïî óìîë÷àíèþ
+	Set(const Set&); // êîíñòðóêòîð êîïèè
+	Set(Set&&); // ïåðåìåùàþùèé êîíñòðóêòîð (C++11) 
+	Set operator = (const Set&); // îïåðàòîð ïðèñâàèâàíèÿ
+	Set operator = (Set&&); //ïðèñâàèâàíèå ñ ïåðåìåùåíèåì (C++11) 
+	~Set() { delete[] A; } // äåñòðóêòîð
+};
+
+Set::Set() : n(0), S('A' + cnt++), A(new bool[N] {0}) {};
+
+Set::Set(char) : S('A' + cnt++), n(0), A(new bool[N] {0}) {
+	for (int i = 0; i < N; i++)
+		if (rand() % 2) {
+			A[i] = true;
+			n++;
+		}
+	cout << '\n' << S << " = [";
+	for (int i = 0; i < N; i++) 
+		if (A[i]) cout << char(i + 'A');
+	cout << "]";
+}
+
+Set::Set(const Set& B) : S('A' + cnt++), n(B.n), A(new bool[N] {0}) {
+	bool* dst(A), * src(B.A); // Èíèöèàëèçàöèÿ àäðåñîâ/ñ÷åò÷èêîâ
+	for (int i = 0; i < N; i++) *dst++ = *src++;
+}
+
+Set Set:: operator= (const Set& B) {
+	if (this != &B) {
+		bool* dst(A), * src(B.A); n = B.n;
+		for (int i = 0; i < N; i++) *dst++ = *src++;
+		S = 'A' + cnt++;
+	}
+	return *this;
+}
+
+Set& Set :: operator &= (const Set& B)
+{
+	Set C(*this);
+	n = 0;
+	for (int i = 0; i < N; ++i) {
+		if (C.A[i] && B.A[i]) { A[i] = true; n++; }
+		else A[i] = false;
+	}
+	return *this;
+}
+
+Set Set :: operator & (const Set& B) const
+{
+	Set C(*this);
+	return std::move(C &= B);
+}
+
+Set& Set :: operator |= (const Set& B)
+{
+	for (int i = 0; i < N; ++i) 
+		if (B.A[i]) {
+			A[i] = true;
+			n++;
+		}
+	return *this;
+}
+
+Set Set :: operator | (const Set& B) const
+{
+	Set C(*this);
+	return std::move(C |= B);
+}
+
+Set Set :: operator ~ () const
+{
+	Set C;
+	for (int i = 0; i < N; ++i) { // Öèêë ïî óíèâåðñóìó
+		C.A[i] = !A[i];
+	}
+	return std::move(C);
+}
+
+Set::Set(Set&& B) : S('A' + cnt++), n(B.n), A(B.A)
+{
+	B.A = nullptr;
+} // Êîïèðîâàíèå ñ ïåðåíîñîì
+
+Set Set:: operator = (Set&& B) // Ïðèñâàèâàíèå ñ ïåðåíîñîì
+{
+	if (this != &B)
+	{
+		n = B.n; A = B.A; S = 'A' + cnt++; B.A = nullptr;
+	}
+	return *this;
+}
+
+void Set::Show() {
+	cout << '\n' << S << " = [";
+	for (int i = 0; i < N; i++) if(A[i]) cout << char(i + 'A');
+	cout << "]";
+}

Part1/Lab2/Set3.h

@@ -0,0 +1,114 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <Windows.h>
+#include <cstdio>
+#include <time.h>
+
+using namespace std;
+
+
+class Set {
+private:
+	static int N, cnt; // ìîùíîñòü óíèâåðñóìà è ñ÷åò÷èê ìíîæåñòâ
+	int n; // ìîùíîñòü ìíîæåñòâà
+	char S; // òåã è ïàìÿòü äëÿ ìíîæåñòâà
+	int A;
+public:
+	Set operator | (const Set&) const; // îáúåäèíåíèå
+	Set& operator |= (const Set&);
+	Set operator & (const Set&) const; // ïåðåñå÷åíèå
+	Set& operator &= (const Set&);
+	Set operator ~ () const; // äîïîëíåíèå äî óíèâåðñóìà
+	void Show(); // âûâîä ìíîæåñòâà íà ýêðàí
+	int power() { return n; } // ïîëó÷åíèå ìîùíîñòè
+	Set(char);// êîíñòðóêòîð ìíîæåñòâà
+	Set(); // åùå êîíñòðóêòîð — ïî óìîë÷àíèþ
+	Set(const Set&); // êîíñòðóêòîð êîïèè
+	Set(Set&&); // ïåðåìåùàþùèé êîíñòðóêòîð (C++11) 
+	Set operator = (const Set&); // îïåðàòîð ïðèñâàèâàíèÿ
+	Set operator = (Set&&); //ïðèñâàèâàíèå ñ ïåðåìåùåíèåì (C++11) 
+	~Set() {} // äåñòðóêòîð
+};
+
+Set::Set() : n(0), S('A' + cnt++), A(0) {};
+
+Set::Set(char) : S('A' + cnt++), n(0), A(0) {
+	for (int i = 0; i < N; i++)
+		if (rand() % 2) {
+			A |= (1 << i);
+			n++;
+		}
+	cout << '\n' << S << " = [";
+	for (int i = 0; i < N; i++)
+		if ((A >> i) & 1) 
+			cout << char(i + 'A');
+	cout << "]";
+}
+
+Set::Set(const Set& B) : S('A' + cnt++), n(B.n), A(B.A) { }
+
+Set Set:: operator= (const Set& B) {
+	if (this != &B) {
+		n = B.n;
+		A = B.A;
+		S = 'A' + cnt++;
+	}
+	return *this;
+}
+
+Set& Set :: operator &= (const Set& B)
+{
+	n = 0;
+	A = A & B.A;
+	for (int i = 0; i < N; i++) if ((A >> i) & 1) n++;
+	return *this;
+}
+
+Set Set :: operator & (const Set& B) const
+{
+	Set C(*this);
+	return std::move(C &= B);
+}
+
+Set& Set :: operator |= (const Set& B)
+{
+	n = 0;
+	A = A | B.A;
+	for (int i = 0; i < N; i++) if ((A >> i) & 1) n++;
+	return *this;
+}
+
+Set Set :: operator | (const Set& B) const
+{
+	Set C(*this);
+	return std::move(C |= B);
+}
+
+Set Set :: operator ~ () const
+{
+	Set C;
+	C.A = ~A;
+	return std::move(C);
+}
+
+Set::Set(Set&& B) : S('A' + cnt++), n(B.n), A(B.A)
+{
+	B.A = 0;
+} // Êîïèðîâàíèå ñ ïåðåíîñîì
+
+Set Set:: operator = (Set&& B) // Ïðèñâàèâàíèå ñ ïåðåíîñîì
+{
+	if (this != &B)
+	{
+		n = B.n; A = B.A; S = 'A' + cnt++; B.A = 0;
+	}
+	return *this;
+}
+
+void Set::Show() {
+	cout << '\n' << S << " = [";
+	for (int i = 0; i < N; i++) if ((A >> i) & 1) 
+		cout << char(i + 'A');
+	cout << "]";
+}

Part1/Lab2/Set4.h

@@ -0,0 +1,208 @@
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <Windows.h>
+#include <cstdio>
+#include <time.h>
+
+using namespace std;
+
+class SetElem {
+public:
+	char el;
+	SetElem* next;
+	SetElem(char e, SetElem* n = nullptr) : el(e), next(n) { }
+	~SetElem() { delete next; }
+};
+
+class Set {
+private:
+	static int N, cnt; // ìîùíîñòü óíèâåðñóìà è ñ÷åò÷èê ìíîæåñòâ
+	int n; // ìîùíîñòü ìíîæåñòâà
+	char S; // òåã è ïàìÿòü äëÿ ìíîæåñòâà
+	SetElem* A;
+public:
+	Set operator | (const Set&) const; // îáúåäèíåíèå
+	Set& operator |= (const Set&);
+	Set operator & (const Set&) const; // ïåðåñå÷åíèå
+	Set& operator &= (const Set&);
+	Set operator ~ () const; // äîïîëíåíèå äî óíèâåðñóìà
+	void Show(); // âûâîä ìíîæåñòâà íà ýêðàí
+	int power() { return n; } // ïîëó÷åíèå ìîùíîñòè
+	Set(char);// êîíñòðóêòîð ìíîæåñòâà
+	Set(); // åùå êîíñòðóêòîð — ïî óìîë÷àíèþ
+	Set(const Set&); // êîíñòðóêòîð êîïèè
+	Set(Set&&); // ïåðåìåùàþùèé êîíñòðóêòîð (C++11) 
+	Set operator = (const Set&); // îïåðàòîð ïðèñâàèâàíèÿ
+	Set operator = (Set&&); //ïðèñâàèâàíèå ñ ïåðåìåùåíèåì (C++11) 
+	~Set() {} // äåñòðóêòîð
+};
+
+Set::Set() : n(0), S('A' + cnt++), A(nullptr) {};
+
+Set::Set(char) : S('A' + cnt++), n(0), A(nullptr) {
+	SetElem* pA = A;
+	for (int i = 0; i < N; i++)
+		if (rand() % 2) {
+			if (A) {
+				pA->next = new SetElem(char(i + 'A'));
+				pA = pA->next;
+			}
+			else {
+				A = new SetElem(char(i + 'A'));
+				pA = A;
+			}
+			n++;
+		}
+	cout << '\n' << S << " = [";
+	for (SetElem* p = A; p; p = p->next)
+		cout << p->el;
+	cout << "]";
+}
+
+Set::Set(const Set& B) : S('A' + cnt++), n(B.n), A(nullptr) {
+	SetElem* pA = A, * pB = B.A;
+	while (pB) {
+		if (pA) {
+			pA->next = new SetElem(pB->el);
+			pA = pA->next;
+		}
+		else {
+			A = new SetElem(B.A->el);
+			pA = A;
+		}
+		pB = pB->next;
+	}
+}
+
+Set Set:: operator= (const Set& B) {
+	if (this != &B) {
+		n = B.n;
+		A = nullptr;
+		SetElem* pA = A, *pB = B.A;
+		while (pB) {
+			if (pA) {
+				pA->next = new SetElem(B.A->el);
+				pA = pA->next;
+			}
+			else {
+				A = new SetElem(B.A->el);
+				pA = A;
+			}
+			pB = pB->next;
+		}
+		S = 'A' + cnt++;
+	}
+	return *this;
+}
+
+Set& Set :: operator &= (const Set& B)
+{
+	n = 0;
+	SetElem* last = nullptr, * pA = A;
+	for (SetElem* pB = B.A; pB; pB = pB->next) {
+		while (pA && pA->el < pB->el) pA = pA->next;
+		if (pA && pA->el == pB->el) {
+			if (last == nullptr) {
+				last = pA;
+				A = pA;
+			}
+			else {
+				last->next = pA;
+				last = pA;
+			}
+		}
+	}
+	if (pA) last->next = nullptr;
+	for (pA = A; pA; pA = pA->next) n++;
+	return *this;
+}
+
+Set Set :: operator & (const Set& B) const
+{
+	Set C(*this);
+	return std::move(C &= B);
+}
+
+Set& Set :: operator |= (const Set& B)
+{
+	n = 0;
+	SetElem* pA = A;
+	for (SetElem* pB = B.A; pB; pB = pB->next) {
+		if (pA) {
+			while (pA->next && pA->next->el - 'A' < pB->el - 'A') pA = pA->next;
+			if (!pA->next || pA->next->el - 'A' != pB->el - 'A') {
+				if (pA == A) {
+					if (pB->el - 'A' <= pA->el - 'A') {
+						pA = new SetElem(pB->el, A);
+						A = pA;
+					}
+				}
+				else {
+					pA->next = new SetElem(pB->el, pA->next);
+					pA = pA->next;
+				}
+			}
+		}
+		else {
+			pA = new SetElem(pB->el);
+			A = pA;
+		}
+	}
+	for (pA = A; pA; pA = pA->next) n++;
+	return *this;
+}
+
+Set Set :: operator | (const Set& B) const
+{
+	Set C(*this);
+	return std::move(C |= B);
+}
+
+Set Set :: operator ~ () const
+{
+	Set C;
+	C.n = N - n;
+	SetElem* pC = C.A, *pA = A;
+	for (char c = 'A'; c <= 'Z'; ++c) { // Öèêë ïî óíèâåðñóìó
+		if (pA && pA->el > c) {
+			if (pC) {
+				pC->next = new SetElem(c);
+				pC = pC->next;
+			}
+			else {
+				C.A = new SetElem(c);
+				pC = C.A;
+			}
+		}
+		else {
+			if(pA) pA = pA->next;
+			else {
+				pC->next = new SetElem(c);
+				pC = pC->next;
+			}
+		}
+	}
+	return std::move(C);
+}
+
+Set::Set(Set&& B) : S('A' + cnt++), n(B.n), A(B.A)
+{
+	B.A = 0;
+} // Êîïèðîâàíèå ñ ïåðåíîñîì
+
+Set Set:: operator = (Set&& B) // Ïðèñâàèâàíèå ñ ïåðåíîñîì
+{
+	if (this != &B)
+	{
+		n = B.n; A = B.A; S = 'A' + cnt++; B.A = 0;
+	}
+	return *this;
+}
+
+void Set::Show() {
+	cout << '\n' << S << " = [";
+	for (SetElem* p = A; p; p = p->next)
+		cout << p->el;
+	cout << "]";
+}

Part1/Lab3/main.cpp

@@ -0,0 +1,281 @@
+#include <iostream>
+#include <fstream>
+using namespace std;
+//Êëàññ «óçåë äåðåâà»
+class Node {
+	char d; //òåã óçëà
+	Node* lft; // ëåâûé ñûí
+	Node* rgt; // ïðàâûé ñûí
+	int count = 0;
+public:
+	Node() : lft(nullptr), rgt(nullptr) { } // êîíñòðóêòîð óçëà
+	Node(const Node&) = delete;
+	Node& operator = (const Node&) = delete;
+	~Node() {
+		delete lft; // äåñòðóêòîð óçëà (óíè÷òîæàåò âñå ïîääåðåâî
+		delete rgt;
+	} // â ïîðÿäêå, îáðàòíîì åãî ñîçäàíèþ)
+	friend class Tree; // äðóæåñòâåííûé êëàññ «äåðåâî»
+};
+// Êëàññ «äåðåâî â öåëîì»
+class Tree
+{
+	Node* root; // óêàçàòåëü íà êîðåíü äåðåâà
+	char num, maxnum; // ñ÷åò÷èê òåãîâ è ìàêñèìàëüíûé òåã
+	int maxrow, offset; // ìàêñèìàëüíàÿ ãëóáèíà, ñìåùåíèå êîðíÿ
+	char** SCREEN; // áóôåð äëÿ âûäà÷è íà ýêðàí
+	void clrscr() // î÷èñòêà áóôåðà
+	{
+		for (int i = 0; i < maxrow; i++)
+			memset(SCREEN[i], '.', 80);
+	}
+
+	Node* MakeNode(int depth) // ñîçäàíèå ïîääåðåâà
+	{
+		Node* v = nullptr;
+		int random;
+		random = rand() % 5 + 1;// cout << random << endl;
+		int Y = (depth < random) && (num <= 'ÿ');
+		//Âàðèàíò: cout << "Node (" << num << ',' << depth << ")1/0: "; cin >> Y;
+		if (Y) { // ñîçäàíèå óçëà, åñëè Y = 1
+			v = new Node;
+			v->lft = MakeNode(depth + 1); 
+			v->d = num++; // âàðèàíò — âî âíóòðåííåì
+			v->rgt = MakeNode(depth + 1); 
+		}
+		return v;
+	}
+	void OutNodes(Node* v, int r, int c) // âûäà÷à ïîääåðåâà // root, 1, 40
+	{
+		if (r && c && (c < 80)) SCREEN[r - 1][c - 1] = v->d; // âûâîä ìåòêè
+		if (r < maxrow) {
+			if (v->lft) OutNodes(v->lft, r + 1, c -(offset >> r)); //ëåâûé ñûí
+			if (v->rgt) OutNodes(v->rgt, r + 1, c + (offset >> r)); //ïðàâûé ñûí
+		}
+	}
+
+	//Tree(const Tree&) = delete; // êîíñòðóêòîð êîïèè
+	//Tree(Tree&&) = delete; // êîïèÿ ñ ïåðåíîñîì (Ñ++11)
+	//Tree& operator = (const Tree&) const = delete; // ïðèñâàèâàíèå
+	//Tree& operator = (Tree&&) const = delete; // òî æå, ñ ïåðåíîñîì
+	//
+	
+
+public:
+	Tree(char nm, char mnm, int mxr) :
+		num(nm), maxnum(mnm), maxrow(mxr), offset(40), root(nullptr),
+		SCREEN(new char* [maxrow])
+	{
+		for (int i = 0; i < maxrow; i++) SCREEN[i] = new char[80];
+	}
+
+	~Tree() {
+		for (int i = 0; i < maxrow; i++) delete[]SCREEN[i];
+		delete[]SCREEN; delete root;
+	}
+	void MakeTree() // ââîä — ãåíåðàöèÿ äåðåâà
+	{
+		root = MakeNode(0);
+	}
+	bool exist() { return root != nullptr; } // ïðîâåðêà «äåðåâî íå ïóñòî»
+	void OutTree() // âûäà÷à íà ýêðàí
+	{
+		clrscr();
+		OutNodes(root, 1, offset);
+		for (int i = 0; i < maxrow; i++)
+		{
+			SCREEN[i][79] = 0;
+			cout << '\n' << SCREEN[i];
+		}
+		cout << '\n';
+	}
+
+	int DFS() // îáõîä äåðåâà «â ãëóáèíó»
+	{
+		const int MaxS = 20; // ìàêñèìàëüíûé ðàçìåð ñòåêà
+		int count = 0;
+		STACK <Node*> S(MaxS); //ñîçäàíèå ñòåêà óêàçàòåëåé íà óçëû
+		S.push(root); // STACK <- root
+		while (!S.empty()) // Ïîêà ñòåê íå ïóñò…
+		{
+			Node* v = S.pop(); // ïîäíÿòü óçåë èç ñòåêà
+			cout << v->d << '_'; count++; // âûäàòü òåã, ñ÷åò óçëîâ
+			if (v->rgt) S.push(v->rgt); // STACK <- (ïðàâûé ñûí)
+			if (v->lft) S.push(v->lft); // STACK <- (ëåâûé ñûí)
+		}
+		return count;
+	}
+
+template <class Item> 
+class STACK
+{
+	Item* S; 
+	int t;
+public:
+	STACK(int maxt) 
+	{
+		S = new Item[maxt]; 
+		t = 0;
+	}
+	int empty() const
+	{
+		return t == 0;
+	}
+	void push(Item item)
+	{
+		S[t++] = item;
+	}
+	Item pop() 
+	{
+		return (t ? S[--t] : 0);
+	}
+};
+
+
+int result()
+{
+	int rezult = 0;
+	search_1(root, 1);
+	search_2(root, 1);
+	return counter(root, 1, &rezult);
+}
+void search_1(Node* v, int x) // ïðîñòàâëÿåì êîëè÷åñòâî ñûíîâåé â êàæäîé âåðøèíå
+{
+	while (x)
+	{
+		if (v->lft != nullptr)
+		{
+			v->count++;
+			search_1(v->lft,1);
+			if (v->rgt != nullptr)
+			{
+				v->count++;
+				search_1(v->rgt, 1);
+				x = 0;
+			}
+			x = 0;
+		}
+		if ((v->rgt == nullptr && v->lft == nullptr) || (v->count > 1))
+		{
+			x = 0; 
+			break;
+		}
+		
+		if (v->rgt != nullptr)
+		{
+			v->count++;
+			search_1(v->rgt, 1);
+			if (v->lft != nullptr)
+			{
+				v->count++;
+				search_1(v->lft, 1);
+				x = 0;
+			}
+			x = 0;
+		}
+
+		if (v->rgt == nullptr && v->lft == nullptr) x = 0;
+	}
+}
+void search_2(Node* v, int x) // ê êîëè÷åñòâó óæå èìåþùèõñÿ ñûíîâåé ó êàæäîé âåðøèíû ïðèáàâëÿåì êîëè÷åñâòî ñûíîâåé ó êàæäîãîãî ñûíà î÷åðåäíîé âåðøèíû
+{
+	while (x)//          //////
+	{
+		if (v->lft != nullptr)
+		{
+			v->count = v->count + v->lft->count;
+			search_2(v->lft, 1);
+			if (v->rgt != nullptr)
+			{
+				v->count = v->count + v->rgt->count;
+				search_2(v->rgt, 1);
+				x = 0;
+			}
+			x = 0;
+		}
+
+
+		if ((v->rgt == nullptr && v->lft == nullptr) || (v->count > 3))
+		{
+			x = 0;
+			break;
+		}
+
+		if (v->rgt != nullptr)
+		{
+			v->count = v->count + v->rgt->count;
+			search_2(v->rgt, 1);
+			if (v->lft != nullptr)
+			{
+				v->count = v->count + v->lft->count;
+				search_2(v->lft, 1);
+				x = 0;
+			}
+			x = 0;
+		}
+
+		if (v->rgt == nullptr && v->lft == nullptr) x = 0;
+	}
+}
+
+int counter(Node* v, int x, int* rezult)
+{// â ðåçóëüòàò èäóò âåðøèíû â êîòîðûõ îäèí èëè 0 ñûíîâåé* (*íå ñûíîâåé à òî ÷òî ìû ñ÷èòàëè â ïðîøëûõ äâóõ ôóíêöèÿõ)
+	while (x)
+	{
+		if (v->count < 2)
+		{
+			(*rezult)++;
+			if (v->lft != nullptr)
+			{
+				counter(v->lft, 1, rezult);
+				x = 0;
+			}
+			if (v->rgt != nullptr)
+			{
+				counter(v->rgt, 1, rezult);
+				x = 0;
+			}
+			if (v->rgt == nullptr && v->lft == nullptr) x = 0;
+		}
+		else
+		{
+			if (v->lft != nullptr)
+			{
+				counter(v->lft, 1, rezult);
+				x = 0;
+			}
+			if (v->rgt != nullptr)
+			{
+				counter(v->rgt, 1, rezult);
+				x = 0;
+			}
+			if (v->rgt == nullptr && v->lft == nullptr) x = 0;
+		}
+	}
+	return *rezult;
+}
+};
+
+
+//
+int main ()
+{
+	int n = 0, rezult;
+	setlocale(LC_ALL, "Russian");
+	srand(time(0));
+
+	Tree tr('à','ÿ',5);
+	tr.MakeTree();
+	if (tr.exist())
+	{
+		tr.OutTree();
+		cout << '\n' << "Îáõîä â ãëóáèíó: ";
+		n = tr.DFS();
+		cout << " Ïðîéäåíî óçëîâ = " << n << '\n';
+		rezult = tr.result();
+		cout << "Êîëè÷åñòâî âåðøèí, èìåþùèõ íå áîëåå îäíîãî ïîòîìêà: " << rezult << '\n';
+	}
+	else
+		cout << "Error." << '\n';
+
+}

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,5 @@
+# Курсовая работа
+На основе программы, составленной по лабораторной работе №3, выполнить статистический эксперимент по измерению фактической временной сложности алгоритма обработки данных, провести анализ.
+## Полезные ссылки
+##### RG41: https://bit.ly/3m9Hcio 
+##### Таблица для данных: https://bit.ly/38TzNAM

README.md

@@ -0,0 +1,6 @@
+# AiSD
+Здесь представлены задания по Алгоритмам и Структурам Данных за 2 курс.
+## Part 1
+Первый семетр второго курса.
+## Part 2
+Второй семест второго курса.