Question

所以我们的目标是读入两个巨大的整数，并将它们相加，相减，并将它们相乘成一个40元素的长整数数组，同时还要比较最初的两个整数，equalTo，notEqualTo等。我的大部分都完成了但我被困在几点上。我的isGreaterThan方法返回与它应该相反的方法，例如：巨大的整数1 = 100和巨大的整数2 = -100。该方法将吐出假，并说巨大的整数1是很小的整数2.我坚持的下一部分是乘法。到目前为止，我可以将整数相乘，得到一个不超过11个元素的新整数。由于某些未知的原因，任何更大的东西都会导致计算错误。有人建议我使用多个for循环，但我不知道这会有多大帮助。我的最后一个问题是，只要任何操作的结果等于零，例如100 +（ - 100），我的add / substract / multiply方法就不会返回0.下面是我当前的代码。

import java.util.Scanner;
import java.util.Arrays;

// Class that prompts the user to enter two HugeIntegers
// then compares those integers and performs addition, subtraction,
// and multiplication on those two HugeIntegers
public class HugeInteger {
    private static final int NUM_DIGITS = 40;
    private int digits[] = new int[NUM_DIGITS];
    private boolean positive;

    // Constructor
    public HugeInteger (String num){
        String parts [] = num.split(" ");
        digits = new int[parts.length];
        for(int n = 0; n < parts.length; n++) {
            digits[n] = Integer.parseInt(parts[n]);
        }
    }

    // Finds first non-zero position for first HugeInteger
    public int findFirstNonZeroPosition(){
        int position = NUM_DIGITS-1;
        for (int i = 0; i < digits.length; i++){
            if (digits[i] > 0){
                position = i;
                break;
            }
        }
        return position;
    }

    // Determines if h1 isEqualTo h2
    public boolean isEqualTo(HugeInteger hi){
        if(Arrays.equals(this.digits, hi.digits)){
            return true;
        }else {
            return false;
        }
    }

    // Determines if hi isGreaterThan h2
    public boolean isGreaterThan(HugeInteger hi){
        // different signs
        if (this.positive && (!hi.positive)){
            return true;
        }
        else if (!this.positive && hi.positive){
            return false;
        }

        // same sign
        else {

            // first number’s length is less than second number’s length
            if (findFirstNonZeroPosition() > hi.findFirstNonZeroPosition()) {
                if (positive)
                    return false;
                else
                    return true;
            }

            // first number’s length is larger than that of second number
            else if (findFirstNonZeroPosition() < hi.findFirstNonZeroPosition()) {
                if (positive)
                    return true;
                else
                    return false;
            }

            // two numbers have same length
            else {
                for (int i = 0; i < digits.length; i++ ) {
                    if ( this.digits[i] > hi.digits[i] )
                        if (positive)
                            return true;
                        else
                            return false;
                }
                if (positive)
                    return false;
                else
                    return true;
            }
        }
    }

    // Determines if h1 isNotEqualTo h2
    public boolean isNotEqualTo(HugeInteger hi){
        if(Arrays.equals(this.digits, hi.digits)){
            return false;
        }else {
            return true;
        }
    }

    // Determines if h1 isLessThan h2
    public boolean isLessThan(HugeInteger hi){
        return !(isGreaterThan(hi) || isEqualTo(hi) );
    }

    // Determines if h1 isGreaterThanOrEqualTo h2
    public boolean isGreaterThanOrEqualTo(HugeInteger hi){
        return !isLessThan(hi);
    }

    // Determines if h1 isLessThanOrEqualTo h2
    public boolean isLessThanOrEqualTo(HugeInteger hi){
        return !isGreaterThan(hi);
    }

    // instance variables are digits, NUM_DIGITS, positive
    // addArrayDigits and subtractArrayDigits
    // Determines how to add h1 and h2
    public void add(HugeInteger hi){
        if(positive!=hi.positive){
            if(this.positive){
                // "this" is positive, hi is negative
                hi.negate(); // negate hi temporarily

                if(this.isGreaterThan(hi)){
                    // |this| > |hi|
                    this.digits = subtractArrayDigits(this.digits, hi.digits);
                }else{
                    // |this| <= |hi|
                    this.digits = subtractArrayDigits(hi.digits, this.digits);
                    // negate the "this"
                    negate();
                }
                hi.negate(); // restore hi's sign
            }else{
                // "this" is negative, hi is positive

            }
        }else{
            // same sign :)
            digits = addArrayDigits(this.digits, hi.digits);
        }
    }

    // instance variables are digits, NUM_DIGITS, positive
    // addArrayDigits and subtractArrayDigits
    // Determines how to subtract h1 and h2
    public void subtract(HugeInteger hi){
        if(positive!=hi.positive){
            if(this.positive){
                // "this" is positive, hi is negative
                hi.negate(); // negate hi temporarily

                if(this.isGreaterThan(hi)){
                    // |this| > |hi|
                    this.digits = addArrayDigits(this.digits, hi.digits);
                }else{
                    // |this| <= |hi|
                    this.digits = addArrayDigits(hi.digits, this.digits);
                    // negate the "this"
                    negate();
                }
                hi.negate(); // restore hi's sign
            }else{
                // "this" is negative, hi is positive
            }
        }else{
            // same sign :)
            digits = subtractArrayDigits(this.digits, hi.digits);
        }
    }

    // Multiplies h1 and h2
    public void multiply(HugeInteger hi){
        for (int i = 0; i < digits.length; ++i) {
            digits[i] = this.digits[i] * hi.digits[i];
        }
    }

    // Flips the sign
    public void negate(){
        positive =! positive;
    }

    // Determines if an element is zero
    public boolean isZero(){
        for(int i = 0; i < digits.length; i++)
        if(digits[i]!= 0)
            return false;
        return true;
    }

    // Puts HugeInteger into a String in LSD format
    public String toString() {
        String str = "";
        int i;
        for(i = digits.length -1; i >= 0; i--) {
            if(digits[i] != 0)
            break;
        }
        for(int j = i; j >= 0; j--) {
            str = digits[j] + str;
        }
        return str;
    }

    // Subtracts h2 from h1
    private static int[] subtractArrayDigits(int[] array1, int[] array2){
        for (int i = 0; i < array1.length; ++i) {
            array1[i] = array1[i] - array2[i];
        }
        return array1;
    }

    // Adds h2 to h1
    private static int[] addArrayDigits(int[] array1, int[] array2){
        //int i = 0;
        for (int i = 0; i < array1.length; ++i) {
            array1[i] = array1[i] + array2[i];
        }
        return array1;
    }

    // Main method
    public static void main(String args[]){
        HugeInteger h1, h2;
        String num;
        Scanner scan=new Scanner(System.in);

        System.out.print("Please enter the first huge integer (h1): ");
        num=scan.nextLine();
        h1=new HugeInteger(num);

        System.out.print("Please enter the second huge integer (h2): ");
        num=scan.nextLine();
        h2=new HugeInteger(num);

        if(h1.isEqualTo(h2)){
            System.out.println("h1 is equal to h2.");
        }
        if(h1.isNotEqualTo(h2)){
            System.out.println("h1 is not equal to h2.");
        }
        if(h1.isGreaterThan(h2)){
            System.out.println("h1 is greater than h2.");
        }
        if(h1.isLessThan(h2)){
            System.out.println("h1 is less than to h2.");
        }
        if(h1.isGreaterThanOrEqualTo(h2)){
            System.out.println("h1 is greater than or equal to h2.");
        }
        if(h1.isLessThanOrEqualTo(h2)){
            System.out.println("h1 is less than or equal to h2.");
        }

        h1.add(h2);
        System.out.printf("h1 + h2 = %s\n",h1);
        h1.subtract(h2);
        h1.subtract(h2);
        System.out.printf("h1 - h2 = %s\n",h1);
        h1.add(h2);
        h1.multiply(h2);
        System.out.printf("h1 * h2 = %s\n",h1);
    }
}

Answer 1

您的代码存在很多问题。

首先，它代表巨大值的内部形式没有记录（除了通过代码分析）并且似乎不一致。它似乎是某种形式的符号/幅度，这很好，但数字出现在哪个顺序？这实际上非常重要。

对于大多数用途，数字数组从最不重要到最重要的运行会更简单，其中最低有效数字在索引为零，但这与数字的写入方式相反（至少在英语语言环境中）。它也可以从最重要到最不重要的运行，但在这种情况下，最低有效数字的唯一合理索引是MAX_DIGITS - 1。从您的构造函数中，我认为您的数字从最高位到最低位数运行，在数字数组中间的某个随机点处具有最低有效位。我认为你意味着以相反的方式做到这一点。

其次，您的构造函数从不设置positive字段。（事实上，它根本不检查负数）。

第三，您的add()和subtract()方法不应该修改他们的论点，即使是暂时的。它是非常糟糕的形式，也是不必要的，除非修改是方法目的的一部分。

第四，对于某些符号组合，您的add()和subtract()方法根本不执行任何操作。

但你真的对你的算术方法产生错误结果的原因感兴趣。让我从那里开始说你绝对不能正确地算算，除非你知道哪个数字是每个巨大的最不重要的数字。至于你的实际算法，你基本上应该实现用于在纸上进行十进制算术的相同过程。非常重要的是，在必要时，您不得忽视从一个数字位置到下一个位置（或在减法的情况下从更重要的位置借用）。你的代码没有这样做。

另请注意，算术结果可能具有与任一操作数不同的非零数字。特别是， m -digit数乘以 n -digit数可以产生最多（ n + m < / em>） - 数字。增加可能需要一个额外的数字。当然，减法可能会减少有效非零数字的数量。

数组比较和乘法

1 个答案: