Question

这是我的代码 -

def Max(lst):
    if len(lst) == 1:
        return lst[0]
    else:
        m = Max(lst[1:])
        if m > lst[0]: 
            return m
        else:
            return lst[0]
def Min(lst):
    if len(lst) == 1:
        return lst[0]
    else:
        m = Min(lst[1:])
        if m < lst[0]: 
            return m
        else:
            return lst[0]
print("Max number:",Max([5,4,100,0,2]))
print("Min number:",Min([5,4,100,0,2]))

基本上我需要一个返回最大和最小数字的函数，它需要递归。我将如何更改此代码？

Answer 1

如果你知道“技巧”，那么在列表输入上运行的某些类型的递归算法/实现很容易想到 ~~very~~ 。那个伎俩是：

假设您已经拥有可以执行所需操作的功能。

等等，不，没有意义，是吗？然后我们就已经完成了。

让我们再试一次：

假设您已经拥有了可以执行所需操作的功能（但仅输入1个小于您需要的元素）。

那里好多了。虽然有点傻，但这是我们可以合作的假设。

那么我们想要做什么？在您的示例中，它返回列表的最小和最大元素。让我们假设我们希望它们以2元组的形式返回（a.k.a。“对”）：

lst = [5, 4, 100, 0, 2]

# Well, actually, we can only do this for a smaller list,
# as per our assumption above.
lst = lst[1:]

lst_min, lst_max = magic_min_max(l)  # I want a pony!

assert lst_min == 0   # Wishful thinking
assert lst_max == 100 # Wishful thinking

如果我们有这样一个神奇的功能，我们可以用它来解决实际输入大小的问题吗？我们试试吧：

def real_min_max(lst):
    candidate = lst[0]
    rest_of_the_list = lst[1:]
    min_of_rest, max_of_rest = magic_min_max(rest_of_the_list) # Allowed because
                                                               # smaller than lst
    min_of_lst = candidate if candidate < min_of_rest else min_of_rest
    max_of_lst = candidate if candidate > max_of_rest else max_of_rest
    return min_of_lst, max_of_lst

不是很简单，但很直接，不是吗？ 但是我们假设我们的魔术函数magic_min_max有一个额外的限制：它无法处理空列表。（毕竟，一个空列表都没有最小值也不是最大元素。甚至 magic 都不能改变它。）

因此如果lst的大小为1，我们就不能调用魔术函数。不过对我们来说没问题。这种情况很容易被发现和易于规避。单个元素是其列表的最小值和最大值，因此我们只返回两次：

def real_min_max(lst):
    candidate = lst[0]
    if len(lst) == 1:
        return candidate, candidate  # single element is both min & max
    rest_of_the_list = lst[1:]
    min_of_rest, max_of_rest = magic_min_max(rest_of_the_list) # Allowed because
                                                               # smaller than lst
                                                               # but (if we get
                                                               # here) not empty
    min_of_lst = candidate if candidate < min_of_rest else min_of_rest
    max_of_lst = candidate if candidate > max_of_rest else max_of_rest
    return min_of_lst, max_of_lst

就是这样。

但等等...... 没有魔法。如果我们想要调用一个函数，它必须实际存在。因此，我们需要实现一个可以返回列表的最小值和最大值的函数，因此我们可以在real_min_max而不是magic_min_max中调用它。由于这是关于递归的，你知道解决方案：real_min_max 是该函数（一旦通过调用存在的函数来修复它），我们就可以拥有它自称：

def real_min_max(lst):
    candidate = lst[0]
    if len(lst) == 1:
        return candidate, candidate  # single element is both min & max
    rest_of_the_list = lst[1:]
    min_of_rest, max_of_rest = real_min_max(rest_of_the_list) # No magic needed,
                                                              # just recursion!
    min_of_lst = candidate if candidate < min_of_rest else min_of_rest
    max_of_lst = candidate if candidate > max_of_rest else max_of_rest
    return min_of_lst, max_of_lst

我们试一试：

lst = [5, 4, 100, 0, 2]
real_min_max(lst)  # returns (0, 100)

有效！

Answer 2

import sys


class MaxMin:
  max = -sys.maxint - 1
  min = sys.maxint

  def getMaxMin(self, lst, obj):
      if len(lst) == 1:
          obj.max = lst[0]
          obj.min = lst[0]
      else:
          self.getMaxMin(lst[1:], obj)
          if obj.max < lst[0]: 
              obj.max = lst[0]
          if obj.min > lst[0]: 
              obj.min = lst[0]

obj = MaxMin()
obj.getMaxMin([5,4,100,0,2], obj)
print("Max number:",obj.max)
print("Min number:",obj.min)

Answer 3

这是高阶函数的确切概念。您可以在函数中添加compare参数，并将lambda a, b: a>b传递给Min和lambda a, b: a < b以获取最大值。然后，使用m > lst[0]

而不是compare(m, lst[0])

需要将两个函数合二为一（Python）

3 个答案: