Question

我需要帮助创建类似于BigInteger的VeryLargeInteger类，但作为我的任务的一部分，我不允许使用BigInteger。我已经开始将大数字存储为字符串，然后将它们转换为int []以使用它们执行数学函数。我遇到的问题是使用两个不同大小的数组，例如：

int[] a = {1, 2, 3, 4, 5}  // represents 12,345
int[] b = {1, 2, 4}       //represents 124

当我添加它们时，我得到：

int[] c = {2, 4, 7, 4, 5}

而不是

int[] c = {1, 2, 4, 6, 9}

这有点乱。

import java.util.Arrays;

public class VeryLargeInteger
{
    int[] test, test2;
    String temp, temp2;
    int size;
    VeryLargeInteger(int[] input)
    {
        int[] test = input;
        System.out.println(Arrays.toString(test));
    }
    VeryLargeInteger(long input1)
    {
        long input = input1;
        temp = Long.toString(input1);
        test = convert(temp);
        System.out.println(Arrays.toString(test));
    }
    VeryLargeInteger(String input1)
    {
        temp = input1;
        test = convert(input1);
        System.out.println(Arrays.toString(test));
    }
    public static int[] convert(String input)
    {
        int [] array = new int[input.length()];
        for (int i = 0; i < input.length(); i++)
        {
            int value = input.charAt(i) - '0';
            array[i] = value;
        }
        return array;
    }
    VeryLargeInteger add(VeryLargeInteger other)
    {
        int max = Math.max(this.temp.length(), other.temp.length());
      int[] result = new int[max];
      int carry = 0;
      for (int i = 0; i < max; ++i)
    {

        int a = i < this.test[i] ? this.test[this.test[i] - i -1] : 0;
        int b = i < other.test[i] ? other.test[other.test[i] - i -1] : 0;
        int sum = a + b + carry;
        carry = sum / 10;
        sum -= carry;
        result[result.length - i - 1] = sum;
    }
    VeryLargeInteger added = new VeryLargeInteger(result);
    return added;
    }
    /*
    VeryLargeInteger sub(VeryLargeInteger other)
    {

    }
    VeryLargeInteger mul(VeryLargeInteger other)
    {

    }
    VeryLargeInteger div(VeryLargeInteger other)
    {

    }
    VeryLargeInteger mod(VeryLargeInteger other)
    {

    }
    static String toString(VeryLargeInteger other)
    {

    }*/
    public static void main(String[] args)
    {
        VeryLargeInteger a = new VeryLargeInteger(1050L);
        VeryLargeInteger b = new VeryLargeInteger("121123");
        VeryLargeInteger c = a.add(b);
    }
}

Answer 1

您可以填充第二个数组以使其正确添加：

int[] a = {1, 2, 3, 4, 5};
int[] b = {0, 0, 1, 2, 4};

然后，如果您的添加方法将a[0]与b[0]进行比较，那么您将获得{1, 2, 4, 6, 9}。

Answer 2

我想做的一个重要提示是：您没有使用整数的好处。整数是32位长，在基数2中是32位。现在，您在基数10中使用整数作为1位数。通过这样做，您只能以有用的方式使用0.0000002％的内存。使用整数支持的全范围。要点是创建一个整数数组，但每个整数有效地代表你想要保持的实际数字的32位。将它们加在一起然后只是按组件方式进行，并使用进位来处理溢出。

要解决现在遇到的问题：正确对齐数组。不要像 Mike Koch 建议的那样添加前导零，但是通过基本上从后到前访问数组元素而不是从前到后访问数组元素，正如您现在所做的那样。通过查看您的代码，您已尝试过，但我猜测您遇到了ArrayIndexOutOfBoundsExceptions问题。像这样访问数组的两个组件：

int[] number0 = ...;
int[] number1 = ...;
int max = Math.max(number0.length + number1.length) + 1;
int[] result = new int[max];

int carry = 0;
for (int i = 0; i < max; ++i)
{
    int c0 = i < number0.length ? number0[number0.length - i - 1] : 0;
    int c1 = i < number1.length ? number1[number1.length - i - 1] : 0;

    int sum = c0 + c1 + carry;
    carry = sum / 10;
    sum -= carry;

    result[result.length - i - 1] = sum;
}

Java添加2个不同大小的int数组的内容

2 个答案: