Python 什么'；我的递归实现有什么问题吗？

我最近开始学习编程，刚刚完成了一门关于edX的课程。我试图解决HackerRank上的问题，但在每种情况下，时间都不多了。我做错了什么

n,k = input().strip().split(' ')
n,k = [int(n),int(k)]
x = [int(x_temp) for x_temp in input().strip().split(' ')]
x.sort()
def transmitter(aList=[], target=0):
    '''
    accepts a list of house location, and a target location for the transmitter
    returns the optimal number of transmitters required to cover all the  houses
    '''
    List = aList[:]
    start = target - k
    end = target + k + 1

    for i in range(start, end):
        if i in List:
            List.remove(i)
    if not List:
        return 1
    m = max(List)
    for e in List:
        if transmitter(List, e) < m:
            m = transmitter(List, e)

    return 1 + m

m = max(x)
for e in x:
    if transmitter(x, e) < m:
        m = transmitter(x, e)

print(m)

n，k=input（）.strip（）.split（“”）
n、 k=[int（n），int（k）]
x=[int（x_temp）表示输入中的x_temp（）.strip（）.split（“”）]
x、 排序（）
def变送器（aList=[]，目标=0）：
'''
接受房屋位置列表和发射器的目标位置
返回覆盖所有房屋所需的最佳发射机数量
'''
列表=列表[：]
开始=目标-k
结束=目标+k+1
对于范围内的i（开始、结束）：
如果我在列表中：
列表.删除（i）
如果没有列出：
返回1
m=最大值（列表）
对于列表中的e：
如果变送器（列表，e）

我对这个很陌生。很抱歉犯了任何明显的错误，或者如果这不是合适的网站，请在此发布。在这种情况下，如果你能推荐一个我可以问这样问题的网站，那将非常有帮助

---

我很确定贪婪算法在

O（N）

时间内最有效地解决了这个问题。不需要任何递归。只需将每个发射机依次放在尽可能靠右的位置，而不必让左侧的任何房屋裸露。当最后一栋房子盖上时停下来

下面是我如何编写代码的：

def hackerland(houses, k):  # houses should be sorted list of locations
    first = None  # location of first uncovered house
    last = 0      # last location covered by a previous transmitter
    prev = None
    count = 0  # transmitters = []

    for x in houses:
        if first is not None and x > first + k:
            first = None
            count += 1  # transmitters.append(prev)
            last = prev + k

        if last is not None and x > last:
            last = None
            first = x

        prev = x

    if first is not None:
        count += 1  # transmitters.append(prev)

    return count  # return transmitters

---

我已经包含了一些注释，说明如何轻松修改此代码，以返回变送器位置列表，而不仅仅是需要多少变送器位置的计数。

无需采用递归方法。事实上，您可以继续工作，在房屋上迭代，当先前放置的发射器无法覆盖当前房屋时放置发射器，等等

这比那要复杂一点，但不多。请参阅此代码：

# input
n,k = input().strip().split(' ')
n,k = [int(n),int(k)]
x = [int(x_temp) for x_temp in input().strip().split(' ')]

# eliminate duplicate house x-xoordinates, they don't influence the result
houses = list(set(x))
houses.sort()
# add extreme far dummy house (will make the loop easier)
houses.append(100000) 
reachedX = 0 # coordinate until where the previously placed transmitter reaches
unreachedX = -1 # coordinate that the next one needs to cover (to the left)
lastHouseId = -1 # index where previous transmitter was placed
transmitters = [] # coordinates of the placed transmitters
for houseId, houseX in enumerate(houses):
    if reachedX > unreachedX: # we might still be in range of last transmitter
        if houseX > reachedX: # we just went out of reach
            unreachedX = houseX # this house must be covered by next one
    elif houseX - k > unreachedX: # transmitter here wouldn't reach far enough back
        lastHouseId = houseId - 1 # place it on previous house
        reachedX = houses[lastHouseId] + k
        transmitters.append(houses[lastHouseId])

print(transmitters)
print(len(transmitters))

---

时间（参见你的问题）和空间（参见你的标题）是两个不同的维度（不想进入时空连续体的争论）。@trincot但我认为我的解决方案太耗费内存了，所以时间不够了。我找不到问题的描述。似乎URL不再有效。您可以添加描述吗？如果您存储递归调用的结果而不是两次调用它们（一次在

if

条件中，一次如果条件为true），会发生什么情况？比如：

result=transmitter（List，e）

然后如果result不知道最初的挑战，我猜算法是错误的：值被用作索引，反之亦然，这可能是有意的，但是数组在开始时被排序真的很奇怪。