eine Rekursionsfunktion, die einen int zurückgibt

Question

Diese Funktion übergab eine verschachtelte Liste von Ints und ein einzelnes int als Argumente; es gibt die Anzahl, wie oft das einzelne int-Argument in dem verschachtelten Liste Argumente erscheint, zum Beispiel:

nested_count([[1,2,[4,[1],8],[1,3,2]],[1,1]], 1) 

kehrt 5

Ich bin nicht sicher, warum meine Funktion nicht

jemand nicht arbeiten kann sagen ich, wie man es repariert? Danke vielmals.

Answer 1

Sie fügen nicht nested_count Ergebnisse c:

def nested_count(lst, l): 
    c = 0 
    for i in lst: 
     if i == l: 
      c += 1 
     elif type(i) == list: 
      c += nested_count(i, l) 
    return c 

Auch ist es besser Liste iterieren mit für.

Answer 2

Die Ergebnisse der geschachtelten Funktionsaufrufe werden nicht verwendet. Sie sollten die Zeilen wahrscheinlich durch c += nested_count(l,a) bzw. c += nested_count(x,a) ersetzen.

Answer 3

Sie sollten die Liste nicht mutieren, während Sie darüber iterieren, und Sie müssen das Ergebnis von rekursiven Aufrufen zurückgeben. Sie können die Funktion erheblich vereinfachen, indem Sie den Typ l überprüfen und int dann bool zurückgeben und sagen, ob es mit a übereinstimmt. Im Fall l ist eine Liste rufen Sie einfach nested_count rekursiv auf seinen Stücke und sum das Ergebnis:

def nested_count(l, a): 
    # Base case 
    if type(l) == int: 
     return l == a 
    return sum(nested_count(x, a) for x in l) 

Answer 4

Warum die heterogene Liste? Warum die Mühe mit der Eingabe machen, wenn Sie nicht alle Parameter eingeben werden? Warum mutieren Sie die Eingabe?

from typing import List 

def deep_count_elem (x:int, xs:List) -> int: 
    # done 
    if len(xs) == 0: 
    return 0 
    # if list, count in this list and recurse 
    elif isinstance(xs[0], list): 
    return deep_count_elem(x, xs[0]) + deep_count_elem(x, xs[1:]) 
    # if element matches, add 1 
    elif x == xs[0]: 
    return 1 + deep_count_elem(x, xs[1:]) 
    # otherwise add nothing, move to next element 
    else: 
    return deep_count_elem(x, xs[1:]) 

print(deep_count_elem(1, [[1,2,[4,[1],8],[1,3,2]],[1,1]])) # 5 

Answer 5

Wie andere erwähnt haben, müssen Sie die Rückgabewerte aus den rekursiven Aufrufen von nested_count akkumulieren die richtige Gesamtsumme.

Auch das Entfernen von Elementen aus einer Liste (oder einer anderen Sammlung), die Sie durchlaufen, kann zu unerwarteten Ergebnissen führen. Weitere Informationen finden Sie in der SO Python Common Question Removing items from a list while iterating over the list und einige relevante SO-Seiten, insbesondere: Removing from a list while iterating over it.

Es ist im Allgemeinen zu call isinstance rather than type vorgezogen, Typprüfung zu tun. Die isinstance Funktion kann für mehrere Typen in einem Aufruf testen, es gibt auch True zurück, wenn das Objekt eine Unterklasse des angegebenen Typs ist.

Hier sind ein paar Einzeiler, die Listen oder Tupel behandeln.

def nested_count(l, a): 
    return sum(nested_count(x, a) if isinstance(x, (list, tuple)) else x == a for x in l) 

und

def nested_count(l, a): 
    return l.count(a) + sum(nested_count(x, a) for x in l if isinstance(x, (list, tuple)))