相关疑难解决方法(0)

所以我一直在做这个家庭作业问题几个小时,我会尽力解释它.

我需要在python中编写一个程序来获取列表并在列表中的第一个项目处启动,您可以向前移动一个空格或跳过一个项目并在其另一侧着陆,每个项目都会降低成本该位置的号码.目标是尽可能便宜地达到目的.

我写了这个函数,

def player(cost, board, player_pos):
    if player_pos == (len(board)) - 1:    
        return cost
    if player_pos < (len(board)) - 2:     
        if board[player_pos + 1] > board[player_pos + 2]:
            return player(cost + board[player_pos + 2], board, player_pos + 2)
        else:
            return player(cost + board[player_pos + 1], board, player_pos + 1)
    elif player_pos == (len(board)) - 2:
        return (cost + board[player_pos] + board[player_pos + 1])

但它无法看到接下来的两个位置,所以它可能会出错.一个很好的例子是这个列表[0,1,2,1000,0]我的程序输出3因为它选择1超过2,然后超过1000,然后是0.这加起来为3,但最快的方法是跳转到2,然后到0.

在家庭作业中它表示可能需要很长时间来运行长列表,我猜他们希望我尝试每种可能的跳转组合并选择最便宜的组合,但我不知道如何使用递归.

编辑: 所以这是我根据评论做出的改进,它适用于我教授的所有例子.给了我除了一个,这是它没有返回他说的应该的列表.[0,98,7,44,25,3,5,55,46,4]他说它应该返回87,但我调整后的程序返回124.这是新代码:

def player(cost, board, player_pos):
    if player_pos == (len(board)) - 1:    
        return cost …

我很好奇python中的MRD（最大递归深度），所以我这样写：

def call(n):
    print (n)
    return call(n+1)

call(1)

最终结果是979，这对我来说是个奇特的数字。我找不到任何地方为什么这个数字是标准的。因为我是一个自学成才的程序员，所以我很理解用简单的术语进行解释。

编辑：显然应该是1000，但是为什么这个数字呢？

我在python中有一个简单的LinkedList实现.如何在方法中使用递归？我知道递归是如何工作的,但我如何使用自我递归.如果有人可以修复我的代码,但我对解释更感兴趣,那么我可以在不同的方法中使用它.

LinkedList代码:

class Node:
    def __init__(self, item, next):
        self.item = item
        self.next = next

class LinkedList:
    def __init__(self):
        self.head = None

    def add(self, item):
        self.head = Node(item, self.head)

    def remove(self):
        if self.is_empty():
            return None
        else:
            item = self.head.item
            self.head = self.head.next
            return item

    def is_empty(self):
        return self.head == None 

我的代码是:

def count(self, ptr=self.head):
    if ptr == None:
        return '0'
    else:
        return 1 + self.count(ptr.next)

它给了我一个错误:

def count(self, ptr=self.head):
NameError: name 'self' is not defined

任何帮助深表感谢.

人们之前已经讨论过如何基于字典在字符串中进行多次替换（例如，参见）。似乎有一组string.replace基于正则表达式的选项和一组基于正则表达式的选项，还有几个选项。

但是我对取决于字典大小的不同方法的效率感兴趣，我发现这具有非常重要的影响。

my_subs = {'Hello world': 'apple', 'is': 'ship'}
string = 'Hello world! This is nice.'
new_string = my_efficient_method(string, my_subs)

需要明确的是，这个问题不是关于如何进行这些替换，而是关于哪种方法在哪些条件下更有效，以及适用哪些注意事项。特别是，当有很多（>100k）个长字符串（10-20k 个字符）并且字典很大（>80k 对）时，我正在寻找最实用的方法。在这些情况下，基于正则表达式的首选方法性能非常差。

我试图将一个函数应用于包含任意子列表子级别的列表的每个元素。像这样。

a = [1,2,3]
b = [[1,2,3],[4,5,6]]
c = [[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]

function = lambda x: x+1
def apply(iterable,f): 
    # do stuff here

print(apply(a,function)) # [2,3,4]
print(apply(b,function)) # [[2,3,4],[5,6,7]]
print(apply(c,function)) # [[[2,3,4],[5,6,7]],[[8,9,10],[11,12,13]]]

基本上我找不到编写apply函数的方法。我尝试过 numpy，但这当然不是解决方案，因为列表的内容也可以是字符串、对象......

回溯：

   File "/usr/lib/python3.7/inspect.py", line 3083, in signature
      return Signature.from_callabl`enter code here`e(obj, follow_wrapped=follow_wrapped)
    File "/usr/lib/python3.7/inspect.py"`enter code here`, li`enter code here`ne 2833, in from_callable
        follow_wrapper_chain`enter code here`s=follow_wrapped)
      File "/usr/lib/python3.7/inspect.py", line 2284, in _signature_from_callable
        return _signature_from_function(sigcls, obj)
      File "/usr/lib/python3.7/inspect.py", line 2154, in _signature_from_function
        kind=_POSITIONAL_OR_KEYWORD))
      File "/usr/lib/python3.7/inspect.py", line 2469, in __init__
        self._kind = _ParameterKind(kind)
      File "/usr/lib/python3.7/enum.py", line 310, in __call__
        return cls.__new__(cls, value)
      File "/usr/lib/python3.7/enum.py", line 530, in __new__
        if type(value) is cls:
RecursionError: maximum recursion depth exceeded while calling a Python object

urls.py …

所以我试图制作一个简单的程序,计算谐波系列的总和,然后打印结果.但随后递归限制阻止它继续下去.

这是程序:

def harm_sum(n):
    if n < 2:
        return 1
    else: 
return (1 / n) + (harm_sum(n - 1))

x = 1
while True:
    print(x, harm_sum(x))
    x += 1

我希望程序继续运行尽管递归限制是否有办法做到这一点？