大整数类

  1 #include <iostream>
  2 #include <algorithm>
  3 #include <cstdio>
  4 #include <string>
  5 #include <string.h>
  6 #include <vector>
  7 using namespace std;
  8 struct BigInteger
  9 {
 10     static const int BASE = 10;
 11     static const int WIDTH = 1;
 12     vector<int> s;
 13     bool flag;
 14     BigInteger(long long num = 0) { *this = num; } // 构造函数
 15     BigInteger operator=(long long num)
 16     { // 赋值运算符
 17         s.clear();
 18         if (num < 0)
 19         {
 20             flag = 0;
 21             num = -num;
 22         }
 23         else
 24             flag = 1;
 25         do
 26         {
 27             s.push_back(num % BASE);
 28             num /= BASE;
 29         } while (num > 0);
 30         return *this;
 31     }
 32     BigInteger operator=(const string &str)
 33     { // 赋值运算符
 34         s.clear();
 35         if (str[0] == '-')
 36             flag = 0;
 37         else
 38             flag = 1;
 39         string strr = str;
 40         if (flag == 0)
 41             strr.erase(0, 1);
 42         int x, len = (strr.length() - 1) / WIDTH + 1;
 43         int i = 0;
 44         for (; i < len; i++)
 45         {
 46             int end = strr.length() - i * WIDTH;
 47             int start = max(0, end - WIDTH);
 48             sscanf(strr.substr(start, end - start).c_str(), "%d", &x);
 49             s.push_back(x);
 50         }
 51         return *this;
 52     }
 53     BigInteger operator+(const BigInteger &b) const
 54     {
 55         BigInteger c, d;
 56         if (b.flag == 0)
 57         {
 58             BigInteger B = b;
 59             B.flag = 1;
 60             if (flag == 0)
 61             {
 62                 d = *this;
 63                 d.flag = 1;
 64                 c = d + B;
 65                 c.flag = 0;
 66                 return c;
 67             }
 68             return *this - B;
 69         }
 70         if (flag == 0)
 71         {
 72             c = *this;
 73             c.flag = 1;
 74             return b - c;
 75         }
 76         c.s.clear();
 77         for (int i = 0, g = 0;; i++)
 78         {
 79             if (g == 0 && i >= s.size() && i >= b.s.size())
 80                 break;
 81             int x = g;
 82             if (i < s.size())
 83                 x += s[i];
 84             if (i < b.s.size())
 85                 x += b.s[i];
 86             c.s.push_back(x % BASE);
 87             g = x / BASE;
 88         }
 89         return c;
 90     }
 91 
 92     BigInteger operator*(const BigInteger &b) const
 93     {
 94         BigInteger c, t;
 95         c = 0;
 96         int flagg;
 97         if (b.flag == flag)
 98             flagg = 1;
 99         else
100             flagg = 0;
101         t.flag = 1;
102         c.flag = 1;
103         for (int i = 0; i < s.size(); i++)
104         {
105             t.s.clear();
106             long long x, g;
107             int j;
108             t.s.insert(t.s.begin(), i, 0);
109             for (j = g = 0;; j++)
110             {
111                 x = g;
112                 if (g == 0 && j >= b.s.size())
113                 {
114                     break;
115                 }
116                 if (j < b.s.size())
117                     x += (long long)s[i] * (long long)b.s[j];
118                 t.s.push_back(x % BASE);
119                 g = x / BASE;
120             }
121             c = c + t;
122         }
123         c.flag = flagg;
124         if (c.s.back() == 0)
125         {
126             vector<int>::iterator it = c.s.end();
127             for (it--; it != c.s.begin(); it--)
128             {
129                 if (*it != 0)
130                     break;
131             }
132             it++;
133             c.s.erase(it, c.s.end());
134         }
135         if (c.s.empty())
136             c.s.push_back(0);
137         return c;
138     }
139     BigInteger operator*(const int &b) const
140     {
141         BigInteger c = b;
142         return c * (*this);
143     }
144     BigInteger operator*(const long long int &b) const
145     {
146         BigInteger c = b;
147         return c * (*this);
148     }
149     BigInteger operator^(int b) const
150     {
151         BigInteger ans = 1, base = *this;
152         while (b)
153         {
154             if (b & 1)
155             {
156                 ans = base * ans;
157             }
158             base = base * base;
159             b >>= 1;
160         }
161         return ans;
162     }
163     BigInteger operator+=(const BigInteger &b) const
164     {
165         return *this + b;
166     }
167     bool operator<(const BigInteger &b) const
168     {
169         if (b.flag == 0 && b.flag != flag)
170             return false;
171         if (s.size() != b.s.size())
172             return s.size() < b.s.size();
173         for (int i = s.size() - 1; i >= 0; i--)
174             if (s[i] != b.s[i])
175                 return s[i] < b.s[i];
176         return false;
177     }
178     bool operator>(const BigInteger &b) const { return b < *this; }
179     bool operator<=(const BigInteger &b) const { return !(b < *this); }
180     bool operator>=(const BigInteger &b) const { return !(*this < b); }
181     bool operator!=(const BigInteger &b) const { return b < *this || *this < b; }
182     bool operator==(const BigInteger &b) const { return !(b < *this) && !(*this < b); }
183 
184     BigInteger operator-(const BigInteger &b) const
185     {
186         if (b.flag == 0)
187         {
188             BigInteger B = b;
189             B.flag = 1;
190             return *this + B;
191         }
192         BigInteger A, B;
193         A = *this;
194         B = b;
195         A.flag = 1;
196         B.flag = 1;
197         BigInteger c;
198         if (A < B)
199         {
200             swap(A, B);
201             c.flag = 0;
202         }
203         c.s.clear();
204         int i, g, x;
205         i = g = 0;
206         while (1) //for (int i = 0, g = 0;; i++)
207         {
208             if (i >= A.s.size() && i >= B.s.size())
209                 break;
210             x = A.s[i];
211             x -= g;
212             g = 0;
213             if (i < B.s.size())
214                 x -= B.s[i];
215             if (x < 0)
216             {
217                 x += BASE;
218                 g = 1;
219             }
220             c.s.push_back(x % BASE);
221             i++;
222         }
223         if (c.s.back() == 0)
224         {
225             vector<int>::iterator it = c.s.end();
226             for (it--; it != c.s.begin(); it--)
227             {
228                 if (*it != 0)
229                     break;
230             }
231             it++;
232             c.s.erase(it, c.s.end());
233         }
234         if (c.s.empty())
235             c.s.push_back(0);
236         return c;
237     }
238     BigInteger operator-(const int &b) const
239     {
240         BigInteger c = b;
241         return *this - c;
242     }
243     BigInteger operator-(const long long int &b) const
244     {
245         BigInteger c = b;
246         return *this - c;
247     }
248     BigInteger operator-=(const BigInteger &b) const { return *this - b; }
249     BigInteger operator!(void)const //阶乘
250     {
251         BigInteger ans = (long long)1;
252         for (BigInteger i = ans; i <= *this; i = i + (long long)1)
253         {
254             ans = i * ans;
255         }
256         return ans;
257     }
258     BigInteger operator/(const BigInteger &b) const
259     {
260         //A/B
261         BigInteger A, B, c, ans;
262         if (b.flag == flag)
263             ans.flag = 1;
264         else
265             ans.flag = 0;
266         if (b > *this)
267             return 0;
268         if (b == *this)
269             return 1;
270         c.s.clear();
271         ans.s.clear();
272         A = *this;
273         B = b;
274         A.flag = B.flag = c.flag = 1;
275         int zero = (A.s.size() - b.s.size());
276         B.s.insert(B.s.begin(), zero, 0);
277         while (!B.s.empty() && B >= b)
278         {
279             int x = 0;
280             while (A >= B)
281             {
282                 A = A - B;
283                 x++;
284             }
285             c.s.push_back(x);
286             B.s.erase(B.s.begin());
287         }
288         if (!c.s.empty())
289             for (vector<int>::reverse_iterator it = c.s.rbegin(); it != c.s.rend(); it++)
290             {
291                 ans.s.push_back(*it);
292             }
293         else
294             ans.s.push_back(0);
295         if (ans.s.empty())
296             ans.s.push_back(0);
297         if (ans.s.back() == 0)
298         {
299             vector<int>::iterator it = ans.s.end();
300             for (it--; it != ans.s.begin(); it--)
301             {
302                 if (*it != 0)
303                     break;
304             }
305             it++;
306             ans.s.erase(it, ans.s.end());
307         }
308         /***************
309         A 为余数
310         ***************/
311         return ans;
312     }
313     BigInteger operator%(const long long &b) const
314     {
315         BigInteger c;
316         long long x;
317         c.s.clear();
318         for (int i = 0; i < s.size(); i++)
319         {
320             x = s[i] % b;
321             c.s.push_back(x);
322         }
323         c.flag = 1;
324         if (b < 0 && flag != 0)
325             c.flag = 0;
326         if (b > 0 && flag == 0)
327             c.flag = 0;
328         return c;
329     }
330     BigInteger operator%(const BigInteger &b) const
331     {
332         //A/B
333         BigInteger A, B;
334         bool flagg;
335         if (b > *this)
336             return 0;
337         if (b == *this)
338             return 1;
339         A = *this;
340         B = b;
341         if (A.flag == B.flag)
342             flagg = 1;
343         else
344             flagg = 0;
345         A.flag = B.flag = 1;
346         int zero = (A.s.size() - b.s.size());
347         B.s.insert(B.s.begin(), zero, 0);
348         while (!B.s.empty() && B >= b)
349         {
350             while (A >= B)
351             {
352                 A = A - B;
353             }
354             B.s.erase(B.s.begin());
355         }
356         /***************
357         A 为余数
358         ***************/
359         A.flag = flagg;
360         return A;
361     }
362 };
363 ostream &operator<<(ostream &out, const BigInteger &x)
364 {
365     if (x.flag == 0)
366         out << '-';
367     out << x.s.back();
368     for (int i = x.s.size() - 2; i >= 0; i--)
369     {
370         char buf[20];
371         sprintf(buf, "%d", x.s[i]);
372         for (int j = 0; j < strlen(buf); j++)
373             out << buf[j];
374     }
375     return out;
376 }
377 istream &operator>>(istream &in, BigInteger &x)
378 {
379     string s;
380     if (!(in >> s))
381         return in;
382     x = s;
383     return in;
384 }
posted @ 2017-07-28 19:21 Jimmy_King 阅读(513) 评论(1) 收藏举报
刷新页面返回顶部
书山有路，学海无涯

Jimmy_King

大整数类
