Question

我正在尝试递归合并/乘以数组中重复的long。所以，如果我有这样的事情： long [] arr = {3，5，6，6，7} => long [] arr = {3，5，36，7}

这就是我所拥有的：

    public static long[] merge(long[] ns, int i, Merger m) {
    m.merge();
    if(i > ns.length) return new long[0];
    if(i < 0) return merge(ns, 0, m);
    else {
        if(ns[i] != ns[i+1]) {
            return append(merge(ns, i-1, m), ns[i+1]);
        }
        else {
            return append(merge(ns, i-1, m), ns[i] * ns[i+1]);
        }
    }

    public long[] append(long[] old, long newLast) {
        long[] result = Arrays.copyOf(old, old.length + 1);
        result[old.length] = newLast;
        return result;
    }
}

但是它停留在递归中。

Answer 1

您采用的方法尚不清楚多种情况。

当多个实例具有相同的值时会发生什么？它们只是成倍增加吗？在当前逻辑中，检查是否假设ns[i] != ns[i+1]。列表（如果排序）。这种情况只会成对出现。

要了解（a）成立的原因，如果您的输入列表为[3,6,5,6,7]，则当前的方法不会将两个6相乘。这是一个有效的假设吗？

要了解为什么（b）成立，请假设您有输入[1,3,5,6,6,6,7]。在这种情况下，将6的前两个出现次数相乘后，结果列表将为[1,3,5,36,6,7]，并且您当前的逻辑不会以36和6相乘。

这是故意的吗？

在实现递归解决方案之前，先写出迭代实现是有指导意义的。这样，问题说明将对您更加清晰。

假设这两个假设适用于您要解决的特定问题，则下面的实现有效。（注意-这是在Python中实现的。如果您正在寻找Java特定的解决方案，则应修改您的问题以指定它，并在您的帖子中添加Java标签。精通Java的人可以为您提供帮助。该解决方案试图尽可能地类似于您的方法。）

def merge(ns, i, resultant_list = None):
    if resultant_list is None:
        resultant_list = []

    if i > len(ns)-1:
        return resultant_list

    else:
        if i == len(ns)-1:
            append(resultant_list, ns[i])
            return resultant_list

        elif(ns[i] != ns[i+1]):
            append(resultant_list, ns[i])
            return merge(ns, i+1, resultant_list)

        else:
            append(resultant_list, ns[i] * ns[i+1])
            return merge(ns, i+2, resultant_list)        

def append(old, newLast):
    old.append(newLast)
    return old

在数组中合并重复的long

1 个答案: