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];

所以你忘记了上一次操作中可能发生的进位。

Answer 2

这段代码比以前复杂得多，这增加了包含难以检测的错误的可能性。

您不必实施该算法3次（基于第一个阵列是小于，大于还是等于第二个阵列）。您可以为两个大小为Math.max(arr1.length,arr2.length)的大小相等的数组实现一次。这将消除2/3的代码。

int len = Math.max(arr1.length,arr2.length);
int[] arr11 = new int[len];
int[] arr22 = new int[len];
int arr3[] = new int[len+1];
for(int i=len-1;i>=-1;i--) {
    if (i>=len-arr1.length)
        arr11[i]=arr1[i-(len-arr1.length)];
    if (i>=len-arr2.length)
        arr22[i]=arr2[i-(len-arr2.length)];
    // now you can use arr11[i] and arr22[i] instead of arr1[i] and arr2[i]
    ...
}

此外，我建议您立即添加随身携带sum = arr1[i] + arr2[i];，而不是sum = arr11[i] + arr22[i] + carry;。现在您只需要检查sum > 9。

    if(i==-1) {
        arr3[i+1] = carry;
    } else {
        sum = arr11[i] + arr22[i] + carry;
        if(sum>9) {
            arr3[i+1] = sum % 10;
            carry = 1;
        } else {
            arr3[i+1] = sum;
            carry = 0;
        }
    }

结合两个片段，您将获得：

int carry = 0;
int sum = 0;
int len = Math.max(arr1.length,arr2.length);
int[] arr11 = new int[len];
int[] arr22 = new int[len];
int arr3[] = new int[len+1];
for(int i=len-1;i>=-1;i--) {
    if(i==-1) {
        arr3[i+1] = carry;
    } else {
        if (i>=len-arr1.length)
            arr11[i]=arr1[i-(len-arr1.length)];
        if (i>=len-arr2.length)
            arr22[i]=arr2[i-(len-arr2.length)];
        sum = arr11[i] + arr22[i] + carry;
        if(sum>9) {
            arr3[i+1] = sum % 10;
            carry = 1;
        } else {
            arr3[i+1] = sum;
            carry = 0;
        }
    }
}
return arr3;

编辑：

我有一个小虫子。我在较小数组的最低有效位（即高索引）中添加0而不是最高有效位（低索引），如果数组具有不同的长度，则会导致结果错误。我修复了它，但现在将元素从原始数组复制到arr11和arr22的部分可读性较差。

Answer 3

int[] firstArray = {1,8,8,8, 8};
        int[] secondArray = {1,8,9};
        String diffstring1 = "", diffstring2 = "";
        for (int i = 0; i < firstArray.length; i++) {
            diffstring1 = diffstring1 + String.valueOf(firstArray[i]);
        }

        for (int i = 0; i < secondArray.length; i++) {
            diffstring2 = diffstring2 + String.valueOf(secondArray[i]);
        }

        int diff = Integer.parseInt(diffstring1) + Integer.parseInt(diffstring2);

        String diifffinal = String.valueOf(diff);
        int[] third = new int[diifffinal.length()];
        for (int j = 0; j < diifffinal.length(); j++) {
            char abc = diifffinal.charAt(j);
            third[j] = Character.getNumericValue(abc);
            Log.d(TAG, "onCreate:---> " + third[j]);
        }

Answer 4

如果您的第二个示例输出中的前导0不是必需的，您也可以通过预先转换输入来使用不同的方法，例如：具有如下功能：

static Integer toNumber(int[] arr) {
  return Integer.valueOf(Arrays.stream(arr)
                               .mapToObj(Integer::toString)
                               .collect(Collectors.joining()));
}

这样你就可以把你的数组总结为正常整数：

Integer sum = toNumber(arr1) + toNumber(arr2);

将其转换回数组可以按如下方式进行：

int[] sumArray = sum.toString().chars()
                               .map(operand -> Character.digit(operand, 10))
                               .toArray();

但是现在输出中没有那个前导0。该代码使用Java 8，但同样也可以在没有流（但未经测试）的情况下写入：

static Integer toNumber(int[] arr) {
  StringBuilder integerStrBuilder = new StringBuilder();
  for (int i = 0; i < arr.length; i++) {
    integerStrBuilder.append(Integer.toString(arr[i]));
  }
  return Integer.valueOf(integerStrBuilder.toString());
}

和数组：

char[] characters = sum.toString().toCharArray();
int[] sumArray = new int[characters.length];
for (int j = 0; j < characters.length; j++) {
  sumArray[j] = Characters.digit(characters[j], 10);
}

Answer 5

有点用

        int[] arr1 = {1, 2, 3, 4, 5, 6}, arr2 = {3, 5, 2, 9, 0};
        int[] output = new int[Math.max(arr1.length, arr2.length)];
        int num1 = 0, num2 = 0;
        for (int value : arr1) {
            num1 = (num1 * 10) + value;
        }

        for (int i : arr2) {
            num2 = (num2 * 10) + i;
        }

        int result = (num1 + num2), k = output.length - 1;

        while(result > 0){
            output[k] = (result % 10);
            result = result / 10;
            k--;
        }

        if(k>0){
            output[k] = 0;
            k--;
        }

        for(int value: output){
            System.out.print(value + " ");
        }
    }

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

5 个答案: