#include <conio.h>
#include <stdio.h>
#include <windows.h>
#include <cstdlib>
#include <stdbool.h>
#include <math.h>
#define MAX 10

#pragma warning (disable:4996)

HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
COORD CursorPosition;

void p1();
void p2();
void p3();
void p4();
void p5();
void p6();
void p7();
void p10();
void p11();

void intersectie(int A[10], int B[10], int n, int m);
void reuniune(int A[10], int B[10], int n, int m, int nr);
void diferenta(int A[10], int B[10], int n, int m);
void diferenta_simetrica(int A[10], int B[10], int n, int m);
bool verificare_numere_prime(int n);
bool isPrime(int n);
void printPrime(int n);
void tab_imult(int n);
void tab_adunare(int n);
void elem_nil(int n, int v[1000]);
void elem_invers(int n, int v[1000]);
void div_zero(int n, int v[1000]);
float  mod(struct complex t1);
struct complex product(struct complex t1, struct complex t2);
struct complex sum(struct complex t1, struct complex t2);
void display(struct complex c);
void read(struct complex *t);
struct complex;
void readArray(int  a[MAX][MAX], int m);
void printArray(int a[MAX][MAX], int  m);
void addArray(int a[MAX][MAX], int b[MAX][MAX], int c[MAX][MAX], int m);
void MultiplyArray(int a[MAX][MAX], int b[MAX][MAX], int c[MAX][MAX], int m);
int  UrnaArray(int A[MAX][MAX], int m);
void transpusa(int A[MAX][MAX], int T[MAX][MAX], int m);
int transpusa_check(int A[MAX][MAX], int T[MAX][MAX], int m, int p);
int det(int A[100][100], int n);
double determinantOfMatrix(double mat[3][3]);
void findSolution(double coeff[3][4]);

void main() {

	int n;

	printf("Alege problema:\n");
	printf("1.Problema 1;\n");
	printf("2.Problema 2;\n");
	printf("3.Problema 3;\n");
	printf("4.Problema 4;\n");
	printf("5.Problema 5;\n");
	printf("6.Problema 6;\n");
	printf("7.Problema 9;\n");
	printf("8.Problema 10;\n");
	printf("9.Problema 11;\n");
	scanf("%d", &n);

	switch (n) {
	case 1:system("cls"); p1(); break;
	case 2:system("cls"); p2(); break;
	case 3:system("cls"); p3(); break;
	case 4:system("cls"); p4(); break;
	case 5:system("cls"); p5(); break;
	case 6:system("cls"); p6(); break;
	case 7:system("cls"); p7(); break;
	case 8:system("cls"); p10(); break;
	case 9:system("cls"); p11(); break;
	default:break;
	}

	_getch();
}

void p1() {

	int A[10], B[10], i, j, m, n;

	printf("Introdu marimea multimi A: ");

	scanf("%d", &n);

	while ((n > 10) || (n < 0)) {
		if (n > 10) {
			printf("Multimea nu poate avea mai mult de 10 elemente!\nMarime: ");
			scanf("%d", &n);
		}
		else {
			printf("Nu se poate introduce o valoare mai mica ca 0!\nMarime: ");
			scanf("%d", &n);
		}
	}

	printf("\n Multimea A poate avea un numar de %d elemente, introdu pe rand elementele multimi.\n", n);

	for (i = 1; i <= n; i++) {
		scanf("%d", &A[i]);
	}

	printf("Introdu marimea multimi B: ");
	scanf("%d", &m);

	while (m > 10 || m < 0) {
		if (m > 10) {
			printf("Multimea nu poate avea mai mult de 10 elemente!\n\nMarime: ");
			scanf("%d", &m);
		}
		else {
			printf("Nu se poate introduce o valoare mai mica ca 0!\n\nMarime: ");
			scanf("%d", &m);
		}
	}

	printf("Multimea B  introdu pe rand elementele multimi.\n", m);

	for (j = 1; j <= m; j++) {
		scanf("%d", &B[j]);
	}

	system("cls");

	printf("A={ ");

	for (i = 1; i <= n; i++) {
		printf("%d ", A[i]);
	}

	printf("}");
	printf("\n\n");
	printf("B={ ");

	for (j = 1; j <= m; j++) {
		printf("%d ", B[j]);
	}

	printf("}");
	printf("\n\n");

	intersectie(A, B, n, m);
	printf("\n\n");

	reuniune(A, B, n, m, 0);
	printf("\n\n");

	printf("Diferenta intre multimile A si B este: \nA - B = { ");

	diferenta(A, B, n, m);

	printf("}");
	printf("\n");

	printf("B - A = { ");

	diferenta(B, A, m, n);

	printf("}");
	printf("\n\n");

	diferenta_simetrica(A, B, n, m);

	_getch();

}

