benötigen zwei Funktionen in einem (Python) kombinieren

Question

Hier ist mein Code-

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

Grundsätzlich muss ich eine einzige Funktion, die sowohl die größte und kleinste Zahl zurückgibt und es muss rekursiv sein. Wie würde ich diesen Code ändern?

Answer 1

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 2

, die die genaue Vorstellung von Funktionen höherer Ordnung ist. Sie können in Ihrer Funktion einen compare Parameter hinzufügen und lambda a, b: a>b für Min und lambda a, b: a < b für max. statt m > lst[0], dann verwenden Sie compare(m, lst[0])

Answer 3

Einige Arten von rekursiven Algorithmen/Implementierungen auf einer Liste Eingangsbetrieb sind sehr ganz einfach, mit zu kommen, wenn Sie den „Trick“ kennen. Dieser Trick ist:

Nehmen Sie einfach an, Sie haben bereits eine Funktion, die tun kann, was Sie wollen.

Warten, nein, das nicht wirklich Sinn macht, nicht wahr? Dann wären wir schon fertig.

Lassen Sie uns versuchen, dass wieder:

nur annehmen, dass Sie bereits eine Funktion haben, die das tun können, was Sie wollen (aber nur für die Eingänge 1 Element kleiner als Sie benötigen) .

Dort, viel besser. Obwohl ein bisschen albern, das ist eine Annahme, mit der wir arbeiten können.

Also was tun wir wollen? In Ihrem Beispiel werden die minimalen und maximalen Elemente einer Liste zurückgegeben. Nehmen wir an, wir wollen, dass sie als ein 2-Tupel zurückgegeben (auch bekannt als ein „Paar“):

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 

Wenn wir eine solche magische Funktion haben, können wir es verwenden, um das Problem für die tatsächliche Eingangsgröße zu lösen? Lass es uns versuchen:

Nicht gerade einfach, aber ziemlich geradlinig, nicht wahr? Aber angenommen, unsere magische Funktion magic_min_max hat eine zusätzliche Einschränkung: Es kann keine leeren Listen behandeln. (Immerhin eine leere Liste nicht haben weder ein Minimum noch ein Maximum Element. Nicht einmal Magie kann das ändern.)

Also, wenn lst Größe hat 1, müssen wir die magische Funktion nicht aufrufen . Kein Problem für uns. Dieser Fall ist leicht zu erkennen und einfach zu umgehen. Das einzige Element ist sowohl Minimum und Maximum seiner Liste, so dass wir es nur zweimal zurück:

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 

Damit basta.

Aber warten ... gibt es keine Magie. Wenn wir eine Funktion aufrufen wollen, muss sie tatsächlich existieren. Also müssen wir eine Funktion implementieren, die das Minimum und Maximum einer Liste zurückgibt, so dass wir sie in real_min_max statt magic_min_max aufrufen können. Da dies über Rekursion ist, wissen Sie die Lösung: real_min_maxist diese Funktion (sobald es durch den Aufruf einer Funktion festgelegt ist, dass nicht vorhanden sind), so können wir es selbst nennen haben:

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 

Versuchen wir es:

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

Es funktioniert!