Wie kann ich wieder die ungeraden zahlen aus einer Liste, die nur mithilfe von Rekursion in Python?

Möchte ich nicht verwenden, while-oder for-Schleifen, die wollen nur, Rekursion zu verwenden, um die Rückkehr der ungeraden zahlen in einer Liste gegeben. Danke!

Ah! Sie sollten immer so sagen.
Das löschen meiner Antwort, da Sie wollte, dass die Rekursion und die Antwort erfolgt durch die GWW. Ich bin mir nicht sicher, warum habe ich von Ihnen positiv bewertet werden für meine Antwort. +1 zu GWW
-1 @ null-Aufwand "mache meine Hausaufgaben für mich, so kann ich vermeiden die Unannehmlichkeiten der etwas lernen"
sorry, es kam aus hw, 1 Jahr [wenn Sie diese Frage gefragt wurde] war ich in der Schule studieren einem völlig unabhängigen Thema (Finanzen)! Ich labaled es hw, weil es war so ähnlich wie auf Fragen in den hw-Bereich. Sorry, es störte Sie, wenn..

InformationsquelleAutor zallarak | 2010-10-28

python recursion

9
```
def find_odds(numbers):
  if not numbers:
    return []
  if numbers[0] % 2 == 1:
    return [numbers[0]] + find_odds(numbers[1:])
  return find_odds(numbers[1:])
```
Keine zusätzlichen Variablen oder Parameter benötigt.
- Dies ist (IMNSHO) die beste Lösung, um Datum, da es sowohl minimiert die übergebenen Argumente und nicht beschädigt die ursprüngliche Liste. +1.
- Ich habe eine dumme Frage zu stellen...ist das nicht eine neue Liste erstellt wird, jedesmal, wenn [numbers[0]] + find_odds(numbers[1:]) ausgeführt wird? :-\ @Josh, +1
- die Linie tatsächlich erstellt zwei Listen, eine mit dem ersten element, und eine mit allen übrigen Elementen.
- Kann mir bitte jemand erklären, in ein wenig mehr detail, wie dieses Programm funktioniert? Btw, wenn die Liste zu lang ist, dann startet das Programm ausspucken RuntimeError: maximum recursion depth exceeded in comparison.
- Ja, das ist ein Risiko, mit Rekursion. Welche Teile der code-snippet möchten Sie klären?
- Ich bin verwirrt, was die zweite if-Anweisung ist dabei. Wie wird Sie gehen Sie durch die Liste, und die überprüfung aus, welche gerade oder ungerade? Dann endlich die Rückgabe nur an den ungeraden.
- Nach der ersten leeren überprüfen, find_odds überprüft, ob das erste element in der Liste ist merkwürdig. Wenn es ist, gibt es eine Liste gemacht, das erste element verkettet mit dem Ergebnis des Aufrufs find_odds auf den rest der Elemente in der Liste. Ansonsten, wenn das erste element ist nicht seltsam, es gibt das Ergebnis des Aufrufs find_odds auf den rest der Elemente in der Liste, ignorieren Sie das erste element. Auf diese Weise werden alle Elemente in der Liste werden nacheinander verarbeitet, und die resultierende Liste enthält nur die ungeraden Elemente, die festgestellt wurden.
InformationsquelleAutor Josh Matthews
7
```
def only_odd(L):
    return L[0:L[0]&1]+only_odd(L[1:]) if L else L
```
Diese version ist viel schneller als es vermeidet Kopien von L
```
def only_odd_no_copy(L, i=0):
    return L[i:i+(L[i]&1)]+only_odd_no_copy(L, i+1) if i<len(L) else []
```
Diese eine verwendet nur O(log n) Stapelspeicher
```
def only_odd_logn(L):
    x=len(L)/2+1
    return L[:L[0]&1] + only_odd2(L[1:x]) + only_odd_logn(L[x:]) if L else L
```
- schön! Ich mag die Verwendung von &
- 1 ist nur eine verschleierte version des some_int % 2 ... was wie? Es ist der L[0:boolean], die die Kontur der gnenius ... +1 von mir.
- Hmm...ich muss das null, weil es explizit ist besser als implizit
- Müssen Sie haben, aber ich ging voran und entfernt ihn, während ich war-profiling-code. +1 ich denke, Sie hatte die beste Antwort vor mir 😉
- was ist nicht zu mögen. Bitweise ops sind genial, und ich glaube nicht, dass wir Sie sehen genug. Ja, das andere bit ist ziemlich clever.
- L[i:] else ... macht eine Kopie (im Durchschnitt) etwa die Hälfte von L, und sofort wirft Sie Weg. Wie wäre es mit einem PEP für ein composite-IS_SLICE_EMPTY oder SLICE_LEN opcode 😕
- Sind Sie richtig. lassen Sie mich ersetzen Sie es mit i<len(L)
InformationsquelleAutor John La Rooy
3
```
def find_odds(numbers, odds):
    if len(numbers) == 0:
        return
    v = numbers.pop()
    if v % 2 == 1:
        odds.append(v)
    find_odds(numbers, odds)

odds = []
numbers = [1,2,3,4,5,6,7]
find_odds(numbers,odds)
# Now odds has the odd numbers
print odds
```
Hier ist eine test-Ausgabe von dem, was ich bekomme, wenn ich dieses

