BigInt

最新推荐文章于 2024-08-01 11:12:47 发布
最新推荐文章于 2024-08-01 11:12:47 发布
阅读量986 收藏
点赞数
分类专栏： Algorithms
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanbird2008/article/details/16866921
版权

 

 

 

const int N = 101;
#include <string>
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
using namespace std;
const int NMAXBITS = 128;
const int NBASE  = 100000000;
const int NSLEN = 8;
typedef int bn_t[NMAXBITS];

class BigInt
{
public:
 BigInt();
 BigInt(int n);
 BigInt(const char *);
    BigInt(const string &s);
// BigInt(BigInt &bt);
public:
 BigInt &operator = (const int &n);
 BigInt &operator = (const BigInt &bt);
 BigInt &operator = (const char *ps);
 BigInt &operator = (const string &s);
    bool operator == (const int &n) const;   
 bool operator == (const BigInt &bt) const;
    bool operator != (const int &n) const;
    bool operator != (const BigInt &bt) const;
    bool operator > (const int &n) const;
    bool operator > (const BigInt &bt) const;
    bool operator >= (const int &n) const;
    bool operator >= (const BigInt &bt) const;
    bool operator < (const int &n) const;
    bool operator < (const BigInt &bt) const;
    bool operator <= (const int &n) const;
    bool operator <= (const BigInt &bt) const;

 BigInt operator -();
 BigInt operator +(const int &n);
 BigInt operator +(const BigInt &bt);
 BigInt& operator +=(const int &n);
 BigInt& operator +=(const BigInt &bt);
    BigInt operator -(const int &n);
    BigInt operator -(const BigInt &bt);
 BigInt& operator -=(const int &n);
 BigInt& operator -=(const BigInt &bt);

 BigInt operator *(const int &n);
 BigInt operator *(const BigInt &bt);
 BigInt& operator *=(const int &n);
 BigInt& operator *=(const BigInt &bt);

 BigInt operator /(const int &n);
 BigInt operator /(const BigInt &bt);

    /*
 BigInt &operator /(BigInt &bt);
 BigInt &operator %(BigInt &bt);
 BigInt &operator **(BigInt &bt);
 */
 void Display();
// BigInt &operator ++();
// BigInt &operator --();
// BigInt operator ++(int);
// BigInt operator --(int);
protected:
 int& operator [] (const int index) const;
private:
 BigInt(int nn[], int n1, int n2);
 BigInt SubInt(int n1, int n2);
 void Init();
 bn_t  bn;
};

void BigInt::Init()
{
 for(int i = 0; i < NMAXBITS; i++) bn[i] = 0;
}

BigInt::BigInt()
{
 Init();
}

BigInt::BigInt(int n)
{
 *this = n;
}

BigInt::BigInt(int nn[], int n1, int n2)
{
 int i = 0,j = 0;
 for(i = n1; i <= n2; i++) {
        bn[j++] = nn[i];
 }

 if(j) bn[NMAXBITS - 1] = j - 1;
}

BigInt::BigInt(const char *s)
{
 int *pt = (int *)bn;
 int nlen = 0;
 int sign = 0, index = -1;
 Init();
 if(!s || !(nlen = (int)strlen(s))) {
      pt[0] = 0;  pt[NMAXBITS - 1] = 0;
 }
 else {
  char *pch = (char *)s, *pch1 = 0;
  char sn[NSLEN + 1];
  if(s[0] == '-') {sign = 0x80000000; nlen--;}
  if(s[0] == '-' || s[0] == '+') pch++;
  while((*pch) == '0') {pch++; nlen--;}
  
  if(nlen <= 0) {sign = 0; index = 0;}
  pch += nlen;
  while(nlen > 0) {
   int nlen1 = nlen - NSLEN;

   if(nlen1 > 0) pch1 = pch - NSLEN;
   else          pch1 = pch - nlen;
   nlen1 = (int) (pch - pch1);
            memcpy_s(sn, NSLEN + 1, pch1, nlen1);
            nlen -= NSLEN;
   sn[nlen1] = 0;
   pt[++index] = atoi(sn);
   pch = pch1;
  }
  pt[NMAXBITS - 1] = sign | index;
 }
}

BigInt::BigInt(const string &s)
{
    int nlen = (int)s.length();
 char *pch = new char[nlen + 1];
 memcpy_s(pch, nlen, s.c_str(), nlen);
 pch[nlen] = 0x00;
 Init();
    *this = (const char *)pch;
 delete [] pch;
}

int& BigInt::operator [] (int index) const
{
 return *(int *)&bn[index];
}

bool BigInt::operator == (const int &n) const
{
 int sign1 = bn[NMAXBITS - 1] & 0x80000000 >> 31;
 int sign2 = (n >= 0 ? 0: 1);
 if(sign1 ^ sign2) return false;

 BigInt bt(n);
 return *this == bt;
}

bool BigInt::operator == (const BigInt &bt) const
{
 int sign1 = bn[NMAXBITS - 1] & 0x80000000 >> 31;
 int sign2 = bt[NMAXBITS - 1] & 0x80000000 >> 31;
 int index1 = bn[NMAXBITS - 1] & 0x7FFFFFFF;
 int index2 = bt[NMAXBITS - 1] & 0x7FFFFFFF;
 if((sign1 ^ sign2) || index1 != index2) return false;

 for(int i = 0; i < index1 + 1; i++) {
  if(bn[i] != bt[i]) return false;
 }

 return true;
}

bool BigInt::operator != (const int &n) const
{
 return !(*this == n);
}

bool BigInt::operator != (const BigInt &bt) const
{
    return !(*this == bt);
}


bool BigInt::operator > (const int &n) const
{
 int sign1 = (bn[NMAXBITS - 1] & 0x80000000) >> 31;
 int sign2 = (n >= 0 ? 0 : 1);
 if(sign1 ^ sign2) {
     if(sign1) return false;
  else      return true;
 }
 else { 
  BigInt bt(n);
  return *this > bt;
 }
}

bool BigInt::operator > (const BigInt &bt) const
{
 bool bflag = false;
 int sign1, sign2, index1, index2, index;

 sign1 = (bn[NMAXBITS - 1] & 0x80000000) >> 31;
 sign2 = (bt[NMAXBITS - 1] & 0x80000000) >> 31;
    index1 = bn[NMAXBITS - 1] &0x7FFFFFFF;
    index2 = bt[NMAXBITS - 1] &0x7FFFFFFF;
    index = max(index1, index2);
 if(sign1 ^ sign2) {
     if(sign1) return false;
  else      return true;
 }
 else {
  int i = 0;
  for(i = index; i >= 0; i--) {
   if(bn[i] != bt[i]) {
    if(bn[i] < bt[i]) {
     if(sign1) return true;
     else      return false;
    }
    else {
     if(sign1) return false;
     else      return true;
    }
   }
  }
  if(i < 0) return false;
 }

 return false;
}

bool BigInt::operator >= (const int &n) const
{
 int sign1 = (bn[NMAXBITS - 1] & 0x80000000) >> 31;
 int sign2 = (n >= 0 ? 0 : 1);
 if(sign1 ^ sign2) {
     if(sign1) return false;
  else      return true;
 }
 else { 
  BigInt bt(n);
  return *this >= bt;
 }
}

bool BigInt::operator >= (const BigInt &bt) const
{
 return (*this == bt || *this > bt);
}

bool BigInt::operator < (const int &n) const
{
 int sign1 = (bn[NMAXBITS - 1] & 0x80000000) >> 31;
 int sign2 = (n >= 0 ? 0 : 1);
 if(sign1 ^ sign2) {
     if(sign1) return true;
  else      return false;
 }
 else { 
  BigInt bt(n);
  return *this < bt;
 }
}

bool BigInt::operator < (const BigInt &bt) const
{
 return !(*this >= bt);
}

bool BigInt::operator <= (const int &n) const
{
 BigInt bt(n);
 return *this <= bt;
}

bool BigInt::operator <= (const BigInt &bt) const
{
 return !(*this > bt);
}

BigInt & BigInt::operator =(const int &n)
{
 int sign = 0;
 int q = 0, r = 0, n1 = n;

 Init();
 if(n < 0) {
  sign = 1;
     n1 = -n1;
 }
    q = n1 / NBASE; r = n1 % NBASE;
 if(q > 0) { bn[NMAXBITS - 1] = 1; bn[1] = q;}
 bn[0] = r;

 bn[NMAXBITS - 1] |= (sign << 31);

 return *this;
}

BigInt & BigInt::operator =(const BigInt &bt)
{
 int index = bt[NMAXBITS - 1] & 0x7FFFFFFF;
 Init();
 bn[NMAXBITS - 1] = bt[NMAXBITS - 1];
 for(int i = 0; i < index + 1; i++) {
         bn[i] = bt[i];
 }
 return *this;
}

BigInt& BigInt::operator =(const char *ps)
{
 BigInt bt(ps);
 *this = bt;

 return *this;
}

BigInt& BigInt::operator =(const string &s)
{
 BigInt bt(s);
 *this = bt;

 return *this;
}

BigInt BigInt::operator -()
{
 BigInt rbt;
 rbt = *this;
 int sign = (rbt[NMAXBITS - 1] & 0x80000000) + 0x80000000;
 rbt[NMAXBITS - 1] = sign | (rbt[NMAXBITS - 1] & 0x7FFFFFFF);
   
 return rbt;
}

BigInt BigInt::operator +(const int &n)
{
 BigInt rbt, rbt1(n);
   
 rbt = *this + rbt1;

 return rbt;
}

BigInt BigInt::operator +(const BigInt &bt)
{
 BigInt rbt;
 int sign1 = (bn[NMAXBITS - 1] & 0x80000000);
 int sign2 = (bt[NMAXBITS - 1] & 0x80000000);
    int index1 = bn[NMAXBITS - 1] & 0x7FFFFFFF;
    int index2 = bt[NMAXBITS - 1] & 0x7FFFFFFF;
    int index = 0, sign = 0;
 index = max(index1, index2);
    sign = sign1;
 if(sign1 == sign2) {
  int sum = 0, q = 0,r = 0;
  for(int i = 0; i <= index; i++) {
   sum = bn[i] + bt[i] + q;
   q = sum / NBASE;
   r = sum % NBASE;
            rbt[i] = r;
  }
  if(q > 0) rbt[++index] = q;
        rbt[NMAXBITS - 1] = sign | index;
 }
 else {
  BigInt bt1 = *this, bt2 = bt;
  bt1[NMAXBITS - 1] = index1;
  bt2[NMAXBITS - 1] = index2;
  if(sign1) rbt = bt2 - bt1;
  else      rbt = bt1 - bt2;
 }

 return rbt;
}

BigInt& BigInt::operator +=(const int &n)
{
 *this = *this + BigInt(n);

 return *this;
}

BigInt& BigInt::operator +=(const BigInt &bt)
{
 *this = *this + bt;

 return *this;
}

BigInt BigInt::operator -(const int &n)
{
 BigInt rbt;
    rbt = *this;

 rbt = rbt - BigInt(n);

 return rbt;
}

BigInt BigInt::operator -(const BigInt &bt)
{
 BigInt rbt, bt1 = *this, bt2 = bt;
    int sign1 = (bt1[NMAXBITS - 1] & 0x80000000) >> 31;
    int sign2 = (bt2[NMAXBITS - 1] & 0x80000000) >> 31;
    int index1 = bt1[NMAXBITS - 1] & 0x7FFFFFFF;
    int index2 = bt2[NMAXBITS - 1] & 0x7FFFFFFF;
    bt1[NMAXBITS - 1] = index1;
 bt2[NMAXBITS - 1] = index2;
 int index = 0, sign = 0;
 index = max(index1, index2);
 if(sign1 ^ sign2) {
  rbt = bt1 + bt2;
  rbt[NMAXBITS - 1] |= (sign1 << 31);
 }
 else {
  if(sign1) {
   rbt = bt2 - bt1;
  }
  else  {
   int sub = 0, rt = 0, ind = 0;
   int *pbt1 = &bt1[0], *pbt2 = &bt2[0];
   if(bt1 >= bt2) sign = 0;
   else           {sign = 1; pbt1 = &bt2[0]; pbt2 = &bt1[0];}
   for(int i = 0; i <= index; i++) {
    sub = 0;
    if(pbt1[i] < pbt2[i]) sub = NBASE;
                sub = sub + pbt1[i] - pbt2[i] - rt;
    rbt[i] = sub;
    if(pbt1[i] < pbt2[i]) rt = 1;
    else                  rt = 0;
    if(rbt[i]) ind = i;
   }
   rbt[NMAXBITS - 1] = (sign << 31) | ind;
  }
 }

 return rbt;
}

BigInt& BigInt::operator -=(const int &n)
{
 *this = *this - BigInt(n);

 return *this;
}

BigInt& BigInt::operator -=(const BigInt &bt)
{
 *this = *this - bt;

 return *this;
}

BigInt BigInt::operator *(const int &n)
{
      BigInt bt(n);

   return *this * bt;
}

BigInt BigInt::operator *(const BigInt &bt)
{
 BigInt rbt;
    int sign1 = (bn[NMAXBITS - 1] & 0x80000000) >> 31;
    int sign2 = (bt[NMAXBITS - 1] & 0x80000000) >> 31;
    int index1 = bn[NMAXBITS - 1] & 0x7FFFFFFF;
    int index2 = bt[NMAXBITS - 1] & 0x7FFFFFFF;
    int sign = 0, index = index1 + index2, h = 0;
 sign = (sign1 + sign2) % 2;
 if(*this == 0 || bt == 0) return rbt;
 __int64 product = 0;
 __int64 q = 0, r = 0, qr = 0;
 for(int i = index2; i >= 0; i--) {
     for(int j = index1; j >= 0; j--) {
   q = bn[j]; r = bt[i];
   //product = (bn[j]) * (bt[i]);
   product = q * r;
   q = product / NBASE;
   r = product % NBASE;
   h = i + j - 1;
   qr = r;
   do {
    h++;
                product = rbt[h] + qr;
    qr = product / NBASE;
    r = product % NBASE;
       rbt[h] = r;
   } while(qr);
   if(h > index) index = h;
   h = i + j;
   if(q) {
    do {
        h++;
        product = rbt[h] + q;
           q = product / NBASE;
           r = product % NBASE;
     rbt[h] = r;
    } while(q);
   }
   if(h > index) index = h;
     }
 }
    rbt[NMAXBITS - 1] = (sign << 31) | index;

 return rbt;
}

BigInt& BigInt::operator *=(const int &n)
{
 *this = *this * BigInt(n);

 return *this;
}

BigInt& BigInt::operator *=(const BigInt &bt)
{
 *this = *this * bt;

 return *this;
}

BigInt BigInt::operator /(const int &n)
{
 return *this / BigInt(n);
}

///???????????///
BigInt BigInt::operator /(const BigInt &bt)
{
 BigInt qbt, rbt;
    int sign1 = (bn[NMAXBITS - 1] & 0x80000000) >> 31;
    int sign2 = (bt[NMAXBITS - 1] & 0x80000000) >> 31;
    int index1 = bn[NMAXBITS - 1] & 0x7FFFFFFF;
    int index2 = bt[NMAXBITS - 1] & 0x7FFFFFFF;
 int sign = 0, index = 0;

 if(bt == 0) {
        qbt[NMAXBITS - 1] = 0x80000000 | 0x7FFFFFFF;
 }
 else {
  qbt = *this;
  qbt[NMAXBITS - 1] = index1;
  rbt = bt;
  rbt[NMAXBITS - 1] = index2;
  if(qbt < rbt) {
   qbt = 0;
  }
  else {
   __int64 q = 0;
   BigInt qbn, tbt = qbt.SubInt(index1, index1 - index2); int j = 0;
   for(int i = index1 - index2; i >= 0; i--) {
    j = max(tbt[NMAXBITS - 1], index2);
    if(!tbt[j]) tbt = tbt * NBASE + (*this)[i];
    else {
     q = tbt[j] / rbt[index2];
     if(!q) {
      tbt = tbt * NBASE + (*this)[i];
      j++;
      q = tbt[j];
      q = q * NBASE;
      q += tbt[j - 1];
     }
     else q = tbt[j];
     q = q / rbt[index2];
     qbn = tbt;
     tbt = qbn - rbt * q;
     while(tbt < 0) {
      q--;
      tbt = qbn - rbt *q;
     }
     qbt[i] = q;
     if(index < i) index = i;
    }
   }
  }
  if(sign1 ^ sign2) sign = 1;
  qbt[NMAXBITS - 1] = (sign << 31) | index;
 }

 return qbt;
}

BigInt BigInt::SubInt(int n1, int n2)
{
 BigInt bt;

 int i = 0,j = 0;
 for(i = n2; i <= n1; i++) {
        bt[j++] = bn[i];
 }

 if(j) bt[NMAXBITS - 1] = j - 1;

 return bt;
}

void BigInt::Display()
{
 int sign = bn[NMAXBITS - 1] & 0x80000000;
 int index = bn[NMAXBITS - 1] & 0x7FFFFFFF;
 if(sign) printf("-");
 printf("%d", bn[index]);
 for(int i = index - 1; i >= 0; i--) {
         printf("%08d", bn[i]);
 }
 printf("\n");
 
}

BigInt bt[N];
int main()
{
    int n = 0;
 bt[0] = "1"; bt[1] = "1"; bt[2] = "2"; bt[3] = "5";
 for(int i = 4; i < N; i++) {
  for(int j = 0; j < i; j++) {
   bt[i] = bt[i] + bt[j] * bt[i - j - 1];
  }
 }

    while(EOF != scanf("%d", &n), n!= -1)
    {
  bt[n].Display();
    }
    return 0;
}

 

fanbird2008
关注
专栏目录
自己写的c++大整数计算BigInt类
frto027的博客
06-07 1594
算法使用vector保存变量，使用一个flug来保存正负。 重载的运算符有 + - * += -= *= 还有string类型转换运算符，<<输出运算符 构造函数有默认构造函数（0），从string构造（支持开头有无限个-号，但不支持正号），从BigInt构造，从long long构造（从而可以支持大多数c++的基本类型） 基本原理和手工列竖式差不多，简单测试了几组数据没问题。
c++ 无符号bigint高精度大整数
PHANTOM
04-03 7432
此代码除了减法和乘法以外均参考了刘汝佳的《算法竞赛入门经典第二版》，亲测DevC++可以编译通过。代码在codevs（ codevs.cn )上通过高精度全部题目。POWERED BY PHANTOM 大神勿喷，希望大家支持！
html css使用
黑客三遍猪
12-13 148
参考 HTML CSS整理笔记
JavaScript BigInt
最新发布
爱敲代码的卡拉米的博客
08-01 988
在 JavaScript 中，所有数字都以 64 位浮点格式存储。大整数无法被精确表示，会被四舍五入超出此范围的整数值会失去精度。
es6 数值 bigint
qianyuge的博客
09-13 839
bigint number 浮点数
java bigint_Java的long和bigint长度对比详解
weixin_34304211的博客
02-20 5016
Java 中Long的值大小比较java.util.Lang 对象吧，而不是基本类型 long (注意大小写)Java中如果使用 == 双等于比较对象，等于比较的是两个对象的内存地址，也就是比较两个对象是否是同一个对象如果比较两个Long对象值是否相等，则不可以使用双等号进行比较，可以采用如下方式：1. 使用 equals 方法Long a = new Long(3);Long b = new ...
Java的long和bigint长度对比详解
08-25
Java 的 long 和 bigint 长度对比详解 在 Java 中，long 和 bigint 是两种不同的数据类型，它们的长度和用途也有所不同。在本文中，我们将详细介绍 Java 中的 long 和 bigint 的长度对比。 long 数据类型 在 Java...
json-bigint:带有bigints支持的JSON.parsestringify
04-30
json-bigint 带有bigints支持的JSON.parse / stringify。 基于Douglas Crockford的包和库。 Native Bigint是最近添加到JS的，因此我们添加了一个利用它的选项，而不是bignumber.js 。 但是，使用本机BigInt进行...
SQLServer中bigint转int带符号时报错问题解决方法
12-15
在这种场景下，`bigint` 数据类型常被用来存储大整数，而`int` 则用于处理常规整数值。然而，从`bigint`转换到`int`时，如果原始值超出了`int`类型的范围或者涉及到符号位，就可能出现“算术溢出错误”。 在描述的...
bigint.ts:BigInteger.js包装器
05-20
`bigint.ts`是一个针对`BigInteger.js`库的TypeScript封装，由Tom Wu开发的`BigInteger.js`是一个广泛使用的JavaScript库，用于处理大整数运算，它弥补了JavaScript原生数据类型在处理超过JavaScript最大安全整数...
node-json-bigint-string
05-31
json-bigint-string JSON.parse 的替代品，它将足够长的整数转换为字符串，从而在 Javascript 中失去精度。 基于 。 用法 var JSONBigInt = require ( 'json-bigint-string' ) ; // console.log(JSON.parse...
QT基本数据类型
热门推荐
云淡风轻
02-29 5万+
QT的基本数据类型qint8：signed char 有符号8比特数据 qint16:signed short 16位数据类型 qint32：signed int. 32位有符号数据类型 qint64：long long int 或(__int64) 64位有符号数据类型，Windows中定义为__int64 qintptr：qint32 或 qint64 指针类型 根据系统类型
MakeTree
fanbird2008的专栏
11-21 1497
#include #include char  s1[27], s2[27]; char  result[27]; int ind1 = 0, ind2 = 0, n = 0; int len = 0; int root; typedef struct _node {  int  lnode;  int  rnode; } node_t; node_t node[27];
Merge sort
fanbird2008的专栏
11-21 823
#include void merge(int *arr, int l, int m, int r) {     int i, tt[r - l + 1];     int cp = 0, lp = l, rp = m + 1;     while(lp         if(arr[lp]         else                  tt[cp++] = ar
quick sort
fanbird2008的专栏
11-21 697
#include const int N = 1024; int m, n, k; int u[N] = {0}; void qsort(int nl, int nr) {  int mid = 0;  int nt, mn;  if(nl   mid = (nl + nr) / 2;   mn = u[mid];         int i = nl, j = nr;
webpack BigInt
06-06
在 Webpack 中使用 BigInt 需要注意以下几点： 1. 首先确保你的浏览器支持 BigInt，否则会报错； 2. 在 Webpack 配置文件中，需要将 target 配置为 "es2020" 或更高版本，以支持 BigInt； 3. 在代码中使用 BigInt 时，需要将其转换为字符串或使用 BigInt 构造函数创建 BigInt 对象。 以下是一个使用 BigInt 的示例： ```javascript // webpack.config.js module.exports = { target: "es2020", // ... }; // code.js const num1 = BigInt("9007199254740991"); const num2 = BigInt("12345678901234567890"); const sum = num1 + num2; console.log(sum.toString()); ``` 在上面的示例中，我们首先将 target 配置为 es2020，然后使用 BigInt 构造函数创建两个 BigInt 对象，并使用加法运算符计算它们的和，最后将结果转换为字符串并输出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值