Das deutsche Python-Forum

def aufsum(i):
    ergebnis = len(i)
    zaehler = len(i[-1])
    x = 1
    summe = 0
    while(ergebnis > 0):
        summe = int(i[zaehler - 1]) * x + summe
        x = x + 1
        ergebnis = ergebnis - 1
        zaehler = zaehler - 1
    return summe
print aufsum("123")

also, mein problem... i-wie bekomme ich nicht das richtige ergebnis...
das programm soll die eingegebenen zahlen aufsummieren, nach dem prinzip 1 * zahl1 + 2* zahl2.... 9*zahl9

zb bei 1956:1*1 + 2*9 +3*5 +4*6

Es geht auch noch kürzer, aber wenn wir als Input eine Liste nehmen:

Code: Alles auswählen

def aufsum(l):
    total = 0
    for n, i in enumerate(l):
        total += (n + 1) * i
    return total

print aufsum([1,2,3])

Hilft das?

Gruß,
Christian

danke, eig würde es ja so gehn, nur darf ich den befehl enumerate nicht benutzen..
es würde auch rekursiv gehen, jedoch nur mit den befehlen (while, for, if, range, len etc)
sonst hätte ich nicht diese probleme ^^

Squaller hat geschrieben:danke, eig würde es ja so gehn, nur darf ich den befehl enumerate nicht benutzen.

Warum?

weil wir den befehl noch nicht iom unterricht hatten...
für private zwecke werde ich den benutzen, jedoch muss ich das auch in der klasse aufschreiben und erklären können, dann etsteht ein problem mit den leuten die diesen befehl nicht kennen, das ist bei uns nicht so gern gesehen

Och, nee: http://www.python-forum.de/topic-1689.html

Dookie hat geschrieben:Hallo,

leider kommt es immer wieder vor, daß hier manche glauben, wir würden ihre Hausaufgaben lösen. Dafür ist dieses Forum echt nicht gedacht. Wenn einer bei einem Problem Hilfe braucht, geben wir gerne Hilfestellung, aber wenn hier Leute her kommen, die weder von Programmierung noch von Python eine Ahnung haben und glauben wir würden Ihnen fertige Lösungen liefern, so sind die hier falsch!

Gruß

Dookie

aber ich hab aj schon selbst ein programm geschrieben und möchte ja nur wissen wo da der fehler liegt und keine fertige lösung, ich bin mir schon bewusst was da steht, ich habs mir selbst schon durchgelesen, allerdings ist dieses forum doch dazu da hilfestellung zu geben, was für mich bedeutet dass man (auch wenn es eine "hausaufgabe" sein sollte) wenigstens helfen sollte fehler zu finden, ich schreibe ja nicht die aufgabenstellung, sondern nur mein programm hin und möchjte den fehler wissen

Ohne `enumerate()` (ungetestet):

Code: Alles auswählen

from itertools import count, izip

def aufsummieren(iterable):
    return sum(int(i) * x for i, x in izip(iterable, count(1)))

Es wird bei euch also nicht gern gesehen, wenn Schüler selbstständig denken und lernen!? Kein Wunder das PISA immer so peinlich ist.

Lustig :3

Code: Alles auswählen

In [7]: sum([(i+1)*int(j) for i, j in enumerate("1458")])
Out[7]: 56

(Gott, ich liebe Generator)

hehe^^
ja, is wirklich so... als append benutzt wurde is der lehrer ganz böse geworden

sry wenn ich nerven sollte, aber das geht nich

findet keiner den fehler bei mir?
würde schon gern wissen wie mein programm richtig wäre, weil ich es dann auch besser nachvollziehen kann, denn: aus fehlern lernnt man doch am meisten

Squaller hat geschrieben:hehe^^
ja, is wirklich so... als append benutzt wurde is der lehrer ganz böse geworden
sry wenn ich nerven sollte, aber das geht nich
findet keiner den fehler bei mir?
würde schon gern wissen wie mein programm richtig wäre, weil ich es dann auch besser nachvollziehen kann, denn: aus fehlern lernnt man doch am meisten

Jap. Man merkt dann nämlich, was für'n Driss man gedacht hat und überlegt sich'ne neue, tollere Struktur.

Lass dich nicht von deinem Lehrer tyrannisieren. Wenn er sich aufregt, dass du enumarate benutzt, erklär ihm einfach was das macht und sag ihm, dass du das aus purem Interesse des Unterichts selbst angeeignet hast. Wenn er sich dann noch aufregt, geh zum Rektor.

Hoi,

hast ja recht: Du hast einen Lösungsvorschlag gegeben, also werde ich mich mal darauf beziehen.

Squaller hat geschrieben:hehe^^
ja, is wirklich so... als append benutzt wurde is der lehrer ganz böse geworden

Dann habt ihr schlechten Unterricht. Wenn ein Lehrer nicht akzeptiert, daß seine Schüler eigenmotiviert lernen, sollte man mit ihm reden.

Squaller hat geschrieben: sry wenn ich nerven sollte, aber das geht nich
findet keiner den fehler bei mir?

Doch, vor allem in der Rechschreibung. Sorry, aber es ist einfach schwieriger wilde Grammatik & Phantasiewörter zu entziffern, als jemanden, der sich da etwas mehr Mühe gibt. Möchte ich auch mal sagen dürfen.

