ООП ЛБ1-19б

30.«Произвольный многоугольник в двумерном пространстве»

#include <iostream>
#include<math.h>
using namespace std;

struct Coordinata {
public:
	double x;
	double y;
	Coordinata() {
		x = 0;
		y = 0;
	}
	Coordinata(double x, double y) {
		this->x = x;
		this->y = y;
	}
	Coordinata(const Coordinata& temp) {
		this->x = temp.x;
		this->y = temp.y;
	}
	Coordinata(Coordinata&& temp)noexcept {
		this->x = temp.x;
		this->y = temp.y;
	}
	Coordinata& operator=(const Coordinata& temp) {
		this->x = temp.x;
		this->y = temp.y;
		return *this;
	}
	Coordinata& operator=(Coordinata&& temp) noexcept {
		this->x = temp.x;
		this->y = temp.y;
		return *this;
	}
};



class Polygon {

private:
	int colVershun;
	Coordinata* coordinates;
public:

	// конструктор по умолчанию
	Polygon() {
		colVershun = 1;
		coordinates = new Coordinata[1];
		coordinates[0] = Coordinata();
	}

	// конструктор копирования
	Polygon(const Polygon& objrect) {
		colVershun = objrect.colVershun;

		coordinates = new Coordinata[colVershun];
		for (int i = 0; i < colVershun; i++) {
			coordinates[i] = objrect.coordinates[i];
		}
	}

	// конструктор перемещения
	Polygon(Polygon&& objrect) noexcept {
		colVershun = objrect.colVershun;

		coordinates = new Coordinata[colVershun];
		for (int i = 0; i < colVershun; i++) {
			coordinates[i] = objrect.coordinates[i];
		}
	}

	// деструктор
	~Polygon() {
		delete[] coordinates;
	}

	// параметрический конструктор
	Polygon(int colVershun, Coordinata* coordinates) {
		this->colVershun = colVershun;
		this->coordinates = coordinates;
	}

	// функция ввода
	void input() {
		cin >> colVershun;
		coordinates = new Coordinata[colVershun];
		for (int i = 0; i < colVershun; i++) {
			double x, y;
			cin >> x;
			cin >> y;
			coordinates[i] = Coordinata(x, y);
		}
	}

	//функция вывода
	void output() {
		for (int i = 0; i < colVershun; i++) {
			cout << "[" << coordinates[i].x << ";" << coordinates[i].y << "]" << endl;
		}
	}


	// функция определения типа фигуры
	string checkFigera() {
		int vershunu = sizeof(coordinates);
		if (vershunu < 3) return"Не фигура";
		if (vershunu == 3) return isTringle(coordinates);
		if (vershunu == 4) return isQuadrilateral(coordinates);
	}

	// функция проверки треугольников
	string isTringle(Coordinata* coord) {
		Coordinata A = coord[0];
		Coordinata B = coord[1];
		Coordinata C = coord[2];

		double AB = sqrt(pow((B.x - A.x), 2) + pow((B.y - A.y), 2));
		double AC = sqrt(pow((C.x - A.x), 2) + pow((C.y - A.y), 2));
		double BC = sqrt(pow((C.x - B.x), 2) + pow((C.y - B.y), 2));
		if (AB == AC || AB == BC || BC == AC) return "Равнобедренный треугольник";
		if (AB == BC == AC) return "Равносторонний треугольник";
		if ((AB * AB == BC * BC + AC * AC) || (BC * BC == AC * AC + AB * AB) || (AC * AC == AB * AB + BC * BC)) return "Прямоугольный треугольник";
		else return "Произвольный треугольник";
	}

