Java: How to sum the elements of two arrays with different lengths

Question

I am trying to add the elements of two arrays with different lengths together. The code below is only for the same length and here is all I have so far.

    //for the same lengths
int[]num1 = {1,9,9,9};
int[]num2 = {7,9,9,9};// {9,9,9}

    int total = 0, carry = 1;
    int capacity = Math.max(num1.length,num2.length);
    int []arraySum = new int [capacity];

        for (int i = capacity - 1 ; i >= 0; i--)
        {   
            arraySum[i] = num1[i]+ num2[i];

            if (arraySum[i] > 9)
            {
                arraySum[i] = arraySum[i] % 10;

                num2[i-1] = num2[i-1] + carry;  
            }


        }

    for(int i = 0; i < arraySum.length; i++)
    {
        System.out.print(arraySum[i]);
    }

What should I do if I change the elements in num2 and length to like {9,9,9}? I know I probably need to put another for-loop as an inside for-loop and control the indices of the array with smaller length but how....?? One more thing... what should I do for those for-loops conditions because num1 and num2 will be eventually INPUTED by the user.

Well, you can tell that the inputs are limited because if num1[0] + num2[0] > 9 the carry has no index to be placed, then it can't be compiled. So, I need to shift the whole array to the right and place the carry from num1[0] + num2[0]. Here is the problem!! Where should I put the shifting code? I am kinda confused.......

Answer 1

You can use an ArrayList instead of an array and implement a normal addition method to it:

public static ArrayList<Integer> sum(int[] arr, int[] arr2) {
    ArrayList<Integer> al = new ArrayList<>();
    int i = arr.length - 1;
    int j = arr2.length - 1;
    int c = 0;
    while (i >= 0 && j >= 0) {
        int temp = arr[i] + arr2[j] + c;
        if (temp >= 10) {
            int r = temp % 10;
            al.add(0, r);
            c = temp / 10;
        } else {
            al.add(0, temp);
            c = 0;
        }
        i--;
        j--;
    }
    if (i < 0 && j >= 0) {
        while (j >= 0) {
            al.add(0, arr2[j] + c);
            c = 0;
            j--;
        }
    } else if (j < 0 && i >= 0) {
        while (i >= 0) {
            al.add(0, arr[i] + c);
            c = 0;
            i--;
        }

    } else
        al.add(0, c);
    return al;
}

Answer 2

Actually, you declare an int[] array with the capacity as Math.max(num1.length, num2.length).

It is not encough. You should set the capacity as Math.max(num1.length, num2.length) +1.

Why?

See if num1 is {1,9,9,9} and num2 is {9,9,9,9}, how can the arraySum to represent the sum {1,1,9,9,8}?

So we need to declare it as below to consider if carry is needed.

 int[] arraySum = new int[capacity + 1];

Then when print the sum, check if arraySum[0] is 0 or 1, if it euqals to 0, do not print it in Console.

Modified code for reference is as follows:

package question;

public class Example {

public static void main(String[] args) {

    // for the same lengths
    int[] num1 = { 1,9,9,9 };
    int[] num2 = { 9,9,9,9};// {9,9,9}

    // 1999+9999 = 11998, its length is greater than the max
    int capacity = Math.max(num1.length, num2.length);
    int[] arraySum = new int[capacity + 1];

    int len2 = num2.length;
    int len1 = num1.length;

    if (len1 < len2) {
        int lengthDiff = len2 - len1;

        /*
         * Flag for checking if carry is needed.
         */
        boolean needCarry = false;

        for (int i = len1 - 1; i >= 0; i--) {
            /**
             * Start with the biggest index
             */
            int sumPerPosition =0;

            if (needCarry) {
                 sumPerPosition = num1[i] + num2[i + lengthDiff] +1;
                 needCarry = false;
            }else
            {
                 sumPerPosition = num1[i] + num2[i + lengthDiff];
            }

            if (sumPerPosition > 9) {
                    arraySum[i + lengthDiff + 1] = sumPerPosition % 10;
                needCarry = true;
            }else
            {
                arraySum[i + lengthDiff + 1] = sumPerPosition % 10;
            }
        }

        /**
         * Handle the remaining part in nun2 Array
         */

        for (int i = lengthDiff - 1; i >= 0; i--) {
            /*
             * Do not need to care num1 Array Here now
             */

            if(needCarry){
                arraySum[i + 1] = num2[i]+1;
            }else
            {
                arraySum[i + 1] = num1[i] ;
            }

            if (arraySum[i + 1] > 9) {
                arraySum[i + 1] = arraySum[i + 1] % 10;
                needCarry = true;
            } else {
                needCarry = false;
            }


        }

        /*
         * Handle the last number, if carry is needed. set it to 1, else set
         * it to 0
         */
        if (needCarry) {
            arraySum[0] = 1;
        } else {
            arraySum[0] = 0;
        }

    } else {
        int lengthDiff = len1 - len2;

        /*
         * Flag for checking if carry is needed.
         */
        boolean needCarry = false;

        for (int i = len2 - 1; i >= 0; i--) {
            /**
             * Start with the biggest index
             */
            int sumPerPosition = 0;


            if (needCarry) {
                 sumPerPosition = num2[i] + num1[i + lengthDiff] +1;
                 needCarry = false;
            }else
            {
                 sumPerPosition = num2[i] + num1[i + lengthDiff];
            }

            if (sumPerPosition > 9) {
                    arraySum[i + lengthDiff + 1] = sumPerPosition % 10;
                needCarry = true;
            }else
            {
                arraySum[i + lengthDiff + 1] = sumPerPosition % 10;
            }
        }

        /**
         * Handle the remaining part in nun2 Array
         */

        for (int i = lengthDiff - 1; i >= 0; i--) {
            /*
             * Do not need to care num1 Array Here now
             */

            if(needCarry){
                arraySum[i + 1] = num1[i]+1;
            }else
            {
                arraySum[i + 1] = num1[i] ;
            }

            if (arraySum[i + 1] > 9) {
                arraySum[i + 1] = arraySum[i + 1] % 10;
                needCarry = true;
            } else {
                needCarry = false;
            }

        }

        /*
         * Handle the last number, if carry is needed. set it to 1, else set
         * it to 0
         */
        if (needCarry) {
            arraySum[0] = 1;
        } else {
            arraySum[0] = 0;
        }
    }

    /*
     * Print sum 
     * 
     * if arraySum[0] ==1, print 1
     * 
     * Do not print 0 when arraySum[0] ==0
     */
    if(arraySum[0] == 1)
    {
        System.out.print(1);
    }
    for (int i = 1; i < arraySum.length; i++) {

        System.out.print(arraySum[i]);
    }
}
}

An example that num1 is {1,9,9,9} and num2 is {9,9,9,9}, the sum result is as follows:

output in Console:

11998

Answer 3

Here is more performance centric solution:

public class SumArrays {

    public static void main(String[] args) {

        int[] num1 = {1, 9, 9, 9};
        int[] num2 = {7, 9, 9, 9, 9, 9, 9};

        int[] biggerArray = num1.length > num2.length ? num1 : num2;
        int[] smallerArray = num1.length <= num2.length ? num1 : num2;

        int[] summedArray = new int[biggerArray.length];
        System.arraycopy(biggerArray, 0, summedArray, 0, biggerArray.length);

        for (int i = 0; i < smallerArray.length; i++) {
            summedArray[i] += smallerArray[i];
        }

        for (int i = 0; i < summedArray.length; i++) {
            System.out.println(summedArray[i]);
        }
    }
}

Answer 4

for kicks, here is an alternative:

int[] num1 =
{ 1, 9, 9, 9 };
int[] num2 =
{ 7, 9, 9, 9 };

//convert the int array to a string
StringBuilder sb = new StringBuilder(num1.length);
for (int i : num1)
{
    sb.append(i);
}
String sNum1 = sb.toString();

System.out.println(sNum1);

StringBuilder sb2 = new StringBuilder(num2.length);
for (int i : num2)
{
    sb2.append(i);
}
String sNum2 = sb2.toString();

System.out.println(sNum2);

try
{
    //parse the string to an int
    int iNum1 = Integer.parseInt(sNum1);
    int iNum2 = Integer.parseInt(sNum2);

    //add them together
    int sum = iNum1 + iNum2;
    String sSum = Integer.toString(sum);

    System.out.println(sSum);

    // convert num back to array
    int[] sumArray = new int[sSum.length()];
    for (int i = 0; i < sSum.length(); i++)
    {
        sumArray[i] = sSum.charAt(i) - '0';
        System.out.println(sumArray[i]);
    }
}
catch (Exception e)
{
    // couldnt parse ints
}

Answer 5

It's quite simpe actually. Inside your loop, check that the current index is valid for both array, and replace the value to add by 0 in case of an invalid index:

int value1 = (i < num1.length) ? num1[i] : 0;
int value2 = (i < num2.length) ? num2[i] : 0;
arraySum[i] = value1 + value2;

EDIT: I didn't understand that you wanted to right-align the arrays and not left-align them. The simplest solution is probably to write and read everything in the arrays in reverse order. So if the numbers are 456 and 7658, the first array would contain 6, 5, 4 and the second one would contain 8, 5, 6, 7.