精华内容
下载资源
问答
  • Java实现 蓝桥杯VIP 算法提高 高精度乘法
    万次阅读 多人点赞
    2019-06-22 09:06:30

    算法提高 高精度乘法
    时间限制:1.0s 内存限制:256.0MB
    问题描述
      在C/C++语言中,整型所能表示的范围一般为-231到231(大约21亿),即使long long型,一般也只能表示到-263到263。要想计算更加规模的数,就要用软件来扩展了,比如用数组或字符串来模拟更多规模的数及共运算。
      现在输入两个整数,请输出它们的乘积。
    输入格式
      两行,每行一个正整数,每个整数不超过10000位
    输出格式
      一行,两个整数的乘积。
    样例输入
    99
    101
    样例输出
    9999
    数据规模和约定
      每个整数不超过10000位

    import java.math.BigInteger;
    import java.util.Scanner;
    
    
    public class 高精度乘法 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		BigInteger bi = new BigInteger(sc.next());
    		BigInteger bi2 = new BigInteger(sc.next());
    		System.out.println(bi.multiply(bi2));
    
    	}
    
    }
    
    
    更多相关内容
  • 高精度乘法 输入格式 两行,两个整数。 输出格式 一行一个整数表示乘积。 思路 其实高精度乘法的思路就是模拟正常的乘法 我们使用一个data二维矩阵存储乘法的中间结果 最后对data进行按列相加 举例说明 我们现在有...

    高精度乘法

    输入格式
    两行,两个整数。

    输出格式
    一行一个整数表示乘积。

    思路

    • 其实高精度乘法的思路就是模拟正常的乘法
    • 我们使用一个data二维矩阵存储乘法的中间结果
    • 最后对data进行按列相加

    举例说明

    我们现在有两个乘数1234和95

    int[] num1 = new int[]{1,2,3,4};
    int[] num2 = new int[]{9,5};
    

    乘法需要将一个数放在上面,一个数放在下面。手算如下:我们默认将num2放在下面。
    在这里插入图片描述
    可以发现中间的计算结果就是一个二维矩阵

    此时我们需要定义如下变量:

    • data【】【】矩阵存储中间的计算结果,要提前计算data的行和列。
    • res【】存储最后的结果

    由于我们将num2放在下面,所以data的行数就等于num2的长度。再仔细观察发现,data的列数应该 = num1.length + num2.length (这是已经考虑进位的结果)

    其次res【】的长度要比data的列数多1,因为最前面可能会进位

    int[][] data = new int[num2.length][num1.length + num2.length];//模拟乘法的矩阵
    int[] res = new int[data[0].length+1];//位数永远会多一位 因为最前面可能进位
    

    这时候我们就要分别将num1去乘以num2的每一位(从个位开始),每次都会得到一个数(数组形式)。

    这里pre是用来记录当前每一行的最后一个数要从哪里开始存。因为我们知道只有第一行的最后一个数是存在末尾的。

    int prex = data[0].length-1;//data矩阵中每一行最后一个数从哪开始存储
    for(int i = num2.length - 1, j = 0; i >= 0; i--, j++){
          data[j] = cacaulate(num1,num2[i],prex--,data[0].length); //计算num1 分别乘以 num2中的每一位 存储到data矩阵中
    }
    
    public static int[] cacaulate(int[] nums1, int n, int prex, int length){
                int[] res = new int[length];
                int flag = 0;
                for(int i = nums1.length-1, j = prex;  i >= 0; i--){
                    int temp = nums1[i] * n + flag;
                    res[j--] = temp % 10;
                    flag = temp / 10;
                    if(i == 0){
                        res[j] = flag;
                        break;
                    }
                }
                return  res;
            }
    

    在计算之后我们会得到如下的data二维数组

    在这里插入图片描述

    此时我们只需要按列将这个二维数组相加就好了

    //开始最后的加法
                int flag = 0; //进位
                for(int j = data[0].length-1, index = data[0].length; j >= 0; j-- ){
                    int temp  = flag;
                    for(int i = 0; i < data.length; i++){
                        temp += data[i][j];
                    }
                    res[index--] = temp % 10;
                    flag = temp / 10;
    
                    if(j == 0) {//如果加到最后一位了,则需要最前面一位进位
                        res[index] = flag;
                        break;
                    }
                }
    

    最终结果需要把前面的0去掉

    完整代码如下:

    public class test18 {
    
            public static void main(String[] args) {
    
                int[] num1 = new int[]{1,2,3,4};
                int[] num2 = new int[]{9,5}; //乘法 num2放在下面乘
    
    
                int[][] data = new int[num2.length][num1.length + num2.length];//模拟乘法的矩阵
                int[] res = new int[data[0].length+1];//位数永远会多一位 因为最前面可能进位
    
                int prex = data[0].length-1;//data矩阵中每一行最后一个数从哪开始存储
                for(int i = num2.length - 1, j = 0; i >= 0; i--, j++){
                    data[j] = cacaulate(num1,num2[i],prex--,data[0].length); //计算num1 分别乘以 num2中的每一位 存储到data矩阵中
                }
    
    
                //开始最后的加法
                int flag = 0; //进位
                for(int j = data[0].length-1, index = data[0].length; j >= 0; j-- ){
                    int temp  = flag;
                    for(int i = 0; i < data.length; i++){
                        temp += data[i][j];
                    }
                    res[index--] = temp % 10;
                    flag = temp / 10;
    
                    if(j == 0) {//如果加到最后一位了,则需要最前面一位进位
                        res[index] = flag;
                        break;
                    }
                }
    
    
    
                //把前面的零去掉
                int i = 0;
                while(res[i++] != 0) ;
                for(int j = i; j < res.length; j++){
                    System.out.print(res[j]);
                }
    
    
    
    
    
            }
    
            public static int[] cacaulate(int[] nums1, int n, int prex, int length){
                int[] res = new int[length];
                int flag = 0;
                for(int i = nums1.length-1, j = prex;  i >= 0; i--){
                    int temp = nums1[i] * n + flag;
                    res[j--] = temp % 10;
                    flag = temp / 10;
                    if(i == 0){
                        res[j] = flag;
                        break;
                    }
                }
                return  res;
            }
    }
    
    展开全文
  • 主要介绍了Java基于高精度整型实现fibonacci数列的方法,是比较典型的算法,需要的朋友可以参考下
  • 要想计算更加规模的数,就要用软件来扩展了,比如用数组或字符串来模拟更多规模的数及共运算。 现在输入两个整数,请输出它们的乘积。 数据规模和约定 每个整数不超过10000位 输入 两行,每行一个正整数,每个整数不...

    题目描述
    在C/C++语言中,整型所能表示的范围一般为-231到231(大约21亿),即使long long型,一般也只能表示到-263到263。要想计算更加规模的数,就要用软件来扩展了,比如用数组或字符串来模拟更多规模的数及共运算。
    现在输入两个整数,请输出它们的乘积。

    数据规模和约定
    每个整数不超过10000位

    输入
    两行,每行一个正整数,每个整数不超过10000位
    输出
    一行,两个整数的乘积。
    样例输入

    99
    101

    样例输出

    9999

    import java.math.BigInteger;
    import java.util.Scanner;
    
    public class Main {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		String str1 = sc.next();
    		// 创建大数运算对象
    		BigInteger bigInteger = new BigInteger(str1);
    		System.out.println(bigInteger.multiply(sc.nextBigInteger()));
    	}
    }
    
    展开全文
  • C++实现高精度计算类库,包含了FFT的乘法除法,开平方,用法类似java的bigint,实测速度比java的快很多
  • Java 算法 高精度乘法

    2022-03-19 19:10:41
    要想计算更加规模的数,就要用软件来扩展了,比如用数组或字符串来模拟更多规模的数及共运算。  现在输入两个整数,请输出它们的乘积。 输入 输入描述:  两行,每行一个正整数,每个整数不超过10000位 输入样例: ...

    题目描述

    在C/C++语言中,整型所能表示的范围一般为-231到231(大约21亿),即使long long型,一般也只能表示到-263到263。要想计算更加规模的数,就要用软件来扩展了,比如用数组或字符串来模拟更多规模的数及共运算。
      现在输入两个整数,请输出它们的乘积。

    输入
    输入描述:
      两行,每行一个正整数,每个整数不超过10000位
    输入样例:
    99
    101

    输出

    输出描述:
      一行,两个整数的乘积。
    输出样例:
    9999

    HINT:时间限制:1.0s 内存限制:256.0MB
      每个整数不超过10000位
    来源

    解题思路

    运用BigInteger自带的函数就行。

    代码

    import java.math.BigInteger;
    import java.util.Scanner;
    
    public class Main {
    
        public static void main(String[] args) {
            Scanner scanner=new Scanner(System.in);
            BigInteger m=scanner.nextBigInteger();
            BigInteger n=scanner.nextBigInteger();
            BigInteger x=m.add(n);          //加
            BigInteger x1=m.subtract(n);    //减
            BigInteger x2=m.multiply(n);    //乘
            BigInteger x3=m.divide(n);      //除
            System.out.println(x2);
        }
    }
    

    基本方法

    BigInteger的加、减、乘、除运算。

    Scanner scanner=new Scanner(System.in);
            BigInteger m=scanner.nextBigInteger();
            BigInteger n=scanner.nextBigInteger();
            BigInteger x=m.add(n);          //加
            BigInteger x1=m.subtract(n);    //减
            BigInteger x2=m.multiply(n);    //乘
            BigInteger x3=m.divide(n);      //除
            System.out.println(x2);
    
    展开全文
  • Java 高精度运算

    2021-02-05 20:31:32
    Java中有两个类可以来处理高精度计算 分别是处理整数的BigInteger和处理小数的BigDecimal BigInteger 只可用于整数 构造方法 BigInteger(byte[] val) 将包含BigInteger的二进制补码二进制表达式的字节数组转换为...
  • 算法提高 高精度乘法 资源限制 时间限制:1.0s 内存限制:256.0MB 问题描述 计算机真是最傻的东西;他都不能计算大于10^65-1的ab,请你帮这个“最傻”的东西过关,否则它就真的只认识1和0了。 输入格式 共两行; 第...
  • 今天在做接口传保费的时候出现了一个奇怪的问题,double类型保费变成了一大长串的非精准保费,甚至奇怪,难道是java的bug?最后通过度娘找到了答案话不多说,先看如下代码public final class Person {public static ...
  • 大数乘法可以进行任意大小和精度的整数和浮点数的乘法运算, 精确度很, 可以用作经融等领域的计算,这个是我看了一些资料, 然后自己整理实现的,简单测试了一下
  • java高精度计算

    2020-12-27 14:41:00
    * 用于精确处理常用的数学运算 */ public class ArithmeticUtils { //默认除法运算精度 private static final int DEF_DIV_SCALE = 10; /** * 提供精确的加法运算 * * @param v1 被加数 * @param v2 加...
  • 蓝桥 高精度乘法Java

    千次阅读 2022-03-13 11:04:31
    要想计算更加规模的数,就要用软件来扩展了,比如用数组或字符串来模拟更多规模的数及共运算。  现在输入两个整数,请输出它们的乘积。 输入格式 两行,每行一个正整数,每个整数不超过10000位 输出格式 一行,两个...
  • JAVA高精度金额计算

    2021-02-12 10:06:17
    一般java代码中遇到高精度金额计算,日常使用bigDecimal类型。在使用BigDecimal类来进行计算的时候,主要分为以下步骤:1、用float或者double变量构建BigDecimal对象。2、通过调用BigDecimal的加,减,乘,除等相应...
  • 有时候我们计算金钱或者其他一些计算的时候需要高精度计算加减乘除,可以使用BigDecimal 加: BigDecimal num1 = new BigDecimal("100.569"); BigDecimal num2 = new BigDecimal("50.799"); BigDecimal data = num...
  • C++ 的高精度乘法

    千次阅读 2021-11-11 08:27:07
    (15条消息) C++ 的高精度乘法_努力中的老周的专栏-CSDN博客
  • P1919 FFT加速高精度乘法题意:给出两个n位10进制整数x和y,你需要计算x*y。题解:对于十进制数我们可以将其转换成\(a0*10^0+a1*10^1+a2*10^2...an*10^n\)那么对于两个数,我们就可以求出两个的系数表示后得到a的...
  • java高精度计算

    2020-02-13 14:57:21
    一、高精度加法 现在有一个简单的问题,给你两个正整数 AA 和 BB,你需要计算出 A+BA+B 的结果。不过要注意哦,这两个正整数非常大。 输入 输入两个正整数 AA 和 BB , AA 和 BB 的位数不超过 100000100000。 输出 ...
  • 高精度乘法是大数乘以一个int型的小数,和前面模拟不同,这里不是一位一位的乘,而是a一位乘以整个数b,当a乘到最高位且没有进位就结束了。 2.代码模板 方法一: //a为大数,倒序存储,b为int型,返回a*b的结果 ...
  • java求小数高精度运算

    2021-07-12 20:38:46
    在实际编码中,会遇到很多高精度的事例,比如,在计算金钱的时候就需要保留高精度小数,这样计算才不会有太大误差 有以下实现可以得证:当两个float型的数字相加,得到的结果和我们的预期结果是有误差的 float x = ...
  • 所以我写了这个方法,保证计算精度。/*** js小数乘法*@parameter arg1:被乘数(接受小数和整数)*@parameter arg2:乘数(接受小数和整数)*@parameter fix: 乘积保留几位(接受正负整数以及0)*/function accMul(arg1,...
  • 算法提高 高精度乘法 描述 在C/C++语言中,整型所能表示的范围一般为-231到231(大约21亿),即使long long型,一般也只能表示到-263到263。要想计算更加规模的数,就要用软件来扩展了,比如用数组或字符串来模拟更多...
  • 高精度减法 问题描述 高精度减法 输入格式 两行,表示两个非负整数a、b,且有a > b。 输出格式 一行,表示a与b的差 样例输入 1234567890987654321 9999 样例输出 1234567890987644322 代码如下: import java....
  • 本文采用c++手动计算大数乘法。 这是是个常见、标准的乘法算法。简单易懂,可以多次看记下来。 string multiply(string num1, string num2) { string sum(num1.size() + num2.size(), '0'); for (int i = num1....
  • JAVA中无法避免需要高精度计算确定金额,日常使用BigDecimal类型使用BigDecimal类型计算,主要有几个步骤1.float或者double变量构建为BigDecimal对象2.通过BigDecimal提供的加减乘除方法进行算数运算3.BigDecimal对象...
  • ^_^这道题目,要用的只是点就一个,高精度乘法运算,如果是C++的话,请用分治的方法,而对于java以及python而言,只需要直接调用对于高精度计算的函数即可,此处用了python的pow计算位数很简单,10^x + k = 2^p -1 -...
  • JAVA实现高精度整数加减乘

    千次阅读 2020-02-09 11:31:44
    所以,在java中其实没有手动实现高精度的必要。 所以写下这篇博客的初衷并不是放在实际情况下使用,而是当做高精度算法的练习,也同时练习java编程能力。 封装类内容: 实现接口 克隆接口Cloneable,重写clone方法。...
  • BigDecimal 是标准的类,在编译器中不需要特殊支持,它可以表示任意精度的小数,并对它们进行计算。 用于加、减、乘和除的方法给 BigDecimal 值提供了算术运算。由于 BigDecimal 对象是不可变的,这些方法中的每一...
  • 实际上高精度就是说参与运算的数据和运算结果的范围,超出标准数据类型能表示的数据大小范围的运算。 1.高精度的加法 思路: 1、输入两个字符串,表示即将要进行加法运算的数,之所以是字符串,是因为有可能要输入的...
  • java中各类型的精度范围参见:http://blog.csdn.net/longshenlmj/article/details/47616481编程时注意:doulbe类型的数,不能用等号判定是否相等(或者是一定范围内可以)。因为两次同样的计算...
  • Java 中,表示小数值一般使用 float 或者 double 类型,可以用于科学计算或者工程计算等。数学意义上的小数是连续的,但 float 和 double 只能表示其中的一些离散点,如果我们要表示的数值刚好无法用 float 或者 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,946
精华内容 3,178
关键字:

java 乘法计算需要考虑高精度吗

java 订阅