void p2() {

	unsigned int numar_div_total = 0;
	unsigned int m, p, q;
	unsigned int r;

	printf("Introduceti valoarea  parametrului M = ");
	scanf("%d", &m);
	while (true)
	{
		bool verificare_prim_p;
		printf("Introdu valoarea lui {P} :");
		scanf("%d", &p);
		verificare_prim_p = verificare_numere_prime(p);
		if (verificare_prim_p == true)
		{
			printf("Numarul este prim! 0\n");
			break;
		}
		else
		{
			printf("Numarul nu este prim !\n");
		}
	}
	while (true)
	{
		bool verificare_prim_q;
		printf("Introdu valoarea lui {Q} :");
		scanf("%d", &q);
		verificare_prim_q = verificare_numere_prime(q);
		if (verificare_prim_q == true)
		{
			printf("Numarul este prim! 0\n");
			break;
		}
		else
		{
			printf("Numarul nu este prim !\n");
		}
	}
	while (true)
	{
		bool verificare_prim_r;
		printf("Introdu valoarea lui {R} :");
		scanf("%d", &r);
		verificare_prim_r = verificare_numere_prime(r);
		if (verificare_prim_r == true)
		{
			printf("Numarul este prim! 0\n");
			break;
		}
		else
		{
			printf("Numarul nu este prim !\n");
		}
	}


	for (int i = m; i >= 1; i--)
	{
		if ((i % q == 0) || (i % r == 0) || (i % p == 0))
		{
			numar_div_total++;
		}
	}

	printf("\nNumerele divizibile cu p,q,r sunt : %d\n", numar_div_total);

	_getch();
}

void p3() {

	int a, b, cmmmc, rest;
	int x, y;

	printf("Introduceti primul numar intreg pozitiv\na = ");
	scanf("%d", &a);

	while (a < 1) {

		printf("\nReintroduceti a = ");

		scanf("%d", &a);
	}

	printf("\nIntroduceti cel de-al doilea numar intreg pozitiv\nb = ");
	scanf("%d", &b);

	while (b < 1) {
		printf("\nReintroduceti b = ");
		scanf("%d", &b);
	}

	x = a;
	y = b;

	while (b != 0) {
		rest = a % b;
		a = b;
		b = rest;
	}

	printf("\nCmmdc = %d ", a);

	cmmmc = (x*y) / a;

	printf("\nCmmmc = %d ", cmmmc);

	_getch();
}

