Python 求数组是否平衡的算法

我正在尝试创建一个程序，它将创建一个10个元素的数组，然后为每个元素分配随机值。然后我想让程序告诉我数组是否平衡。通过平衡，我的意思是，数组中的任何地方的值，在某个元素上，元素中的值之和等于元素中大于当前元素的数组值之和

范例

元素（1,2,3,4）值（2,1,3,0） 然后程序将显示元素1-2与元素3-4平衡，因为它们都等于4

到目前为止我有

import random

size = 10
mean = 0
lists = [0] * size
for i in range(size):
    var = random.randint(0,4)
    lists[i] = var

for i in lists:
    mean += i

avg = (mean)/(size)

我认为元素平衡的唯一方法是，如果平均值等于2，那么我认为应该这样开始

---

如果我能理解这个问题，最简单的解决方案是这样的：

def balanced(numbers):
    for pivot in range(len(numbers)):
        left_total = sum(numbers[:pivot])
        right_total = sum(numbers[pivot:])
        if left_total == right_total:
            return pivot
    return None

def find_pivot(series):
    cs = cumulative_sum(series)
    total = cs[-1]
    even_total = not (total & 1)
    if even_total:
        target = total // 2
        try:
            return cs.index(target)
        except ValueError:
            return -1
    return -1

例如：

>>> numbers = [2, 1, 3, 0]
>>> balanced(numbers)
2
>>> more_numbers = [2, 1, 3, 4]
>>> balanced(numbers)

（它没有打印任何内容，因为它返回了

None

，这意味着没有轴心来平衡列表。）

---

虽然这是最简单的解决方案，但显然不是最有效的，因为您不断地将相同的数字相加

如果您仔细想想，应该很容易找到如何保持运行

left\u total

和

right\u total

的总计，只调用

sum

一次

def balanced(numbers):
    left_total, right_total = 0, sum(numbers)
    for pivot, value in enumerate(numbers):
        if left_total == right_total:
            return pivot
        left_total += value
        right_total -= value
    return None

---

最后，以下是如何围绕它构建一个程序：

size = 10
numbers = [random.range(4) for _ in range(size)]
pivot = balanced(numbers)
if pivot is None:
    print('{} is not balanced'.format(numbers))
else:
    print('{} is balanced, because elements 1-{} equal {}-{}'.format(
        numbers, pivot+1, pivot+2, size+1))

---

对于此类问题，需要了解的一个好的数据结构是具有累积和的数组<代码>元素[j]-元素[i]是原始序列中从

i

到

j

的总和。如果您有原始序列

[1,2,3,4]

，则累积序列是

[0,1,3,6,10]

。原始序列中

i

位置的总和为

element[i]-element[0]

。对于这个问题，我们只对从0开始的和感兴趣，所以这有点过头了，但是，对于其他问题来说，这更有用

下面是累积总和的代码：

def cumulative_sum(series):
    s = [0]
    for element in series:
        s.append(element + s[-1])
    return s

因此，我们可以使用以下代码找到轴心点：

def find_pivot(series):
    cs = cumulative_sum(series)
    total = cs[-1]
    even_total = not (total & 1)
    if even_total:
        target = total // 2
        for i, element in enumerate(cs[1:]):
            if element == target:
                return i + 1
    return -1

请注意，如果我们知道序列和为奇数，则无需尝试对序列进行除法：这样就不可能有轴心点

或者，您可以这样编写

find_pivot

：

def balanced(numbers):
    for pivot in range(len(numbers)):
        left_total = sum(numbers[:pivot])
        right_total = sum(numbers[pivot:])
        if left_total == right_total:
            return pivot
    return None

def find_pivot(series):
    cs = cumulative_sum(series)
    total = cs[-1]
    even_total = not (total & 1)
    if even_total:
        target = total // 2
        try:
            return cs.index(target)
        except ValueError:
            return -1
    return -1

它的优点是循环不是在python中显式完成的，而是在标准库中的C代码中完成的

正在尝试代码：

def test():
    for i in range(1, 30):
        test_values = range(i)
        j = find_pivot(test_values)
        if j >= 0:
            print "{0} == {1}".format(test_values[:j], test_values[j:])

我们得到这个输出：

[0] == []
[0, 1, 2] == [3]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] == [15, 16, 17, 18, 19, 20]

---

要创建

n

元素的随机列表：

lists=[randint（0，4）表示范围（n）]

。要查找数字列表的平均/第一个采样时刻：

avg=sum（lists）/float（len（lists））

。您的变量名称令人困惑，就像有一个名为

lists

、名为

mean

的列表一样，……您的意思是列表中某些元素的总和等于其他一些元素的总和吗，而且这两组可能不会相交？@Lennart是的，这就是我的意思。我知道这是一个令人困惑的问题。而且，你的逻辑也令人困惑。示例中的平均值是1.5，而不是2，但它是平衡的。那么，当平均值为2时，是什么让你认为元素是平衡的呢？关于最终函数的一个建议是：如果列表是平衡的，那么在某个点上

left_total

必须等于

right_total

，因此它们必须都等于整个列表的一半。因此，只需计算一次

sum（numbers）/2

并测试

left\u total

，就可以避免做一些工作。您不需要在运行过程中不断更新

right\u total

。