加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 （https://www.lidatong.com.cn/）- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置： 首页 > 大数据 > 正文

大数模板

发布时间：2020-12-14 01:55:51 所属栏目：大数据 来源：网络整理
导读：拷贝下ps代码，以备不时之需。。 #includeiostream#includestdio.h#includestdlib.h#includestring.husing namespace std;#define MAXN 9999//万进制#define DLEN 4//4位class BigNum{private: int a[5000];///可以控制大数位数(500*4) int len;///大数长度p

拷贝下ps代码，以备不时之需。。

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
using namespace std;

#define MAXN 9999//万进制
#define DLEN 4//4位

class BigNum{
private:
    int a[5000];///可以控制大数位数(500*4)
    int len;///大数长度
public:
    BigNum(){///构造函数
        len=1;
        memset(a,sizeof(a));
    }
    BigNum(const int);///将int转化为大数
    BigNum(const char*);///将字符串转化为大数
    BigNum(const BigNum &);///拷贝构造函数
    BigNum &operator=(const BigNum &);///重载复制运算符，大数之间赋值

    BigNum operator+(const BigNum &)const;///大数+大数
    BigNum operator-(const BigNum &)const;///大数-大数
    BigNum operator*(const BigNum &)const;///大数*大数
    BigNum operator/(const int &)const;///大数/int

    BigNum operator^(const int &)const;///幂运算
    int operator%(const int &)const;///取模
    bool operator>(const BigNum &)const;///大数与大数比较
    bool operator>(const int &)const;///大数与int比较

    void print();///输出大数
};

BigNum::BigNum(const int b){///将int转化为大数
    int c,d=b;
    len=0;
    memset(a,sizeof(a));
    while(d>MAXN){
        ///c=d-(d/(MAXN+1))*(MAXN+1);
        c=d%(MAXN+1);///取出后四位
        d=d/(MAXN+1);//
        a[len++]=c;
    }
    a[len++]=d;
}

BigNum::BigNum(const char *s){//将字符串转化为大数
    int t,k,index,l,i,j;
    memset(a,sizeof(a));
    l=strlen(s);
    len=l/DLEN;
    if(l%DLEN)++len;
    index=0;
    for(i=l-1;i>=0;i-=DLEN){
        t=0;
        k=i-DLEN+1;
        if(k<0)k=0;
        for(j=k;j<=i;++j)
            t=t*10+s[j]-'0';
        a[index++]=t;
    }
}

BigNum::BigNum(const BigNum &T):len(T.len){//拷贝构造函数
    int i;
    memset(a,sizeof(a));
    for(i=0;i<len;++i)
        a[i]=T.a[i];
}

BigNum &BigNum::operator=(const BigNum &n){//重载复制运算符，大数之间赋值
    int i;
    len=n.len;
    memset(a,sizeof(a));
    for(i=0;i<len;++i)
        a[i]=n.a[i];
    return *this;
}

BigNum BigNum::operator+(const BigNum &T)const{//大数+大数
    BigNum t(*this);
    int i,big;//位数
    big=T.len>len?T.len:len;
    for(i=0;i<big;++i){
        t.a[i]+=T.a[i];
        if(t.a[i]>MAXN){
            ++t.a[i+1];
            t.a[i]-=MAXN+1;
        }
    }
    if(t.a[big]!=0)t.len=big+1;
    else t.len=big;
    return t;
}

BigNum BigNum::operator-(const BigNum &T)const{//大数-大数
    int i,j,big;
    bool flag;
    BigNum t1,t2;//t1大的，t2小的
    if(*this>T){
        t1=*this;
        t2=T;
        flag=0;//前面的大
    }
    else{
        t1=T;
        t2=*this;
        flag=1;//前面的小
    }
    big=t1.len;
    for(i=0;i<big;++i){
        if(t1.a[i]<t2.a[i]){
            j=i+1;
            while(t1.a[j]==0)++j;
            --t1.a[j--];
            while(j>i)t1.a[j--]+=MAXN;
            t1.a[i]+=MAXN+1-t2.a[i];
        }
        else t1.a[i]-=t2.a[i];
    }
    while(t1.a[t1.len-1]==0&&t1.len>1){
        --t1.len;
        --big;
    }
    if(flag)t1.a[big-1]=-t1.a[big-1];//前面的小，结果为负
    return t1;
}

BigNum BigNum::operator*(const BigNum &T)const{//大数*大数
    BigNum ret;
    int i,up;
    int temp,temp1;
    for(i=0;i<len;++i){
        up=0;
        for(j=0;j<T.len;++j){
            temp=a[i]*T.a[j]+ret.a[i+j]+up;
            if(temp>MAXN){
                //temp1=temp-temp/(MAXN+1)*(MAXN+1);
                temp1=temp%(MAXN+1);
                up=temp/(MAXN+1);
                ret.a[i+j]=temp1;
            }
            else{
                up=0;
                ret.a[i+j]=temp;
            }
        }
        if(up!=0)ret.a[i+j]=up;
    }
    ret.len=i+j;
    while(ret.a[ret.len-1]==0&&ret.len>1)--ret.len;
    return ret;
}

BigNum BigNum::operator/(const int &b)const{//大数/int
    BigNum ret;
    int i,down=0;
    for(i=len-1;i>=0;--i){
        ret.a[i]=(a[i]+down*(MAXN+1))/b;
        down=a[i]+down*(MAXN+1)-ret.a[i]*b;
    }
    ret.len=len;
    while(ret.a[ret.len-1]==0&&ret.len>1)--ret.len;
    return ret;
}

BigNum BigNum::operator^(const int &n)const{//幂运算
    BigNum t,ret(1);
    int i;
    if(n<0)exit(-1);
    if(n==0)return 1;
    if(n==1)return *this;
    int m=n;
    while(m>1){
        t=*this;
        for(i=1;i<<1<=m;i<<=1){
            t=t*t;
        }
        m-=i;
        ret=ret*t;
        if(m==1)ret=ret*(*this);
    }
    return ret;
}

int BigNum::operator%(const int &b)const{//取模
    int i,d=0;
    for(i=len-1;i>=0;--i){
        d=((d*(MAXN+1))%b+a[i])%b;
    }
    return d;
}

bool BigNum::operator>(const BigNum &T)const{//大数与大数比较
    int ln;
    if(len>T.len)return true;
    else if(len==T.len){
        ln=len-1;
        while(a[ln]==T.a[ln]&&ln>=0)--ln;
        if(ln>=0&&a[ln]>T.a[ln])return true;
        else return false;
    }
    else return false;
}

bool BigNum::operator>(const int &t)const{//大数与int比较
    BigNum b(t);
    return *this>b;
}

void BigNum::print(){//输出大数
    int i;
    printf("%d",a[len-1]);
    for(i=len-2;i>=0;--i){
        printf("%.4d",a[i]);//%.4d代表4位，不够前面补0
    }
    printf("n");
}

int main(){
    int n,i;
    BigNum a,b;
    char str1[10000],str2[10000];
    scanf("%d",&n);
    for(i=1;i<=n;++i){
        scanf("%s%s",str1,str2);
        a=BigNum(str1);
        b=BigNum(str2);
        if( (( !(a>b) && !(b>a))) && a%11==0  )
            printf("YESn");
        else
             printf("NOn");
    }
    return 0;
}

在用C或者C++处理大数时感觉非常麻烦，但是在JAVA中有两个类BigInteger和BigDecimal分别表示大整数类和大浮点数类，至于两个类的对象能表示最大范围不清楚，理论上能够表示无线大的数，只要计算机内存足够大。

这两个类都在java.math.*包中，因此每次必须在开头处引用该包。


Ⅰ基本函数：

1.valueOf(parament); 将参数转换为制定的类型

??比如 int a=3;

??BigInteger b=BigInteger.valueOf(a);

??则b=3;

??String s=”12345”;

??BigInteger c=BigInteger.valueOf(s);

??则c=12345；


2.add(); 大整数相加

BigInteger a=new BigInteger(“23”);

BigInteger b=new BigInteger(“34”);

a.add(b);


3.subtract(); 相减

4.multiply(); 相乘

5.divide();????相除取整

6.remainder(); 取余

7.pow();???a.pow(b)=a^b

8.gcd();???最大公约数

9.abs(); 绝对值

10.negate(); 取反数

11.mod(); a.mod(b)=a%b=a.remainder(b);

12.max(); min();

13.punlic int comareTo();

14.boolean equals(); 是否相等

15.BigInteger构造函数：

一般用到以下两种：

BigInteger(String val);

将指定字符串转换为十进制表示形式；

BigInteger(String val,int radix);

将指定基数的 BigInteger 的字符串表示形式转换为 BigInteger

Ⅱ.基本常量：

A=BigInteger.ONE????1

B=BigInteger.TEN????10

C=BigInteger.ZERO???0

Ⅲ.基本操作

1.读入：

用Scanner类定义对象进行控制台读入,Scanner类在java.util.*包中

Scanner cin=new Scanner(System.in);// 读入

while(cin.hasNext())???//等同于!=EOF

{

?int n;

?BigInteger m;

?n=cin.nextInt(); //读入一个int;

?m=cin.BigInteger();//读入一个BigInteger;

?System.out.print(m.toString());

}

Ⅳ.运用

四则预算：

import java.util.Scanner;
import java.math.*;
import java.text.*;
public class Main
{
 public static void main(String args[])
 {
  Scanner cin = new Scanner ( System.in );
  BigInteger a,b;
  int c;
  char op;
  String s;
  while( cin.hasNext() )
  {
   a = cin.nextBigInteger();
   s = cin.next();
   op = s.charAt(0);
   if( op == '+')
   {
    b = cin.nextBigInteger();
    System.out.println(a.add(b));
   }
   else if( op == '-')
   {
    b = cin.nextBigInteger();
    System.out.println(a.subtract(b));
   }
   else if( op == '*')
   {
    b = cin.nextBigInteger();
    System.out.println(a.multiply(b));
   }
   else
   {
    BigDecimal a1,b1,eps;
    String s1,s2,temp;
    s1 = a.toString();
    a1 = new BigDecimal(s1);
    b = cin.nextBigInteger();
    s2 = b.toString();
    b1 = new BigDecimal(s2);
    c = cin.nextInt();
    eps = a1.divide(b1,c,4);
    //System.out.println(a + " " + b + " " + c);
    //System.out.println(a1.doubleValue() + " " + b1.doubleValue() + " " + c);
    System.out.print( a.divide(b) + " " + a.mod(b) + " ");
    if( c != 0)
    {
     temp = "0.";
     for(int i = 0; i < c; i ++) temp += "0";
     DecimalFormat gd = new DecimalFormat(temp);
     System.out.println(gd.format(eps));
    }
    else System.out.println(eps);
   }
  }
 }
}


//=====================================================================================

//PKU1311八进制浮点数化为十进制浮点数，高精度

import java.io.*;
import java.util.*;
import java.math.*;
public class Main
{
 public static void main(String[] args)
 {
  Scanner cin=new Scanner(System.in);
  BigDecimal temp,sum,ans,num;  //java大数
  String str;
  int i,len;
  while(cin.hasNext())
  {
   str=cin.next();
   len=str.length();
   temp=BigDecimal.valueOf(8.0);
   sum=BigDecimal.ONE;
   ans=BigDecimal.ZERO;
   for(i=2;i<len;i++)
   {
    int val=str.charAt(i)-'0';
    num=BigDecimal.valueOf(val);
    sum=sum.multiply(temp);       //8的n次幂
    ans=ans.add(num.divide(sum)); //按权累加
   }
   System.out.printf("%s [8] = ",str);
   System.out.println(ans+" [10]");
  }
 }
}

BigDecimal类?
　　双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。表5.7中列出了BigDecimal类的主要构造器和方法。?

　　BigDecimal类的主要构造器和方法?
　　构 造 器描 述?
　　BigDecimal(int)创建一个具有参数所指定整数值的对象。?
　　BigDecimal(double)创建一个具有参数所指定双精度值的对象。?
　　BigDecimal(long)创建一个具有参数所指定长整数值的对象。?
　　BigDecimal(String)创建一个具有参数所指定以字符串表示的数值的对象。?
　　方 法描 述?
　　add(BigDecimal)BigDecimal对象中的值相加，然后返回这个对象。?
　　subtract(BigDecimal)BigDecimal对象中的值相减，然后返回这个对象。?
　　multiply(BigDecimal)BigDecimal对象中的值相乘，然后返回这个对象。?
　　divide(BigDecimal)BigDecimal对象中的值相除，然后返回这个对象。?
　　toString()将BigDecimal对象的数值转换成字符串。?
　　doublue()将BigDecimal对象中的值以双精度数返回。?
　　floatValue()将BigDecimal对象中的值以单精度数返回。?
　　longValue()将BigDecimal对象中的值以长整数返回。?
　　intValue()将BigDecimal对象中的值以整数返回。?
　　注意，由于一般数值类型，例如double，不能准确地代表16位有效数以上的数字，在使用BigDecimal时，应用BigDecimal(String)构造器创建对象才有意义。另外，BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。?
　　构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。关于构造器概念和编写技术，将在本书第6章详细介绍。?
　　下面讨论BigDecimal的一些常用例子：?
　//完整程序例子在本书配套资源目录Ch5中名为BigDecimalTestApp.Java?
　　//创建BigDecimal对象?
　　BigDecimal　bigNumber　=　new　BigDecimal("89.1234567890123456789");?
　　BigDecimal　bigRate　=　new　BigDecimal(1000);?
　　BigDecimal　bigResult　=　new　BigDecimal();　//对象bigResult的值为0.0?
　　//对bigNumber的值乘以1000，结果　赋予bigResult?
　　bigResult　=　bigNumber.multiply(bigRate);?
　　System.out.println(bigResult.toString());?
　　//或者System.out.println(bigResult);?
　　//显示结果：89123.4567890123456789000?
　　//以双精度数返回bigNumber中的值?
　　double　dData　=　bigNumber.doublue();?
　　System.out.println(dData);　//结果：89.12345678901235?
　　注意使用方法doublue()将对象bigNumber中的值以双精度数值返回时，将丢失数据的准确性。使用其他方法，如xxxValue()时均存在这个问题，使用时必须慎重。?
　　BigDecimal用来对超过16有效位以上的数值进行运算和操作。所有的算术运算都通过调用其相应的方法进行。创建一个超过16有效位数的对象时，运用BigDecimal(String)才可避免丢失数字的精确度。?
　　BigDecimal和格式化?
　　由于NumberFormat类的format()方法可以使用BigDecimal对象作为其参数，可以利用BigDecimal对超出16位有效数字的货币值，百分值，以及一般数值进行格式化控制。?
java四舍五入?
package Test;?
import java.math.BigDecimal; //引入这个包?
public class Test {?
public static void main(String[] args) {?
?? double i = 3.856;?
?? // 舍掉小数取整?
?? System.out.println("舍掉小数取整:Math.floor(3.856)=" + (int) Math.floor(i));?
?? // 四舍五入取整?
?? System.out.println("四舍五入取整:(3.856)="?
???? + new BigDecimal(i).setScale(0,BigDecimal.ROUND_HALF_UP));?
?? // 四舍五入保留两位小数?
???? + new BigDecimal(i).setScale(2,sans-serif; font-size:14px; line-height:25.2px">?? // 凑整，取上限?
?? System.out.println("凑整:Math.ceil(3.856)=" + (int) Math.ceil(i));?
?? System.out.println("舍掉小数取整:Math.floor(-3.856)=" + (int) Math.floor(-i));?
?? System.out.println("四舍五入取整:(-3.856)="?
???? + new BigDecimal(-i).setScale(0,sans-serif; font-size:14px; line-height:25.2px">???? + new BigDecimal(-i).setScale(2,sans-serif; font-size:14px; line-height:25.2px">?? System.out.println("凑整(-3.856)=" + (int) Math.ceil(-i));? 

package com.bigDecimal;

import java.math.BigDecimal;
/**
 * 对BigDecimal类的封装操作
 * BigDecimal的构造函数的参数必须要是字符串型
 */
public class Arith {
	// 默认除法运算精度
	private static final int DEF_DIV_SCALE = 10;

	// 这个类不能实例化
	private Arith() {
	}

	/**
	 * 提供精确的加法运算。
	 * 
	 * @param v1 被加数
	 * @param v2 加数
	 * @return 两个参数的和
	 */
	public static double add(double v1,double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.add(b2).doubleValue();
	}

	/**
	 * 提供精确的减法运算。
	 * 
	 * @param v1 被减数
	 * @param v2 减数
	 * @return 两个参数的差
	 */
	public static double sub(double v1,double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.subtract(b2).doubleValue();
	}

	/**
	 * 提供精确的乘法运算。
	 * 
	 * @param v1 被乘数
	 * @param v2 乘数
	 * @return 两个参数的积
	 */
	public static double mul(double v1,double v2) {
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.multiply(b2).doubleValue();
	}

	/**
	 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。
	 * 
	 * @param v1 被除数
	 * @param v2 除数
	 * @return 两个参数的商
	 */
	public static double div(double v1,double v2) {
		return div(v1,v2,DEF_DIV_SCALE);
	}

	/**
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
	 * 
	 * @param v1 被除数
	 * @param v2 除数
	 * @param scale 表示表示需要精确到小数点以后几位。
	 * @return 两个参数的商
	 */
	public static double div(double v1,double v2,int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException("The scale must be a positive integer or zero");
		}
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		BigDecimal b2 = new BigDecimal(Double.toString(v2));
		return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
	}

	/**
	 * 提供精确的小数位四舍五入处理。
	 * 
	 * @param v 需要四舍五入的数字
	 * @param scale 小数点后保留几位
	 * @return 四舍五入后的结果
	 */
	public static double round(double v,int scale) {
		if (scale < 0) {
			throw new IllegalArgumentException("The scale must be a positive integer or zero");
		}
		BigDecimal b = new BigDecimal(Double.toString(v));
		BigDecimal one = new BigDecimal("1");
		return b.divide(one,BigDecimal.ROUND_HALF_UP).doubleValue();
	}
}

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
    相关内容
      推荐文章
        站长推荐
        热点阅读

          【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

          建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

          Copygight © 2008-2022 https://www.lidatong.com.cn/ All Rights Reserved. 李大同