void p4() {

	int n, a[100], i = 0, j, k = 0, count = 0, p = 0;
	int sn, v[100], s = 0, count2 = 0, var_check = 0;
	int vector[100], loop, kp = 3;
	int c;


	printf("Introdu numarul :");
	scanf("%d", &n);

	for (i = 1; i <= n; i++)
	{
		if (n%i == 0)
		{
			a[p++] = i;
			count++;
		}
	}
	for (i = 2; i < n; i++)
	{
		if (n%i == 0)
			k++;
		if (n == 1)
			k++;
	}

	if (k == 0)
		printf("\nNumarul (%d) este prim! \n", n);

	else
		printf("\nNumarul (%d) nu este prim!\n", n);

	printf("\n");
	printf("Divizorii lui %d sunt {", n);
	for (i = 0; i < count; i++)
		printf("%d,", a[i]);
	printf("}");

	printf("\n");
	printf("\n");
	printf("\n");
	printf("\n");
	printf("\n");



	printf("Tabela operatiei ^\n");
	printf("\n");
	printf("\n");
	printf("^");
	for (i = 0; i < count; i++)

		printf("\t%d", a[i]);
	printf("\n__________________________________________________________________________________");


	for (i = 0; i < count; i++)
	{
		printf("\n%d\t", a[i]);

		for (j = 0; j < count; j++)
		{
			if (a[i] < a[j])
				printf("%d\t", a[i]);
			else
				printf("%d\t", a[j]);
		}
		printf("\n");
	}

	printf("\n");
	printf("\n");
	printf("\n");
	printf("\n");
	printf("\n");



	printf("Tabela operatiei V\n");
	printf("\n");
	printf("\n");
	printf("V");
	for (i = 0; i < count; i++)

		printf("\t%d", a[i]);
	printf("\n__________________________________________________________________________________");


	for (i = 0; i < count; i++)
	{
		printf("\n%d\t", a[i]);

		for (j = 0; j < count; j++)
		{
			if (a[i] > a[j])
				printf("%d\t", a[i]);
			else
				printf("%d\t", a[j]);
		}
		printf("\n");
	}

	printf("\n");
	printf("\n");
	printf("\n");
	printf("\n");
	printf("\n");

	printf("Decompunerea in factorii primi a numarului (%d) este :", n);

	sn = n;
	for (i = 2; i <= sn; i++)
	{
		if (sn%i == 0)
		{
			v[s++] = i;
			sn /= i;
			count2++;
			i--;
		}
	}

	for (i = 0; i < count2; i++)
		printf("%d*", v[i]);

	for (i = 0; i <= count2; i++)
	{
		for (int ii = i + 1; ii <= count2; ii++)
		{
			if (v[i] == v[ii])
				++var_check;
		}
	}
	printf("\n");
	if (var_check == 0)
		printf("\nNumarul este liber de patrate !\n");
	else
		printf("\nNumarul nu este liber de patrate !\n");
	printf("Prim{");
	printPrime(n);
	printf("}");

}

void p5() {

	int a[50], i = 0, count = 0, k = 0, n;

	printf("Introdu numarul ");
	scanf("%d", &n);

	for (i = 1; i <= n; i++) {
		if (n%i == 0) {
			a[k++] = i;
			count++;
		}
		if (n == 2) {
			a[k++] = i;
			count++;
		}
	}
	if (count == 2) {
		printf("\nNumarul (%d) este prim\n", n);
		printf("\nDivizorii numarului %d sunt :{", n);
		for (i = 1; i < count; i++)
			printf("%d ", a[i]);
	}
	else
		if (n > 2) {
			printf("\nNumarul (%d) este compus\n", n);
			printf("\nDivizorii numarului %d sunt :{", n);

			for (i = 1; i < count; i++)
				printf("%d ", a[i]);
		}

	printf("}");
	printf("\n");

	_getch();


}

void p6() {

	int n, v[1000];

	printf("Introdu dimensiunea :");

	scanf_s("%d", &n);
	printf("\n");

	elem_nil(n, v);

	div_zero(n, v);

	elem_invers(n, v);

	printf("\n\n");

	tab_imult(n);

	printf("\n\n");

	tab_adunare(n);

	_getch();
}

void p7() {

	struct complex c1, c2, c3, c4;

	printf("\nIntrodu Z1 : \n");
	read(&c1);

	printf("\nIntrodu Z2 : \n");
	read(&c2);

	system("cls");

	printf("\n\nNumarul complex Z1 : ");
	display(c1);

	printf("\n\nNumarul complex Z2 : ");
	display(c2);

	c3 = sum(c1, c2);

	printf("\n\nAdunarea = \n");
	display(c3);

	printf("'\n");

	c4 = product(c1, c2);

	printf("\nProdusul = \n");
	display(c4);

	printf("\n\nModulul \n");
	printf("\n|Z1|=|%.1f + %.1fi |=>Z1 => %.2f", c1.real, c1.imag, mod(c1));

	printf("\n");
	printf("\n|Z2|=|%.1f + %.1fi |=>Z2 = %.2f", c2.real, c2.imag, mod(c2));

}