	// функция проверки четырехугольников
	string isQuadrilateral(Coordinata* coord) {
		Coordinata A = coord[0];
		Coordinata B = coord[1];
		Coordinata C = coord[2];
		Coordinata D = coord[3];

		double AB = sqrt(pow((B.x - A.x), 2) + pow((B.y - A.y), 2));
		double BC = sqrt(pow((C.x - B.x), 2) + pow((C.y - B.y), 2));
		double CD = sqrt(pow((D.x - C.x), 2) + pow((D.y - C.y), 2));
		double AD = sqrt(pow((D.x - A.x), 2) + pow((D.y - A.y), 2));

		//если все стороны равны, проверяем на квадрат/ромб
		if (AB == BC == CD == AD) {
			// находим угол между сторонами через скалярное произведение векторов
			if ((B.x - A.x) * (C.x - B.x) + (B.y - A.y) * (C.y - B.y) == 0) return "Квадрат";
			else return"Ромб";
		}

		// если противоположные стороны равны, проверяем тем же методом на прямоугольник/параллелепипед
		if (AB == CD && BC == AD) {
			// находим угол между сторонами через скалярное произведение векторов
			if ((B.x - A.x) * (C.x - B.x) + (B.y - A.y) * (C.y - B.y) == 0) return "Прямоугольник";
			else return"Параллелепипед";
		}

		if ((B.x - A.x) * (C.y - D.y) == (C.x - D.x) * (B.y - A.y) || (C.x - B.x) * (D.y - A.y) == (D.x - A.x) * (C.y - B.y)) return "Трапеция";
		else return "Произвольный четыхеругольник";
	}

	// функция проверки выпуслоси многоугольника
	bool isBulging() {
		int vershunu = sizeof(coordinates);

		if (vershunu <= 3) {
			return true;
		}

		Coordinata A = coordinates[0];
		Coordinata B = coordinates[1];
		Coordinata C = coordinates[2];
		Coordinata D = coordinates[3];
		double ABx = B.x - A.x;
		double ABy = B.y - A.y;
		double BCx = C.x - B.x;
		double BCy = C.y - B.y;
		double CDx = D.x - C.x;
		double CDy = D.y - C.y;
		double ADx = D.x - A.x;
		double ADy = D.y - A.y;

		double array[8];
		array[0] = ABx;
		array[1] = ABy;
		array[2] = BCx;
		array[3] = BCy;
		array[4] = CDx;
		array[5] = CDy;
		array[6] = ADx;
		array[7] = ADy;
		bool value;

		for (int i = 0; i < vershunu * 2; i += 2) {
			bool valueNow;
			if (i == 6) {
				valueNow = checkForBulging(array[i], array[i + 1], array[0], array[1]);
			}
			else valueNow = checkForBulging(array[i], array[i + 1], array[i + 2], array[i + 3]);
			if (i == 0) value = valueNow;
			if (value != valueNow) break;
		}
	}

	// функция знака поворота ребет при вершине для функции выпуклости
	bool checkForBulging(double arr1x, double arr1y, double arr2x, double arr2y) {
		double value;
		// формала, которая дает знак поворота следующего ребра по отношению к предыдущему
		// Для поворота налево это значение будет положительным, а для поворота направо - отрицательным 
		// (я предполагаю, что ось Y направлена вверх). Нулевое значение означает, что ребра коллинеарны.
		value = arr1x * arr2y - arr1y * arr2x;
		if (value > 0) return 1;
		else return 0;
	}

	// функция вычисления площади
	double sqaure() {
		int vershunu = sizeof(coordinates);
		if (vershunu < 3) return 0;

		if (vershunu == 3) {
			Coordinata A = coordinates[0];
			Coordinata B = coordinates[1];
			Coordinata C = coordinates[2];
			return 1 / 2 * ((B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y));
		}

		if (vershunu == 4) {
			Coordinata A = coordinates[0];
			Coordinata B = coordinates[1];
			Coordinata C = coordinates[2];
			Coordinata D = coordinates[3];
			return abs(((A.x * B.y - A.y * B.x) + (B.x * C.y - B.y * C.x) + (C.x * D.y - C.y * D.x) + (D.x * A.y - D.y * A.x)) / 2);
		}
	}
};

31.«Вектор в многомерном пространстве».

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