Zu Deinem Code:
- Wieso bestimmst Du "Zaehler" so wie Du es tust? Auf diese Weise wird "Zaehler" abhängig von der letzten Ziffer.
- Wieso wird in der Schleife von einem Zähler (ich nehme mal an, es soll eine Zählvariable darstellen) etwas abgezogen?

Wenn ich das berücksichtige komme ich auf

Code: Alles auswählen

def aufsum(i):
    ergebnis = len(i)
    zaehler = 0
    summe = 0
    x = 1
    while(ergebnis > 0):
        summe += int(i[zaehler]) * x 
        x += 1
        ergebnis -= 1
        zaehler += 1
    return summe
print aufsum("1956")

Das ist aber immer noch reichlich von hinten durch die Brust ins Auge! Überlege mal, ob Du - selbst ohne die vielen schönen Features von Python - *wirklich* zwei "Zählvariablen", nämlich "ergebnis" und "zaehler" brauchst, die Du verändern mußt. Tipp: In welcher Beziehung könntest Du die beiden Größen stellen? Kannst Du das vielleicht beim Start der Schleife abfragen?

Gruß,
Christian

Hier nochmal eine Version ohne Enumarate :3

Code: Alles auswählen

In [63]: def aufsummieren(liste, enum=1):
    if len(liste) > 1:
        return (liste[0] * enum) + aufsummieren(liste[1:], enum+1)
    else:
        return liste[0] * enum
   ....:     
   ....:     

In [68]: aufsummieren([1,4,5,8])
Out[68]: 56

erstmal danke...
ich weiß was du meinst... nur ich komme nicht drauf wie ich nur eine variable verwenden kann...
ich denk dass ich ja jetzt das gröbste habe ist auch schonmal ein großer fortschritt..
aber ich habe eine frage...
die variable zähler, warum wird die jetzt hoch gezählt und ist nicht mehr len(i)...

überfordert^^

Code: Alles auswählen

def aufsum(i): 
    zaehler = 0 
    summe = 0 
    x = 1 
    while(len(i) > zaehler): 
        summe = summe + int(i[zaehler]) * x 
        x = x + 1 
        zaehler = zaehler + 1 
    return summe

so in etwa

@BlackVivi: Rekursionsanker ist typischerweise eher die leere Liste:

Code: Alles auswählen

def aufsummieren(xs, n=1):
    if xs:
        return n * xs[0] + aufsummieren(xs[1:], n + 1)
    else:
        return 0

Wobei das in Python natürlich eine ziemlich ineffiziente Lösung ist.

@Squaller: Man kann noch einen Namen einsparen. Entweder `zaehler` oder `x`.

OT: Zwei mögliche Lösungen in Logo:

Code: Alles auswählen

to aufsummieren :zahlen
output apply "sum map [# * ?] :zahlen
end

to aufsummieren :zahlen [:n 1]
output ifelse (emptyp :zahlen) ~
    [0] ~
    [(:n * first :zahlen) + (aufsummieren (butfirst :zahlen) (:n + 1))]
end

BlackJack hat geschrieben:@BlackVivi: Rekursionsanker ist typischerweise eher die leere Liste:
Code: Alles auswählen
def aufsummieren(xs, n=1):
    if xs:
        return n * xs[0] + aufsummieren(xs[1:], n + 1)
    else:
        return 0
Wobei das in Python natürlich eine ziemlich ineffiziente Lösung ist.

Ein Tag, an dem man nichts lernst, ist ein verlorener. Vielen Dank :3

(Das's ineffizent ist, merk ich scho, bei einer Liste mit 993 Elementen ist bereits Schluß. Mit PyPy wird's wohl da besser.)

Nicht wirklich. Ich meinte nicht mal das Rekursionslimit, sondern das bei jedem rekursiven Aufruf mit ``xs[1:]`` die ganze Liste bis auf das jeweils erste Element kopiert wird. Damit "explodiert" der Speicherbedarf völlig unnötig. Funktionale Programmiersprachen, wo seine eine Rekursion eine "natürliche" Lösung wäre, benutzen für Listen in der Regel verkettete Listen und da ist das eine schnelle und speicherschonende Operation.

BlackJack hat geschrieben:Nicht wirklich. Ich meinte nicht mal das Rekursionslimit, sondern das bei jedem rekursiven Aufruf mit ``xs[1:]`` die ganze Liste bis auf das jeweils erste Element kopiert wird. Damit "explodiert" der Speicherbedarf völlig unnötig. Funktionale Programmiersprachen, wo seine eine Rekursion eine "natürliche" Lösung wäre, benutzen für Listen in der Regel verkettete Listen und da ist das eine schnelle und speicherschonende Operation.

Oh, oki. Hast wohl recht, dasselbe ist mir mal aufgefallen, als ich selber mit verschiedenen Implementationen vom Sieb des Erathosthenes gespielt habe, wenn Listen aufgesplittet oder Elemente gelöscht und hinzugefügt werden, is das'n unglaublicher Speicherfresser.

(Bah, derb' Off Topic wegen mir geworden. Verzeiht...)

@BlackJack

man könnte auch beide sparen und xrange nehmen - oder sehe ich dies falsch ?

Code: Alles auswählen


for index in xrange(len(i)):

gruß frank

Das deutsche Python-Forum

problem beim code zu aufsummieren

problem beim code zu aufsummieren