void p10() {

	int A[MAX][MAX], B[MAX][MAX];
	int ADD[MAX][MAX], k[MAX][MAX];
	int T[MAX][MAX];

	int M, S, P = 0, X;

	printf("\nIntrodu marimea matricei :");
	scanf("%d", &M);

	printf("\nIntrodu elementele matricei A: :\n");
	readArray(A, M);

	printf("\nIntrodu elementele matricei B:\n");
	readArray(B, M);
	addArray(A, B, ADD, M);

	system("cls");

	printf("Matricea A:\n");
	printArray(A, M);
	printf("Matricea B:\n");
	printArray(B, M);

	printf("Aunarea este :");
	printArray(ADD, M);
	MultiplyArray(A, B, k, M);

	printf("Produsul  este :\n");
	printArray(k, M);
	S = UrnaArray(A, M);

	printf("\nSuma elementelor de pe diagonala principala este S=%d \n\n", S);

	transpusa(A, T, M);

	printf("Matricea:\n");
	printArray(A, M);

	printf("\nTranspus matricei A :\n");
	printArray(T, M);

	X = transpusa_check(A, T, M, P);

	printf("\n");

	if (X == M * M)
		printf("Matricea este simetrica\n");
	else

		printf("Matricea este antisimetrica\n");

	_getch();
}

void p11() {

	double coeff[3][4];
	int A[100][100];
	int i, j, k, n, res;
	printf("Introdu ordinul matricei: ");
	scanf("%d", &n);
	printf("\nIntrodu elementele matricei: \n");
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			scanf("%d", &A[i][j]);
		}
	}
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			printf("%5d", A[i][j]);
		}
		printf("\n");
	}

	printf("\nIntrodu ecuatiile de forma urmatoare !\n");
	printf("\nax+by+cz=du\n");
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 4; j++) {
			printf("M[%d][%d] =", i, j);
			scanf("%lf", &coeff[i][j]);
		}
	printf("\n");
	printf("\nMatricea introdusa !\n");
	printf("\n\n");
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			printf("%3.0lf ", coeff[i][j]);
		}
		printf("\n");
	}
	printf("Matricea unitate !\n");
	for (int i = 0, j = 3; i < 3; i++)
	{
		printf("%3.0lf\n", coeff[i][j]);
	}
	findSolution(coeff);
	res = det(A, n);
	printf("Determinantul rezultat din prima introducere este Det = %d", res);

	_getch();
}

void intersectie(int A[10], int B[10], int n, int m) {

	int M[20], N[20], g, i, j, k, e, ok;
	bool validare;
	validare = false;
	ok = 0;
	i = 0;
	e = 1;
	g = 1;
	if (n > m) {
		for (j = 1; j <= n; j++) {
			for (k = 1; k <= m; k++) {
				if (A[j] == B[k]) { ok++; }
			}
			if (ok > 0) {
				M[e] = A[j];
				e++;
				ok = 0;
			}
		}
		i++;
	}
	else {
		for (k = 1; k <= m; k++) {
			for (j = 1; j <= n; j++) {
				if (B[k] == A[j]) { ok++; }
			}
			if (ok > 0) {
				M[e] = B[k];
				e++;
				ok = 0;
			}
		}
		i++;
	}
	for (i = 1; i < e; i++) {
		for (j = 1; j <= g; j++) {
			if (M[i] != N[j]) { validare = true; }
			else {
				validare = false;
				break;
			}
		}
		if (validare == true) {
			N[g] = M[i];
			g++;
			validare = false;
		}
	}
	printf("Intersectia multimilor A si B este: I = { ");
	for (i = 1; i < g; i++) {
		printf("%d ", N[i]);
	}
	printf("}\n");
}

