Die längste Liste in einer Liste von Listen in Python finden

Question

Ich muss die längste Liste von Listen in Python finden.

Zum Beispiel:

longest([1,2,3]) kehrt 3

longest([[[1,2,3]]]) gibt auch 3

longest([[], [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]], [1,2,3,4,5]]) kehrt 7 Gerade jetzt (Liste [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]] enthält 7 Elemente)

(innere Liste 3) Ich habe dieser Code, aber es macht nicht den Trick mit den ersten beiden Beispielen ..

def longest(list1): 
    longest_list = max(len(elem) for elem in list1) 
    return longest_list 

Vielleicht hilft Rekursion? Vielen Dank!

Answer 1

Hier ist eine rekursive Lösung für jede Tiefe Liste:

def longest(l): 
    if(not isinstance(l, list)): return(0) 
    return(max([len(l),] + [len(subl) for subl in l if isinstance(subl, list)] + 
     [longest(subl) for subl in l])) 

Answer 2

Python 3.3 Version:

def lengths(x): 
    if isinstance(x,list): 
     yield len(x) 
     for y in x: 
      yield from lengths(y) 

Nutzung:

>>> l = [[], [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]], [1,2,3,4,5]] 
>>> max(lengths(l)) 
7 

In Python 2.6+ Sie haben nicht die yield from Anweisung (wurde in Python 3.3 eingeführt wurde), so dass Sie das ändern müssen Code leicht:

def lengths(x): 
    if isinstance(x,list): 
     yield len(x) 
     for y in x: 
      for z in lengths(y): 
       yield z 

Answer 3

In der Tat kann Rekursion dies lösen.

def longest(lst): 
    if type(lst) is not list: 
     return 0 
    max = len(lst) 
    for i in lst: 
     max_i = longest(i) 
     if max_i > max: 
      max = max_i 
    return max 

Answer 4

Sie können dies tun, mit Rekursion:

def longest(list1) : 
    l = 0 
    if type(list1) is list : 
     l = len(list1) 
     if l > 0 : 
      l = max(l,max(longest(elem) for elem in list1)) 
    return l 

(online demo).

Der Code überprüft zunächst, ob es sich um is list handelt. Wenn ja, nehmen wir zuerst die len der Liste. Als nächstes führen wir einen rekursiven Aufruf seiner Elemente durch. Und berechnen Sie das Maximum longest der Elemente. Wenn das Maximum größer als die Länge selbst ist. Wir geben das Maximum zurück, sonst geben wir die Länge zurück.

Da die longest einer Nicht-Liste Null ist, wird die Rekursion stoppen, und wir haben eine Antwort für einzelne Elemente im induktiven Schritt verwendet werden.

Answer 5

Eine weitere rekursive Funktion Karte:

def longest(a): 
    return max(len(a), *map(longest, a)) if isinstance(a, list) and a else 0 

---

In [2]: longest([1,2,3]) 
Out[2]: 3 

In [3]: longest([[[1,2,3]]]) 
Out[3]: 3 

In [4]: longest([[], [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]], [1,2,3,4,5]]) 
Out[4]: 7 

und iterativ:

def longest(a): 
    mx = 0 
    stack = [a[:]] 
    while stack: 
     cur = stack.pop() 
     if isinstance(cur, list): 
      mx = max(mx, len(cur)) 
      stack += cur 
    return mx 

---

In [6]: longest([1,2,3]) 
Out[6]: 3 

In [7]: longest([[[1,2,3]]]) 
Out[7]: 3 

In [8]: longest([[], [3,[4,5],[2,3,4,5,3,3], [7], 5, [1,2,3], [3,4]], [1,2,3,4,5]]) 
Out[8]: 7