Untitled

#include <iostream>
#include <vector>
#include <functional>
#include <string>
#include <algorithm>
using namespace std;

// множества
vector <int> set_1;
vector <int> set_2;
vector <int> set_3;

// универсум
vector <int> main_set = { -50, -49, -48, -47, -46, -45, -44, -43, -42, -41, -40, -39, -38, -37, -36, -35, -34,
-33, -32, -31, -30, -29, -28, -27, -26, -25,-24, -23, -22, -21, -20, -19, -18,
-17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3,
4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,26, 27,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50 };

//----------------------—
// побочные функции

// функция удаление повторяющихся элементов в векторе
vector<int> removing_duplicate_elements(vector<int>& vect) {
	vector<int> temp;
	temp.push_back(vect[0]);
	for (int i = 0; i < vect.size(); i++) {
		if ((count(temp.begin(), temp.end(), vect[i]) + 1) == 1) {
			temp.push_back(vect[i]);
		}
	}
	return temp;
}

// функция вывода множесства в консоль
void print_vector(vector <int> v) {
	for (int i = 0; i < v.size(); i++) {
		if (i % 10 == 0)
			cout << endl;
		cout << v[i] << " ";
	}
	cout << "\n\n";
}

// вывод всех множеств
void print_sets() {
	cout << "\n\nмножество 1:\n";
	print_vector(set_1);
	cout << "множество 2:\n";
	print_vector(set_2);
	cout << "множество 3:\n";
	print_vector(set_3);
}


//----------------------—
// функции ввода множества

// ввод множества пересечением
void set_input(vector<int>& vect) {
	int size;
	cout << "Введите длинну множества\n";
	cin » size;
	cout << "Введите множество\n";
	for (int i = 0; i < size; i++) {
		int temp;
		cin » temp;
		vect.push_back(temp);
	}
}

// проверка границ диапазона
bool range_check(int first, int second) {
	bool result = true;
	if ((first < -50) || (second > 50) || (first > second)) {
		result = false;
	}
	return result;
}

// ввод множества диапазоном
void set_input_diapason(vector<int>& vect) {
	int first_number;
	int second_number;

	cout << "Введите первую границу\n";
	cin » first_number;
	cout << "Введите вторую границу\n";
	cin » second_number;

	while (range_check(first_number, second_number) == false) {
		cout << "Диапазон выходит за границы универсума\n";
		cout << "Введите границы диапазона зановоn\n";
		cout << "Введите первую границу\n";
		cin » first_number;
		cout << "Введите вторую границу\n";
		cin » second_number;
	}


	for (int i = first_number; i < second_number + 1; i++) {
		vect.push_back(i);
	}
}

// создание случайного множества
void random_set(vector<int>& vect) {
	cout << "Введите размер множества\n";
	int size;
	cin » size;
	int temp = 10;
	for (int i = 0; i < size; i++) {
		srand(time(NULL) + i + temp);
		vect.push_back(-50 + rand() % 100);
		temp = (temp + 23) / temp;
	}
	sort(vect.begin(), vect.end());
}

// ввод множества кратностью с диапазоном
void set_input_diapason_condition(vector<int>& vect) {
	int choice_multiplicity;
	cout << "Введите число-кратность\n";
	cin » choice_multiplicity;

	int first_number;
	int second_number;

	cout << "Введите первую границу\n";
	cin » first_number;
	cout << "Введите вторую границу\n";
	cin » second_number;

	while (range_check(first_number, second_number) == false) {
		cout << "Диапазон выходит за границы универсума\n"
			<< "Введите границы диапазона зановоn\n"
			<< "Введите первую границу\n";
		cin » first_number;
		cout << "Введите вторую границу\n";
		cin » second_number;
	}


	for (int i = first_number; i < second_number + 1; i++) {
		if (i % choice_multiplicity == 0) {
			vect.push_back(i);
		}
	}
}

// ввод множества кратностью с знаком
void set_input_sign_condition(vector<int>& vect) {

	int choice_multiplicity;
	cout << "Введите число-кратность\n";
	cin » choice_multiplicity;

	cout << "Выберите знак множества\n"
		<< "1 - Плюс\n"
		<< "2 - Минус\n";
	int sign;
	cin » sign;
	switch (sign) {
	case 1:
		for (int i = 1; i < 50; i++) {
			if (i % choice_multiplicity == 0) {
				vect.push_back(i);
			}
		}
		break;
	case 2:
		for (int i = -50; i < 0; i++) {
			if (i % choice_multiplicity == 0) {
				vect.push_back(i);
			}
		}
		break;
	}

}

//----------------------—
// Операции:

// операция объединения
vector<int> union_sets(vector<int>& vect_1, vector<int>& vect_2) {
	vector <int> temp;
	temp = vect_1;
	for (int i = 0; i < vect_2.size(); i++) {
		temp.push_back(vect_2[i]);
	}
	temp = removing_duplicate_elements(temp);
	return temp;
}

// функция операции дополнение
vector<int> unary_operation_sets(vector<int>& vect_1) {
	vector<int> temp;
	for (int i = 0; i < 101; i++) {
		if (count(vect_1.begin(), vect_1.end(), main_set[i]) == 0) {
			temp.push_back(main_set[i]);
		}
	}
	return temp;
}

// функция пересечения
vector<int> intersect_sets(vector<int>& vect_1, vector<int>& vect_2) {
	vector<int> temp;
	for (int i = 0; i < main_set.size(); i++) {
		if ((count(vect_1.begin(), vect_1.end(), main_set[i]) == 1)
			&& (count(vect_2.begin(), vect_2.end(), main_set[i]) == 1)) {
			temp.push_back(main_set[i]);
		}
	}
	return temp;
}

// фукнция разности
vector<int> difference_sets(vector<int>& vect_1, vector<int>& vect_2) {
	vector<int> temp;
	for (int i = 0; i < vect_1.size(); i++) {
		if ((count(vect_1.begin(), vect_1.end(), vect_1[i]) == 1)
			&& (count(vect_2.begin(), vect_2.end(), vect_1[i]) != 1)) {
			temp.push_back(vect_1[i]);
		}
	}
	return temp;
}

// функция симметрической разности
vector<int> symmetrical_difference_sets(vector<int>& vect_1, vector<int>& vect_2) {
	vector<int> temp;
	for (int i = 0; i < main_set.size(); i++) {
		if ((count(vect_1.begin(), vect_1.end(), main_set[i]) == 1
			&& count(vect_2.begin(), vect_2.end(), main_set[i]) == 0)
			|| ((count(vect_2.begin(), vect_2.end(), main_set[i]) == 1)
				&& (count(vect_1.begin(), vect_1.end(), main_set[i]) == 0))) {
			temp.push_back(main_set[i]);
		}
	}
	return temp;
}

//----------------------—
// меню

// меню задания множества
void first_menu() {
	cout << "Выберите способ задания множества:\n"
		<< "1 - Перечислением\n"
		<< "2 - Диапазоном\n"
		<< "3 - Условием\n"
		<< "4 - Случайное множество\n"

		<< "0 - Выход\n\n";
}

// меню операций над множествами
void print_menu() {
	cout << endl << endl << "Меню:\n\n"

		<< "Выбор операции над множествами: \n"
		<< "1 - Объединение\n"
		<< "2 - Пересечение\n"
		<< "3 - Разность\n"
		<< "4 - Симметричная разность\n"
		<< "5 - Дополнение\n"

		<< "6 - Показать множества\n"
		<< "0 - Выход\n" << endl;
}

// меню выбора множества
void print_menu_sets() {
	cout << "Выберите множество: \n"
		<< "1 - Множество 1\n"
		<< "2 - Множество 2\n"
		<< "3 - Множество 3\n\n";
	//<< "0 - Назад\n";
}

void print_menu_sets(int choice) {
	cout << "Выберите множество: \n";
	switch (choice) {
	case(1):
		cout << "2 - Множество 2\n"
			<< "3 - Множество 3\n\n";
		break;
	case(2):
		cout << "1 - Множество 1\n"
			<< "3 - Множество 3\n\n";
		break;
	case(3):
		cout << "1 - Множество 1\n"
			<< "2 - Множество 2\n\n";
		break;
	}
}

// меню задания множества с условием
void menu_choice_condition(vector<int>& vect) {
	cout << "\nВыберете условие\n"
		<< "1 - Кратность с диапазоном\n"
		<< "2 - Кратность со знаком\n\n";
	int choice;
	cin » choice;
	switch (choice) {
	case 1:
		set_input_diapason_condition(vect);
		break;
	case 2:
		set_input_sign_condition(vect);
		break;
	}
}