void reuniune(int A[10], int B[10], int n, int m, int nr) {

	int M[20], N[20], i, j, e, k, ok, g;
	bool verificare;
	verificare = false;
	g = 1;
	ok = 0;
	e = 1;
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= e; j++) {
			if (A[i] != M[j]) { verificare = true; }
			else {
				verificare = false;
				break;
			}
		}
		if (verificare == true) {
			M[e] = A[i];
			e++;
		}
		verificare = false;
	}
	for (k = 1; k <= m; k++) {
		for (j = 1; j < e; j++) {
			if (B[k] == M[j]) {
				ok++;
			}
		}
		if (ok == 0) {
			M[e] = B[k];
			e++;
		}
		ok = 0;
	}
	for (i = 1; i < e; i++) {
		for (j = 1; j <= g; j++) {
			if (M[i] != N[j]) {
				verificare = true;
			}
			else {
				verificare = false;
				break;
			}
		}
		if (verificare == true) {
			N[g] = M[i];
			g++;
		}
		verificare = false;

	}
	if (nr == 0) {
		printf("Reuniunea multimilor A si B este: R={ ");
		for (i = 1; i < e; i++) {
			printf("%d ", M[i]);
		}
		printf("}\n");
	}
	else if (nr == 1) {
		printf("Diferenta simetrica a multimilor A si B este multimea: { ");
		for (i = 1; i < e; i++) {
			printf("%d ", M[i]);
		}
		printf("}\n");
	}
}

void diferenta(int A[10], int B[10], int n, int m) {

	int M[10], i, j, e, ok;
	e = 1;
	ok = 0;
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= m; j++) {
			if (A[i] == B[j]) { ok++; }
		}
		if (ok == 0) {
			M[e] = A[i];
			e++;
		}
		ok = 0;
	}

	for (i = 1; i < e; i++) {
		printf("%d ", M[i]);
	}

}

void diferenta_simetrica(int A[10], int B[10], int n, int m) {

	int M[10], N[10], i, j, g, e, ok, oky;
	e = 1;
	g = 1;
	ok = 0;
	oky = 0;
	for (i = 1; i <= n; i++) {
		for (j = 1; j <= m; j++) {
			if (A[i] == B[j]) { ok++; }
		}
		if (ok == 0) {
			M[e] = A[i];
			e++;
		}
		ok = 0;
	}
	for (j = 1; j <= m; j++) {
		for (i = 1; i <= n; i++) {
			if (B[j] == A[i]) { oky++; }
		}
		if (oky == 0) {
			N[g] = B[j];
			g++;
		}
		oky = 0;
	}
	e--;
	g--;
	reuniune(N, M, g, e, 1);
}

bool verificare_numere_prime(int n)
{
	int var = 0;

	for (int i = 1; i <= n; i++)
	{
		if (n % i == 0) var++;
	}
	if (var <= 2)
	{
		return true;
	}
	else
		return false;
}

bool isPrime(int n)
{

	if (n <= 1)
		return false;


	for (int i = 2; i < n; i++)
		if (n % i == 0)
			return false;

	return true;
}

void printPrime(int n)
{
	for (int i = 2; i <= n; i++) {
		if (isPrime(i))
			printf("%d ", i);
	}
}

void tab_imult(int n)
{

	printf("Tabela inmultiri in Z%d:\n\n", n);

	printf("*   ");
	for (int i = 0; i < n; i++)
	{
		printf("%3d  ", i);
	}
	printf("\n\n");
	for (int i = 0; i < n; i++)
	{
		printf("%d   ", i);
		for (int j = 0; j < n; j++)
		{
			int a;
			a = i * j;
			if (a < n)
				printf("%3d  ", a);
			else
			{
				int z;
				z = a % n;
				printf("%3d  ", z);
			}
		}
		printf("\n");
	}

}

void tab_adunare(int n)
{

	printf("Tabela adunari in Z%d:\n", n);
	printf("\n");
	printf("  +    ");
	for (int i = 0; i < n; i++)
	{
		printf("%3d  ", i);
	}
	printf("\n\n");
	for (int i = 0; i < n; i++)
	{
		printf("%3d   ", i);
		for (int j = 0; j < n; j++)
		{
			int a;
			a = i + j;
			if (a < n)
				printf("%3d  ", a);
			else
			{
				int z;
				z = a % n;
				printf("%3d  ", z);
			}
		}

		printf("\n");
	}

}

void elem_nil(int n, int v[1000])
{

	long long int  produs;
	int power = 2, k = 0;
	int number = 0;

	while (number < n)
	{

		produs = pow(number, power);
		if (produs%n == 0)
		{
			v[k++] = number;
			++number;
			power = 2;
			produs = 0;
		}
		else
			if (power == 10)
			{
				++number;
				power = 2;
			}
		++power;
	}
	printf("\nAfisarea elementelor nilpotente :");
	for (int i = 0; i < k; i++)
		printf("%d ", v[i]);

}

void elem_invers(int n, int v[1000])
{

	int i = 2, j = 2, k = 1;
	long long int produs;
	v[0] = 1;



	for (i = 2; i < n; i++)
	{

		for (j = 2; j < n; j++)
		{
			produs = (i*j) % n;
			if (produs == 1)
			{
				v[k++] = i;
			}
		}
	}


	for (i = 0; i < k; i++)
	{
		for (j = i + 1; j < k; )
		{
			if (v[j] == v[i])
			{
				for (int p = j; p < k; p++)
					v[p] = v[p + 1];
				k--;
			}
			else
				j++;
		}
	}
	printf("\nElementele inversabile sunt :");
	for (i = 0; i < k; i++)
		printf("%d ", v[i]);

}

void div_zero(int n, int v[1000])
{
	int k = 0, i = 0, j = 0;
	long long int produs = 0;
	for (i = n - 1; i > 0; i--)
	{
		for (j = n - 1; j > 0; j--)
		{
			produs = i * j;
			if (produs%n == 0)
			{

				v[k++] = j;


			}

		}
	}

	for (i = 0; i < k; i++)
	{
		for (j = i + 1; j < k; )
		{
			if (v[j] == v[i])
			{
				for (int p = j; p < k; p++)
				{
					v[p] = v[p + 1];
				}
				k--;
			}
			else
			{
				j++;
			}
		}
	}

	printf("\n");
	printf("\nDivizorii lui zero sunt :");
	for (i = 0; i < k; i++)
		printf("%d ", v[i]);
	printf("\n");

}

struct complex {
	float real;
	float imag;
};

void read(struct complex *t) {
	printf("\nIntrodu valoriile :\n");
	printf("Real : ");
	scanf("%f", &t->real);
	printf("Imag : ");
	scanf("%f", &t->imag);
}

void display(struct complex c) {
	printf("\n%0.2f + %0.2f i", c.real, c.imag);
}

struct complex sum(struct complex t1, struct complex t2) {
	struct complex t;
	t.real = t1.real + t2.real;
	t.imag = t1.imag + t2.imag;
	return t;
}

struct complex product(struct complex t1, struct complex t2) {
	struct complex t;
	t.real = t1.real * t2.real - t1.imag * t2.imag;
	t.imag = t1.real * t2.imag + t1.imag * t2.real;
	return t;
}

float  mod(struct complex t1) {

	float t;
	t = sqrt(pow(t1.real, 2) + pow(t1.imag, 2));

	return t;

}

void readArray(int  a[MAX][MAX], int m)
{
	int i, j;
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < m; j++)
		{

			printf("A[%d][%d]= :", i, j);
			scanf("%d", &a[i][j]);

		}
	}

}

void printArray(int a[MAX][MAX], int  m)
{
	int i, j;
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < m; j++)
		{
			printf(" %d ", a[i][j]);
		}
		printf("\n");
	}


}

void addArray(int a[MAX][MAX], int b[MAX][MAX], int c[MAX][MAX], int m)
{
	int i, j;
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < m; j++)
		{
			c[i][j] = a[i][j] + b[i][j];
		}
		printf("\n");
	}

}

void MultiplyArray(int a[MAX][MAX], int b[MAX][MAX], int c[MAX][MAX], int m)
{
	int i, j, k;

	for (i = 0; i < m; i++)
	{
		for (j = 0; j < m; j++)
		{
			c[i][j] = 0;
			for (k = 0; k < m; k++)
			{
				c[i][j] += a[i][k] * b[k][j];
			}
		}
		printf("\n");
	}

}

