需要两个功能结合成一个（Python）的

-1

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]))

基本上，我需要的是同时返回的最大和最小数量的单一功能，它需要递归。我将如何更改此代码？

来源

2017-02-09 computer science noob

你尝试过什么吗？一个有两个最小值和最大值参数的常规循环会执行这个技巧 –

StackOverflow不是一个代码编写论坛。你试过什么了？请展示你的工作。 – Soviut

你可以写一个返回'Max（lst），Min（lst）'的函数。这将是低效率的，因为它会递归两次，但它是结合两个现有函数的最简单方法。 – BrenBarn

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)

来源

2017-02-09 20:17:29

这是高阶函数确切的想法。您可以在您的功能中添加compare参数，并通过lambda a, b: a>b获取Min和lambda a, b: a < b的最大值。然后，而不是m > lst[0]，使用compare(m, lst[0])

来源

2017-02-09 20:23:06

某些类型的列表输入操作递归算法/实现都非常很容易拿出，如果你知道的“猫腻”。这招是：

只是假设你已经有一个功能，可以做你想做的。

等待，不，不没有真正意义，不是吗？那么我们已经完成了。

我们认为再次尝试：

只是假设你已经有一个可以做你想做（但仅为投入1元小于你需要）什么功能。

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

那么我们想要什么做？在你的例子中，它返回列表的最小和最大元素。假设我们希望他们返回为2元组（也称为一个“对”）：

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有一个额外的限制：它不能处理空列表。（毕竟，空单不已经既不是最小的，也不是最大的因素。甚至没有魔法可以改变这一点。）

所以，如果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)

它的工作原理！

来源

2017-02-09 21:28:37

需要两个功能结合成一个（Python）的

回答

相关问题