精华内容
下载资源
问答
  • 大数相加相减相乘

    2015-07-01 11:12:00
    题目:个非常大的数字相乘(相加相减) 该题目在java中可以使用BigInteger类中的方法来实现。否则的话可以使用如下方式来实现。 大数相乘:假设有A和B个大数,位数分别为a和b。根据我们平常手动计算乘法的...

    题目:两个非常大的数字相乘(相加,相减)

           该题目在java中可以使用BigInteger类中的方法来实现。否则的话可以使用如下方式来实现。

           大数相乘:假设有A和B两个大数,位数分别为a和b。根据我们平常手动计算乘法的方式可以看出,最终的结果的位数c一定小于等于a+b,我们可以举一个简单的例子来说明,99*999=98901,最终结果是五位(a+b)。下面我们根据98*765 = 74970来看看结果中的每一位是怎么得来的,最后一位0是A的最后一位8和B的最后一位5的乘机除10取余得到的,结果的倒数第二位7是A的倒数第二位9和B的最后一位5的乘积45与A的最后一位8和B的倒数第二位6的乘积48之和93然后加上上一位的进位4得到97然后在除10取余得到的7……依次进行下去就可以得到最终结果。

            下面来总结一下规律:A中的第i位与B的第j位之积最终会存放到结果的第i+j位中(i和j都是从后往前数),所以我们可以先进行结果中每一位的计算,完成所有计算后在进行进位的计算。为了将i和j从0开始计算,我们先将字符串A和B进行逆转,然后在进行计算的时候就可以从0开始了。具体程序如下:

     

    [java] view plaincopy
     
    1. public static void bigNumberSimpleMulti(String f, String s) {  
    2.         System.out.print("乘法:\n" + f + "*" + s + "=");  
    3.         // 获取首字符,判断是否是符号位  
    4.         char signA = f.charAt(0);  
    5.         char signB = s.charAt(0);  
    6.         char sign = '+';  
    7.         if (signA == '+' || signA == '-') {  
    8.             sign = signA;  
    9.             f = f.substring(1);  
    10.         }  
    11.         if (signB == '+' || signB == '-') {  
    12.             if (sign == signB) {  
    13.                 sign = '+';  
    14.             } else {  
    15.                 sign = '-';  
    16.             }  
    17.             s = s.substring(1);  
    18.         }  
    19.         // 将大数翻转并转换成字符数组  
    20.         char[] a = new StringBuffer(f).reverse().toString().toCharArray();  
    21.         char[] b = new StringBuffer(s).reverse().toString().toCharArray();  
    22.         int lenA = a.length;  
    23.         int lenB = b.length;  
    24.         // 计算最终的最大长度  
    25.         int len = lenA + lenB;  
    26.         int[] result = new int[len];  
    27.         // 计算结果集合  
    28.         for (int i = 0; i < a.length; i++) {  
    29.             for (int j = 0; j < b.length; j++) {  
    30.                 result[i + j] += (int) (a[i] - '0') * (int) (b[j] - '0');  
    31.             }  
    32.         }  
    33.         // 处理结果集合,如果是大于10的就向前一位进位,本身进行除10取余  
    34.         for (int i = 0; i < result.length; i++) {  
    35.             if (result[i] > 10) {  
    36.                 result[i + 1] += result[i] / 10;  
    37.                 result[i] %= 10;  
    38.             }  
    39.         }  
    40.         StringBuffer sb = new StringBuffer();  
    41.         // 该字段用于标识是否有前置0,如果是0就不需要打印或者存储下来  
    42.         boolean flag = true;  
    43.         for (int i = len - 1; i >= 0; i--) {  
    44.             if (result[i] == 0 && flag) {  
    45.                 continue;  
    46.             } else {  
    47.                 flag = false;  
    48.             }  
    49.             sb.append(result[i]);  
    50.         }  
    51.         if (!sb.toString().equals("")) {  
    52.             if (sign == '-') {  
    53.                 sb.insert(0, sign);  
    54.             }  
    55.         } else {  
    56.             sb.append(0);  
    57.         }  
    58.         // 返回最终结果  
    59.         System.out.println(sb.toString());  
    60.     }  

     

            大数相加:和相乘是类似的,不同的地方只是result结果集的长度,其值为较长字符串的长度加一。具体代码如下:

     

    [java] view plaincopy
     
    1. public String bigNumberAdd(String f, String s) {  
    2.         //翻转两个字符串,并转换成数组  
    3.         char[] a = new StringBuffer(f).reverse().toString().toCharArray();  
    4.         char[] b = new StringBuffer(s).reverse().toString().toCharArray();  
    5.         int lenA = a.length;  
    6.         int lenB = b.length;  
    7.         //计算两个长字符串中的较长字符串的长度  
    8.         int len = lenA > lenB ? lenA : lenB;  
    9.         int[] result = new int[len + 1];  
    10.         for (int i = 0; i < len + 1; i++) {  
    11.             //如果当前的i超过了其中的一个,就用0代替,和另一个字符数组中的数字相加  
    12.             int aint = i < lenA ? (a[i] - '0') : 0;  
    13.             int bint = i < lenB ? (b[i] - '0') : 0;  
    14.             result[i] = aint + bint;  
    15.         }  
    16.         //处理结果集合,如果大于10的就向前一位进位,本身进行除10取余  
    17.         for (int i = 0; i < result.length; i++) {  
    18.             if (result[i] > 10) {  
    19.                 result[i + 1] += result[i] / 10;  
    20.                 result[i] %= 10;  
    21.             }  
    22.         }  
    23.         StringBuffer sb = new StringBuffer();  
    24.         //该字段用于标识是否有前置0,如果有就不要存储  
    25.         boolean flag = true;  
    26.         for (int i = len; i >= 0; i--) {  
    27.             if (result[i] == 0 && flag) {  
    28.                 continue;  
    29.             } else {  
    30.                 flag = false;  
    31.             }  
    32.             sb.append(result[i]);  
    33.         }  
    34.         return sb.toString();  
    35.     }  

            大数相减:大数相减和大数相加类似,只是需要判断正负

     

    [java] view plaincopy
     
    1. public static String bigNumberSub(String f, String s) {  
    2.         System.out.print("减法:" + f + "-" + s + "=");  
    3.         // 将字符串翻转并转换成字符数组  
    4.         char[] a = new StringBuffer(f).reverse().toString().toCharArray();  
    5.         char[] b = new StringBuffer(s).reverse().toString().toCharArray();  
    6.         int lenA = a.length;  
    7.         int lenB = b.length;  
    8.         // 找到最大长度  
    9.         int len = lenA > lenB ? lenA : lenB;  
    10.         int[] result = new int[len];  
    11.         // 表示结果的正负  
    12.         char sign = '+';  
    13.         // 判断最终结果的正负  
    14.         if (lenA < lenB) {  
    15.             sign = '-';  
    16.         } else if (lenA == lenB) {  
    17.             int i = lenA - 1;  
    18.             while (i > 0 && a[i] == b[i]) {  
    19.                 i--;  
    20.             }  
    21.             if (a[i] < b[i]) {  
    22.                 sign = '-';  
    23.             }  
    24.         }  
    25.         // 计算结果集,如果最终结果为正,那么就a-b否则的话就b-a  
    26.         for (int i = 0; i < len; i++) {  
    27.             int aint = i < lenA ? (a[i] - '0') : 0;  
    28.             int bint = i < lenB ? (b[i] - '0') : 0;  
    29.             if (sign == '+') {  
    30.                 result[i] = aint - bint;  
    31.             } else {  
    32.                 result[i] = bint - aint;  
    33.             }  
    34.         }  
    35.         // 如果结果集合中的某一位小于零,那么就向前一位借一,然后将本位加上10。其实就相当于借位做减法  
    36.         for (int i = 0; i < result.length - 1; i++) {  
    37.             if (result[i] < 0) {  
    38.                 result[i + 1] -= 1;  
    39.                 result[i] += 10;  
    40.             }  
    41.         }  
    42.   
    43.         StringBuffer sb = new StringBuffer();  
    44.         // 如果最终结果为负值,就将负号放在最前面,正号则不需要  
    45.         if (sign == '-') {  
    46.             sb.append('-');  
    47.         }  
    48.         // 判断是否有前置0  
    49.         boolean flag = true;  
    50.         for (int i = len - 1; i >= 0; i--) {  
    51.             if (result[i] == 0 && flag) {  
    52.                 continue;  
    53.             } else {  
    54.                 flag = false;  
    55.             }  
    56.             sb.append(result[i]);  
    57.         }  
    58.         // 如果最终结果集合中没有值,就说明是两值相等,最终返回0  
    59.         if (sb.toString().equals("")) {  
    60.             sb.append("0");  
    61.         }  
    62.         // 返回值  
    63.         System.out.println(sb.toString());  
    64.         return sb.toString();  
    65.     }  

     

            在上述的各中计算过程中有几点需要说明:大数相加的时候没有判断数字的正负,如果都是正数,那么就可以按照正数相加来计算,如果是一正一负可以转换成大整数相减,两个负数可以先保存符号,然后相加。

    转载于:https://www.cnblogs.com/berylqliu/p/6261500.html

    展开全文
  • 大数相乘假设有A和B个大数,位数分别为a和b。根据我们平常手动计算乘法的方式可以看出,最终的结果的位数c一定小于等于a+b,我们可以举一个简单的例子来说明,99999=98901,最终结果是五位(a+b)。下面我们根据...

    大数相乘

    假设有A和B两个大数,位数分别为a和b。根据我们平常手动计算乘法的方式可以看出,最终的结果的位数c一定小于等于a+b,我们可以举一个简单的例子来说明,99999=98901,最终结果是五位(a+b)。下面我们根据98765 = 74970来看看结果中的每一位是怎么得来的,最后一位0是A的最后一位8和B的最后一位5的乘机除10取余得到的,结果的倒数第二位7是A的倒数第二位9和B的最后一位5的乘积45与A的最后一位8和B的倒数第二位6的乘积48之和93然后加上上一位的进位4得到97然后在除10取余得到的7……依次进行下去就可以得到最终结果。

    下面来总结一下规律:

    A中的第i位与B的第j位之积最终会存放到结果的第i+j位中(i和j都是从后往前数),所以我们可以先进行结果中每一位的计算,完成所有计算后在进行进位的计算。为了将i和j从0开始计算,我们先将字符串A和B进行逆转,然后在进行计算的时候就可以从0开始了。具体程序如下:

    public static void bigNumberSimpleMulti(String f, String s) {

    System.out.print("乘法:\n" + f + "*" + s + "=");

    // 获取首字符,判断是否是符号位

    char signA = f.charAt(0);

    char signB = s.charAt(0);

    char sign = '+';

    if (signA == '+' || signA == '-') {

    sign = signA;

    f = f.substring(1);

    }

    if (signB == '+' || signB == '-') {

    if (sign == signB) {

    sign = '+';

    } else {

    sign = '-';

    }

    s = s.substring(1);

    }

    // 将大数翻转并转换成字符数组

    char[] a = new StringBuilder(f).reverse().toString().toCharArray();

    char[] b = new StringBuilder(s).reverse().toString().toCharArray();

    int lenA = a.length;

    int lenB = b.length;

    // 计算最终的最大长度

    int len = lenA + lenB;

    int[] result = new int[len];

    // 计算结果集合

    for (int i = 0; i < a.length; i++) {

    for (int j = 0; j < b.length; j++) {

    result[i + j] += (int) (a[i] - '0') * (int) (b[j] - '0');

    }

    }

    // 处理结果集合,如果是大于10的就向前一位进位,本身进行除10取余

    for (int i = 0; i < result.length; i++) {

    if (result[i] > 10) {

    result[i + 1] += result[i] / 10;

    result[i] %= 10;

    }

    }

    StringBuffer sb = new StringBuffer();

    // 该字段用于标识是否有前置0,如果是0就不需要打印或者存储下来

    boolean flag = true;

    for (int i = len - 1; i >= 0; i--) {

    if (result[i] == 0 && flag) {

    continue;

    } else {

    flag = false;

    }

    sb.append(result[i]);

    }

    if (!sb.toString().equals("")) {

    if (sign == '-') {

    sb.insert(0, sign);

    }

    } else {

    sb.append(0);

    }

    // 返回最终结果

    System.out.println(sb.toString());

    }

    大数相加

    和相乘是类似的,不同的地方只是result结果集的长度,其值为较长字符串的长度加一。具体代码如下:

    public String bigNumberAdd(String f, String s) {

    //翻转两个字符串,并转换成数组

    char[] a = new StringBuilder(f).reverse().toString().toCharArray();

    char[] b = new StringBuilder(s).reverse().toString().toCharArray();

    int lenA = a.length;

    int lenB = b.length;

    //计算两个长字符串中的较长字符串的长度

    int len = lenA > lenB ? lenA : lenB;

    int[] result = new int[len + 1];

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

    //如果当前的i超过了其中的一个,就用0代替,和另一个字符数组中的数字相加

    int aint = i < lenA ? (a[i] - '0') : 0;

    int bint = i < lenB ? (b[i] - '0') : 0;

    result[i] = aint + bint;

    }

    //处理结果集合,如果大于10的就向前一位进位,本身进行除10取余

    for (int i = 0; i < result.length; i++) {

    if (result[i] > 10) {

    result[i + 1] += result[i] / 10;

    result[i] %= 10;

    }

    }

    StringBuilder sb = new StringBuilder();

    //该字段用于标识是否有前置0,如果有就不要存储

    boolean flag = true;

    for (int i = len; i >= 0; i--) {

    if (result[i] == 0 && flag) {

    continue;

    } else {

    flag = false;

    }

    sb.append(result[i]);

    }

    return sb.toString();

    }

    大数相减

    大数相减和大数相加类似,只是需要判断正负。

    public static String bigNumberSub(String f, String s) {

    System.out.print("减法:" + f + "-" + s + "=");

    // 将字符串翻转并转换成字符数组

    char[] a = new StringBuilder(f).reverse().toString().toCharArray();

    char[] b = new StringBuilder(s).reverse().toString().toCharArray();

    int lenA = a.length;

    int lenB = b.length;

    // 找到最大长度

    int len = lenA > lenB ? lenA : lenB;

    int[] result = new int[len];

    // 表示结果的正负

    char sign = '+';

    // 判断最终结果的正负

    if (lenA < lenB) {

    sign = '-';

    } else if (lenA == lenB) {

    int i = lenA - 1;

    while (i > 0 && a[i] == b[i]) {

    i--;

    }

    if (a[i] < b[i]) {

    sign = '-';

    }

    }

    // 计算结果集,如果最终结果为正,那么就a-b否则的话就b-a

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

    int aint = i < lenA ? (a[i] - '0') : 0;

    int bint = i < lenB ? (b[i] - '0') : 0;

    if (sign == '+') {

    result[i] = aint - bint;

    } else {

    result[i] = bint - aint;

    }

    }

    // 如果结果集合中的某一位小于零,那么就向前一位借一,然后将本位加上10。其实就相当于借位做减法

    for (int i = 0; i < result.length - 1; i++) {

    if (result[i] < 0) {

    result[i + 1] -= 1;

    result[i] += 10;

    }

    }

    StringBuilder sb = new StringBuilder();

    // 如果最终结果为负值,就将负号放在最前面,正号则不需要

    if (sign == '-') {

    sb.append('-');

    }

    // 判断是否有前置0

    boolean flag = true;

    for (int i = len - 1; i >= 0; i--) {

    if (result[i] == 0 && flag) {

    continue;

    } else {

    flag = false;

    }

    sb.append(result[i]);

    }

    // 如果最终结果集合中没有值,就说明是两值相等,最终返回0

    if (sb.toString().equals("")) {

    sb.append("0");

    }

    // 返回值

    System.out.println(sb.toString());

    return sb.toString();

    }

    展开全文
  • 题目:个非常大的数字相乘(相加相减)  该题目在java中可以使用BigInteger类中的方法来实现。否则的话可以使用如下方式来实现。  大数相乘:假设有A和B个大数,位数分别为a和b。根据我们平常手动计算...

    转载自lichong_87


    题目:两个非常大的数字相乘(相加,相减)

           该题目在java中可以使用BigInteger类中的方法来实现。否则的话可以使用如下方式来实现。

           大数相乘:假设有A和B两个大数,位数分别为a和b。根据我们平常手动计算乘法的方式可以看出,最终的结果的位数c一定小于等于a+b,我们可以举一个简单的例子来说明,99*999=98901,最终结果是五位(a+b)。下面我们根据98*765 = 74970来看看结果中的每一位是怎么得来的,最后一位0是A的最后一位8和B的最后一位5的乘机除10取余得到的,结果的倒数第二位7是A的倒数第二位9和B的最后一位5的乘积45与A的最后一位8和B的倒数第二位6的乘积48之和93然后加上上一位的进位4得到97然后在除10取余得到的7……依次进行下去就可以得到最终结果。

            下面来总结一下规律:A中的第i位与B的第j位之积最终会存放到结果的第i+j位中(i和j都是从后往前数),所以我们可以先进行结果中每一位的计算,完成所有计算后在进行进位的计算。为了将i和j从0开始计算,我们先将字符串A和B进行逆转,然后在进行计算的时候就可以从0开始了。具体程序如下:

    [java] view plain copy
    1. public static void bigNumberSimpleMulti(String f, String s) {  
    2.         System.out.print("乘法:\n" + f + "*" + s + "=");  
    3.         // 获取首字符,判断是否是符号位  
    4.         char signA = f.charAt(0);  
    5.         char signB = s.charAt(0);  
    6.         char sign = '+';  
    7.         if (signA == '+' || signA == '-') {  
    8.             sign = signA;  
    9.             f = f.substring(1);  
    10.         }  
    11.         if (signB == '+' || signB == '-') {  
    12.             if (sign == signB) {  
    13.                 sign = '+';  
    14.             } else {  
    15.                 sign = '-';  
    16.             }  
    17.             s = s.substring(1);  
    18.         }  
    19.         // 将大数翻转并转换成字符数组  
    20.         char[] a = new StringBuffer(f).reverse().toString().toCharArray();  
    21.         char[] b = new StringBuffer(s).reverse().toString().toCharArray();  
    22.         int lenA = a.length;  
    23.         int lenB = b.length;  
    24.         // 计算最终的最大长度  
    25.         int len = lenA + lenB;  
    26.         int[] result = new int[len];  
    27.         // 计算结果集合  
    28.         for (int i = 0; i < a.length; i++) {  
    29.             for (int j = 0; j < b.length; j++) {  
    30.                 result[i + j] += (int) (a[i] - '0') * (int) (b[j] - '0');  
    31.             }  
    32.         }  
    33.         // 处理结果集合,如果是大于10的就向前一位进位,本身进行除10取余  
    34.         for (int i = 0; i < result.length; i++) {  
    35.             if (result[i] > 10) {  
    36.                 result[i + 1] += result[i] / 10;  
    37.                 result[i] %= 10;  
    38.             }  
    39.         }  
    40.         StringBuffer sb = new StringBuffer();  
    41.         // 该字段用于标识是否有前置0,如果是0就不需要打印或者存储下来  
    42.         boolean flag = true;  
    43.         for (int i = len - 1; i >= 0; i--) {  
    44.             if (result[i] == 0 && flag) {  
    45.                 continue;  
    46.             } else {  
    47.                 flag = false;  
    48.             }  
    49.             sb.append(result[i]);  
    50.         }  
    51.         if (!sb.toString().equals("")) {  
    52.             if (sign == '-') {  
    53.                 sb.insert(0, sign);  
    54.             }  
    55.         } else {  
    56.             sb.append(0);  
    57.         }  
    58.         // 返回最终结果  
    59.         System.out.println(sb.toString());  
    60.     }  

            大数相加:和相乘是类似的,不同的地方只是result结果集的长度,其值为较长字符串的长度加一。具体代码如下:

    [java] view plain copy
    1. public String bigNumberAdd(String f, String s) {  
    2.         //翻转两个字符串,并转换成数组  
    3.         char[] a = new StringBuffer(f).reverse().toString().toCharArray();  
    4.         char[] b = new StringBuffer(s).reverse().toString().toCharArray();  
    5.         int lenA = a.length;  
    6.         int lenB = b.length;  
    7.         //计算两个长字符串中的较长字符串的长度  
    8.         int len = lenA > lenB ? lenA : lenB;  
    9.         int[] result = new int[len + 1];  
    10.         for (int i = 0; i < len + 1; i++) {  
    11.             //如果当前的i超过了其中的一个,就用0代替,和另一个字符数组中的数字相加  
    12.             int aint = i < lenA ? (a[i] - '0') : 0;  
    13.             int bint = i < lenB ? (b[i] - '0') : 0;  
    14.             result[i] = aint + bint;  
    15.         }  
    16.         //处理结果集合,如果大于10的就向前一位进位,本身进行除10取余  
    17.         for (int i = 0; i < result.length; i++) {  
    18.             if (result[i] > 10) {  
    19.                 result[i + 1] += result[i] / 10;  
    20.                 result[i] %= 10;  
    21.             }  
    22.         }  
    23.         StringBuffer sb = new StringBuffer();  
    24.         //该字段用于标识是否有前置0,如果有就不要存储  
    25.         boolean flag = true;  
    26.         for (int i = len; i >= 0; i--) {  
    27.             if (result[i] == 0 && flag) {  
    28.                 continue;  
    29.             } else {  
    30.                 flag = false;  
    31.             }  
    32.             sb.append(result[i]);  
    33.         }  
    34.         return sb.toString();  
    35.     }  
            大数相减:大数相减和大数相加类似,只是需要判断正负

    [java] view plain copy
    1. public static String bigNumberSub(String f, String s) {  
    2.         System.out.print("减法:" + f + "-" + s + "=");  
    3.         // 将字符串翻转并转换成字符数组  
    4.         char[] a = new StringBuffer(f).reverse().toString().toCharArray();  
    5.         char[] b = new StringBuffer(s).reverse().toString().toCharArray();  
    6.         int lenA = a.length;  
    7.         int lenB = b.length;  
    8.         // 找到最大长度  
    9.         int len = lenA > lenB ? lenA : lenB;  
    10.         int[] result = new int[len];  
    11.         // 表示结果的正负  
    12.         char sign = '+';  
    13.         // 判断最终结果的正负  
    14.         if (lenA < lenB) {  
    15.             sign = '-';  
    16.         } else if (lenA == lenB) {  
    17.             int i = lenA - 1;  
    18.             while (i > 0 && a[i] == b[i]) {  
    19.                 i--;  
    20.             }  
    21.             if (a[i] < b[i]) {  
    22.                 sign = '-';  
    23.             }  
    24.         }  
    25.         // 计算结果集,如果最终结果为正,那么就a-b否则的话就b-a  
    26.         for (int i = 0; i < len; i++) {  
    27.             int aint = i < lenA ? (a[i] - '0') : 0;  
    28.             int bint = i < lenB ? (b[i] - '0') : 0;  
    29.             if (sign == '+') {  
    30.                 result[i] = aint - bint;  
    31.             } else {  
    32.                 result[i] = bint - aint;  
    33.             }  
    34.         }  
    35.         // 如果结果集合中的某一位小于零,那么就向前一位借一,然后将本位加上10。其实就相当于借位做减法  
    36.         for (int i = 0; i < result.length - 1; i++) {  
    37.             if (result[i] < 0) {  
    38.                 result[i + 1] -= 1;  
    39.                 result[i] += 10;  
    40.             }  
    41.         }  
    42.   
    43.         StringBuffer sb = new StringBuffer();  
    44.         // 如果最终结果为负值,就将负号放在最前面,正号则不需要  
    45.         if (sign == '-') {  
    46.             sb.append('-');  
    47.         }  
    48.         // 判断是否有前置0  
    49.         boolean flag = true;  
    50.         for (int i = len - 1; i >= 0; i--) {  
    51.             if (result[i] == 0 && flag) {  
    52.                 continue;  
    53.             } else {  
    54.                 flag = false;  
    55.             }  
    56.             sb.append(result[i]);  
    57.         }  
    58.         // 如果最终结果集合中没有值,就说明是两值相等,最终返回0  
    59.         if (sb.toString().equals("")) {  
    60.             sb.append("0");  
    61.         }  
    62.         // 返回值  
    63.         System.out.println(sb.toString());  
    64.         return sb.toString();  
    65.     }  

            在上述的各中计算过程中有几点需要说明:大数相加的时候没有判断数字的正负,如果都是正数,那么就可以按照正数相加来计算,如果是一正一负可以转换成大整数相减,两个负数可以先保存符号,然后相加。

    展开全文
  • 大数相乘:假设有A和B个大数,位数分别为a和b。根据我们平常手动计算乘法的方式可以看出,最终的结果的位数c一定小于等于a+b,我们可以举一个简单的例子来说明,99*999=98901,最终结果是五位(a+b)。下面我们...

    大数相乘:假设有A和B两个大数,位数分别为a和b。根据我们平常手动计算乘法的方式可以看出,最终的结果的位数c一定小于等于a+b,我们可以举一个简单的例子来说明,99*999=98901,最终结果是五位(a+b)。下面我们根据98*765 = 74970来看看结果中的每一位是怎么得来的,最后一位0是A的最后一位8和B的最后一位5的乘机除10取余得到的,结果的倒数第二位7是A的倒数第二位9和B的最后一位5的乘积45与A的最后一位8和B的倒数第二位6的乘积48之和93然后加上上一位的进位4得到97然后在除10取余得到的7……依次进行下去就可以得到最终结果。

      下面来总结一下规律:A中的第i位与B的第j位之积最终会存放到结果的第i+j位中(i和j都是从后往前数),所以我们可以先进行结果中每一位的计算,完成所有计算后在进行进位的计算。为了将i和j从0开始计算,我们先将字符串A和B进行逆转,然后在进行计算的时候就可以从0开始了。具体程序如下:

        public static String bigNumberMultiply(String num1, String num2) {
            char signA = num1.charAt(0);
            char signB = num2.charAt(0);
            char sign = '+';
            if (signA == '+' || signA == '-') {
                sign = signA;
                num1 = num1.substring(1);
            }
            if (signB == '+' || signB == '-') {
                if (sign == signB) {
                    sign = '+';
                } else {
                    sign = '-';
                }
                num2 = num2.substring(1);
            }
            // 将大数翻转并转换成字符数组
            char[] a = new StringBuffer(num1).reverse().toString().toCharArray();
            char[] b = new StringBuffer(num2).reverse().toString().toCharArray();
            int lenA = a.length;
            int lenB = b.length;
            // 计算最终的最大长度
            int len = lenA + lenB;
            int[] result = new int[len];
            // 计算结果集合
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < b.length; j++) {
                    result[i + j] += (int) (a[i] - '0') * (int) (b[j] - '0');
                }
            }
            // 处理结果集合,如果是大于10的就向前一位进位,本身进行除10取余
            for (int i = 0; i < result.length; i++) {
                if (result[i] > 10) {
                    result[i + 1] += result[i] / 10;
                    result[i] %= 10;
                }
            }
            StringBuffer sb = new StringBuffer();
            // 该字段用于标识是否有前置0,如果是0就不需要打印或者存储下来
            boolean flag = true;
            for (int i = len - 1; i >= 0; i--) {
                if (result[i] == 0 && flag) {
                    continue;
                } else {
                    flag = false;
                }
                sb.append(result[i]);
            }
            if (!sb.toString().equals("")) {
                if (sign == '-') {
                    sb.insert(0, sign);
                }
            } else {
                sb.append(0);
            }
            // 返回最终结果
            return sb.toString();
        }

    大数相加:和相乘是类似的,不同的地方只是result结果集的长度,其值为较长字符串的长度加一。具体代码如下:

        public static String bigNumberAdd(String num1, String num2) {
            // 翻转两个字符串,并转换成数组
            char[] A = new StringBuffer(num1).reverse().toString().toCharArray();
            char[] B = new StringBuffer(num2).reverse().toString().toCharArray();
            int lenA = A.length;
            int lenB = B.length;
            // 计算两个长字符串中的较长字符串的长度
            int len = lenA > lenB ? lenA : lenB;
            int[] result = new int[len + 1];
            for (int i = 0; i < len; i++) {
                int aint = i < lenA ? (A[i] - '0') : 0;
                int bint = i < lenB ? (B[i] - '0') : 0;
                result[i] = aint + bint;
            }
    
            // 处理结果集合,如果大于10的就向前一位进位,本身进行除10取余
            for (int i = 0; i < len; i++) {
                if (result[i] >= 10) {
                    result[i + 1] += result[i] / 10;
                    result[i] %= 10;
                }
            }
            StringBuffer sb = new StringBuffer();
            // 该字段用于标识是否有前置0,如果有就不要存储
            boolean flag = true;
            for (int i = len; i >= 0; i--) {
                if (result[i] == 0 && flag) {
                    continue;
                } else {
                    flag = false;
                }
                sb.append(result[i]);
            }
            return sb.toString();
        }

    大数相减:大数相减和大数相加类似,只是需要判断正负

        public static String bigNumberSub(String j, String k) {
            // 将字符串翻转并转换成字符数组
            char[] a = new StringBuffer(j).reverse().toString().toCharArray();
            char[] b = new StringBuffer(k).reverse().toString().toCharArray();
            int lenA = a.length;
            int lenB = b.length;
            // 找到最大长度
            int len = lenA > lenB ? lenA : lenB;
            int[] result = new int[len];
            // 表示结果的正负
            char sign = '+';
            // 判断最终结果的正负
            if (lenA < lenB) {
                sign = '-';
            } else if (lenA == lenB) {
                int i = lenA - 1;
                while (i > 0 && a[i] == b[i]) {
                    i--;
                }
                if (a[i] < b[i]) {
                    sign = '-';
                }
            }
            // 计算结果集,如果最终结果为正,那么就a-b否则的话就b-a
            for (int i = 0; i < len; i++) {
                int aint = i < lenA ? (a[i] - '0') : 0;
                int bint = i < lenB ? (b[i] - '0') : 0;
                if (sign == '+') {
                    result[i] = aint - bint;
                } else {
                    result[i] = bint - aint;
                }
            }
            // 如果结果集合中的某一位小于零,那么就向前一位借一,然后将本位加上10。其实就相当于借位做减法
            for (int i = 0; i < result.length - 1; i++) {
                if (result[i] < 0) {
                    result[i + 1] -= 1;
                    result[i] += 10;
                }
            }
    
            StringBuffer sb = new StringBuffer();
            // 如果最终结果为负值,就将负号放在最前面,正号则不需要
            if (sign == '-') {
                sb.append('-');
            }
            // 判断是否有前置0
            boolean flag = true;
            for (int i = len - 1; i >= 0; i--) {
                if (result[i] == 0 && flag) {
                    continue;
                } else {
                    flag = false;
                }
                sb.append(result[i]);
            }
            // 如果最终结果集合中没有值,就说明是两值相等,最终返回0
            if (sb.toString().equals("")) {
                sb.append("0");
            }
            // 返回值
            return sb.toString();
        }

     

    转载于:https://www.cnblogs.com/SaraMoring/p/5849545.html

    展开全文
  • 所谓大数相乘,就是指数字比较大,相乘的结果超出了基本类型的表示范围,所以这样的不能够直接做乘法运算。 假设有A和B个大数,位数分别为a和b。根据我们平常手动计算乘法的方式可以看出,最终的结果的位数c...
  • 题目:个非常大的数字相乘(相加相减) 该题目在java中可以使用BigInteger类中的方法来实现。否则的话可以使用如下方式来实现。 大数相乘:假设有A和B个大数,位数分别为a和b。根据我们平常手动计算乘法的...
  • 题目:个非常大的数字相乘(相加相减)  该题目在java中可以使用BigInteger类中的方法来实现。否则的话可以使用如下方式来实现。  大数相乘:假设有A和B个大数,位数分别为a和b。根据我们平常手动计算...
  • =head1->prev) //head0存的整数绝对值比head1大,即head0的节点大于或等于head1 { currptr=new LinkNode; currptr->data=(p->data)*m1+(q->data)*m2+s; //整数相加 if((m1*m2)>0) //如果符号相同 { ...
  • 定点的运算

    2020-03-07 18:32:52
    两个数相加时符号位也参与运算。两个数和的补码等于两个补码的和。 二、减法: 1.原码: 可按照原码的加法运算来。 2.补码: x-y的补码等于x加上负y的补码,根据补码的加法原则可以得到x-y的补码等于x的补码加上负y的...
  • 思路:先对n个数排序,然后用头尾个指针向中间扫,记录相加之和大于m的数量,最后用组合数相减即可。 #include #include #define N 20005 int s[N]; int n,m; int cmp(const void *a,const void *b){ return (*...
  • 算术运算符(1) + (加):两个对象相加(2) - (减):两个数相减,得到一个负数或者正数(3) * (乘):两个数相乘或者是返回一个被重复若干次的字符串(4) / (除):两数相除(5) % (取模):两数相除,返回除法的余数...
  • 设计一个智力开发软件,要求进行4则运算的测试,分别包括2个数的相加(可以设置个10以内的数相加、2个100以内的数相加)、相减(可以设置个10以内的数相减、2个100以内的数相减,注意可以设置结果是否允许为负)...
  • 设计一个智力开发软件,要求进行4则运算的测试,分别包括2个数的相加(可以设置个10以内的数相加、2个100以内的数相加)、相减(可以设置个10以内的数相减、2个100以内的数相减,注意可以设置结果是否允许为负)...
  • 矩阵

    2010-05-30 18:48:00
    定义:个矩阵相加等于把这个矩阵的对应元素相加。应注意,并非任何个矩阵都可以相加,只有当个矩阵具有相同的行数和相同的列时才能相加。 个矩阵相减等于把这个矩阵的对应元素相减。 乘法:一个与...
  • 题目大意:给你$n$个数,$m$个询问($n,m\...x$询问区间$[l,r]$内有没有数相加等于$x$ $3\;l\;r\;x$询问区间$[l,r]$内有没有个数相乘等于$x$ 注意,个数位置可以相同 题解:莫队。 1. 即询问区间...
  • + :两数相加 - :两数相减 * :两数相乘 / :两数相除 % :两数取余 全部符合数学规则 2.关系运算符 < : 大于 > : 小于 >= : 大于等于 <= : 小于等于 == : 常用于判断符号左右两边是否相等 != : 不等于 ...
  • 题意:有个数,把其中一个数分成个数,这个数的和等于原来的数(例如把5分成2和3),求这三个数相加相减能得到多少个数。 题记:把所有情况都枚举出来即可。 #include<iostream> #include<cmath>...
  • luogu-P3674

    2019-11-21 14:30:59
    题目大意:给出一个序列,然后给出一些区间,询问在这些区间中是否存在可以相加等于x,相减等于x,相乘等于x,如果有,那么我们就输出"hana",否则就输出"bi"。 解法:这里我们很容易的会想到莫队算法来记录...
  • ① +:个操作数相加 ② -:个操作数相减 ③ *:个操作数想乘 ④ /:个操作数相除(结果为带小数点的实数) ⑤ %:取余 ⑥ //:取商的整数部分(结果为整数) ⑦ **:(操作数1)的(操作数2)次方...
  • 有理数加减乘除混合运算知识点总结法则符号计算绝对值加法同号取相同的符号绝对值相加异号取绝对值大的符号绝对值相减减法减去一个数等于加上这个的相反乘法同号取正绝对值相乘异号取负除法同号取正绝对值相除异...
  • 运算符算数运算符序号符号描述实例1+加,个操作数相加6 + 3 输出结果92-减,个操作数相减6 - 3 输出结果33*乘,个操作数相乘6 * 3 输出结果184/除,个操作数相除6 / 3 输出结果25%取模,返回除法的余数6 % 4...
  • 2. -减,可以让数相减,活着定义负数。2-1等于1。 3.*乘,可以让个数字相乘,5*5等于25,*乘法也可以用在字符串上,可以使一个字符或者字符串重复若干次。 4./除,个数相除,做除法运算。 5.%取模...
  • 定点加减法运算原码加减法:同号:数值部分相加,结果的符号与加数符号相同。...运算规则:两个补码相加,符号位也参与运算,最终两个数和的补码等于两个数的补码之和。[X+Y]补= [X]补+[Y]补 任意两数的补码之和...
  • A中的元素可用小写字母加行列下标表示,如 矩阵加减法 个矩阵相加相减,需要满足个矩阵的列和行数一致。 加法交换律:A + B = B + A矩阵乘法 个矩阵A和B相乘,需要满足A的列数等于B的行数。 矩阵乘法很...
  • A中的元素可用小写字母加行列下标表示,如a1,2= 2, a2,2= 4矩阵加减法 个矩阵相加相减,需要满足个矩阵的列和行数一致。 加法交换律:A+B=B+A矩阵乘法 个矩阵A和B相乘,需要满足A的列数等于B的行数。 ...
  • 简单来说,矩阵是充满数字的表格。  A和B是个典型的...个矩阵相加相减,需要满足个矩阵的列和行数一致。  加法交换律:A+B=B+A 矩阵乘法  个矩阵A和B相乘,需要满足A的列数等于B的行数。  ...

空空如也

空空如也

1 2 3
收藏数 45
精华内容 18
关键字:

两数相加等于两数相减