Aufsummieren mal anders

[duodiscus]

Hallo zusammen,
wenn ich eine Summe von Werten bilden wollte, habe ich dieses bisher immer mit einer Schleife gelöst:

Code: Alles auswählen

def summe(n):
    summe=0
    for i in range(n):

        summe = summe + i+1
        
    print(summe)

Wie könnte ich denn eine Aufsummierung der Zahlen rekursiv angehen? Also das sich die Funktion immer wieder selbst aufruft und die Werte bis n aufsummiert? Kann mir da jemand was zu sagen? Vielen Dank!

[duodiscus]

Habe es schon.

Code: Alles auswählen

return n + SummeRek(n-1)

[snafu]

Wohl eher so:

Code: Alles auswählen

def gib_summe(n):
    return n + gib_summe(n - 1) if n > 1 else n

Denn ohne eine Abbruchbedingung wird die rekursive Aufrufkette niemals beendet. Außer natürlich, wenn der Stack voll ist. Wobei die Abbruchbedingung keinesfalls nur ein notwendiges Übel ist, sondern vielmehr einen essentiellen Bestandteil für die dahinter stehende Logik darstellt.

Und falls man mal was ganz Verrücktes machen möchte:

Code: Alles auswählen

def gib_summe(n):
    return sum(range(n + 1))

Oder auch total crazy:

Code: Alles auswählen

def gib_summe(n):
    return (n**2 + n) / 2

[BlackJack]

Und wieder eine Hausaufgabenlösung für duodiscus. Hihihi.

[Hyperion]

In Scala mit Endrekursion

Code: Alles auswählen

package Summen

import scala.annotation.tailrec

object Summe {

  def main(args: Array[String]) {
    println("Summe von 5 ist " + sum(5))
  }

  def sum(limit: Int) = {

    @tailrec
    def sumAcc(acc: Int, rest: Int): Int =
      if (rest == 0) acc
      else sumAcc(acc + rest, rest - 1)

    sumAcc(0, math.abs(limit))
  }

}

[BlackJack]

Vielleicht noch die *vernünftige* Lösung für diese Aufgabe, die weder iterativ noch rekursiv ist:

Code: Alles auswählen

def gib_summe(n):
    return n * (n + 1) / 2

[Hyperion]

Vielleicht noch die *vernünftige* Lösung für diese Aufgabe, die weder iterativ noch rekursiv ist:

Ach komm... der kleine Gauß wäre doch auch nie darauf gekommen, wenn seine REPL nicht aus Schiefer gewesen wäre

[Hyperion]

Hier noch mal der rekursive Ansatz in Clojure (Wieso gibt es da kein Syntax-Highlighting? Nicht mal irgend ein Lisp / Scheme finde ich da )

Code: Alles auswählen

(defn sum [n]
  (loop [acc 0 rest n]
    (if (zero? rest)
      acc
      (recur (+ acc rest) (dec rest)))))

Dabei fiel mir ein, dass wir den über ``reduce`` "vergessen" haben, also auch den mal in Clojure:

Code: Alles auswählen

(defn sum [n]
  (reduce + (range 1 (+ n 1))))

[BlackJack]

@Hyperion: Lisp und Scheme kann man manuell angeben. Aber wie man sieht, sind die nicht besonders.

[Hyperion]

Danke für den Tipp... ja, bringt jetzt nicht so viel

Verwendet das Board hier Geshi? Dafür gibts ne Implementierung: Link

[BlackJack]

@Hyperion: Jup, das Board verwendet Geshi.

[snafu]

Steht ja nur unter jedem Codeblock rechts unten...

[Hyperion]

Steht ja nur unter jedem Codeblock rechts unten...

Ja hab ich die Zeit und Muße alles zu lesen...

Auf uu.de gibt's Clojure Highlighting bereits - Pygments sei dank

Edit: Hier auch! s.o.
@BlackJack: Man kann auch "clojure" von Hand angeben - da geht vermutlich also so ziemlich alles von Geshi

[BlackJack]

Dann will ich auch mal etwas Rekursives beisteuern. Langweiliges JavaScript:

Code: Alles auswählen

var sum = function (n) { return (n > 0) ? n + sum(n - 1) : 0; };

[EyDu]

Dann mache ich mal mit:

Code: Alles auswählen

sum = lambda n: (lambda f, x: f(f, x))(lambda f, x: x + f(f, x - 1) if x > 0 else 0, n)

[DasIch]

Wirklich elegant lässt sich sowas doch nur in Opal implementieren:

Sum.sign

Code: Alles auswählen

SIGNATURE Sum

IMPORT Nat ONLY nat
       Seq ONLY seq


FUN sum : seq[nat] -> nat

Sum.impl

Code: Alles auswählen

IMPLEMENTATION Sum

IMPORT Nat COMPLETELY
       Seq COMPLETELY
       SeqReduce COMPLETELY


DEF sum(ns) == (+, 0) \ ns

[BlackJack]

Iterativ in 6510-Assembler:

Code: Alles auswählen

!zone
; In:   A = n
; Out:  A/X = sum from 1 to n
;       Y = 0
; Uses: A, X, Y, r1
sum:
        ldx #0
        tay
        cpy #0
        beq .exit
        stx r1
-
        clc
        tya
        adc r1
        sta r1
        bcc +
        inx
+
        dey
        bne -

        lda r1
.exit:
        rts