对数字列表求和，直到找到数字 0

Question

我有一个数据列表，如下所示data = [1, 0, 0, 0, 1, 1, 1, 0, 2, 3, 1, 0, 0, 1, 1, 1, 0]我想添加列表的元素如下所示： [1, 0, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 0, 0, 3, 0] ，其中前一个element 的值是 0，最后一个非 0 的元素是前一个元素的值的结果。

我已经尝试使用以下代码，如果我进行跟踪，它看起来可以完成，但是当我运行它时它不会显示结果，但它仍然处于不会停止的循环中。

我试过了：

data = [1, 0, 0, 0, 1, 1, 1, 0]
k = len(data)-1
while True:
    print(k)
    if(data[k-1] == 0):
        continue
    elif(data[k] == 0):
        print("h")
        continue
    elif(data[k-1] != 0):
        data[k] = data[k] + data[k-1]
        data[k-1] = 0
    k = k-1
    if(k == 0):
        break
print(data)

Answer 1

这是一个非常简单的实现。 我认为这是不言自明的。 您遍历列表中的每个项目n ，如果n为零，您有两个选项 a) 如果有先前的总和x ， append x然后是n b) 如果没有总和，则只有 append 0。如果n不同从零开始，将其与x相加。

data = [1, 0, 0, 0, 1, 1, 1, 0, 2, 3, 1, 0, 0, 1, 1, 1, 0]

x = 0
r = []
for n in data:
    if n == 0:
        if x:
            r.append(x)
            x = 0
        r.append(n)
    else:
        x += n
        
print(r)
[1, 0, 0, 0, 3, 0, 6, 0, 0, 3, 0]

Answer 2

遍历列表，如果当前和下一个元素不为 0，则添加到临时变量并将当前元素设为 0，当下一个元素为零时，将值放在当前元素中。 因为，代码使用当前元素检查下一个元素，迭代第二个最后一个元素并分别检查最后一个元素。

def arrange_list(arr):
    value = 0
    for x in range(len(arr)-1):
        if arr[x] != 0:
            value += arr[x]
        else:
            value = 0
        if arr[x+1] != 0:
            arr[x] = 0
        else:
            arr[x] = value
            value = 0
    if value !=0:
        arr[-1] = value + arr[-1]
    return arr

Answer 3

• 遍历列表，每次只需将一个非零数字和 append 一个零添加到列表中。
• 当只有 append 出现 0 时，总和为 0。
• 如果最后一个元素为 0，则将零添加到最后一个数字或相应的最后一个数字。
• 只需删除第一个零并返回列表。

.

data = [1, 0, 0, 0, 1, 1, 1, 0, 2, 3, 1, 0, 0, 1, 1, 1, 0]

def calc(data):
    sum = 0
    new = []
    for i in range(len(data)):
        if data[i] == 0:
            new.append(sum)
            if i == len(data) - 1:
                new.append(0)
            sum = 0
        else:
            sum = sum = sum + data[i]
            new.append(0)
            if i == len(data) - 1:
                new.append(sum)
    if new[0] == 0:
        del new[0]
    return new

Answer 4

正如评论中提到的，由于所有的继续，您会进入无限循环。 您需要确保行 k=k-1 恰好避免无限循环。

其次，为什么要while True然后if k==0: break将其更改为while k>=0 。

无论如何，您的代码将无法正常工作，因为它会对跟随零的元素产生问题。

此代码将起作用：

ans = []
tmp = 0
data = [1, 0, 0, 0, 1, 1, 1, 0]
for curr in data:
    if curr != 0:
        tmp += curr
    elif tmp == 0:
        ans.append(tmp)
    else:
        ans.append(tmp)
        ans.append(0)
        tmp = 0
print(ans)

Answer 5

您只需要从 1 开始 k 的值并设置elif(data[k]:= 0): 。 但是，它将修改您的原始列表。

data=[1, 0, 0, 0, 1, 1, 1, 0, 2, 3, 1, 0, 0, 1, 1, 1, 0]
k = 1
while True:
    
    if(data[k-1] == 0):
        pass
    elif(data[k] == 0):
        pass
    elif(data[k] != 0):
        data[k] = data[k] + data[k-1]
        print(data[k])
        data[k-1] = 0
    k = k+1
    if(k == len(data)):
        break
print(data)

Output

3
5
6
2
3
[1, 0, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 0, 0, 3, 0]

Answer 6

• 在这里，您的代码运行到无限循环，因为您使用 continue 语句将再次从头开始循环。
• 在您的情况下， data[k] 为零，因此第一个 elif 语句始终为真，并且 continue 语句正在执行。
• 由于上述原因，代码 k=k-1 行始终无法访问，并且在您的情况下 k 值始终为 7。 所以while循环无限运行。

以下是满足您的用例的建议代码示例。

data = [1, 0, 0, 0, 1, 1, 1, 0, 2, 3, 1, 0, 0, 1, 1, 1, 0]
k = len(data)-1
for i in range(0,k):
    if(data[i]==0):
        continue
    if(data[i]!=0 and data[i+1]!=0):
        data[i+1]=data[i]+data[i+1]
        data[i]=0
print(data)

Answer 7

为什么不这样做：

def convert(A):
    B = [0] * len(A)
    partial_sum = 0
    for i in range(len(A) - 1):
        partial_sum += A[i]
        if A[i + 1] == 0:
            B[i] = partial_sum
            partial_sum = 0
            
    if A[-1] != 0:
        B[-1] = partial_sum + A[-1]
        
    return B

与前面的答案相反，这实际上保留了原始数组的长度。

Answer 8

您可以定义在某些情况下可用的通用可重用方法。

在这里，它返回一个生成器：

def slice_when(predicate, iterable):
    i, x, size = 0, 0, len(iterable)
    while i < size-1:
        if predicate(iterable[i], iterable[i+1]):
            yield iterable[x:i+1]
            x = i + 1
        i += 1
    yield iterable[x:size]

---

使用示例

一旦你有了这个方法，你可以这样使用它：

data = [1, 0, 0, 0, 1, 1, 1, 0, 2, 3, 1, 0, 0, 1, 1, 1, 0]

test_method = slice_when(lambda _, y: y==0, data)
list(test_method)
#=> [[1], [0], [0], [0, 1, 1, 1], [0, 2, 3, 1], [0], [0, 1, 1, 1], [0]]

---

你的情况

这是如何应用它来解决您的问题：

res = []
for e in slice_when(lambda _, y: y==0, data):
    res += [0]*(len(e)-1) + [sum(e)]
    
res
#=> [1, 0, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 0, 0, 3, 0]