BASIC CALCULATE (INTEGER)_BIG NUMBER_CÁC PHÉP TOÁN CƠ BẢN SỐ NGUYÊN TRÀN DỮ LIỆU

/*Các trường hợp của phép cộng:
Trường hợp 2 số dương;
A={1,2,2,3}
B={  1,2,3}
=>
C={1,3,4,6}


A={2,3}
B={9,9}
=>
C={1,2,2}
Trường hợp 2 số âm;
tương tự làm như số âm rồi *-1;
Trường hợp -+;
A={1,2,2}
B={-1,2} //thuật toán chổ này là phép trừ số A - (-B);
=>
C={1,1,0}
Làm thuật toán lồng :D hàm lồng nhau :D

A={1,1,2}
B={-1,2,4}
=>
C={-2}

A={-1,2,3}
B={1,2} đổi thành B-A
=>
C={-1,1,1}

A={-1,2,3}
B={1,2,5}
=>
C={2}

*/
#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<stdlib.h>
#include<malloc.h>
#include <iostream>
typedef short typeofnumber;

struct bignum{
	typeofnumber *Arr=NULL;
	typeofnumber length = 0;
};
bignum operator - (bignum A, bignum B);
bignum  value(bignum A)
{
	bignum C;
	C.length = A.length;
	C.Arr = (typeofnumber *)malloc(C.length*sizeof(typeofnumber));
	for (int i = 0; i < C.length; i++)
	{
		*(C.Arr + i) = *(A.Arr + i);
	}
	return C;
}
bignum operator - (bignum A)
{
	bignum C;
	C = value(A);
	*(C.Arr) = -*(C.Arr);
	return C;
}

//Thêm giá trị vào đầu
void addhead(bignum &C, typeofnumber K)
{
	C.length++;
	C.Arr = (typeofnumber*)realloc(C.Arr, C.length*sizeof(typeofnumber));
	if (C.length > 1)
	{
		for (typeofnumber i = C.length-1; i >0; i--)
		{
			*(C.Arr + i) = *(C.Arr + i - 1);
		}
	}
	*(C.Arr) = K;
}

bignum operator + (bignum A, bignum B)
{
	bignum C;
	typeofnumber memoryNumber = 0;
	typeofnumber SumNode;
	typeofnumber mark = 1;
	typeofnumber delta =(typeofnumber) abs(A.length - B.length);
	if (*(B.Arr) == 0 && B.length == 1)
	{
		return C = value(A);
	}
	else if ((*(A.Arr) == 0 && A.length == 1))
	{
		return C = value(B);
	}
	if (*(A.Arr) * *(B.Arr) > 0)
	{

		if (*(A.Arr) < 0 && *(B.Arr) < 0)
		{
			mark = -1;
			*(A.Arr) = -*(A.Arr);
			*(B.Arr) = -*(B.Arr);
		}
		if (A.length < B.length)
		{
			typeofnumber *temp = A.Arr;
			A.Arr = B.Arr;
			B.Arr = temp;
			typeofnumber gan = A.length;
			A.length = B.length;
			B.length = gan;
		}//éo phải sai ở trên
		for (typeofnumber i = A.length - 1; i >= 0; i--)
		{
			if ((i - delta) >= 0)
			{
				SumNode = *(A.Arr + i) + *(B.Arr + i - delta) + memoryNumber;
				addhead(C, SumNode % 10);
				memoryNumber = SumNode / 10;
			}
		}

		for (typeofnumber j = delta - 1; j >= 0; j--)
		{
			SumNode = *(A.Arr + j) + memoryNumber;
			addhead(C, SumNode % 10);
			memoryNumber = SumNode / 10;
		}
		if (memoryNumber == 1)
		{
			addhead(C, memoryNumber);
		}
		//Thiếu trường hợp dấu trừ dấu cộng nè :D
		*(C.Arr) = *(C.Arr)*mark;
	}
	else
	{
		if (*(A.Arr) < 0)
		{
			C = B - -(A);
		}
		else
		{
			C = A - -(B);
		}
	}
	return C;
}
short compare(bignum A,bignum B)
{
	if (A.length == B.length)
	{
		char k = 0;
		if (*(B.Arr) < 0)
		{
			if (-*(A.Arr) < -*(B.Arr))
			{
				return 1;
			}
			for (k = 1; k < A.length; k++)
			{
				if (*(A.Arr + k)<*(B.Arr + k))
				{
					return 1;
				}
				else if (-*(A.Arr) > -*(B.Arr))
				{
					return -1;
				}
			}
			return 0;

		}
		else
		{
			for (k = 0; k < A.length; k++)
			{
				if (*(A.Arr + k) > *(B.Arr + k))
				{
					return 1;
				}
				else if (*(A.Arr + k) < *(B.Arr + k))
				{
					return -1;
				}
			
			}
			return 0;
		}

	}
	if (*(A.Arr) * *(B.Arr) < 0)
	{
		if (*(A.Arr)>0)
		{
			return 1;
		}
		return -1;
	}
	else if (A.length > B.length)
	{
		if (*(A.Arr) > 0)
		{
			return 1;
		}
			return -1;
	}
	if (A.length < B.length)
	{
		if (*(A.Arr) < 0)
		{
			return 1;
		}
			return -1;
	}
	return 0;
}
void remove0(bignum &C)
{
	while (*(C.Arr) == 0 && C.length >1)
	{
		for (typeofnumber j = 0; j < C.length - 1; j++)
		{
			*(C.Arr + j) = *(C.Arr + j + 1);
		}
		C.length--;
	}
	C.Arr = (typeofnumber*)realloc(C.Arr, C.length*sizeof(typeofnumber));
}
bignum operator - (bignum A, bignum B) //A: số trừ B: số bị trừ
{
	typeofnumber minusNode;
	typeofnumber memoryNumber = 0;
	typeofnumber mark = 1, mark2=1;
	typeofnumber delta = (typeofnumber)abs(A.length - B.length);
	bignum C;

	if (compare == 0)
	{
		addhead(C, 0);
		return C;
	}
	if (*(A.Arr) * *(B.Arr) > 0)
	{
		if (*(A.Arr) < 0 && *(B.Arr) < 0)
		{
			mark2 = -1;
			*(A.Arr) = -*(A.Arr);
			*(B.Arr) = -*(B.Arr);
		}
		if (compare(A, B) == -1)
		{
			mark = -1;
			typeofnumber *temp = A.Arr;
			A.Arr = B.Arr;
			B.Arr = temp;
			typeofnumber gan = A.length;
			A.length = B.length;
			B.length = gan;
		}
		for (typeofnumber i = A.length - 1; i >= 0; i--)
		{
			if ((i - delta) >= 0)
			{
				if (*(A.Arr + i) >= *(B.Arr + i - delta))
				{
					minusNode = *(A.Arr + i) - *(B.Arr + i - delta) - memoryNumber;
					addhead(C, minusNode);
					memoryNumber = 0;
				}
				else
				{
					minusNode = 10 + *(A.Arr + i) - *(B.Arr + i - delta) - memoryNumber;
					addhead(C, minusNode);
					memoryNumber = 1;
				}
			}
		}
		for (typeofnumber j = delta - 1; j >= 0; j--)
		{
			minusNode = *(A.Arr + j) - memoryNumber;
			addhead(C, minusNode);
			memoryNumber = 0;
		}
		remove0(C);
		*(C.Arr) = *(C.Arr) * mark*mark2;
	}
	else
	{
		if (*(A.Arr) < 0)
		{
			C = A + -(B);
		}
		else
		{
			C = A + -(B);
		}
	}
	return C;
}
bignum operator * (bignum A, bignum B)
{
	bignum C;
	typeofnumber memoryNumber = 0;
	typeofnumber multiplication;
	typeofnumber delta;
	
	bignum *temp = new bignum[B.length];
	typeofnumber mark = 1;
	if (*(A.Arr)* *(B.Arr) < 0)
	{
		mark = -1;
	}
	*(A.Arr) = abs(*(A.Arr));
	*(B.Arr) = abs(*(B.Arr));
	for (typeofnumber i = 0; i < B.length; i++)
	{
		if (B.Arr[i] == 0)
		{
			addhead(temp[i], 0);
			continue;
		}
		delta = B.length - i - 1;
		while (delta > 0)
		{
			addhead(temp[i], 0);
			delta--;
		}

		for (typeofnumber j = A.length - 1; j >= 0; j--)
		{
			multiplication = B.Arr[i] * A.Arr[j] + memoryNumber;
			addhead(temp[i], multiplication % 10);
			memoryNumber = multiplication / 10;
		}
		if (memoryNumber != 0)
		{
			addhead(temp[i], memoryNumber);
			memoryNumber = 0;
		}
	}
	C = value(temp[0]);
	for (typeofnumber i = 1; i < B.length; i++)
	{
		C = C + temp[i];
	}
	for (typeofnumber i = 0; i < B.length; i++)
	{
		delete temp[i].Arr;
	}

	*(C.Arr) = *(C.Arr)*mark;
	delete temp;
	return C;
}// thiếu dấu rồi

bignum operator / (bignum A, bignum B)
{
	bignum C;
	typeofnumber mark = 1;
	if (*(A.Arr)* *(B.Arr) < 0)
	{
		mark = -1;
	}
	*(A.Arr) = abs(*(A.Arr));
	*(B.Arr) = abs(*(B.Arr));
	if (*(B.Arr) == 0 && B.length == 1)
	{
		printf("ERROR!!! divide or mod by zero!!!\n");
		return C;
	}
	if (compare(A, B) == 0)
	{
		addhead(C, 1);
		return C;
	}
	if (compare(A, B) == -1)
	{
		addhead(C, 0);
		*(C.Arr) = *(C.Arr)*mark;
		return C;
	}
	bignum i,j ;
	i.Arr = (typeofnumber*)malloc(sizeof(typeofnumber));
	*(i.Arr) = i.length = 1;
	j.Arr = (typeofnumber*)malloc(sizeof(typeofnumber));
	*(j.Arr) = j.length = 1;
	while (1)
	{
		if (compare(A, i * B) == -1)
		{
			break;
		}
		i = i + j;
	}
	i = i - j;
	for (typeofnumber g = i.length - 1; g >= 0; g--)
	{
		addhead(C, *(i.Arr + g));
	}
	free(i.Arr);
	free(j.Arr);
	*(C.Arr) = *(C.Arr)*mark;
	return C;
}
void main()
{
	bignum A, B,C;
	A.length = 3;
	B.length = 2;
	A.Arr = (typeofnumber*)malloc(A.length*sizeof(typeofnumber));
	B.Arr = (typeofnumber*)malloc(B.length*sizeof(typeofnumber));

	A.Arr[0] = 0;
	A.Arr[1] = 0;
	A.Arr[2] = 0;
	//A.Arr[3] = 1;
	B.Arr[0] = -2;
	B.Arr[1] = 1; //B có 0 là lỗi và A 0 đầu là lỗi
	//B.Arr[2] = 1;
	//printf("%d", compare(A, B));
	remove0(A);
	remove0(B);
	C = A / B;

	for (typeofnumber i = 0; i < C.length; i++)
	{
		printf("%d", *(C.Arr + i));
	}
	free(C.Arr);
	free(A.Arr);
	free(B.Arr);
	
	_getch();
}