Колинько 4 семестр 2018 / ConsoleApplication5

яю// ConsoleApplication5.cpp: >?@545;O5B B>G:C 2E>40 4;O :>=A>;L=>3> ?@8;>65=8O.

//



#include "stdafx.h"

#include<iostream>

#include<set>

#include<vector>

#include<algorithm>

#include<iterator>

#include<time.h>

#include <fstream>

#include <chrono>



using namespace std;



class mySet {

public:

	set<int> values;

	vector<set<int>::iterator> pointers;

	char name;



	mySet(char n) :name(n) {}



	void gen(int n, int mod) {

		for (int i = 0; i < n; ++i)

			pointers.push_back(values.insert(rand() % (1 + mod)).first);

	}



	void setOut() {

		cout << "\n" << name << " = {";

		for (auto it = values.cbegin(); it != values.cend(); ++it)

			cout << (*it) << ' ';

		cout << "\b}" << endl;

	}



	void seqOut() {

		cout << "\n" << name << " = {";

		for (auto it = pointers.cbegin(); it != pointers.cend(); ++it)

			cout << (*(*it)) << ' ';

		cout << "\b}" << endl;

	}

	void push_back(int key);

};



void mySet::push_back(int key) {

	pointers.push_back(values.insert(key).first);

}



string sub(string str, string del) {

	string::size_type pos = str.find(del);

	while (pos != string::npos)

	{

		str.erase(pos, del.size());

		pos = str.find(del, pos + 1);

	}

	return str;

}



int setAnd(mySet A, mySet B, mySet& C) { // &

	C.values.clear();

	C.pointers.clear();

	set_intersection<set<int>::const_iterator, set<int>::const_iterator, insert_iterator<set<int>>>

		(A.values.cbegin(), A.values.cend(), B.values.cbegin(), B.values.cend(), inserter(C.values, C.values.begin()));

	for (auto it = C.values.cbegin(); it != C.values.cend(); ++it)

		C.pointers.push_back(it);

	return C.pointers.size();

}



int setDif(mySet A, mySet B, mySet& C) {  //-

	C.values.clear();

	C.pointers.clear();

	set_difference<set<int>::const_iterator, set<int>::const_iterator, insert_iterator<set<int>>>

		(A.values.cbegin(), A.values.cend(), B.values.cbegin(), B.values.cend(), inserter(C.values, C.values.begin()));

	for (auto it = C.values.cbegin(); it != C.values.cend(); ++it)

		C.pointers.push_back(it);

	return C.pointers.size();

}





int excl(mySet a, mySet b, mySet& C) {

	string s1, s2, s3;

	vector<int> temp(a.values.begin(), a.values.end()), temp2(b.values.begin(), b.values.end());

	for (int i = 0; i < temp.size(); i++)

		s1 += temp[i] + '0';

	for (int i = 0; i < temp2.size(); i++)

		s2 += temp2[i] + '0';

	s3 = sub(s1, s2);

	for (int i = 0; i < s3.size(); i++)

		C.pointers.push_back(C.values.insert((int)s3[i]-'0').first);

	return C.values.size();

}



int setSymDif(mySet A, mySet B, mySet& C) { // xor

	C.values.clear();

	C.pointers.clear();

	set_symmetric_difference<set<int>::const_iterator, set<int>::const_iterator, insert_iterator<set<int>>>

		(A.values.cbegin(), A.values.cend(), B.values.cbegin(), B.values.cend(), inserter(C.values, C.values.begin()));

	for (auto it = C.values.cbegin(); it != C.values.cend(); ++it)

		C.pointers.push_back(it);

	return C.pointers.size();

}



int subst(mySet& A, mySet B, int p) {

	mySet T('A');

	int i = 0;

	auto itA = A.pointers.cbegin();

	for (; itA != A.pointers.cend() && i < p; ++itA, ++i)

		T.pointers.push_back(T.values.insert((*(*itA))).first);

	for (auto it = B.pointers.cbegin(); it != B.pointers.cend(); ++it)

		T.pointers.push_back(T.values.insert((*(*it))).first);

	for (; itA != A.pointers.cend(); ++itA)

		T.pointers.push_back(T.values.insert((*(*itA))).first);

	swap(A, T);

	return A.pointers.size();

}



int concat(mySet&A, mySet B) {

	for (auto it = B.pointers.cbegin(); it != B.pointers.cend(); ++it)

		A.pointers.push_back(A.values.insert((*(*it))).first);

	return A.pointers.size();

}



mySet generate(int power)
{
	mySet res(0);

	for (int i = 0; i < power; i++)
		res.push_back(rand() % power);

	return res;
}



int main() {

	srand(time(nullptr));

	mySet a('A'), b('B'), c('C'), d('D'), e('E'), fab('1'), fcd('2'), fabcd('3'), fe('4'), conc('5'), subs('6'),exc('7'), co('8'), te('9');
	std::ofstream out;

	out.open("in.txt");


	out << 190 << std::endl;


	for (int power = 500; power < 2500; power+=10) {
		try {


			int av_power = 0;
			a = generate(power);
			b = generate(power);
			c = generate(power);
			d = generate(power);
			e = generate(power);
			subs = a;
			co = a;

			std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();

			setAnd(a, b, fab);
			av_power += fab.pointers.size();

			setAnd(c, d, fcd);
			av_power += fcd.pointers.size();

			setSymDif(fab, fcd, fabcd);
			av_power += fabcd.pointers.size();


			setDif(fabcd, e, fe);
			av_power += fe.pointers.size();

			concat(a, b);
			av_power += a.pointers.size();


			//excl(a, b, exc);
			concat(co, b);
			av_power += co.pointers.size();

			subst(subs,b, 3);
			av_power += subs.pointers.size();
			
			std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();

			auto dt = std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1);

			av_power /= 7;

			out << av_power << " " << dt.count() << std::endl;
			//std::cout << av_power << " " << dt.count() << std::endl;

		}
		catch (std::exception ignored)
		{
		}
	}

	out.close();



	system("pause");

	return 0;

}