class Vector {
private:
    int size;
    int* point;
public:
    Vector();
    explicit Vector(int);
    Vector(int, const int[]);
    Vector(const Vector&);
    Vector(Vector&&) noexcept;
    ~Vector();
    int getSize() const;
    void print() const;
    int getValue(int) const;
    Vector Sum(const Vector&) const;
    Vector Diff(const Vector&);
    Vector Multi(int);
    float Mod() const;
    int Scalar(const Vector&) const;
};
Vector::Vector() {
    size = 0;
    point = nullptr;
}
Vector::Vector(int a) {
    if (a < 0) {
        abort();
    }
    else
    {
        srand(time(nullptr));
        size = a;
        point = new int[size];
        for (int i = 0; i < size; i++)
        {
            point[i] = -10 + rand() % 21;
        }
    }
}
Vector::Vector(int size_arr, const int a[]) {
    size = size_arr;
    point = new int[size];
    for (int i = 0; i < size; i++)
    {
        point[i] = a[i];
    }
}
Vector::Vector(const Vector& a)
{
    size = a.size;
    point = new int[size];
    for (int i = 0; i < size; i++)
    {
        point[i] = a.point[i];
    }
}
Vector::Vector(Vector&& a) noexcept {
    size = a.size;
    point = new int[size];
    for (int i = 0; i < size; i++)
    {
        point[i] = a.point[i];
    }
    a.size = 0;
    delete[] a.point;
}
int Vector::getSize() const {
    return size;
}
int Vector::getValue(int a) const {
    if (a > size) {
        abort();
    }
    return point[a + 1];
}
Vector Vector::Sum(const Vector& a) const {
    int sizeTemp;
    int* pointTemp;
    if (size > a.size) {
        sizeTemp = size;
        pointTemp = new int[size];

        for (int i = 0; i < a.size; ++i)
            pointTemp[i] = point[i] + a.point[i];
        for (int i = a.size; i < size; i++)
            pointTemp[i] = point[i];
    }
    else {
        sizeTemp = a.size;
        pointTemp = new int[a.size];

        for (int i = 0; i < size; ++i)
            pointTemp[i] = point[i] + a.point[i];
        for (int i = size; i < a.size; i++)
            pointTemp[i] = a.point[i];
    }
    Vector temp(sizeTemp, pointTemp);
    delete[] pointTemp;
    return temp;
}
Vector Vector::Diff(const Vector& a) {
    int sizeTemp;
    int* pointTemp;
    if (size > a.size) {
        sizeTemp = size;
        pointTemp = new int[size];

        for (int i = 0; i < a.size; ++i)
            pointTemp[i] = point[i] - a.point[i];
        for (int i = a.size; i < size; i++)
            pointTemp[i] = point[i];
    }
    else {
        sizeTemp = a.size;
        pointTemp = new int[a.size];

        for (int i = 0; i < size; ++i)
            pointTemp[i] = point[i] - a.point[i];
        for (int i = size; i < a.size; i++)
            pointTemp[i] = -a.point[i];
    }
    Vector temp(sizeTemp, pointTemp);
    delete[] pointTemp;
    return temp;
}
Vector Vector::Multi(int a) {
    int* pointTemp = new int[size];
    for (int i = 0; i < size; i++)
    {
        pointTemp[i] = a * point[i];
    }
    Vector temp(size, pointTemp);
    delete[] pointTemp;
    return temp;
}
float Vector::Mod() const {
    float res = 0;
    for (int i = 0; i < size; i++)
    {
        res += pow(point[i], 2);
    }
    res = sqrt(res);
    return res;
}
void Vector::print() const
{
    for (int i = 0; i < size; i++)
    {
        cout << point[i] << ' ';
    }
    cout << endl;
}
int Vector::Scalar(const Vector& a) const {
    int res = 0;
    if (size != a.size)
        abort();
    for (int i = 0; i < size; i++)
    {
        res += point[i] * a.point[i];
    }
    return res;
}

Vector::~Vector() {
    size = 0;
    delete[] point;
}

32. «Полином от одной переменной»

#include <iostream>
#include <math.h>

using namespace std;
class Polinom
{
private:
    int sz;
    double* zn;
public:
    // конструктор по умолчанию
    Polinom() {
        sz = 1;
        zn = new double[1];
    }

    // конструктор копирования
    Polinom(const Polinom& objrect) {
        sz = objrect.sz;

        zn = new double[sz];
        for (int i = 0; i < sz; i++) {
            zn[i] = objrect.zn[i];
        }
    }

    // конструктор перемещения
    Polinom(Polinom&& objrect) noexcept {
        sz = objrect.sz;

        zn = new double[sz];
        for (int i = 0; i < sz; i++) {
            zn[i] = objrect.zn[i];
        }
    }

    // деструктор
    ~Polinom() {
        delete[] zn;
    }

    // параметрический конструктор
    Polinom(int sz, double* zn) {
        this->sz = sz;
        this->zn = zn;
    }
    void In()
    {
        cin >> sz;
        double* a = new double[sz];
        for (int i = 0; i < sz; i++)
            cin >> a[i];
        zn = a;
    }
    void Out()
    {
        for (int i = 0; i < sz; i++)
        {
            if (zn[i] != 0) {
                if (i == sz - 1 and zn[i] > 0) cout << zn[i]; else
                    if (i == sz - 1 and zn[i] < 0) cout << "\b" << zn[i]; else
                        if (zn[i] > 0) cout << zn[i] << "x^" << sz - 1 - i << "+"; else
                            if (zn[i] < 0) cout << "\b" << zn[i] << "x^" << sz - 1 - i << "+";
            }

        }
        cout << endl;
    }

    Polinom AddP(Polinom P)
    {
        if (sz <= P.sz)
        {
            int S = sz;
            int M = P.sz;
            double* a = new double[M];
            for (int i = 0; i < P.sz; i++)
                a[i] = P.zn[i];

            for (int i = S - 1; i >= 0; i--)
                a[M - S + i] += zn[i];

            Polinom A(M, a);

            return A;
        }
        else
        {
            int S = P.sz;
            int M = sz;
            double* a = new double[M];
            for (int i = 0; i < sz; i++)
                a[i] = zn[i];
            for (int i = S - 1; i >= 0; i--)
                a[M - S + i] += P.zn[i];
            Polinom A(M, a);

            return A;
        }
    }

    Polinom MnCh(double Ch)
    {
        int size = sz;
        double* a = new double[size];
        for (int i = 0; i < sz; i++)
            a[i] = zn[i];

        for (int i = 0; i < sz; i++)
            a[i] *= Ch;

        Polinom A(sz, a);
        return A;
    }

    Polinom DobCh(double Ch)
    {
        int size = sz;
        double* a = new double[size];
        for (int i = 0; i < sz; i++)
            a[i] = zn[i];
        a[size - 1] += Ch;
        Polinom A(sz, a);
        return A;
    }

    Polinom MinP(Polinom P)
    {
        int size = sz;
        double* a = new double[size];
        for (int i = 0; i < sz; i++)
            a[i] = zn[i];
        Polinom A(size, a);
        Polinom P1 = P.MnCh(-1);
        Polinom B = A.AddP(P1);
        return B;
    }

    double Vch(double b)
    {
        double a = 0;
        for (int i = 0; i < sz; i++)
        {
            a += zn[i] * pow(b, sz - 1 - i);
        }
        return a;
    }

    Polinom Pr(Polinom P)
    {
        int S = sz + P.sz - 1;
        double* a = new double[S];
        for (int i = 0; i < S; i++)
        {
            a[i] = 0;
            for (int j = 0; j < sz; j++)
                for (int k = 0; k < P.sz; k++)
                    if (j + k == i) a[i] += zn[j] * P.zn[k];
        }
        Polinom A(S, a);
        return A;
    }

    bool IsEqual(Polinom P)
    {
        if (P.sz == sz)
        {
            bool T = true;
            for (int i = 0; i < sz; i++)
                if (P.zn[i] != zn[i]) T = false;
            return T;
        }
        else return false;
    }

};

int main()
{
    system("color F0");
    Polinom A, B, C;
    A.In();
    B.In();
    C.In();

    cout << "A:"; A.Out();
    cout << "B:"; B.Out();
    cout << "C:"; C.Out();

    cout << A.IsEqual(B) << endl;

    Polinom D = A.AddP(B);
    cout << "D=A+B:"; D.Out();

    Polinom E = C.MinP(B);
    cout << "E=C-B:"; E.Out();

    Polinom F = A.DobCh(4);
    cout << "F=A+4:"; F.Out();

    Polinom G = C.MnCh(2);
    cout << "G=C*2:"; G.Out();

    cout << "B(3):" << B.Vch(3) << endl;

    Polinom H = A.Pr(C);
    cout << "H=A*C:"; H.Out();
}

33.«Полином от одной переменной» (перемножение полиномов)

#include <iostream>
#include <math.h>

using namespace std;
class Polinom
{
private:
	int sz;
	double* zn;
public:

	// конструктор по умолчанию
	Polinom() {
		sz = 1;
		zn = new double[1];
	}

	// конструктор копирования
	Polinom(const Polinom& objrect) {
		sz = objrect.sz;

		zn = new double[sz];
		for (int i = 0; i < sz; i++) {
			zn[i] = objrect.zn[i];
		}
	}

	// конструктор перемещения
	Polinom(Polinom&& objrect) noexcept {
		sz = objrect.sz;

		zn = new double[sz];
		for (int i = 0; i < sz; i++) {
			zn[i] = objrect.zn[i];
		}
	}

	// деструктор
	~Polinom() {
		delete[] zn;
	}

	// параметрический конструктор
	Polinom(int sz, double* zn) {
		this->sz = sz;
		this->zn = zn;
	}

	void In()
	{
		cin >> sz;
		double* a = new double[sz];
		for (int i = 0; i < sz; i++)
			cin >> a[i];
		zn = a;
	}
	void Out()
	{
		for (int i = 0; i < sz; i++)
		{
			if (zn[i] != 0) {
				if (i == sz - 1 and zn[i] > 0) cout << zn[i]; else
					if (i == sz - 1 and zn[i] < 0) cout << "\b" << zn[i]; else
						if (zn[i] > 0) cout << zn[i] << "x^" << sz - 1 - i << "+"; else
							if (zn[i] < 0) cout << "\b" << zn[i] << "x^" << sz - 1 - i << "+";
			}

		}
		cout << endl;
	}

	Polinom AddP(Polinom P)
	{
		if (sz <= P.sz)
		{
			int S = sz;
			int M = P.sz;
			double* a = new double[M];
			for (int i = 0; i < P.sz; i++)
				a[i] = P.zn[i];

			for (int i = S - 1; i >= 0; i--)
				a[M - S + i] += zn[i];

			Polinom A(M, a);

			return A;
		}
		else
		{
			int S = P.sz;
			int M = sz;
			double* a = new double[M];
			for (int i = 0; i < sz; i++)
				a[i] = zn[i];
			for (int i = S - 1; i >= 0; i--)
				a[M - S + i] += P.zn[i];
			Polinom A(M, a);

			return A;
		}
	}

	Polinom MnCh(double Ch)
	{
		int size = sz;
		double* a = new double[size];
		for (int i = 0; i < sz; i++)
			a[i] = zn[i];

		for (int i = 0; i < sz; i++)
			a[i] *= Ch;

		Polinom A(sz, a);
		return A;
	}

	Polinom DobCh(double Ch)
	{
		int size = sz;
		double* a = new double[size];
		for (int i = 0; i < sz; i++)
			a[i] = zn[i];
		a[size - 1] += Ch;
		Polinom A(sz, a);
		return A;
	}

	Polinom MinP(Polinom P)
	{
		int size = sz;
		double* a = new double[size];
		for (int i = 0; i < sz; i++)
			a[i] = zn[i];
		Polinom A(size, a);
		Polinom P1 = P.MnCh(-1);
		Polinom B = A.AddP(P1);
		return B;
	}

	double Vch(double b)
	{
		double a = 0;
		for (int i = 0; i < sz; i++)
		{
			a += zn[i] * pow(b, sz - 1 - i);
		}
		return a;
	}

	Polinom Multiplication(Polinom P)
	{
		int S = sz + P.sz - 1;
		double* a = new double[S];
		for (int i = 0; i < S; i++)
		{
			a[i] = 0;
			for (int j = 0; j < sz; j++)
				a[i + j] += zn[i] * P.zn[j];
		}
		Polinom A(S, a);
		return A;
	}

	bool IsEqual(Polinom P)
	{
		if (P.sz == sz)
		{
			bool T = true;
			for (int i = 0; i < sz; i++)
				if (P.zn[i] != zn[i]) T = false;
			return T;
		}
		else return false;
	}

};

int main()
{
	system("color F0");
	Polinom A, B, C;
	A.In();
	B.In();
	C.In();

	cout << "A:"; A.Out();
	cout << "B:"; B.Out();
	cout << "C:"; C.Out();

	cout << A.IsEqual(B) << endl;

	Polinom D = A.AddP(B);
	cout << "D=A+B:"; D.Out();

	Polinom E = C.MinP(B);
	cout << "E=C-B:"; E.Out();

	Polinom F = A.DobCh(4);
	cout << "F=A+4:"; F.Out();

	Polinom G = C.MnCh(2);
	cout << "G=C*2:"; G.Out();

	cout << "B(3):" << B.Vch(3) << endl;

	Polinom H = A.Multiplication(C);
	cout << "H=A*C:"; H.Out();
}

34.«Матрица произвольной размерности» (вычисление
определителя).

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

class Matrix {
private:
    int line;
    int column;
    int** array;

