Addition, subtraction, multiplication, division and comparison templates for large numbers

Due to the pressure of the large numbers, I had to write a few templates and apply them myself.

Write simple additions and subtractions first.

 

 

Large numbers are input as strings, and the final return value is also of string type.

 1 string bigadd(string s,string ss){
 2     string tt;
 3     int slen = s.length();
 4     int sslen = ss.length();
 5     reverse(s.begin(),s.end());
 6     reverse(ss.begin(),ss.end());
 7     int index = 0;
 8     for(int i=0;i<min(slen,sslen);i++){
 9         int a = s[i]-'0',b = ss[i]-'0';
10         int at = a+b+index;
11         if(at>9){
12             tt+=at-10+'0';
13             index = 1;
14         }else{
15             tt+=at+'0';
16             index = 0;
17         }
18     }
19     for(int i=min(slen,sslen);i<max(slen,sslen);i++){
20         if(slen>i){
21             int a = s[i]-'0';
22             int at = a+index;
23             if(at>9){
24                 tt+=at-10+'0';
25                 index = 1;
26             }else{
27                 tt+=at+'0';
28                 index = 0;
29             }
30         }else{
31             int b = ss[i]-'0';
32             int at = b+index;
33             if(at>9){
34                 tt+=at-10+'0';
35                 index = 1;
36             }else{
37                 tt+=at+'0';
38                 index = 0;
39             }
40         }
41     }
42     if(index){
43         tt+='1';
44     }
45     reverse(tt.begin(),tt.end());
46     return tt;
47 }

 

 

Subtraction of large numbers:

The same is to enter two large numbers of string type first, but there is a premise here, s>=ss;

You can compare before entering.

Use the comparison function as follows:

 

 1 string bigdel(string s,string ss){//s>=ss
 2     string tt,st;
 3     int slen = s.length();
 4     int sslen = ss.length();
 5     reverse(s.begin(),s.end());
 6     reverse(ss.begin(),ss.end());
 7     int index = 0;
 8     for(int i=0;i<sslen;i++){
 9         int a = s[i]-'0';
10         int b = ss[i]-'0';
11         int at = a-b-index;
12         if(at<0){
13             tt+=at+10+'0';
14             index = 1;
15         }else{
16             tt+=at+'0';
17             index = 0;
18         }
19     }
20     for(int i=sslen;i<slen;i++){
21         int b = s[i]-'0';
22         int at = b - index;
23         if(at<0){
24             tt+=at+10+'0';
25             index = 1;
26         }else{
27             tt+=at+'0';
28             index = 0;
29         }
30     }
31     bool prime = true;
32     for(int i = slen-1;i>=0;i--){
33         if(tt[i]!='0'){
34             prime = false;
35         }
36         if(!prime){
37             st+=tt[i];
38         }
39     }
40     if(st.length()==0)
41         st+='0';
42     return st;
43 }

 

 

compare two string sizes,

What is returned here is of type int. If s>ss returns 1, s<ss returns 0, and s==ss returns 2;

 

 1 int compare(string s,string ss){
 2     int slen = s.length();
 3     int sslen = ss.length();
 4     if(slen==sslen){
 5         for(int i=0;i<slen;i++){
 6             if(s[i]==ss[i]){
 7                 continue;
 8             }else{
 9                 return s[i]>ss[i];
10             }
11         }
12     }else{
13         return slen > sslen;
14     }
15     return 2;
16 }

 

 

To be continued. . . . . . . . . . . . . .