[7, 5, 3, 1]
- wo ist die Verschiedenheit Liste zurückgegeben?
- Die variable odds bearbeitete ich meine Antwort ein bisschen helfen
- Es wird modifiziert durch die Verweis . So würde man die Funktion wie result = []; find_odds(nums, result)
- ich versuchte dies und es ist nicht für mich arbeiten
- Es funktioniert völlig in Ordnung für mich.
- Bitte nicht die Hausaufgaben für jemand nächste mal.
InformationsquelleAutor GWW
3

Unter Berücksichtigung der Standard-stack depth limit von 1000 in python, ich würde wirklich keine Rekursion für diese. Ich weiß, es gibt eine Menge von rekursiven Implementierungen vor, so dass hier eine nicht-rekursive man, dass es zu tun ist, den python-Weg:
```
print filter(lambda x: x % 2, range(0, 10))
```
Und der Vollständigkeit halber; wenn Sie wirklich, wirklich müssen Rekursion hier ist mein gehen Sie. Dies ist sehr ähnlich zu der version von Josh Matthews.
```
def rec_foo(list):
    if not list:
        return []
    return ([list[0]] if list[0] % 2 else []) + rec_foo(list[1:])

print rec_foo(range(1, 10))
```
- +1: filter scheint zu sein, die pythonic way.
- Mehr pythonic way wäre [x for x in lst if x % 2]. Und bitte verwenden Sie nicht builtin-Namen (Liste) als parameter-Namen.
- Gut, ich gebe zu, die Verwendung der Liste nicht die beste Wahl, aber hey, wir alle machen Fehler. Was ich nie verstehe ist, wie man eine Liste comp ist mehr pythonic als eine vordefinierte Funktion.
- Art erklärt, dass Verstehens eine "bessere" Art und Weise wie dieses: artima.com/weblogs/viewpost.jsp?thread=98196
- Ich war schon immer ein für die Prüfung seiner Güte.
InformationsquelleAutor dcolish
2

Hier ist ein weiterer Weg, es zu tun, gibt die Liste der ungeraden zahlen eher als das ändern der Liste übergeben. Sehr ähnelt GWW aber ich dachte, ich füge es der Vollständigkeit halber.
```
def find_odds(numbers, odds):
    if len(numbers) == 0:
        return odds

    if numbers[0] % 2 == 1:
        odds.append(numbers[0])

    return find_odds(numbers[1:],odds)

print find_odds([1,2,3,4,5,6,7,8,9],[])
```
Ausgabe:
```
[1, 3, 5, 7, 9]
```
- können Sie denken Sie an einen Weg, es zu tun mit nur einem parameter? danke
- Sicher, man könnte (als eine Möglichkeit) erstellen der Liste enthalten alle die Informationen und übergeben Sie einfach die Liste. Aber das ist eine noch schlimmere Forderung als Ihre ebenso willkürliche "müssen Rekursion", da es Hinzugefügt wurde, nachdem die Frage beantwortet wurde. Und, um ehrlich zu sein, ich würde lieber Menschen helfen, als spielen "wir ändern die Anforderungen von" Spiele - es ist nicht als ob ich nicht genug davon bekommen, dass in meinem echte job 🙂
InformationsquelleAutor paxdiablo

Da es eine party, die ich dachte, ich würde in Glockenspiel mit eine schöne, vernünftige, Echte Programmierer^TM Lösung. Es ist geschrieben in emacs und inspiriert von gnibbler Antwort. Mag sein, es nutzt &1 statt % 2 (Zugabe von 2 in co_consts ist Reine Dekadenz, wenn 1 ist schon vorhanden) und nutzt das praktische trick für immer das erste element nur, wenn es ist seltsam, aber Rasiert einige Zyklen ab, die für eine Zeitersparnis von rund 5% (auf meinem Rechner läuft 2.6.5 kompiliert mit GCC 4.4.3 auf eine linux2 kernel).

from opcode import opmap
import types

