Werte eines Arrays addieren

[BlackSalad]

hallo,

ich hab ne Frage zum addieren von arrays.

Wenn ich jetzt ein array hab und will alle Werte dieses arrays addieren um eine Zahl zu erhalten mit der ich rechnen kann. Wie mache ich das denn dann?


Hab schon gegooglet und das gefunden , verstehe es aber leider nicht so ganz:

for (int i = 0; i < array.length; i++ )
{
zaehler += array[i];
}

Würd mich freuen, wenn mir das jm daran erklären könnte.

 

[Der Müde Joe]

zaehler += array[i];

entspricht:

zaehler = zaehler + array[i];

und drum rum ne schleife.

 

[Fu3L]

Addiere jedes Element i des Arrays zu der Variablen zaehler, die vorher irgendwo deklariert wurde, damit sie nach dem Schleifendurchlauf auch noch lesbar ist...

 

[BlackSalad]

Super! Vielen Dank!!

 

[s_1895]

und wenn der Algorithmus rekursiv sein muss?

 

[s_1895]

und wenn der Algorithmus rekursiv sein muss?

 

[kneitzel]

Und wieder ein Zombi-Thread ....

Wenn Du den Thread rekursiv haben willst: Was hast Du Dir denn bisher überlegt? Was könntest Du denn da machen?

 

[s_1895]

Und wieder ein Zombi-Thread ....

Wenn Du den Thread rekursiv haben willst: Was hast Du Dir denn bisher überlegt? Was könntest Du denn da machen?

int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum();

 

[kneitzel]

int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum();

Das ist eine Stream Lösung, aber wo siehst Du eine Rekursion. Du wolltest doch eine Rekursive Lösung (unabhängig von der Sinn-Frage)....

 

[s_1895]

Muss ich das mit einer If Bedingung machen ?

Ich studiere neben bei und ich hab das mit der Rekursion noch nicht richtig verstanden und durch das online Semester (zwecks Corona ) gibt auch nicht wirklich jemanden den ich fragen kann. Ich soll ein Array rekursiv aufsummieren, das ist die Aufgabe.

 

[fhoffmann]

Die Idee ist folgende:

sum({1,2,3,4} = 1 + sum({2,3,4});
sum({2,3,4}) = 2 + sum({3,4})
sum({3,4}) = 3 + sum({4})
sum({4}) = 4 + sum({})
sum({}) = 0

 

[s_1895]

Ich habe allerdings kein gegebenes Array, und wenn ich das so mache, muss ich doch für jede Array Länge ein Code schreiben richtig?

Die Idee ist folgende:

sum({1,2,3,4} = 1 + sum({2,3,4});
sum({2,3,4}) = 2 + sum({3,4})
sum({3,4}) = 3 + sum({4})
sum({4}) = 4 + sum({})
sum({}) = 0

 

[kneitzel]

Bei der Rekursion ist die Idee immer gleich:
- Du führst es immer auf f(x) = irgendwas mit f(x-1). Bei einem Array wäre es also so wie @fhoffmann es gezeigt hat: Immer ein Array mit einem Element weniger.
- Und dann hast Du eine Abbruchbedingung. Die Summe bei einem leeren Array ist 0.

Da du aber nun nicht auf einfache Art und weise immer ein um eins kleineres Array haben kannst, könntest Du das über Parameter machen, Du hast also eine Methode, die nicht nur das Array sondern auch das erste oder letzte Element als Parameter nimmt.

Du hättest also sozusagen etwas wie:

sum({1,2,3,...}, 0) = 1 + sum({1,2,3,4}, 1);
sum({1,2,3,...}, 1) = 1 + 2 + sum({1,2,3,4}, 2);
...

Und Abbruch wäre, wenn der zweite Parameter dann gleich der Länge ist ...

 

[temi]

Hier ein Beispiel für die rekursive Ausgabe eines Char-Arrays:

    public static void main(String[] args) {

        char[] chars = "Hallo Welt!".toCharArray();

        print(chars, 0); // beginne bei Index 0 (= erstes Zeichen)
    }

    public static void print(char[] chars, int index) {
        if (index >= chars.length) return; // Abbruchbedingung: hör hier auf, wenn du am Ende bist

        System.out.print(chars[index]); // Mach was, hier: gib das geforderte Zeichen aus

        print(chars, index + 1); // ruf dich selbst auf, mit anderen Parametern, hier: nächster Index
    }

 

[mihe7]

@httpdigest hattest Du nicht einmal eine Zusammenfassung bzgl. Rekursion geschrieben?

 

[fhoffmann]

wenn ich das so mache, muss ich doch für jede Array Länge ein Code schreiben

Du hast nur eine Funktion:
- wenn das Array leer ist, gebe 0 zurück,
- ansonsten addiere das erste Elemt zur Summe des Arrays ab dem zweiten Element.

Da es in Java aber mühselig ist, ein Array ab dem zweiten Element zu erstellen (man muss hier sehr viel kopieren - in anderen Programmiersprachen (z.B Lisp) ist dies ganz natürlich), gab es hier schon einige Vorschläge, das Problem mit einem weiteren Parameter "index" zu erschlagen. Die ursprüngliche Idee bleibt aber die gleiche.

 

[mihe7]

ich hab das mit der Rekursion noch nicht richtig verstanden

Das Prinzip solltest Du eigentlich aus der Mathematik kennen.

Das Produkt der ersten n natürlichen Zahlen kann man wie folgt definieren:

Das wäre eine "iterative" Definition: man hat eine Laufvariable i, die von 1 bis n läuft , so dass das Produkt 1*2*3*...*(n-1)*n entsteht.

Nun ist aber:

und für das Produkt ganz rechts gilt offensichtlich:

Also haben wir insgesamt:

Damit hätte man fak(n) unter "Rückgriff auf sich selbst" (=> rekursiv) definiert, allerdings mit einem kleinen Problem: fak(0)=n*fak(-1) ist nicht definiert, denn -1 ist kein Element der natürlichen Zahlen. Wir müssen also dafür sorgen, dass die Rekursion definiert endet:

Und genau das kann man nun im Programm schreiben:

public int fak(int n) {
    if (n == 0) {
        return 1;
    }
    return n*fak(n-1);

    // oder kurz: return n == 0 ? 1 : n*fak(n-1);
}