Trennungsliste mit Rekursion

Ich versuche, diese Funktion mit Rekursion zu implementieren, die Funktion nimmt einen Funktionsparameter f an, wo bei einem Wert ein Wert zurückgegeben wird, der als wahr oder falsch zurückgegeben wird. Es sollte alle Werte in der Liste überprüfen und alle wahren Werte in einer Liste speichern und falsche Werte in einer anderen Liste, die sie in einem Tupel zurückgibt.

def divL(f, l): if not l: return ([],[]) else: a = list() b = list() for i in range(len(l)): if f(l[i]): a.append(l[i]) else: b.append(l[i]) return (a, b) 

3 Solutions collect form web for “Trennungsliste mit Rekursion”

Rekursive Version.

Aber ich stimme mit anderen überein, dass es besser ist, dies ohne Rekursion zu tun.

 def divL(f, l): if not l: return ([],[]) else: a, b = divL(f,l[1:]) if f(l[0]): a.insert(0, l[0]) else: b.insert(0, l[0]) return (a, b) #-- test --- def f(x): return x > 0 divL(f,[1,-2,3,4,2,-5]) ([1, 3, 4, 2], [-2, -5]) 

Um dieses Problem rekursiv zu lösen, dann kannst du mit:

 def div_l(fn, elements): if not elements: return ([], []) else: trues, falses = div_l(fn, elements[1:]) if fn(elements[0]): trues.append(elements[0]) else: falses.append(elements[0]) return (trues, falses) 

Eine Sache, um über Ihren Code zu bemerken, ist das, im Moment gibt es keine rekursiven Anrufe. Im obigen Code ist unser Basisfall, wenn die Liste der Elemente leer ist ( if not elements ). Dann überprüfen wir ständig das erste Element der Liste, um zu sehen, ob es fn befriedigt, es an trues oder falses entsprechend falses . Dann übergeben wir alle Elemente der Liste neben dem ersten ( elements[1:] ) zur Funktion wieder und wiederholen, bis die Liste leer ist.

Das Problem scheint nicht rekursiv in der Natur zu sein. Warum nicht nur Listenverständnisse verwenden :

 a = [element for element in l if f(element)] b = [element for element in l if not f(element)] 

Auch Namen wie a , b , l und f sind nicht so toll, weil sie nichts davon sagen, was sie eigentlich meinen.

In Bezug auf die Art und Weise, wie Sie Ihren Code so weit geschrieben haben, ist die pythonische Art, durch die Elemente einer Liste zu iterieren, nicht dasselbe wie Sprachen wie C / C ++ / Java / etc; Sie sollten selten Listenelemente mit ihrem Index erhalten müssen. Stattdessen können Sie Ihre for statement wie folgt neu schreiben:

 for element in l: if f(element): a.append(element) else: b.append(element) 

PS Ich habe den Code noch nicht getestet, aber es sollte ein vernünftiger Ausgangspunkt sein.

Rekursive Funktion, die Splitlisten als Parameter aufnimmt:

 def _R(f, l, ts, fs): if not l: return ts, fs if f(l[0]): return _R(f, l[1:], ts + l[:1], fs) return _R(f, l[1:], ts, fs + l[:1]) def R(f, l): return _R(f, l, [], []) print R( lambda x: x > 10, range(20) ) 
  • N-Queen-Backtracking in Python: Wie gibt man Lösungen zurück, anstatt sie zu drucken?
  • Den längsten Teilstring in alphabetischer Reihenfolge finden
  • Rekursiv finden Sie die kth größte int in Liste der Liste der int in Python
  • Baktracking-Funktion, die die Berechnung berechnet, überschreitet die maximale Rekursionstiefe
  • Merkwürdiges Rekursionsverhalten in Python
  • Rekursionsfunktion funktioniert nicht richtig
  • Maximales Niveau der Rekursion in Python
  • Python-Rekursions- und return-Anweisungen
  • Finde alle Index mit Rekursion
  • Python Recursive Funktion fehlende Ergebnisse
  • Lösen von vollständig versteckten Ausdrücken mit Rekursion
  • Python ist die beste Programmiersprache der Welt.