所以我们的目标是读入两个巨大的整数，并将它们相加，相减，并将它们相乘成一个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);
}
}
答案 0 :(得分：1)
您的代码存在很多问题。
首先，它代表巨大值的内部形式没有记录（除了通过代码分析）并且似乎不一致。它似乎是某种形式的符号/幅度，这很好，但数字出现在哪个顺序？这实际上非常重要。
对于大多数用途，数字数组从最不重要到最重要的运行会更简单，其中最低有效数字在索引为零，但这与数字的写入方式相反（至少在英语语言环境中）。它也可以从最重要到最不重要的运行，但在这种情况下，最低有效数字的唯一合理索引是MAX_DIGITS - 1。从您的构造函数中，我认为您的数字从最高位到最低位数运行，在数字数组中间的某个随机点处具有最低有效位。我认为你意味着以相反的方式做到这一点。
其次，您的构造函数从不设置positive字段。 （事实上，它根本不检查负数）。
第三，您的add()和subtract()方法不应该修改他们的论点，即使是暂时的。它是非常糟糕的形式，也是不必要的，除非修改是方法目的的一部分。
第四，对于某些符号组合，您的add()和subtract()方法根本不执行任何操作。
但你真的对你的算术方法产生错误结果的原因感兴趣。让我从那里开始说你绝对不能正确地算算，除非你知道哪个数字是每个巨大的最不重要的数字。至于你的实际算法，你基本上应该实现用于在纸上进行十进制算术的相同过程。非常重要的是，在必要时，您不得忽视从一个数字位置到下一个位置（或在减法的情况下从更重要的位置借用）。你的代码没有这样做。
另请注意，算术结果可能具有与任一操作数不同的非零数字。特别是， m -digit数乘以 n -digit数可以产生最多（ n + m < / em>） - 数字。增加可能需要一个额外的数字。当然，减法可能会减少有效非零数字的数量。