Question

我一直在尝试编写一个计算极大整数的小程序，BigInteger类无法在Java中处理这些整数。我的方法是将Integer作为一个字符串并将其推入堆栈，然后比较堆栈的pop()并进行数学运算，并push()结果。这种方法适用于我的添加，一个addStacks方法，它将两个Stacks作为参数。就我测试添加大量数字而言，这很有效。

 int carry = 0;

            while(!stackA.empty() && !stackB.empty())
            {
                try
                {   
                    //get the digits to add
                    int tokenA = stackA.pop();
                    int tokenB = stackB.pop();

                    //add them and mod 10
                    int result = tokenA + tokenB + carry;
                    int resultDigit = result % 10;

                    //push the result on to the new stack
                    resultStack.push(resultDigit);

                    //the updated carry
                    carry = result / 10;
                }
                catch(ArithmeticException e)
                {
                    e.printStackTrace();
                }
            }
            if (carry > 0)
            {
                resultStack.push(carry);
            }

我的问题是当我尝试用减法实现相同的逻辑时。在我看来，我认为两个操作都是一样的。我的减法方法，两种方法之间唯一真正的区别是附加代码，以确保较大的数字总是减去较小的数字。我觉得我的方法已关闭，因为当我输入100和10时，我得到结果010哈哈，这是非常错误的，因为它应该是90。有关如何修复数学的任何提示吗？

int carry = 0;

        while (!stackA.empty() && !stackB.empty())
        {
            int tempA = 0;    
            int tempB = 0;

            int tokenA = stackA.pop();
            int tokenB = stackB.pop();

            if (tokenA <= tokenB)
            {
                tempA = tokenB;
                tempB = tokenA;

                //System.out.println("StackApop: " + tokenA);
                //System.out.println("StackBpop: " + tokenB);

                int result = tempA - tempB;
                int resultDigit = result % 10;

                resultStack.push(resultDigit);

                carry = result / 10;
            }
            else if (tokenA >= tokenB)
            {
                int result = tempA - tempB;
                int resultDigit = result % 10;

                resultStack.push(resultDigit);

                carry = result / 10;
            }
        }
        if (carry > 0)
        {
            resultStack.push(carry);
        }

Answer 1

我会重命名借用。

int isPrime(int number) {
    if (number < 2) return 0;
    if (number == 2) return 1;
    if (number == 3) return 1;
    if (number == 5) return 1;
    if (!(number % 2)) return 0;
    if (!(number % 3)) return 0;
    if (!(number % 5)) return 0;
    if (number < 7 * 7) return 1;
    int step[] = { 7, 11, 13, 17, 19, 23, 29, 31 };
    int sentry = (int)sqrt((double)number);
    for (int r = 0; r < sentry; r += 30)
        for (int i = 0; i < 8; ++i)
            if (!(number % (r + step[i])))
                return 0;
    return 1;
}

BigInteger非常聪明，您可能希望查看来源。

当减去两位数时，可能是前一步骤中已有的一位数减1，在前一步骤中加10。

当减去并得到否定结果时，添加10，并从下一步中减去1。

（使用modulo int result = tempA - tempB - carry; carry = result < 0 ? 1 : 0; result += 10*carry; int resultDigit = result % 10; resultStack.push(resultDigit); if (carry > 0) { resultStack.push(10 - carry); // Negative number actually }需要注意负数;结果可能是负数。）

减去两个整数堆栈的每个节点

1 个答案: