#include <string> // для работы со строками
#include <iostream> // для ввода-вывода
#include <stdexcept> // для исключений
#include <vector> // выделение памяти для массива
#include <time.h> // типы и функции для работы с датой и временем
#include <ctime> // для манипуляций с временем
#include <cmath> // для матиматических функций (sqrt)

using std::cout;
using std::endl;
using std::string; // для использования стринг
using std::invalid_argument; // для исключения
using std::to_string; // для перевода в стринг
using std::rand; // для генератора ранд числа
using std::time; // для манипуляций с временем

class MyVector {
private:
	int* begin; // Выделение памяти/разыменованием указателя.

	unsigned int len;

public:
	MyVector() = default; //Вместо определения конструктора без параметров, в C++11 появилась возможность просто указать компилятору сгенерировать его по-умолчанию

	MyVector(const MyVector& b) { // конструктор копирования одного вектора в другой
		len = b.len;
		begin = new int[len];

		for (int i = 0; i < len; ++i)
			begin[i] = b.begin[i];
	}

	explicit // для создания явного конструктора, то есть руктор MyClass с ключевым словом explicit, то это автоматическое конвертирование не будет выполняться
		// прим MyClass ob2 = 10 =/> MyClass ob2(10);
		// unsigned - положительное значение
		MyVector(unsigned int _len) { // конструктор создания вектора
		this->len = _len;
		begin = new int[_len];
	}

	//Обычно деструктор используется для "очистки", когда объект больше не нужен.
	~MyVector() = default;

	string ToString() { // вывод вектора строкой
		string str("[");
		for (int i = 0; i < len - 1; i++) {
			str = str + to_string(this->begin[i]) + ",";
		}
		str += to_string(this->begin[len - 1]) + ("]");
		return str;

	}

	// int& - указатель на переменную int
	int& operator[] (unsigned int loc) // перегрузка оператора индексирования
	{
		if (loc/*то, что передаётся в скобках*/ > len - 1)
			// Определяет исключение, которое должно быть брошено в случае неправильного аргумента.
			throw std::invalid_argument("Vector out of range");
		return *(begin + loc);
	}

	MyVector& operator++(int) // перегрузка оператора инкремента – это операция в языках программирования, которая увеличивает переменную на единицу
	{
		int* tmp = new int[++len]; //
		int* tmp_begin = tmp;

		for (int i = 0; i < len - 1; ++i)
			tmp[i] = begin[i];

		delete begin;
		begin = tmp_begin;

		return *this;
	}

	MyVector& operator-- (int) // перегрузка оператора декремента
	{
		int* tmp = new int[--len];
		int* tmp_begin = tmp;

		for (int i = 0; i < len; ++i)
			tmp[i] = begin[i];

		delete begin;
		begin = tmp_begin;

		return *this;
	}

	MyVector& operator= (MyVector b) {
		len = b.len;
		int* tmp = new int[b.len]; // временное место для масива
		int* tmp_begin = tmp;

		for (int i = 0; i < b.len; i++)
			tmp[i] = b[i];

		delete begin;
		begin = tmp_begin;

		return *this;
	}

	MyVector operator+ (MyVector b) // перегрузка оператора сложения
	{
		if (b.len != len) throw std::invalid_argument("Vectors length do not match");

		MyVector ans(len);

		for (int i = 0; i < len; i++)
			ans[i] = begin[i] + b[i];

		return ans;
	}

	MyVector operator- (MyVector b) { // перегрузка оператора вычитания
		if (b.len != len) throw std::invalid_argument("Vectors length do not match");

		MyVector ans(len);

		for (int i = 0; i < len; i++)
			ans[i] = begin[i] - b[i];

		return ans;
	}

	int operator* (MyVector b) { // перегрузка умножения
		if (b.len != len) throw std::invalid_argument("Vectors length do not match");

		return scl(b);
	}

	double mod() { // модуль или длина векторов
		double x = 0;

		for (int i = 0; i < len; i++)
			//Функция pow() возвращает значение base, возведенное в степень ехр, т. е. baseexp.
			x += pow(2, this->begin[i]);

		return sqrt(x);
	}

	int scl(MyVector b) { // скалярное произведение векторов
		if (b.len != len) throw std::invalid_argument("Vectors length do not match");

		int x = 0;

		for (int i = 0; i < len; i++)
			x += begin[i] * b[i];

		return x;
	}
	MyVector operator* (int a) { // перегрузка оператора умножения на константу
		MyVector ans(len);

		for (int i = 0; i < len; i++)
			ans[i] = begin[i] * a;

		return ans;
	}

	bool col(MyVector b) { //проверка на коллинеарность
		if (b.len != len) throw std::invalid_argument("Vectors length do not match");
		// ???
		bool check = true;
		double lm1;
		double lm = (double)this->begin[0] / b[0];
		for (int i = 0; i < len; i++) {
			if ((double)this->begin[i] / b[i] != lm)
				return false;
		}
		return true;

	}

	bool ort(MyVector b) {
		if (this->scl(b) == 0)
			return true;
		else return false;
	}
};

class MyMatrix {
private:
	int** begin;

	unsigned int rows;
	unsigned int cols;


public:
	MyMatrix() = default;
	~MyMatrix() = default;

	MyMatrix(unsigned int _rows, unsigned int _cols) // конструктор
	{
		rows = _rows;
		cols = _cols;

		begin = new int*[rows];
		for (int i = 0; i < rows; i++) {
			begin[i] = new int[cols];
		}
	}

	MyMatrix(const MyMatrix& other) { // конструктор копирования
		rows = other.rows;
		cols = other.cols;

		begin = new int*[rows];
		for (int i = 0; i < rows; i++) {
			begin[i] = new int[cols];
			for (int j = 0; j < cols; j++) {
				begin[i][j] = other.begin[i][j];
			}
		}
	}

	MyMatrix operator* (int lambda)  // ???
	{
		MyMatrix ans(rows, cols);

		for (int i = 0; i < rows; i++)
			for (int j = 0; j < cols; j++)
				ans.begin[i][j] = begin[i][j] * lambda;

		return ans;
	}

	MyMatrix operator+ (MyMatrix other) // перегрузка сложения
	{
		if (cols != other.cols || rows != other.rows)
			throw invalid_argument("Matrix dimensions sizes don't fit each other!");

		MyMatrix ans(rows, cols);

		for (int i = 0; i < rows; i++)
			for (int j = 0; j < cols; j++)
				ans.begin[i][j] = begin[i][j] + other.begin[i][j];

		return ans;
	}

	MyMatrix operator- (MyMatrix other) // перегрузка вычитания
	{
		if (cols != other.cols || rows != other.rows)
			throw invalid_argument("Matrix dimensions sizes don't fit each other!");

		MyMatrix ans(rows, cols);

		for (int i = 0; i < rows; i++)
			for (int j = 0; j < cols; j++)
				ans.begin[i][j] = begin[i][j] - other.begin[i][j];

		return ans;
	}

	MyMatrix operator* (MyMatrix other) // ??? перегрузка перемножение
	{
		if (cols != other.rows || rows != other.cols) //TODO rework
			throw invalid_argument("Matrix dimensions sizes don't fit each other!");

		MyMatrix ans(rows, other.cols);

		for (int i = 0; i < rows; i++) {
			for (int j = 0; j < other.cols; j++) {
				ans.begin[i][j] = 0;
				for (int k = 0; k < cols; k++)
					ans.begin[i][j] += begin[i][k] * other.begin[k][j];
			}
		}
		return ans;
	}

	MyMatrix& operator= (const MyMatrix other) // перезагрузка присваивания
	{
		delete begin;

		rows = other.rows;
		cols = other.cols;

		begin = new int*[rows];
		for (int i = 0; i < rows; i++) {
			begin[i] = new int[cols];
			for (int j = 0; j < cols; j++) {
				begin[i][j] = other.begin[i][j];
			}
		}

		return *this;
	}

	int Norm() // вычисление нормы мартицы???
	{
		int ans;

		for (int i = 0; i < rows; i++)
		{
			int sum = 0;
			for (int j = 0; j < cols; j++)
				sum += begin[i][j];

			if (sum > ans)
				ans = sum;
		}
		return ans;
	}

	string ToString() { // вывод?
		string ans;

		for (int i = 0; i < rows; i++) {
			ans += "[";
			for (int j = 0; j < cols - 1; j++)
				ans += to_string(begin[i][j]) + ", ";
			ans += to_string(begin[i][cols - 1]) + "]\n";
		}
		return ans;
	}

	void Randomize() {

		for (int i = 0; i < rows; i++)
			for (int j = 0; j < cols; j++)
				begin[i][j] = rand() % 10;
	}
};

void SquareIElement(MyMatrix mat[], int i) { //  возведение в квадрат
	mat[i] = mat[i] * mat[i];
}

class MyStack {
private:
	int* begin;

	int len;
public:
	MyStack() // конструктор
	{
		len = 0;
		begin = new int[0];
	}

	~MyStack() = default;

	void push_back(int val) { //?

		int* tmp = new int[len + 1];
		for (int i = 0; i < len; i++)
		{
			tmp[i] = begin[i];
		}
		tmp[len] = val;
		len++;
		delete begin;
		begin = tmp;
	}

	bool pop() { //?
		return --len != 0;
	}

	int top() { //?
		return begin[len - 1];
	}

	string ToString()
	{
		string ans = "[";
		for (int i = 0; i < len - 1; i++)
			ans += to_string(begin[i]) + ", ";
		ans += to_string(begin[len - 1]);
		return ans;
	}

};

void deleteOdd(MyStack& stack) {
	MyStack tmp_stack;

	int i = 0;
	do {
		if (i % 2 == 1)
			tmp_stack.push_back(stack.top());
		i++;
	} while (stack.pop());

	do {
		stack.push_back(tmp_stack.top());
	} while (tmp_stack.pop());

}

class MyBoolVector {
private:
	bool *begin;
	unsigned int length;
public:

	MyBoolVector() = default;
	~MyBoolVector() = default;


	MyBoolVector(unsigned int _length) {
		length = _length;
		begin = new bool[length];
	}

	MyBoolVector(unsigned int _length, bool* _begin) { // кконструктор
		length = _length;
		begin = new bool[length]; // выделение памяти

		for (int i = 0; i < length; ++i) {
			begin[i] = _begin[i];
		}
	}



	MyBoolVector(const MyBoolVector& other) // конструктор копирования
	{
		begin = new bool[other.length];
		length = other.length;
		for (int i = 0; i < length; i++)
			begin[i] = other.begin[i];
	}

	MyBoolVector operator&& (MyBoolVector other) { // ???
		if (length != other.length)
			throw invalid_argument("Vectors length don't match!");

		MyBoolVector ans = MyBoolVector(length);

		for (int i = 0; i < length; i++)
			ans.begin[i] = begin[i] && other.begin[i];

		return ans;
	}

	MyBoolVector operator|| (MyBoolVector other) { // ???
		if (length != other.length)
			throw invalid_argument("Vectors length don't match!");

		MyBoolVector ans = MyBoolVector(length);

		for (int i = 0; i < length; i++)
			ans.begin[i] = begin[i] || other.begin[i];

		return ans;
	}

	unsigned int CountZeros() {
		unsigned int ans = 0;

		for (int i = 0; i < length; ++i) {
			if (begin[i]) // ??
				ans++;
		}
		return ans;
	}

	unsigned int CountOnes() {
		unsigned int ans = 0;

		for (int i = 0; i < length; ++i) {
			if (!begin[i])
				ans++;
		}
		return ans;
	}

	MyBoolVector operator! () { // ???
		MyBoolVector ans = MyBoolVector(*this);

		for (int i = 0; i < length; ++i) {
			ans.begin[i] = !ans.begin[i];
		}

		return ans;
	}

	string ToString() {
		string ans = "[";
		for (int i = 0; i < length - 1; ++i) {
			ans += to_string(begin[i]) + ", ";
		}
		ans += to_string(begin[length - 1]) + " ]";
		return ans;
	}




};

void TestMyVector() {
	MyVector vec1(3);
	for (int i = 0; i < 3; i++) {
		vec1[i] = i;
	}
	cout << vec1.ToString() << '\n';
	vec1++;
	vec1[3] = 3;
	cout << vec1.ToString() << '\n';
	MyVector vec2(4);
	for (int i = 0; i < 4; i++) {
		vec2[i] = i * i;
	}
	cout << vec2.ToString() << '\n';
	//vec2--;
	cout << vec2.ToString() << '\n';
	MyVector vec3(5);
	for (int i = 0; i < 5; i++) {
		vec3[i] = i * i*i;
	}
	cout << vec3.ToString() << '\n';
	vec3 = vec3 * 10;
	cout << "модуль " << vec3.mod() << '\n';
	cout << "скалярное произведение " << vec1.scl(vec2) << '\n';
	cout << "произведение на константу " << vec3.ToString() << '\n';

	/* MyVector vec (2) ; // Array of vectors
	MyVector vec1 (3);
	MyVector vec2 (3);
	MyVector vec4 (5);
	for (int i = 0; i < 5; i++){
	vec4[i] = i;
	}
	MyVector vec6 (7);
	for (int i = 0; i < 7; i++){
	vec6[i] = i;
	}
	vec4 = vec6;
	cout << vec4.ToString() << '\n';
	cout << vec6.ToString() << '\n';
	vec[0] = 1;
	vec[1] = 2;
	vec1[0] = 2;
	vec1[1] = 4;
	vec1[2] = 6;
	vec++;
	vec[2] = 3;
	vec2 = vec * 10;
	int a = vec * vec1;
	cout << vec.mod() << "\n";
	cout << vec.ToString() << "\n";
	cout << vec1.ToString() << "\n";
	cout << vec.scl(vec1) << "\n";
	cout << a << "\n";
	cout << vec2.ToString() << "\n";
	cout << vec.ort(vec1) << "\n";
	cout << vec.col(vec1) << "\n";*/
}

void TestMyMatrix() {
	std::srand(unsigned(time(0)));

	MyMatrix mat1(2, 3);
	MyMatrix mat2(2, 3);
	MyMatrix mat3(3, 2);

	mat1.Randomize();
	cout << "mat1:\n" << mat1.ToString() << "\n";

	mat2.Randomize();
	cout << "mat2:\n" << mat2.ToString() << "\n";

	mat3.Randomize();
	cout << "mat3:\n" << mat3.ToString() << "\n";

	mat1 = mat1 + mat2;
	cout << "mat1 = mat1 + mat2:\n" << mat1.ToString() << "\n";

	MyMatrix mat4 = mat1 * mat3;
	cout << "mat4 = mat1 * mat3:\n" << mat4.ToString() << "\n";

	MyMatrix matArray[] = { mat1, mat2, mat3, mat4 };

	SquareIElement(matArray, 3);
	cout << "SquareIElement:\n" << matArray[3].ToString() << "\n";
}

void TestMyStack() {
	srand(unsigned(time(0)));

	MyStack stack1;
	MyStack stack2;
	MyStack stack3;

	for (int i = 0; i < 10; i++)
	{
		stack1.push_back(rand() % 100);
		stack2.push_back(rand() % 100);
		stack3.push_back(rand() % 100);
	}

	cout << stack1.ToString() << "\n";
	cout << stack2.ToString() << "\n";
	cout << stack3.ToString() << "\n";

	MyStack stackArray[] = { stack1, stack2, stack3 };

	for (int i = 0; i < 3; i++)
	{
		deleteOdd(stackArray[i]);
	}

	for (int i = 0; i < 3; i++)
	{
		cout << stackArray[i].ToString() << "\n";
	}
}

void TestMyBoolVector() {
	MyBoolVector A = MyBoolVector(4, new bool[4]{ 1, 0, 1, 0 });
	MyBoolVector B = MyBoolVector(4, new bool[4]{ 1, 1, 0, 0 });

	A = A && !B;

	cout << A.ToString();
}

int main() {

	TestMyVector();

	TestMyMatrix();

	TestMyStack();

	TestMyBoolVector();

	return 0;
}