两个数组元素之和的总和？

Question

存在这样的问题:给出两个随机整数数组,其中在每个索引处存在从0到9的数字(即,在给定数组的每个索引处存在单个数字整数).我需要找到输入数组所代表的数字之和,并将结果放在另一个数组中.

我相信我的代码一切都很好,因为我为不同的数组执行它几乎50到60次.但是当我在学校的在线评委中提交它时,它只接受了4个测试用例并拒绝了另外两个.我无法弄清楚在哪种情况下会产生错误的输出.需要一些帮助的人.

这是我的代码

public static int[] sumOfTwoArrays(int[] arr1, int[] arr2){
    int size1 = arr1.length;
    int size2 = arr2.length;
    int carry = 0,sum,s,r;
    if(size1 == size2) {
        int arr3[] = new int[size1+1];
        for(int i=arr1.length-1;i>=-1;i--) { 
            if(i==-1) {
                arr3[i+1] = carry;
                //System.out.println(i+1+" "+arr3[i+1]);
            } else {
                sum = arr1[i] + arr2[i];
                if(sum>9) {
                    s =sum;
                    r = s % 10;
                    arr3[i+1] = carry + r;
                    carry = 1;
                    //System.out.println(i+" "+arr3[i]);    
                } else {
                    if(sum==9 && carry==1) {
                        s =sum+carry;
                        r = s % 10;
                        arr3[i+1] = r;
                    } else {
                        arr3[i+1] = sum+carry;
                        carry=0; 
                    }
                    //System.out.println(i+" "+arr3[i]);
                }  
            }      
        }
        return arr3;
    } else if (size1>size2) {
       int arr3[] = new int[size1+1];
       int diff = arr1.length - arr2.length;
       for(int i=arr1.length-1;i>=-1;i--) {
           if(i==-1) {
               arr3[i+1] = carry;
           } else {
               if(i>=diff) {
                   sum = arr1[i] + arr2[i-diff];
                    if(sum>9) {
                        s =sum;
                        r = s % 10;
                        arr3[i+1] = carry + r;
                        carry = 1;
                    } else {
                        if(sum==9 && carry==1) {
                            s =sum+carry;
                            r = s % 10;
                            arr3[i+1] = r;
                        } else {
                            arr3[i+1] = sum+carry;
                            carry=0; 
                        }
                    } 
                }  // end of diff i
                else {
                   arr3[i+1] =  arr1[i];
                   carry = 0;
                }
            }      
        }
        return arr3;
    } else {
        int arr3[] = new int[size2+1];
        int diff = arr2.length - arr1.length;
        for(int i=arr2.length-1;i>=-1;i--) {
            if(i==-1) {
                arr3[i+1] = carry;
            } else {
                if(i>=diff) {
                    sum = arr2[i] + arr1[i-diff];
                    if(sum>9) {
                        s =sum;
                        r = s % 10;
                        arr3[i+1] = carry + r;
                        carry = 1;
                    } else {
                        if(sum==9 && carry==1) {
                            s =sum+carry;
                            r = s % 10;
                            arr3[i+1] = r;
                        } else {
                            arr3[i+1] = sum+carry;
                            carry=0; 
                        }
                    }  
                }  // end of diff i
                else {
                    arr3[i+1] =  arr2[i];
                    carry = 0;
                }
            }      
        }
        return arr3;
    }   
}

样本输入:

int[] arr1 = {8,5,3,9,6};
int[] arr2 = {3,3,3,3,3};

样本输出:

{1,1,8,7,2,9}

样本输入:

int[] arr1 = {8,5,3,9,6};
int[] arr2 = {1,0,5}; 

样本输出:

{0,8,5,5,0,1}

Answer 1

好吧，我有一个基于Eran解决方案的算法（正在修复他自更正以来的错误），由于我使用的数组较少，因此我将与大家分享。

public static int[] sum(int[] arr1, int[] arr2){
    int carry = 0;
    int sum = 0;

    int len1 = arr1.length;
    int len2 = arr2.length;
    int len = Math.max(len1, len2);

    int arr3[] = new int[len + 1];

    for (int i = 1; i <= len; i++) {
        sum =
            (len1 - i >= 0 ? arr1[len1-i] : 0)
            + (len2 - i >= 0 ? arr2[len2-i] : 0)
            + carry;

        arr3[len-i+1] = sum%10;
        carry = sum/10;
    }
    arr3[0] = carry;

    return arr3;
}

三元运算符的用法仍然可读，因此我发现这是一个很好的解决方案。

为了简短说明，我们从头开始读取数组，使用i从右到左的顺序，但基于数组的长度。如果数组大小不同，则使用三元运算。

编辑：

您的算法无法正确管理大小不同的数组的进位值。

185 + 16给101。

仅仅是因为您将值设置为：

arr3[i+1] =  arr1[i];

因此，您忘记了上次操作中可能发生的进位。