Question

来自http://blog.codility.com/2011/03/solutions-for-task-equi.html

任务是解决均衡问题。序列的平衡指数是一个指数，使得较低指数处的元素之和等于较高指数处的元素之和。

例如，在序列A：

中

A[0]=-7 A[1]=1 A[2]=5 A[3]=2 A[4]=-4 A[5]=3 A[6]=0

即。

A = [-7, 1, 5, 2, -4, 3, 0]

3是均衡指数，因为：

 A[0]+A[1]+A[2]=A[4]+A[5]+A[6]

6也是一个均衡指数，因为：

A[0]+A[1]+A[2]+A[3]+A[4]+A[5]=0

当我尝试写一个超级pythonic答案，即：

def solution(A):
    for i in range(len(A)):
        if sum(A[:i]) == sum(A[i+1:]):
            return i 
    return -1

我得到O(N**2)的最坏情况复杂性。 为什么会这样？

如何获得O(N)的最佳案例复杂性？

这会给我O(N)吗？ 为什么会这样？

def solution(A):
    total = sum(A)
    sum_left = 0
    for i in range(len(A)):
        sum_right = sum - sum_left
        if sum_left == sum_right:
            return i
    return -1

Answer 1

是的，您的解决方案是O(N)，因为您只遍历列表一次，每次迭代都是O(1)。您之前的解决方案也迭代了列表一，但它总结了每次迭代中的所有元素，这些元素也使每次迭代O(N)，导致O(N^2)的总复杂性。

但我认为你的解决方案是错误的 - 你没有积累sum_left。您必须在循环中添加A[i]。

Answer 2

只是稍微调整Hugh的答案，练习要求你返回一个均衡指数（如果没有找到则返回-1），而不是生成器，所以传递的解决方案看起来像：

def solution(A):
    sum_left, sum_right = 0, sum(A)
    for index, value in enumerate(A):
        sum_right -= value
        if sum_left == sum_right:
            return index
        sum_left += value
    return -1

Answer 3

重写为生成器函数，

def solution(a):
    sum_left, sum_right = 0, sum(a)
    for index,value in enumerate(a):
        sum_right -= value
        if sum_left == sum_right:
            yield index
        sum_left += value

然后找到所有解决方案，

list(solution([-7, 1, 5, 2, -4, 3, 0]))    # => [3, 6]

在python中解决Equi任务

3 个答案: