Java模拟两个大整数的加法、乘法、除法

java大数相加代码 java实现大数相加,在不使用BigInteger工具的前提下实现大数相加 立即下载
package ddd;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class BigIntegerAddition {

    /**
     * 
     * 问题:java实现两个大数相加,可能存在溢出。 如123456789 + 987654321 返回 1111111110
     * 
     * 解决办法:
     * 1.直接用BigInteger 
     * 
     * 2.模拟手算加法,进位相加(暂时没有考虑负数的情况),该类模拟两个大数的相加, 相乘,相除。至于相减,看了该类的相加就知道如何实现了。
     * 该类中的加、乘、除的算法思路与人工的计算方式一致。虽然算法目的是达到了,但效率的话的确有待商榷,因为本人能力有限,实在是想不到更好的实现方式,还望
     * 各位路过的高人指点!!!若有更好的实现方式,记得留言咯!
     */
    public static void main(String[] args) {

        String x = "23456789";
        String y = "987654321";

        BigInteger a = new BigInteger(x);
        BigInteger b = new BigInteger(y);
        BigInteger c = a.add(b);
        System.out.println(c.toString());

        System.out.println(add(x, y));

        System.out.println(add("-100", "1"));
        System.out.println(add("-1000", "1"));
        System.out.println(add("-1", "1"));
        System.out.println(add("-17", "901"));

        System.out.println(add("1", "-100"));
        System.out.println(add("1", "-1000"));
        System.out.println(add("1", "-1"));
        System.out.println(add("901", "-17"));

        System.out.println(posMultiPos("556", "7"));

        System.out.println(posMultiPos("195", "5"));

        System.out.println(posMultiPos("919", "8"));

        System.out.println("--->" + trimPrefixedZero("0"));

        System.out.println(posMultiPos("99", "0"));

        System.out.println(divid("138", "12", 6));
        System.out.println(divid("10", "3", 6));

    }


    /**
     * 两个整数的加法运算,考虑正负数,由于减法可以转化为加法运算,
     * 所以本人并没有直接给出求大整数减法的算法
     * @param x
     * @param y
     * @return
     */
    public static String add(String x, String y) {
        if (isNullOrEmpty(x) || isNullOrEmpty(y)) {
            return null;
        }
        if (!isNumeric(x) || !isNumeric(y)) {
            return null;
        }
        if (x.equals("0")) {
            return y;
        }
        if (y.equals("0")) {
            return x;
        }

        if (x.charAt(0) == '-' && y.charAt(0) == '-') {

            x = x.substring(1);
            y = y.substring(1);
            return "-" + posAddPos(x, y);

        } else if (x.charAt(0) != '-' && y.charAt(0) != '-') {

            return posAddPos(x, y);

        } else if (x.charAt(0) == '-' && y.charAt(0) != '-') {

            return negAddPos(x, y);

        } else if (x.charAt(0) != '-' && y.charAt(0) == '-') {

            String tem = x;
            x = y;
            y = tem;
            return negAddPos(x, y);
        }

        return null;
    }


    /**
     * 一个负数与一个正数的加法
     * @param x
     * @param y
     * @return
     */
    public static String negAddPos(String x, String y) {

        if (x.charAt(0) != '-' || y.charAt(0) == '-') {
            throw new IllegalArgumentException("x必须是负数数,y必须是正数");
        }
        // 判断x代表的负数的绝对值是否比正数y的绝对值大
        boolean isAbsXLarger = false;

        x = x.substring(1);

        if (x.length() > y.length()) {
            isAbsXLarger = true;
            String tmp = x;
            x = y;
            y = tmp;
        } else if (x.length() == y.length()) {
            isAbsXLarger = isAbsXLarger(x, y);
            if (isAbsXLarger) {
                String tmp = x;
                x = y;
                y = tmp;
            }
        }

        x = addZeroToFirst(x, y.length());

        int len = y.length();
        int[] a = toIntArray(y);
        int[] b = toIntArray(x);
        int[] c = new int[len + 1];

        for (int i = 0; i < len; i++) {
            int ac = a[len - 1 - i];
            int bc = b[len - 1 - i];

            if (ac - bc >= 0) {
                c[len - i] = ac - bc;
            } else {

                c[len - i] = (ac + 10) - bc;

                int r = 1;
                while ((len - 1 - i - r) >= 0 && a[len - 1 - i - r] == 0) {
                    a[len - 1 - i - r] = 9;
                    r++;
                }
                a[len - 1 - i - r] = a[len - 1 - i - r] - 1;
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i <= len; i++) {
            sb.append(c[i]);
        }

        String z = trimPrefixedZero(sb.toString());

        if (z.equals("0")) {
            z = "";
        }

        if (z.length() > 0 && isAbsXLarger) {
            return "-" + sb.toString();
        } else if (z.length() > 0) {
            return sb.toString();
        } else {
            return "0";
        }
    }


    /**
     * 两个正数的加法
     * @param x
     * @param y
     * @return
     */
    public static String posAddPos(String x, String y) {
        if (x.length() > y.length()) {
            String tmp = x;
            x = y;
            y = tmp;
        }
        x = addZeroToFirst(x, y.length());

        String z = "";
        int len = x.length();
        int[] a = toIntArray(x);
        int[] b = toIntArray(y);
        int[] c = new int[len + 1];
        int d = 0;
        for (int i = 0; i < len; i++) {
            int tmpSum = a[len - 1 - i] + b[len - 1 - i] + d;
            c[len - i] = tmpSum % 10;
            d = tmpSum / 10;
        }
        c[0] = d;

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i <= len; i++) {
            sb.append(c[i]);
        }

        z = trimPrefixedZero(sb.toString());

        return z;
    }

    /**
     * 大整数的乘法
     * @param x
     * @param y
     * @return
     */
    public static String multi(String x, String y) {
        if (isNullOrEmpty(x) || isNullOrEmpty(y)) {
            return null;
        }
        if (!isNumeric(x) || !isNumeric(y)) {
            return null;
        }

        if (x.charAt(0) == '-' && y.charAt(0) == '-') {

            x = x.substring(1);
            y = y.substring(1);
            return posMultiPos(x, y);

        } else if (x.charAt(0) != '-' && y.charAt(0) != '-') {

            return posMultiPos(x, y);

        } else if (x.charAt(0) == '-' && y.charAt(0) != '-') {

            x = x.substring(1);
            return "-" + posMultiPos(x, y);

        } else if (x.charAt(0) != '-' && y.charAt(0) == '-') {

            y = y.substring(1);
            return "-" + posMultiPos(x, y);
        }

        return null;
    }

    /**
     * 一个多位数与一个个位数的乘法,注:这两个数都只能是正数
     * @param x
     * @param y
     * @return
     */
    private static String posMultiSingleDigit(String x, String y) {
        if (y.length() != 1 || x.charAt(0) == '-') {
            throw new IllegalArgumentException("参数异常");
        }
        String z = "";
        int len = x.length();
        int[] a = toIntArray(x);
        int b = Integer.parseInt(y);
        int[] c = new int[len + 1];

        int d = 0;
        for (int i = 0; i < len; i++) {
            int tempV = a[len - 1 - i] * b;
            int r = (tempV % 10) + d;
            d = tempV / 10;
            if (r >= 10) {
                c[len - i] = r - 10;
                d = d + 1;
            } else {
                c[len - i] = r;
            }
        }
        c[0] = d;

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i <= len; i++) {
            sb.append(c[i]);
        }

        z = trimPrefixedZero(sb.toString());

        return z;
    }

    /**
     * 两个正数的乘法
     * @param x
     * @param y
     * @return
     */
    public static String posMultiPos(String x, String y) {
        if (x.length() < y.length()) {
            String tem = x;
            x = y;
            y = tem;
        }

        int[] b = toIntArray(y);
        int len = b.length;

        String[] temp = new String[len];

        for (int i = 0; i < len; i++) {

            temp[len - 1 - i] = posMultiSingleDigit(x, b[len - 1 - i] + "");
            temp[len - 1 - i] += getZeroStringOfLenght(i);
        }

        String result = "0";
        for (int i = 0; i < len; i++) {
            result = posAddPos(result, temp[i]);
        }

        return result;

    }


    /**
     * 大整数的除法, 如果不能整除, 则小数保留位数为precision,如果能整除,则保留一位小数
     * @param x
     * @param y
     * @param precision 小数的精度
     * @return
     */
    public static String divid(String x, String y, int precision) {
        if (isNullOrEmpty(x) || isNullOrEmpty(y)) {
            return null;
        }
        if (!isNumeric(x) || !isNumeric(y)) {
            return null;
        }
        boolean flag = false;

        List<String> li = new ArrayList<String>();
        if (x.charAt(0) == '-' && y.charAt(0) == '-') {

            x = x.substring(1);
            y = y.substring(1);
            posDividPos(x, y, "", li, precision, false);

        } else if (x.charAt(0) != '-' && y.charAt(0) != '-') {

            posDividPos(x, y, "", li, precision, false);

        } else if (x.charAt(0) == '-' && y.charAt(0) != '-') {
            flag = true;
            x = x.substring(1);
            posDividPos(x, y, "", li, precision, false);

        } else if (x.charAt(0) != '-' && y.charAt(0) == '-') {
            flag = true;
            y = y.substring(1);
            posDividPos(x, y, "", li, precision, false);
        }

        String result = "";
        for(String ele : li)
        {
            result += ele;
        }

        result = trimPrefixedZero(result);

        if(flag && !result.equals("0")) {
            result = "-" + result;
        }

        return result;
    }


    /**
     * 两个正整数的除法
     * @param x
     * @param y
     * @param temp
     * @param li
     */
    private static void posDividPos(String x, String y, String temp, List<String> li, int precision, boolean dotIncluded) {

        if (x.length() == 0 && precision  == 0) {
            return;
        }

        char[] charArray = x.toCharArray();
        String[] xArray = new String[charArray.length];
        for (int i = 0; i < charArray.length; i++) {
            String s = String.valueOf(charArray[i]);
            xArray[i] = s;
        }

        List<String> xList = new ArrayList<String>(Arrays.asList(xArray));
        if (xList.size() > 0) {
            temp += xList.remove(0);
        } else {
            if(!dotIncluded) {
                li.add(".");
                dotIncluded = true;
            }

            if(precision > 0) {
                precision--;
                temp += "0";  
            }
        }
        temp = trimPrefixedZero(temp);

        while (isAbsXLarger(y, temp)) {
            li.add("0");
            if (xList.size() > 0) {
                temp = temp + xList.remove(0);
            } else if(precision > 0) {
                if(!dotIncluded) {
                    li.add(".");
                    dotIncluded = true;
                }
                temp = temp + "0";
                precision--;
                temp = trimPrefixedZero(temp);
                if(temp.equals("0")) {
//                  return;
                }
            } else {
                return;
            }
        }

        int k = cacu(temp, y);
        li.add(k + "");
        String result = add(temp, "-" + posMultiSingleDigit(y, k + ""));
        result = trimPrefixedZero(result);

        if (result.equals("0")) {
            result = "";
        }
        temp = result;

        String newX = "";
        for (String str : xList) {
            newX += str;
        }
        System.out.println(result);
        posDividPos(newX, y, result, li, precision, dotIncluded);
    }

    public static String getZeroStringOfLenght(int a) {
        String str = "";
        for (int i = 0; i < a; i++) {
            str += "0";
        }
        return str;
    }

    public static int[] toIntArray(String str) {
        int len = str.length();
        int[] result = new int[len];
        for (int i = 0; i < len; i++) {
            result[i] = str.charAt(i) - '0';
        }
        return result;
    }

    public static String addZeroToFirst(String str, int length) {
        StringBuilder sb = new StringBuilder();
        int diff = length - str.length();
        while (diff > 0) {
            sb.append("0");
            diff--;
        }
        sb.append(str);
        return sb.toString();
    }

    public static boolean isNumeric(String str) {
        Pattern p = Pattern.compile("^\\-?[0-9]*$");
        Matcher isNum = p.matcher(str);
        return isNum.matches();
    }

    public static boolean isNullOrEmpty(String str) {
        if (str == null) {
            return true;
        }
        if (("").equals(str.trim())) {
            return true;
        }
        return false;
    }

    public static boolean isAbsXLarger(String x, String y) {
        if (x.length() > y.length()) {
            return true;
        } else if (x.length() == y.length()) {

            int[] xArray = toIntArray(x);
            int[] yArray = toIntArray(y);
            for (int i = 0; i < xArray.length; i++) {
                if (xArray[i] > yArray[i]) {
                    return true;
                } else if (xArray[i] == yArray[i]) {
                    continue;
                } else {
                    return false;
                }
            }
        }

        return false;
    }

    public static String trimPrefixedZero(String z) {
        while (z.length() > 1 && z.charAt(0) == '0') {
            z = z.substring(1);
        }
        return z;
    }

    /**
     * 该方法相当于求 x/y的值,注意x、y都是一个正整数
     * @param x
     * @param y
     * @return
     */
    public static int cacu(String x, String y) {

        int k = 0;
        for (int i = 0; i <= 9; i++) {
            if (isAbsXLarger(x, posMultiSingleDigit(y, i + "")) || (x.equals(posMultiSingleDigit(y, i + "")))) {
//              System.out.println(x);
//              System.out.println(posMultiSingleDigit(y, i + ""));
                k = i;
            }
        }

        return k;

    }

}
java大数运算,包括加减乘除 自己编写的Java大数字运算函数,没有使用Java自带的运算函数,支持特大int型数据的运算 立即下载

相关推荐

java编写的计算器(仅支持两位数字加减乘除计算)

java编写的计算器(仅支持两位数字加减乘除计算) java编写的计算器(仅支持两位数字加减乘除计算)

Q4:Java中使用条件运算符完成计算两个数字中的最大值

前言 条件运算符的语法:variable x = (expression) ? value if true : value if false max = (n1 >= n2) ? n1 : n2; 这边的括号里面是写一个表达式 一、计算两个数字中的最大值 public class day01_1 { public static void main(String[] args) { // TODO Auto-generated metho

白菜小皮艇的博客 3615

Crossformer实战:从零开始搭建多变量时间序列预测模型(附ETTh1数据集调参指南)

本文提供了从零开始搭建Crossformer多变量时间序列预测模型的实战指南,并附有详细的ETTh1数据集调参攻略。文章深入解析了Crossformer的核心设计,重点探讨了seg_len和win_size等关键参数对模型性能的影响,并分享了环境配置、训练调试及常见问题的解决方案,帮助开发者高效应用这一前沿深度学习模型。

weixin_29281915的博客 330

两个大数相加(Java)

题目 两个大数相加 题目描述 两个大数相加。 1、是整数; 2、两个数无限大,long都装不下; 3、不能用BigInteger; 4、不能用任何包装类提供的运算方法; 5、两个数都是以字符串的方式提供。 思路 * 字符串逐位相加,需要进位则进位处理,考虑两个问题: * 1、char怎么转换为integer, 减去'0'即可 * 2、怎么处理对应位相加?反转字符串相加,正确处理进位即可,...

聚沙成塔 1万+

ModbusRTU串口读写报文解析

解析MODBUS报文的格式,讨论异常状态、读多个寄存器与写多个寄存器

Serendipitor的博客 9212

【2021最新版】Dubbo面试题总结(40道题含答案解析)

文章目录1、为什么要用Dubbo?2、Dubbo的整体架构设计有哪些分层?3、默认使用的是什么通信框架,还有别的选择吗?4、服务调用是阻塞的吗?5、一般使用什么注册中心?还有别的选择吗?6、默认使用什么序列化框架,你知道的还有哪些?7、服务提供者能实现失效踢出是什么原理?8、服务上线怎么不影响旧版本?9、如何解决服务调用链过长的问题?10、说说核心的配置有哪些?11、Dubbo推荐用什么协议?12、同一个服务多个注册的情况下可以直连某一个服务吗?13、画一画服务注册与发现的流程图?14、Dubbo集群容错有

程序媛小琬的博客 1万+

Java解决两个大数相加(简单又高效)

两个大数相加 public String sum(String s1,String s2){ char[] char1 = s1.toCharArray(); char[] char2 = s2.toCharArray(); int flag=0;//记录进位 int i=char1.length,j=char2.length;//记录两个长度 当索引index StringBuilder sb=new Str

快乐学习50年 2364

第十篇|网络子系统 ②——无损以太网、PFC/ECN、DCQCN 与拥塞可视化

网络部分了解了解

qq_37535542的博客 1877

JAVA实现两个大数相加

public class BigIntAdd { private int[] array;//声明一个数组 //计算大数相加的函数 public static String bigAdd(BigIntAdd fisrtNum, BigIntAdd secondNum) { String result = ""; boolean falg = false;//判

静水流深 8032

CMN-700组件全解析:从XP路由器到HN-F主节点的实战配置指南

本文深入解析Arm CMN-700片上网络IP的核心组件与实战配置。重点剖析了XP网格路由器的拓扑规划与CHI通道管理,以及HN-F全一致性主节点在维护缓存一致性、管理SLC和地址映射中的关键作用。通过一个12×12网格的配置案例,为硬件工程师提供了从组件布局、地址映射到性能调优的系统级设计指南。

weixin_29313423的博客 291

直流无刷电机FOC控制算法 理论到实践 —— 实践

关于直流无刷电机FOC控制算法的理论章节,本人已经在前两章进行过详细说明,大家可以自行进行阅读,请务必了解过理论之后再来学习如何具体进行实现。直流无刷电机FOC控制算法 理论到实践 —— 理论(一)直流无刷电机FOC控制算法 理论到实践 —— 理论(二)本章节主要讨论采用MCU微控制器如何具体实现直流无刷电机的FOC控制。

爱出名的狗腿子 1万+

JAVA 实现精确的加、减、乘、除、运算

import java.math.BigDecimal; public class Arith { //默认除法运算精度 private static final int DEF_DIV_SCALE = 10; //提供精确的加法运算 public static double add(double v1, double v2) { BigDecimal b1 = BigDecimal.valueOf(v1); BigDecimal b2 = BigDecimal.valueOf...

6002

【OCPP】ocpp1.6协议3.3章节:功能配置文件及接口

Smart Charging Profile中定义了4个接口请求,即GetCompositeSchedule、ClearChargingProfile、SetChargingProfile和ClearCache等。Smart Charging: 包含智能充电相关的功能,如计划充电,报告充电计划,并改变充电速度。Core: 包含电动汽车充电相关的基础功能,如启动和停止充电,更改充电配置,报告充电状态等。Reservation: 包含预约服务相关的功能,如创建,取消和更改预约。

qq_53871375的博客 2173

C++高精度【C++|AcWing|算法】

C++高精度

m0_62327743的博客 185

Docker - 基本概念、与虚拟机的区别、架构、镜像操作、容器操作、数据卷挂载

p :将宿主机端口与容器端口映射,冒号左侧是宿主机端口,右侧是容器端口(配置映射是因为用户只能通过 http 请求访问到服务器,不能直接访问到对应的容器,因此需要服务器端口与容器端口建立映射关系)这里我们有两种启动 redis 的方式,第一种是直接启动 redis ,第二种是以 AOF 持久化的方式启动容器(--appendonly yes),如下图。如果需要持续查看日志信息可以添加 -f 参数,例如:docker logs -f mn ,这里 mn 是自定义容器名称, ctrl + c 可以停止跟踪。

CYK_byte的博客 1万+

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

高精度运算

高精度 1. 高精度原理 原理 利用vector对很大的数据(long long没法存下,一般用string存储)进行计算,可以分为高精度加减乘除,对于给定A、B(位数最多为10610^6106),给定b(b<=1000),求:(1)A+B;(2)A-B;(3)A*b;(4)A/b。 具体每个细节可以参考下面的题目。 2. AcWing上的高精度题目 AcWing 791. 高精度加法 问题描述 问题链接:AcWing 791. 高精度加法 分析 首先就要考虑数据

weixin_42638946的博客 829

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

高精度算法

高精度运算是指对超出基本数据类型范围的大整数进行运算(例如超过long范围的整数)。在Java中,可以通过字符串或数组来表示大整数,并手动实现加法、减法、乘法和除法。

2301_80215285的博客 481

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

关于大整数的加减乘除求余运算 java

自己用java 实现了大字符串整数的加减乘除和求余运算, 加减法的算法是模拟手工笔算的计算过程, 除法就是从最高位不停的减操作, 乘法的算法 :遍历一个数的各个位数以及他所在位置,另一个数根据这个数的位置末位添n个0,然后累加次数为这个位置数的数值 原创代码如下: public class Demo6 { public static void main(String[]ar...

weixin_30468137的博客 119

超大整数的加减乘除计算方法

目录   问题由来及解决思路: 超大整数的加法运算: 超大整数的减法运算: 超大整数的乘法运算: 超大整数的除法运算: 问题由来及解决思路: 在任何一种编程语言中,基本类型的数据都是具有一定的范围的。例如:在Java中长整型long占有8个字节,即64位。那么当两个数足够大,大到无法用long来定义的时候,如何进行他们的加减乘除这种简单的运算? 在编程语言中用于存储超级大的数据我...

My_name_is_ZwZ的博客 7119

一文读懂『高精度整数加法/减法/乘法/除法』(含算法模板)

一文读懂『高精度整数加法/减法/乘法/除法』(含算法模板)

qq_40430360的博客 1308

【高精度】大整数类实现一 [数组模拟]【模板】

文章目录1. 大整数类的存储2. 大整数类的比较和打印3. 大整数类的四则运算1. 高精度加法2. 高精度减法3. 高精度和低精度的乘法★★★ 4. 高精度乘法5. 高精度与低精度的除法6. 高精度除法4. 题目和总结和预告 一道A+BA + BA+B的题目,都在intintint范围内,没有难度。但是如果 AAA 和 BBB 都是有 100010001000 位的整数,就不能够直接使用已有的数据...

memcpy0的博客 911

java 进行超大整数的加减乘除四则运算(自己实现的BigInteger)

public class MyBigInteger { private StringBuffer data; public MyBigInteger(){ data = new StringBuffer("0"); } public MyBigInteger(String str){ data = new StringBuffer(str); } public My...

a823837282的博客 2446

位运算 实现加法 详解

位运算 实现加法 详解

T_Y_F_的博客 2003

【C++】详解高精度加法、高精度减法、高精度乘法、高精度除法代码

在进行大整数运算中,因为在C++/C中整数最大也就是unsigned long long也就才(1e19+8e18)位,如果要几百位的相加减就不行了,所以就要用高精度了,这里只在C++/C上使用有价值,在例如python、Java语言上无需写此算法,python可以无限大,Java里有相关库可以引入。

AiryCloud的博客 4677

[Java]模拟实现大整数类

一、解决问题:     实现长整数类BigInt, 支持任意精度的整数及其运算. 二、数据结构: public class BigInt { private int length; private boolean pn; //positiveor negative. + is true, - is false private

CristianoJason的博客 3434

第一章 基础算法 大整数计算

1、算法思路 对于java(有大整数类)和python来说,没有大整数计算的问题,对于c++来说,当一个整数的位数过大就会无法计算。 这里我们定义: 一个大整数,其长度可以在10610^6106,用大写字母表示 一个小整数,其数值小于10910^9109,用小写字母表示。 我们讨论四种类型的大整数计算 A + B A - B A* a A / a 1. 数据存储 使用数组存储大整数,将低位放在数组的开始,将高位放在后面,方便进位 2. 运算 其实就是模拟小学手算的过程。例如对于加法 119 + 11

刘胖仔学后端 432
上一篇: 自己常用的Sublime Text3快捷键列表
下一篇: 八皇后问题的递归解法(最易理解的版本)
lhever_
博客等级 码龄14年 213粉丝 130原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值