opcodes = [opmap['LOAD_FAST'],      0,0,   #    L
           opmap['JUMP_IF_FALSE'],  24,0, 
           opmap['DUP_TOP'],
           opmap['LOAD_CONST'],     0,0,   #    0
           opmap['BINARY_SUBSCR'],  
           opmap['LOAD_CONST'],     1,0,   #    1
           opmap['BINARY_AND'],
           opmap['SLICE+2'],
           opmap['LOAD_GLOBAL'],    0,0,   #    odds
           opmap['LOAD_FAST'],      0,0,
           opmap['LOAD_CONST'],     1,0,
           opmap['SLICE+1'],
           opmap['CALL_FUNCTION'],  1,0,
           opmap['BINARY_ADD'],
           opmap['RETURN_VALUE']]

code_str = ''.join(chr(byte) for byte in opcodes)

code = types.CodeType(1, 1, 4, 0x1 | 0x2 | 0x40, code_str, (0, 1),
                      ('odds',), ('L',), '<nowhere>', 'odds',
                      0, '')

odds = types.FunctionType(code, globals())

+1 Würde gerne sehen, dass der Ausgang des OP Absenden dieses für Ihre Hausaufgaben. Ich Hinzugefügt ein paar bessere Möglichkeiten, auf meine Antwort
+1 für den wtf-Blick des prof

InformationsquelleAutor aaronasterling

1
```
odds = []
def findOdds(listOfNumbers):
    if listOfNumbers[0] % 2 == 1:
        odds.append(listOfNumbers[0])
    if len(listOfNumbers) > 1:
        findOdds(listOfNumbers[1:])

findOdds(range(0,10))
print odds
# returns [1,3,5,7,9]
```
- Was ist Rekursion?
- Dies ist eindeutig eine bessere Lösung für die Rekursion.
- Also, wenn Ihr Kunde Sie fragt, was für eine web-app für die Ausführung unter IIS (eine ganz bestimmte Anforderung), was denken Sie, was Sie sagen wird, wenn Sie liefern ein Websphere-version, weil Sie "eindeutig eine bessere Lösung"? 🙂
- In dieser situation wäre, würde ich Sie beschimpfen, weil die Lehrer zu bitten, eine dumme Frage. 🙂 Es war schon immer ein Favorit vergangene Zeit von mir.
- anderes Szenario
- Ich nehme an, Sie don ' T Arbeit, dann.
- -1 für die falsche regex-basierte Lösung. Nicht nur, dass es keine Rekursion, aber es nicht kommen in der Nähe arbeiten (es gibt 1 wenn Sie es passieren 12)! Wenn Sie wollen, es zu tun mit nur einem einzigen Ausdruck filter(lambda x: x % 2 == 1, arrayOfNumbers) ist der richtige Weg, es zu tun, nicht regexes.
- so richtig...
- Sie brauchen noch nicht einmal den == 1
- Ein regex für zahlen (was bedeutet das str->int>str Umstellung) klingt wie ein hammer-Nagel-situation.
InformationsquelleAutor Scott

def odds(L):
    if L == []: 
        return []
    else:
        if L[0]%2:
            B = odds(L[1:])
            B.append(L[0])
            return B
        else:
            return odds(L[1:])

InformationsquelleAutor inspectorG4dget

>>> def fodds(alist, odds=None):
...     if odds is None: odds = []
...     if not alist: return odds
...     x = alist[0] # doesn't destroy the input sequence
...     if x % 2: odds.append(x)
...     return fodds(alist[1:], odds)
...
>>> fodds(range(10)) # only one arg needs to be supplied
[1, 3, 5, 7, 9] # same order as input
>>>

Dadurch vermeidet man die Liste kopieren overhead, der sich auf die Kosten bekommen die Antwort nach hinten und eine große Steigerung in der Hässlichkeit-Faktor:

>>> def fo(aseq, pos=None, odds=None):
...     if odds is None: odds = []
...     if pos is None: pos = len(aseq) - 1
...     if pos < 0: return odds
...     x = aseq[pos]
...     if x % 2: odds.append(x)
...     return fo(aseq, pos - 1, odds)
...
>>> fo(range(10))
[9, 7, 5, 3, 1]
>>>

InformationsquelleAutor John Machin

gut, da sind wir alle beitragen:

def odds(aList):
    from operator import lshift as l
    if aList and not aList[1:]:
        return aList if aList[-1] - l(aList[0]>>1, 1) else list()
    return odds(aList[:len(aList)/3+1]) + odds(aList                                     \
    [len(aList)/3+1:]) if aList else []

InformationsquelleAutor SingleNegationElimination

0

Gut, es gibt ein paar andere Antworten, aber ich denke mir das die sauberste:
```
def odds(L):
   if not L: 
      return []
   return [L[0]] * (L[0] % 2) + odds(L[1:])
```
Spaß ausüben, aber nur zu wiederholen, nicht immer tun Sie dies rekursiv in der Praxis.
- mutiert das input-argument eine leere Liste ist sauber?
InformationsquelleAutor Triptych

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.