// задание множеств
void choice_input(vector<int>& vect) {
	first_menu();
	int choice;
	cin » choice;
	switch (choice) {
		// пересечением
	case (1):
		set_input(vect);
		break;
		// диапазоном
	case (2):
		set_input_diapason(vect);
		break;
		// условием
	case (3):
		menu_choice_condition(vect);
		break;
		// случайное
	case (4):
		random_set(vect);
		break;
	default:
		cout << "Введен некорректный вариант\n";
		break;
	}
}

// функция для выбора множеств
для совершения операции и дальнейший вывод результата операции
void func_menu(function<vector<int>(vector<int>& vect_1, vector<int>& vect_2)> func) {
	int choice_1;
	int choice_2;
	vector<int> temp;
	print_menu_sets();
	cin » choice_1;
	switch (choice_1) {
	case (1):
		print_menu_sets(1);
		cin » choice_2;
		switch (choice_2) {
		case(2):
			temp = func(set_1, set_2);
			if (!temp.empty()) {
				print_vector(temp);
			}
			else {
				cout << "Пустое множество" << "\n";
			}
			break;
		case(3):
			temp = func(set_1, set_3);
			if (!temp.empty()) {
				print_vector(temp);
			}
			else {
				cout << "Пустое множество" << "\n";
			}
			break;
		}
		break;
	case(2):
		print_menu_sets(2);
		cin » choice_2;
		switch (choice_2) {
		case(1):
			temp = func(set_2, set_1);
			if (!temp.empty()) {
				print_vector(temp);
			}
			else {
				cout << "Пустое множество" << "\n";
			}
			break;
		case(3):
			temp = func(set_2, set_3);
			if (!temp.empty()) {
				print_vector(temp);
			}
			else {
				cout << "Пустое множество" << "\n";
			}
			break;
		}
		break;
	case(3):
		print_menu_sets(3);
		cin » choice_2;
		switch (choice_2) {
		case(1):
			temp = func(set_3, set_1);
			if (!temp.empty()) {
				print_vector(temp);
			}
			else {
				cout << "Пустое множество" << "\n";
			}
			break;
		case(2):
			temp = func(set_3, set_2);
			if (!temp.empty()) {
				print_vector(temp);
			}
			else {
				cout << "Пустое множество" << "\n";
			}
			break;
		}
		break;
	}
}

void main() {


	setlocale(LC_ALL, "Rus");
	cout << "Калькулятор множеств\n"
		<< "Универсум - все целые числа от -50 до 50\n\n";

	// ввод множеств
	cout << "\nВведите первое множество\n";
	choice_input(set_1);

	cout << "\nВведите второе множество\n";
	choice_input(set_2);

	cout << "\nВведите третье множество\n";
	choice_input(set_3);

	print_sets();

	// операции над множествами
	int choice = 1;

	// для выбора множеств
	int choice_1;


	vector<int> temp;

	while (choice != 0) {
		print_menu();
		cin » choice;
		switch (choice) {
		case(1):
			func_menu(union_sets);
			break;
		case(2):
			func_menu(intersect_sets);
			break;
		case(3):
			func_menu(difference_sets);
			break;
		case(4):
			func_menu(symmetrical_difference_sets);
			break;
		case(5):
			print_menu_sets();
			cin » choice_1;
			switch (choice_1) {
			case(1):
				temp = unary_operation_sets(set_1);
				if (!temp.empty()) {
					print_vector(temp);
				}
				else {
					cout << "Пустое множество" << "\n";
				}
				break;
			case(2):
				temp = unary_operation_sets(set_2);
				if (!temp.empty()) {
					print_vector(temp);
				}
				else {
					cout << "Пустое множество" << "\n";
				}
				break;
			case(3):
				temp = unary_operation_sets(set_3);
				if (!temp.empty()) {
					print_vector(temp);
				}
				else {
					cout << "Пустое множество" << "\n";
				}
				break;
			}
			break;
		case(6):
			print_sets();
			break;
		case(0):
			break;
		default:
			cout << "Введён некорректный вариант";
			break;
		}
	}
}