使用python的数组操作Hackerrank

这种逻辑适用于大多数测试用例，但并非所有测试用例。我做错了什么

def arrayManipulation(n, queries, m):
    li = []
    for j in range(0, m):
        p = queries[j][0]
        r = queries[j][1]
        v = queries[j][2]

        lo = []
        for i in range(0, n):
            lo.append(0)

        for i in range(p - 1, r):
            lo[i] = lo[i] + v

        li.append(lo)

    for i in range(1, m):
        for j in range(0, n):
            li[i][j] = li[i-1][j] + li[i][j]
    return max(max(li))

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')
    nm = input().split()
    n = int(nm[0])
    m = int(nm[1])

    queries = []
    for _ in range(m):
        queries.append(list(map(int, input().rstrip().split())))

    result = arrayManipulation(n, queries,m)
    print(result)
    fptr.write(str(result) + '\n')
    fptr.close()

---

没有一个python示例将m传递给arrayManipulation，因为这是不必要的—在python中，您只需迭代列表而不是列表的索引：

您使这种方式变得比需要的更复杂，您不需要保留以前的列表，只需更新一个列表即可，例如：

def arrayManipulation(n, queries):
    arr = [0]*n
    for a, b, k in queries:
        for i in range(a-1, b):
            arr[i] += k
    return max(arr)

这仍然是一种蛮力方法，不太可能解决像Hankerak这样的网站提出的挑战，因为这些网站希望您以更具分析性的方式解决这些问题

因此，考虑到这一点，你可以只考虑每个查询的端点，只需要一个计数器，在开始时递增，最后递减。现在的挑战是如何对所有这些开始和结束进行排序。因此，它使用itertools.chain.from_iterable将所有a、k、b、-k值和itertools.congregate放在排序列表上，以提供一个运行总数。返回此项的最大值，例如：

import itertools as it

def arrayManipulation(n, queries):
    q = it.chain.from_iterable([(a, k), (b, -k)] for a, b, k in queries)
    return max(it.accumulate(c for _, c in sorted(q, key=lambda x: (x[0], -x[1]))))

注意：您需要基于负k进行排序，否则在相同端点值处进行相加之前将进行减法运算，这会给出错误的答案，可以使用键参数进行排序。或者，你可以把k倒转成q，然后累加-c。。。不需要密钥参数：

快速比较两种方法，使用随机5000个查询，对100000个条目的数组进行查询，低于测试限制，但在比较的蛮力方法的限制下：

Brute force: 19.6 s ± 1.04 s per loop (mean ± std. dev. of 7 runs, 1 loop each)
Efficient  : 12.4 ms ± 3.25 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)

在测试限制下：超过10**7数组长度的2*10**5查询：

Efficient  : 891 ms ± 34 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

---

您使用的for循环太多，可以很快减少到只有两个

所使用的方法可以是：

定义最大值和当前值。这首先用于存储完成数组中的最大整数值，以及存储当前最大值的当前整数值

第一个for的起始部分可以用类似li=[0]*n+1的内容替换

只使用两个循环-一个用于计算数组中的第一步和最后一步，另一个用于获取最大int值

计算数组中每一步或每一步的总和

如果最大值小于当前值，则最大值将为当前值

总而言之

#!/bin/python3

import math
import os
import random
import re
import sys

# Complete the arrayManipulation function below.
def arrayManipulation(n, queries):
    maximum_int_value = 0
    current_int_value  = 0
    li = [0] * n

    for query in queries:
        li[query[0] - 1] += query[2]
        # edge case taken from here - https://sites.northwestern.edu/acids/2018/11/12/solution-hackerrank-array-manipulation/
        if query[1] != len(li):
            li[query[1]] -= query[2]

    for i in range(len(li)):
        current_int_value  += li[i]
        if maximum_int_value < current_int_value :
            maximum_int_value = current_int_value 

    return maximum_int_value

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    nm = input().split()

    n = int(nm[0])

    m = int(nm[1])

    queries = []

    for _ in range(m):
        queries.append(list(map(int, input().rstrip().split())))

    result = arrayManipulation(n, queries)

    fptr.write(str(result) + '\n')

    fptr.close()

它将通过所有当前的16个测试用例

首先，检查所有低端，即：每个数组，数组的第二个值，以获取其中的最大值，从而创建一个所有值均为零的嵌套数组。 然后将所有零值替换为所有queriesmain给定数组中描述的上限和下限，并将数组放入第三个值 所有嵌套列表的总和 最后找到最终列表的最高值

使用此方法，因为 对于这个循环，我们使用变量代替列表，这是因为列表比变量占用更多的空间。因此，请尝试使用变量

def arrayManipulation(n, queries):
arr = [0]*n
for i in queries:
    arr[i[0] - 1] += i[2]
    if i[1] != len(arr):
        arr[i[1]] -= i[2]
k = 0
p = 0
print(arr)
for q in arr:
    p += q
    if p > k:
        k = p
return k

---

你想解决什么问题？这就是问题所在。你的方法非常残忍。寻找合适的数据结构-段树或Fenwick树当你提问时，如果你提到你所面临的具体问题，这会很有帮助。在这种情况下，共享失败的特定测试，以及您最难处理的代码部分或您遇到的任何错误，将有助于其他人更快地回答。这个问题中一定有错误。在给定的链接中，函数只有两个参数，n是数组中的元素数，并查询二维查询数组，其中每个查询[i]包含三个整数a、b和k。虽然算法在技术上是正确的，但由于时间限制，它无法通过情况7到13。我们如何加快您的实现速度？这不会超过时间限制，也不是一个有效的解决方案。@EbramShehata我没有试图解决Hankernak问题，只是简化OP使用的方法。看看这个问题，它看起来很容易解决，更新了答案。它通过了meCode的所有测试，没有任何解释，对堆栈溢出没有帮助，也不鼓励，因为它没有解释为什么或者如何回答这个问题。请提高你的文章质量。另请参见以获取参考。添加的说明不能全部通过。11项测试failed@Mehdi我说得更清楚了。检查当前版本，我只是在这里运行它，它工作正常。

def arrayManipulation(arr):
    check = []
    for i in range(len(arr)):
        check.append(arr[i][1])
    big_jug = max(check) + 1

    temps = []
    for i in range(len(arr)):
        temps = [[0] * big_jug for _ in range(len(arr))]

    for i in range(len(temps)):
        for j in range(arr[i][0], arr[i][1] + 1):     
            temps[i][j] = arr[i][2]
   
sums = list(map(sum, zip(*temps)))
print(max(sums))

def arrayManipulation(n, queries):
arr = [0]*n
for i in queries:
    arr[i[0] - 1] += i[2]
    if i[1] != len(arr):
        arr[i[1]] -= i[2]
k = 0
p = 0
print(arr)
for q in arr:
    p += q
    if p > k:
        k = p
return k