Java добавление содержимого 2 массивов int size

Question

Мне нужна помощь в создании класса VeryLargeInteger, подобного BigInteger, однако в рамках моего задания мне не разрешено использовать 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 бита длиной, которые составляют 32 цифры в базе 2. Теперь вы используете целые числа как 1 цифру в базе 10. Посредством этого вы используете только полезный способ использования 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; 
}