    void getNewMatrix(int** arr, int** temp, int i, int j, int n) {
        int indexLine = 0, indexCol = 0;
        for (int i1 = 0; i1 < n - 1; i1++) {
            if (i1 == i) indexLine = 1;
            for (int j1 = 0; j1 < n - 1; j1++) {
                if (j1 == j) indexCol = 1;
                temp[i1][j1] = arr[i1 + indexLine][j1 + indexCol];
            }
        }
    }
    int detExecute(int** arr, int n) {
        int res = 0, k = 1;
        int** temp = new int* [n];
        for (int i = 0; i < n; i++)
            temp[i] = new int[n];
        if (n == 1) {
            res = arr[0][0];
            return(res);
        }
        if (n == 2) {
            res = arr[0][0] * arr[1][1] - (arr[1][0] * arr[0][1]);
            return(res);
        }
        if (n > 2) {
            for (int i = 0; i < n; i++) {
                getNewMatrix(arr, temp, i, 0, n);
                res = res + k * arr[i][0] * detExecute(temp, n - 1);
                k = -k;
            }
        }
    }
public:
    Matrix() {
        line = 0;
        column = 0;
        array = nullptr;
    }
    Matrix(int line, int column) {
        srand(time(nullptr));
        this->line = line;
        this->column = column;
        array = new int* [line];
        for (int i = 0; i < line; i++)
            array[i] = new int[column];
        for (int i = 0; i < line; i++)
            for (int j = 0; j < column; j++)
                array[i][j] = -3 + rand() % 7;
    }
    Matrix(int line, int column, int** arr) {
        this->line = line;
        this->column = column;
        array = arr;
    }
    void print() {
        if (column == 0 || line == 0)
            cout << "Matrix is empty";
        else {
            for (int i = 0; i < line; i++) {
                for (int j = 0; j < column; j++)
                    cout << array[i][j] << ' ';
                cout << endl;
            }
            cout << endl;
        }
    }
    ~Matrix() {
        if (line != 0) {
            for (int i = 0; i < line; i++)
                delete[] array[i];
            delete[] array;
        }
        column = 0;
        line = 0;
    }
    Matrix(const Matrix& a) {
        line = a.line;
        column = a.column;
        array = new int* [line];
        for (int i = 0; i < line; i++)
            array[i] = new int[column];
        for (int i = 0; i < line; i++)
            for (int j = 0; j < column; j++)
                array[i][j] = a.array[i][j];
    }
    Matrix(Matrix&& a)  noexcept {
        line = a.line;
        column = a.column;
        array = new int* [line];
        for (int i = 0; i < line; i++)
            array[i] = new int[column];

        for (int i = 0; i < line; i++)
            for (int j = 0; j < column; j++)
                array[i][j] = a.array[i][j];

        for (int i = 0; i < line; i++)
            delete[] a.array[i];
        delete[] a.array;
        a.column = 0;
        a.line = 0;
    }
    Matrix sum(const Matrix& a) {
        if (column != a.column && line != a.line)
            abort();

        int** tempArray = new int* [line];
        for (int i = 0; i < line; i++)
            tempArray[i] = new int[column];

        for (int i = 0; i < line; i++)
            for (int j = 0; j < column; j++)
                tempArray[i][j] = a.array[i][j] + array[i][j];
        Matrix temp = Matrix(line, column, tempArray);

        return temp;
    }
    Matrix multiplication(const Matrix& a) {

        if (column != a.line)
            abort();

        int** tempArray = new int* [line];
        for (int i = 0; i < line; i++)
        {
            tempArray[i] = new int[a.column];
            for (int j = 0; j < a.column; j++)
            {
                tempArray[i][j] = 0;
                for (int k = 0; k < column; k++) {
                    tempArray[i][j] += array[i][k] * a.array[k][j];
                }
            }
        }
        Matrix temp(line, a.column, tempArray);

        return temp;
    }
    Matrix multiplicationOnNumber(const int a) {
        int** tempArray = new int* [line];
        for (int i = 0; i < line; i++)
            tempArray[i] = new int[column];

        for (int i = 0; i < line; i++)
            for (int j = 0; j < column; j++)
                tempArray[i][j] = array[i][j] * a;
        Matrix temp = Matrix(line, column, tempArray);

        return temp;
    }

    int determinant() {
        if (line != column)
            abort();
        int res = detExecute(array, line);
        return res;
    }
};

35. «Матрица произвольной размерности» (транспонирование
матрицы).