int  UrnaArray(int A[MAX][MAX], int m)
{
	int i, j, S = 0;
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < m; j++)
		{
			if (i == j)
			{
				S += A[i][j];
			}
		}

	}

	return S;
}

void transpusa(int A[MAX][MAX], int T[MAX][MAX], int m)
{

	int i, j;
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < m; j++)
		{
			T[i][j] = A[j][i];
		}
	}

}

int transpusa_check(int A[MAX][MAX], int T[MAX][MAX], int m, int p)
{

	int i, j;
	p = 0;
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < m; j++)
		{

			if (A[i][j] == T[i][j])
			{
				p++;
			}

		}
	}
	return p;
}

int det(int A[100][100], int n)
{
	int Minor[100][100];
	int i, j, k, c1, c2;
	int determinant;
	int c[100];
	int O = 1;
	determinant = 0;
	if (n == 2)
	{

		determinant = A[0][0] * A[1][1] - A[0][1] * A[1][0];
		return determinant;
	}
	else
	{
		for (i = 0; i < n; i++)
		{
			c1 = 0, c2 = 0;
			for (j = 0; j < n; j++)
			{
				for (k = 0; k < n; k++)
				{
					if (j != 0 && k != i)
					{
						Minor[c1][c2] = A[j][k];
						c2++;
						if (c2 > n - 2)
						{
							c1++;
							c2 = 0;
						}
					}
				}
			}
			determinant = determinant + O * (A[0][i] * det(Minor, n - 1));
			O = -1 * O;
		}
	}
	return determinant;
}

double determinantOfMatrix(double mat[3][3])
{
	double ans;
	ans = mat[0][0] * (mat[1][1] * mat[2][2] - mat[2][1] * mat[1][2])
		- mat[0][1] * (mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0])
		+ mat[0][2] * (mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0]);
	return ans;
}

void findSolution(double coeff[3][4])
{

	double d[3][3] = {
		{ coeff[0][0], coeff[0][1], coeff[0][2] },
		{ coeff[1][0], coeff[1][1], coeff[1][2] },
		{ coeff[2][0], coeff[2][1], coeff[2][2] },
	};

	double d1[3][3] = {
		{ coeff[0][3], coeff[0][1], coeff[0][2] },
		{ coeff[1][3], coeff[1][1], coeff[1][2] },
		{ coeff[2][3], coeff[2][1], coeff[2][2] },
	};

	double d2[3][3] = {
		{ coeff[0][0], coeff[0][3], coeff[0][2] },
		{ coeff[1][0], coeff[1][3], coeff[1][2] },
		{ coeff[2][0], coeff[2][3], coeff[2][2] },
	};

	double d3[3][3] = {
		{ coeff[0][0], coeff[0][1], coeff[0][3] },
		{ coeff[1][0], coeff[1][1], coeff[1][3] },
		{ coeff[2][0], coeff[2][1], coeff[2][3] },
	};


	double D = determinantOfMatrix(d);
	double D1 = determinantOfMatrix(d1);
	double D2 = determinantOfMatrix(d2);
	double D3 = determinantOfMatrix(d3);


	// Case 1
	if (D != 0) {
		printf("\nMatricea este inversabila!\n");
		double x = D1 / D;
		double y = D2 / D;
		double z = D3 / D;
		printf("Determinatul: %.1lf \n", D);
		printf("DeterminatX : %.1lf \n", D1);
		printf("DeterminatY : %.1lf \n", D2);
		printf("DeterminatZ : %.1lf \n", D3);

		printf("X : %.1lf\n", x);
		printf("Y : %.1lf\n", y);
		printf("Z: %.1lf\n", z);
	}

	else {

		if (D1 == 0 && D2 == 0 && D3 == 0)
		{
			printf("Matricea nu este inversabila!\n");
			printf("Nu se poate rezolva cu metoda Cramer\n");
		}
		else
		{
			if (D1 != 0 || D2 != 0 || D3 != 0)
				printf("Fara solutii\n");
		}
	}
}