非常简单的问题：我需要的是步骤而不是结果。
背景：我正在获取非常大的数字并将它们存储在一个数组中。然后我要么加要么减两者。因为它是一个数组，所以我必须逐列进行。我已经完成了添加。但是对于我的一生来说，从较小的数字中减去较大的数字时，我无法弄清楚/记住要做什么。
逐列解决这个问题的步骤是什么？
50
-500
-----
编辑：它们存储在 int[] 中。使用数组，因为它是分配要求。只需要了解逐列减法的逻辑即可。
问问题
6052 次
3 回答
1
我认为您将数字表示为数字数组。因此，例如，50 由 [5, 0] 表示（或者，也许更方便的是，[0, 5]）。我还假设您有某种方式来表示负数（减法时需要）。
您有几个选项可以处理从较小的数字中减去较大的数字：
- 颠倒减法的顺序，然后否定结果
- 对减数取反并将两个数相加得到结果
后一个选项假定您的加法算法适用于混合符号参数，并且无论被减数和减数的大小如何都可以工作。这两个选项都假定您有一个否定数字的算法。
如果您无法表示负数，那么您唯一能做的就是在被要求计算 50 - 500 时发出信号失败（因为您无法表示结果）。
于 2013-01-25T18:48:12.273 回答
0
遵循以下假设：
- 500 表示为 [5,0,0]
- 被减数表示为
mi - 减数表示为
su
.您可以使用以下算法减去两个整数数组：
- 比较
mi.length_su.length - if
mi.length<su.length然后在两个数组之间交换array和之后的减法（从最后一个索引移动到索引的逐列减法0th）否定结果。 - 如果
mi.length==su.length则开始比较 mi (mi[i]) 的索引 i 处的元素与 su (su[i]) 的索引 i 处的元素。如果mi结果小于sr然后交换array. 两个数组之间的减法后否定结果。 - 如果
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);
}
}
}
如果任何测试失败或发现差异，请告诉我。
于 2013-01-25T22:46:03.643 回答
-1
我怀疑我完全理解你的问题，但这里有一个答案：
a[i] = 50 - 500;
编辑：正如最初所说，您的问题完全不清楚。我会以与您所说的相反的顺序存储数字，因此索引 0 始终是“个”位置，索引 1 始终是“十”位置，等等。然后您可以遍历索引，直到您有涵盖了所有这些，将超出数组末尾的访问视为该位置的零值。您可以按照指定的顺序存储数字，它只会使循环逻辑更复杂一些。
于 2013-01-25T18:37:33.443 回答