大数减法(A - B Problem Plus)问题

解题思路

flagA为0表示A为正整数,为-1表示A为负整数;

flagB为0表示B为正整数,为2表示B为负整数;

而 flag = flagA + flagB。

1.当 flag == 0 表示数A为正整数,数B为正整数

则A - B 可能是正整数或负整数。

2.当 flag == 1 表示数A为负整数,数B为负整数

则A - B 可能是正整数或负整数。

因为差值可能是正整数,也可能是负整数,所以采用如下方法:

(1) 先判断被减数和减数哪⼀个位数⻓。若被减数位数⻓是正常的减法;若减数位数⻓,则⽤被减数减去减数,最后还要加上负号。

(2) 当两数位数⻓度相等时,最好⽐较哪⼀个数⼤,否则负号处理会很繁琐。处理每⼀项时,如果前⼀位相减有借位,就先减去上⼀位的借位,⽆则不减,再去判断是否能够减开被减数,如果减不开,就要借位后再去减,同时置借位为1,否则置借位为0。

3.当 flag == -1 表示数A为负整数,数B为正整数

则A - B 一定为负整数。

由于计算时数字去掉了负号,可以则先相加,最后加上负号。

如-3 - 18,是3 + 18 = 21,再加上负号,即-21。

4.当 flag == 2 表示数A为正整数,数B为负整数

则A - B 一定为正整数。

由于计算时数字去掉了负号,则可以直接相加。

如3 - (-18),是3 + 18 = 21。

样例输入1
-3 98
样例输出1:
-3 - 98 = -101
样例输入2:
-3 -98
样例输出2:
-3 - (-98) = 95
样例输入3:
3 98
样例输出3:
3 - 98 = -95

5.代码实现


#include<stdio.h>
#include<string.h>
#define NUM_MAX 1000                // 大数的最大位数

/*
 大数减法
 参数:
 numA为第一个大数
 numB为第二个大数
 difference保存相减的结果  即:numA - numB = difference
 lenA为char指针的长度
 lenB为char指针的长度
 flag为-1表示A为负整数、B为正整数,为0表示A与B均为正整数,
 为1表示A与B均为负整数,为2表示A为正整数、B为负整数
 返回值:返回数组difference的有效长度,即计算结果的位数
 */

void Minus(char* numA, char* numB, int* difference, int lenA, int lenB, int flag)
{
    char* temp = NULL;
    int symbol = 0;                             // symbol为0表示计算结果是正整数,为1表示结果是负整数
    int tempFlag = 0;                           // 临时标志
    
    int maxLen = lenA > lenB ? lenA : lenB;     // 取字符串numA与numB的最大长度
    
    // flag == 0 表示数A为正整数,数B为正整数,则A - B 可能是正整数或负整数
    // flag == 1 表示数A为负整数,数B为负整数,则A - B 可能是正整数或负整数
    if (flag == 0 || flag == 1)
    {
        // 如果被减数位数小于减数
        if (lenA < lenB)
        {
            tempFlag = 1;
            // 交换两数,方便计算
            temp = numA;
            numA = numB;
            numB = temp;
            
            maxLen = lenA;
            lenA = lenB;
            lenB = maxLen;
        }
        else if (lenA == lenB)                  // 如果被减数位数等于减数的位数
        {
            for (int i = 0; i < lenA; i++)
            {
                if (numA[i] == numB[i])
                {
                    continue;
                }
                else if (numA[i] > numB[i])
                {
                    tempFlag = 0;
                    break;
                }
                else
                {
                    tempFlag = 1;
                    temp = numA;
                    numA = numB;
                    numB = temp;
                    break;
                }
            }
        }
    }
    
    
    // 数A与B均为正整数
    if (flag == 0)
    {
        if (tempFlag == 0)
        {
            symbol = 0;
        }
        else
        {
            symbol = 1;
        }
    }
    else if (flag == 1)                         // 数A与B均为负整数
    {
        if (tempFlag == 0)
        {
            symbol = 1;
        }
        else
        {
            symbol = 0;
        }
    }
    else if (flag == -1)                        // 数A为负整数,数B为正整数,则A - B 一定为负整数
    {
        symbol = 1;
    }
    else                                        // flag == 2表示数A为正整数,数B为负整数,则A - B 一定为正整数
    {
        symbol = 0;
    }
    
    int l = 0;
    int k = 0;
    int array[NUM_MAX] = {0};
    
    // 将numA字符数组的字符数字转换为整型数字,且逆向保存到整型数组sum中,即低位在前,高位在后
    for (int i = lenA - 1; i >= 0; i--)
    {
        difference[k++] = numA[i] - '0';               // 可以使用'9' - '0' = 9的方式将字符数字转换为整型数字
    }
    
    // 转换第二个数
    for (int j = lenB - 1; j >= 0; j--)
    {
        array[l++] = numB[j] - '0';
    }
    
    // 两数相减
    // flag == 0 表示数A为正整数,数B为正整数,则A - B 可能是正整数或负整数
    // flag == 1 表示数A为负整数,数B为负整数,则A - B 可能是正整数或负整数
    // 这种情况采用上面的方法:先比较数A与数B的长度,长度相等的话,从第一个元素开始逐位比较值的大小
    // 最终,会用较大的数减去较小的数
    
    // flag == -1 表示数A为负整数,数B为正整数,则A - B 一定为负整数
    // 由于这里数字去掉了负号,则先计算A + B之和,最后输出的时候再加上负号
    // 如-3 - 8,在这里是3 + 8 = 11,再加上负号,即-11
    
    // flag == 2 表示数A为正整数,数B为负整数,则A - B 一定为正整数
    // 由于这里数字去掉了负号,则计算A + B之和
    // 如3 - (-8),在这里是3 + 8 = 11,不用加负号
    for (int i = 0; i <= maxLen; i++)
    {
        if (flag == 0 || flag == 1)
        {
            difference[i] -= array[i];             // 两个数从低位开始相减
            if (difference[i] < 0)                 // 判断是否有借位
            {
                difference[i] += 10;
                difference[i+1]--;
            }
        }
        else if (flag == -1 || flag == 2)
        {
            difference[i] += array[i];             // 两个数从低位开始相加
            if (difference[i] > 9)                 // 判断是否有进位
            {
                difference[i] %= 10;
                difference[i+1]++;
            }
        }
        
    }
    
    // 计算结果为负数
    if (symbol == 1)
    {
        // 高位maxLen - 1没有值
        if(difference[maxLen] == 0)
        {
            // 在⾼位添加⼀个 -1 表示负数
            difference[maxLen] = -1;
            maxLen++;
        }
        else                                // 高位maxLen - 1有值
        {
            // 在⾼位添加⼀个 -1 表示负数
            difference[maxLen + 1] = -1;
            maxLen = maxLen + 1 + 1;
        }
    }
    else                                    // 计算结果为正数
    {
        if(difference[maxLen] == 0)
        {
            maxLen++;
        }
        else
        {
            maxLen = maxLen + 1 + 1;
        }
    }
    
    int i = 0;
    
    // 根据高位是否是-1判断是否是负数
    if (difference[i = maxLen - 1] < 0)
    {
        printf("-");                        // 输出负号
        i--;
    }
    else
    {
        i = maxLen;
    }
    
    // 高位是0的话不输出,从第一个不是0的位开始输出
    while (difference[i] == 0)
    {
        i--;
    }
    
    // 打印计算结果
    for ( ; i >= 0; i--)
    {
        printf("%d", difference[i]);
    }
    
}

int main()
{
    char strA[NUM_MAX] = {0};
    char strB[NUM_MAX] = {0};
    
    while (scanf("%s%s", strA, strB) != EOF)
    {
        char numA[NUM_MAX] = {0};
        char numB[NUM_MAX] = {0};
        int difference[NUM_MAX] = {0};      // 存放计算的结果,低位在前,高位在后,即sum[0]是低位
        int flag = 0;
        int flagA = 0;                      // flagA为0表示A为正整数,为-1表示A为负整数
        int flagB = 0;                      // flagB为0表示B为正整数,为2表示B为负整数
        int lenA = strlen(strA);            // 计算数组numA的长度,即数A的位数
        int lenB = strlen(strB);            // 计算数组numB的长度,即数B的位数
        
        // 若为负数,去掉负号,且数字所在字符长度减1
        if (strA[0] == '-')
        {
            flagA = -1;
            lenA--;
        }
        if (strB[0] == '-')
        {
            flagB = 2;
            lenB--;
        }
        
        // flag为-1表示A为负整数、B为正整数,为0表示A与B均为正整数,
        // 为1表示A与B均为负整数,为2表示A为正整数、B为负整数
        flag = flagA + flagB;
        
        // 将strA与strB字符串重新存储到numA与numB字符串中,主要为了重新存储去掉负号的字符串
        for (int i = lenA - 1; i >= 0; i--)
        {
            if (flagA == -1)
            {
                numA[i] = strA[i+1];
            }
            else
            {
                numA[i] = strA[i];
            }
        }
        
        for (int j = lenB - 1; j >= 0; j--)
        {
            if (flagB == 2)
            {
                numB[j] = strB[j+1];
            }
            else
            {
                numB[j] = strB[j];
            }
        }
        
        if (flagB == 2)
        {
            printf("%s - (%s) = ", strA, strB);
        }
        else
        {
            printf("%s - %s = ", strA, strB);
        }
        
        // 调用大数减法函数
        Minus(numA, numB, difference, lenA, lenB, flag);
        
        // 换行
        printf("\n");
    }
    
    return 0;
}
上一篇:python 入门到实践第四章课后练习


下一篇:035、Java中自增之++在后面的写法