Question

非常简单的问题：我需要的步骤不是结果。

背景：我正在拍摄非常大的数字并将它们存储在一个数组中。然后我要么添加要么减去两个。因为它是一个数组，我必须逐列完成。我已经完成了添加。但是对于我的生活来说，无法弄清楚/记住从较小的数字中减去更大的数字时的内容。

逐栏解决此问题的步骤是什么？

   50
 -500
 -----

编辑：它们存储在int []中。使用数组，因为它是赋值要求。只需要逐列了解减法的逻辑。

Answer 1

我认为你将数字表示为数字数组。因此，例如，50由[5,0]（或者更方便地，[0,5]）表示。我还假设你有一些表示负数的方法（你需要减法）。

您可以使用几个选项来处理从较小的数字中减去较大的数字：

颠倒减法的顺序，然后否定结果
否定子带并添加两个数字以获得结果

后一个选项假定您的加法算法适用于混合符号参数，并且无论minuend和subtractend的大小如何都可以使用。这两个选项都假设您有一个否定数字的算法。

如果您无法表示负数，那么您唯一可以做的就是在被要求计算50 - 500时发出信号失败（因为您无法表示结果）。

Answer 2

遵循假设：

500表示为[5,0,0]
minuend由mi
subtrahend由su

。您可以使用以下算法减去两个整数数组：

将mi.length与su.length
if mi.length＆lt; su.length然后交换array并在两个数组之间进行减法（从最后一个索引到0th索引进行逐列减法）否定结果。
if mi.length == su.length然后开始将mi（mi[i]）的索引i处的元素与su（su[i]）的索引i处的元素进行比较。如果mi小于sr，则交换array。在两个数组之间减法后，否定结果。
if mi.length > su.length然后只在两个数组之间执行正常减法。

以下是添加和减法的完整代码。

//Assumed that none of number represented by array is LPaded by "0s" and the initegers at other than 0th position is not negative.
public class BigNumberAddSubtract
{
    private int array1[];
    private int array2[];
    private boolean shouldBeNegative = false;
    public BigNumberAddSubtract(int[] iArray1, int[] iArray2)
    {
        array1 = iArray1;
        array2 = iArray2;
    }
    public void setArray1(int[] array)
    {
        this.array1 = array;
    }
    public void setArray2(int[] array)
    {
        this.array2 = array;
    }
    //Subtraction 
    private int[] subtract()
    {
        int length1 = array1.length;
        int length2 = array2.length;
        boolean isMinus = false;
        int mi[] = array1 ;//Minuend
        int su[] = array2 ;//Subtrahend
        boolean isPrevEqual = false;
        boolean isFirstNegative = false;
        if (length1 == length2 )                
        {   
            if (array1[0] < 0 )
            {
                isFirstNegative = true;
            }
            for (int i =0 ; i < length1 ; i++)
            {
                if (Math.abs(array1[i]) == Math.abs(array2[i]))    
                {                                                  
                    isPrevEqual = true;
                    continue;
                }
                else if (array1[i] < array2[i])
                {
                    if (isPrevEqual)
                    {
                        isMinus = true;
                        System.out.println("breaking");
                        break;
                    }
                }
                else
                {
                    isPrevEqual = false;
                }
            }
        }
        else if (length1 < length2) 
        {                           
            if (array1[0] < 0)
            {
                isFirstNegative = true;
            }
            isMinus = true; 
        }
        else
        {
            if (array1[0] < 0 )
            {                                                                 
                isFirstNegative = true;
            }
        }
        array1[0] = Math.abs(array1[0]);
        array2[0] = Math.abs(array2[0]);
        if (isMinus)
        {
            mi = array2;
            su = array1;
        }
        int[] result = new int[mi.length];
        int iCursor1 = mi.length - 1;
        int iCursor2 = su.length - 1;
        int iCarry = 0;
        for (int i=result.length - 1 ; i >= 0 ; i--, iCursor1--, iCursor2--)
        {
            int iValue = 0;
            int iFrom =  0;
            iFrom = mi[iCursor1] - iCarry;                  
            if (iFrom < (iCursor2 < 0 ? 0 : su[iCursor2]))
            {
                if (iCursor1 > 0)
                {
                    iFrom = 10 + iFrom;
                }
                iCarry = 1;
            }
            else
            {
                iCarry = 0;
            }
            iValue = iFrom - (iCursor2 < 0 ? 0 : su[iCursor2]) ;      
            result[i] = iValue;                                       
        }
        int[] temp = null;
        if (isMinus)
        {
            int counter = 0;
            for (int i=0; i < result.length; i++)
            {
                if (result[i] == 0)
                {
                    counter++ ;
                    continue;
                }
                else
                {
                    result[i] = -result[i];
                    break;
                }
            }
            temp = new int[result.length - counter];
            System.arraycopy(result,counter,temp,0,result.length - counter);
            result = new int[temp.length];
            System.arraycopy(temp,0,result,0,temp.length);
        }
        if (isFirstNegative)
        {
            int counter = 0;
            for (int i=0; i < result.length; i++)
            {
                if (result[i] == 0)
                {
                    counter++ ;
                    continue;
                }
                else
                {
                    result[i] = -result[i];
                    break;
                }
            }
            temp = new int[result.length - counter];
            System.arraycopy(result,counter,temp,0,result.length - counter);
            result = new int[temp.length];
            System.arraycopy(temp,0,result,0,temp.length);
        }
        return result;
    }
    //Addition
    private int[] add()
    {
        int length1 = array1.length;
        int length2 = array2.length;
        int[] result = new int[length1 > length2 ? length1 : length2];
        int iCursor1 = array1.length - 1;
        int iCursor2 = array2.length - 1;
        int iCarry = 0;
        array1[0] = Math.abs(array1[0]);
        array2[0] = Math.abs(array2[0]);
        for (int i=result.length - 1 ; i >= 0 ; i--, iCursor1--, iCursor2--)
        {
            int iValue = 0;
            if (iCursor1 >= 0 && iCursor2 >= 0)
            {
                iValue = array1[iCursor1]  + array2[iCursor2] + iCarry;
            }
            else if (iCursor1 < 0 && iCursor2 >=0)
            {
                iValue = array2[iCursor2] + iCarry;
            }
            else if (iCursor1 >=0 && iCursor2 < 0)
            {
                iValue = array1[iCursor1] + iCarry;
            }
            if (iCursor1 == 0 && iCursor2 ==0)
            {
                result[i] = iValue;
                iCarry = 0;
            }
            else
            {
                result[i] = iValue % 10;            
                iCarry = iValue / 10;               
            }
        }
        result[0] = result[0] + iCarry;
        if (shouldBeNegative)
        {
            result[0] = -result[0];
        }
        return result;
    }
    public int[] performOperation()
    {
        if (array1[0] < 0 && array2[0] < 0)//If digit at one's place of both number is negative
        {
            shouldBeNegative = true;
            return add();
        }
        else if (array1[0] > 0 && array2[0] > 0)
        {
            return add();
        }
        else //if digit at one's place of one of the numbers is negative
        {
            return subtract();
        }
    }
    public static void main(String[] st)
    {
        int[] arr1 ={-9,0,0,6};
        int[] arr2 = {1,9,7,8};
        BigNumberAddSubtract big = new BigNumberAddSubtract(arr1,arr2);
        int[] addResult = big.performOperation();
        for (int i : addResult )
        {
            System.out.print(i);
        }
    }
}

如果测试失败或发现差异，请告知我们。

Answer 3

我怀疑我完全理解你的问题，但这是一个答案：

a [i] = 50 - 500;

编辑：您最初提出的问题完全不清楚。我会按照你所说的相反的顺序存储数字，这样索引0总是“1”位置，索引1总是“数十”位置等等。然后你可以循环索引，直到你有覆盖它们全部，将访问超过数组末尾的访问权限视为该位置的零值。您可以按照指定的顺序存储数字，只是使循环逻辑更复杂。

用数组减法

3 个答案: