#include
#include
#include
#include
#include
Typedef int et;
Typedef struct node {
ET DATA;
Struct node * p;
Struct node * n;
} Node, * nodeh;
Typedef struct list {
Nodeh head;
Nodeh End;
Int length;
} List, * lisith;
Inline Bool Initlist (Listh & L)
{
// Turn the head node L
L = (LISTH) Malloc (SizeOf (list));
ASSERT (L);
L-> Head = l-> end = null;
L-> Length = 0;
Return True;
}
Inline Nodeh Nmalloc (Const et & elem)
{
// Return a new node, its data is ELEM
Nodeh Temp = (Nodeh) Malloc (Sizeof (Node));
Assert (TEMP);
Temp-> Data = ELEM;
Return Temp;
}
Inline Bool Preadd (Listh & L, Const et & elem)
{
/ / Add new node ELEM on the head
Nodeh Temp = Nmalloc (ELEM);
(l-> length);
IF (null == l-> Head && null == L-> End) {
Temp-> n = TEMP-> P = NULL;
L-> Head = l-> end = TEMP;
Return True;
}
Temp-> P = NULL;
Temp-> n = l-> head;
L-> Head-> p = TEMP;
L-> Head = Temp;
Return True;
}
Inline Bool Endadd (Listh & L, Const et & elem)
{
// Add new node ELEM at the end
Nodeh Temp = Nmalloc (ELEM);
(l-> length);
IF (null == l-> Head && null == L-> End) {
Temp-> n = TEMP-> P = NULL;
L-> Head = l-> end = TEMP;
Return True;
}
TEMP-> n = null;
Temp-> p = l-> end;
L-> end-> n = TEMP;
L-> End = Temp;
Return True;
}
Inline Bool DestoryList (Listh & L)
{
// Release Table 1
Nodeh Temp = L-> Head, IT;
IF (temp == null) {
Free (l);
Return True;
}
While (Temp! = L-> End) {
IT = TEMP;
Temp = Temp-> N;
Free (it);
}
Free (TEMP);
Free (l);
Return True;
}
Inline void printlist (listh & l) {
Nodeh it = l-> head, end = l-> end;
IF (it == null) return;
For (; it! = end; it = it-> n)
Putchar (It-> Data '0');
Putchar (It-> Data '0');
}
Inline Bool Addzero (Listh & L, Int Count)
{
// Plus COUNT 0 in the tail of L
While (count -) endadd (l, 0);
Return True;
}
Inline Bool Bitmul (Listh & Num)
{
// Deposit L and Number multiplied the result in Num
// NUM should be empty! ! ! ! ! ! ! ! !
Nodeh L_END = L-> End;
Int status = 0, TEMP;
For (; l_end! = l-> head; l_end = l_end-> p) {
Temp = l_end-> data * number status;
Preadd (NUM, TEMP% 10);
Status = TEMP / 10;
}
Temp = l-> Head-> data * number status;
IF (TEMP> 10) {
Preadd (NUM, TEMP% 10);
Preadd (NUM, TEMP / 10);
}
Else Preadd (NUM, TEMP);
// Less one time :)
Return True;
}
Inline Bool Add (Const Listh & La, Listh & lb)
{
// lb = la lb
Nodeh pa = la-> end, pb = lb-> end;
INT status = 0;
For (; pa! = la-> head; pa = pa-> p, pb = pb-> p) {
IF (PB == NULL) {
Preadd (lb, 0);
Pb = lb-> head;
}
Int sum = pa-> data pb-> data status;
IF (SUM> = 10) {
PB-> DATA = SUM% 10;
STATUS = 1;
}
Else {
PB-> DATA = SUM;
STATUS = 0;
}
}
IF (PB == NULL) {
Preadd (lb, 0);
Pb = lb-> head;
}
Int sum = pa-> data pb-> data status;
IF (SUM> = 10) {
PB-> DATA = SUM% 10;
IF (PB-> P == null) {
Preadd (lb, 0);
Pb = lb-> head;
PB-> DATA = SUM / 10;
Return True;
}
PB = Pb-> P;
IF (PB == NULL) {
Preadd (lb, 0);
Pb = lb-> head;
}
PB-> DATA = SUM / 10;
Return True;
}
ELSE // sum <10pb-> data = sum;
Return True;
}
///
Inline void Mul (const char * a, const char * b)
{
// init
Listh cs = null; // multiplier
Listh bcs = null; // is multiplied
Listh num = null; //
Assert (A && B);
Assert (Initlist (NUM));
Assert (Initlist (CS) && InitList (BCS);
{
// symbol processing
INT SIG = 1;
IF ('-' == * a) {
a;
SIG * = - 1;
}
ELSE IF (' ' == * a) A;
IF ('-' == * b) {
b;
SIG * = - 1;
}
ELSE IF (' ' == * b) B;
IF (SIG <0) PUTCHAR ('-');
}
IF (strcmp (a, b)> 0) {
Const char * pa = a, * pb = b;
For (; '/ 0'! = * Pa; Pa) {
INT TEMP = * PA-'0 ';
ASSERT (Endadd (BCS, TEMP));
}
For (; '/ 0'! = * pb; pb) {
INT TEMP = * PB-'0 ';
ASSERT (Endadd (CS, TEMP));
}
}
Else {
Const char * pa = a, * pb = b;
For (; '/ 0'! = * Pa; Pa) {
INT TEMP = * PA-'0 ';
ASSERT (Endadd (CS, TEMP));
}
For (; '/ 0'! = * pb; pb) {
INT TEMP = * PB-'0 ';
ASSERT (Endadd (BCS, TEMP));
}
}
// init end !!!!
Nodeh CS_P = CS-> END;
INT bit = 0; // digit
For (; cs_p! = cs-> head; cs_p = cs_p-> p) {
Listh Temp;
Initlist (TEMP);
Bitmul (BCS, CS_P-> DATA, TEMP);
///
PUTS ("================================================ ================== / n ");
PrintList (BCS); ///
Printf ("X% D =", CS_P-> DATA);
PrintList (TEMP);
///
// <======================================= h !!!!!!!!!!!!!!!! !!!!!!!!!!!!!! Addzero (TEMP, BIT);
Add (TEMP, NUM);
/
PUTS ("/ nnum:");
PrintList (NUM);
Printf ("/ nbit:% d / n", bit);
bit;
DestoryList (TEMP);
}
Listh Temp;
Initlist (TEMP);
Bitmul (BCS, CS_P-> DATA, TEMP);
///
Puts ("=============================================== ================== / n ");
PrintList (BCS); ///
Printf ("X% D =", CS_P-> DATA);
PrintList (TEMP);
///
// <======================================= h !!!!!!!!!!!!!!!! !!!!!!!!!!!!!!
Adzero (Temp, Bit);
Add (TEMP, NUM);
/
PUTS ("/ nnum:");
PrintList (NUM);
Printf ("/ nbit:% d / n", bit);
///
Std :: cout << '/ n' << "Result =";
PrintList (NUM);
PUTCHAR ('/ n');
/// Clean up work
DestoryList (TEMP);
DestoryList (BCS);
DestoryList (CS);
DestoryList (NUM);
}
Int main (void)
{
Std :: string a, b;
Std :: cin >> a;
Std :: cin >> b;
Mul (A.c_STR (), B.C_STR ());
System ("pause");
Return 0;
}
