➕

Vorlesung 10

Algorithmen Grundlagen II — Akkumulieren & Zählen

Grundlagen der Programmierung
Prof. Dr. Alexandra Mikityuk
HTW Berlin

Summe · Durchschnitt · Zählen · Produkt

📚 Rückblick & heute

🔙 Letzte Vorlesung

🔄 Werte tauschen (Swap)
⬆️⬇️ Maximum und Minimum finden
🔁 Schleifen: aufwärts vs. abwärts

🎯 Heute lernen wir

➕ Summe berechnen (Akkumulator-Muster)
📊 Durchschnitt berechnen
🔢 Elemente zählen
✖️ Produkt berechnen
🎯 Muster kombinieren

                Roter Faden: Eine Variable läuft durch die Schleife und sammelt ein Ergebnis ein — das ist das Akkumulator-Muster.
            

🎯 Das Akkumulator-Muster

Ein Akkumulator ist eine Variable, die Werte über die Schleife hinweg „einsammelt".

3[0]

7[1]

2[2]

5[3]

→

17summe

📐 Das Grundmuster — immer dieselben 2 Schritte

int akku = startwert;        // 1. Initialisieren

for (int i = 0; i < n; i++)
{
    akku = akku ○ arr[i];     // 2. Kombinieren
}
// ○ steht für: +, *, ++, …

➕ Summe berechnen

Berechne die Summe aller Zahlen im Array.

3[0]

+

7[1]

+

2[2]

+

5[3]

=

17summe

💡 Die Idee in 3 Schritten

Starte mit summe = 0 (neutrales Element für +)
Gehe durch alle Elemente
Addiere jedes Element zur Summe

➕ Summe — Schritt für Schritt

Mit dem Array {3, 7, 2, 5} — wie wächst die Summe?

Schritt	i	arr[i]	Berechnung	summe
Start	—	—	—	0
1	0	3	0 + 3	3
2	1	7	3 + 7	10
3	2	2	10 + 2	12
4	3	5	12 + 5	17 ✓

                Beobachtung: Die Summe wird in jedem Schritt aktualisiert — sie „erinnert" sich an alle bisherigen Werte.
            

➕ Summe im Code

#include <stdio.h>

int main()
{
    int zahlen[4] = {3, 7, 2, 5};
    int summe = 0;   // Startwert für +: 0

    for (int i = 0; i < 4; i++)
    {
        summe = summe + zahlen[i];
        // Kurzform: summe += zahlen[i];
    }

    printf("Die Summe ist: %d\n", summe);

    return 0;
}

Output

Die Summe ist: 17

💡 Kurzschreibweise

summe += zahlen[i] ist identisch mit
summe = summe + zahlen[i]

❓ Warum `summe = 0`?

✅ 0 ist das neutrale Element

Für die Addition gilt:

0 + x = x

Mit Start bei 0 ist das erste Ergebnis genau das erste Array-Element — die Summe wird nicht verfälscht.

⚠️ Häufiger Fehler

int summe;   // NICHT initialisiert!
for (...) {
    summe += zahlen[i];  // Zufallswert!
}

Ohne Initialisierung enthält summe einen zufälligen Wert → falsches Ergebnis.

Merksatz: Ein Akkumulator muss immer mit seinem neutralen Element starten.

📊 Durchschnitt berechnen

Erst die Summe sammeln, dann durch die Anzahl teilen.

#include <stdio.h>

int main()
{
    int zahlen[4] = {3, 7, 2, 5};
    int summe = 0;
    int anzahl = 4;

    for (int i = 0; i < anzahl; i++)
    {
        summe += zahlen[i];
    }

    double schnitt = (double)summe / anzahl;

    printf("Summe: %d\n", summe);
    printf("Durchschnitt: %.2f\n", schnitt);

    return 0;
}

Output

Summe: 17 Durchschnitt: 4.25

                        Formel:
Durchschnitt = Summe ÷ Anzahl
                    

⚠️ Achtung: Type Cast!

Bei int / int rechnet C ganzzahlig — der Rest fällt weg.

❌ Falsch

int summe = 17;
int anzahl = 4;
double d = summe / anzahl;

d = 4.00 (nicht 4.25!)

int / int = int → abgerundet.

✅ Richtig

int summe = 17;
int anzahl = 4;
double d = (double)summe / anzahl;

d = 4.25 ✓

(double)int / int = double

                💡 Merke: Für einen genauen Durchschnitt mindestens einen Operanden zu double casten — bevor dividiert wird.
            

🔢 Elemente zählen

Wie viele Zahlen sind größer als 5?

3[0]

7[1]

2[2]

8[3]

5[4]

9[5]

Antwort: 3 Zahlen (7, 8, 9)

💡 Die Idee

Starte mit zaehler = 0
Gehe durch alle Elemente
Wenn die Bedingung erfüllt ist → Zähler um 1 erhöhen

🔢 Zählen im Code

#include <stdio.h>

int main()
{
    int zahlen[6] = {3, 7, 2, 8, 5, 9};
    int zaehler = 0;   // Startwert: 0

    for (int i = 0; i < 6; i++)
    {
        if (zahlen[i] > 5)   // Bedingung prüfen
        {
            zaehler++;        // zaehler = zaehler + 1
        }
    }

    printf("%d Zahlen sind groesser als 5\n", zaehler);

    return 0;
}

Output

3 Zahlen sind groesser als 5

🔍 Kern

if (bedingung)
→ nur dann zaehler++

🔢 Verschiedene Bedingungen

Das Muster bleibt gleich — nur die Bedingung in if (…) ändert sich.

🔢 Gerade Zahlen

if (zahlen[i] % 2 == 0)
    zaehler++;

🔢 Ungerade Zahlen

if (zahlen[i] % 2 != 0)
    zaehler++;

➕ Positive Zahlen

if (zahlen[i] > 0)
    zaehler++;

🎯 Bestimmter Wert

if (zahlen[i] == 5)
    zaehler++;

Das Muster ist immer gleich: if (bedingung) zaehler++;

✖️ Produkt berechnen

Gleiches Muster wie die Summe — nur multiplizieren statt addieren.

#include <stdio.h>

int main()
{
    int zahlen[4] = {3, 7, 2, 5};
    int produkt = 1;   // Startwert für *: 1

    for (int i = 0; i < 4; i++)
    {
        produkt = produkt * zahlen[i];
        // Kurzform: produkt *= zahlen[i];
    }

    printf("Das Produkt ist: %d\n", produkt);

    return 0;
}

Output

Das Produkt ist: 210

                        Rechnung:
3 × 7 × 2 × 5 = 210
                    

❓ Warum `produkt = 1`?

1 ist das neutrale Element der Multiplikation.

1 × x = x

➕ Summe

Startwert: 0

weil 0 + x = x

✖️ Produkt

Startwert: 1

weil 1 × x = x

⚠️ Falle: Mit produkt = 0 wäre das Ergebnis immer 0 — denn 0 × x = 0.

✖️ Praxis — Fakultät berechnen

n! = 1 × 2 × 3 × … × n — z.B. 5! = 120

#include <stdio.h>

int main()
{
    int n = 5;
    int fakultaet = 1;   // Produkt startet bei 1

    for (int i = 1; i <= n; i++)
    {
        fakultaet *= i;   // 1, 2, 6, 24, 120
    }

    printf("%d! = %d\n", n, fakultaet);

    return 0;
}

Output

5! = 120

🔍 Beachte

Schleife startet bei i = 1 und nutzt i <= n — wir multiplizieren mit den Zahlen selbst, nicht mit Array-Indizes.

🎯 Muster kombinieren

Summe und Bedingung: nur die geraden Zahlen aufsummieren.

#include <stdio.h>

int main()
{
    int zahlen[6] = {3, 8, 5, 2, 7, 4};
    int summe = 0;

    for (int i = 0; i < 6; i++)
    {
        if (zahlen[i] % 2 == 0)   // nur gerade
        {
            summe += zahlen[i];
        }
    }

    printf("Summe der geraden Zahlen: %d\n", summe);
    // 8 + 2 + 4 = 14

    return 0;
}

Output

Summe der geraden Zahlen: 14

Idee: Akkumulator + Filter — kombiniere summe += mit einem if.

📊 Praxis — Notenstatistik

Zwei Akkumulatoren in einer Schleife: Durchschnitt und Bestanden-Zähler.

#include <stdio.h>

int main()
{
    int noten[8] = {2, 1, 3, 2, 5, 1, 4, 2};
    int summe = 0;
    int bestanden = 0;

    for (int i = 0; i < 8; i++)
    {
        summe += noten[i];
        if (noten[i] <= 4)
            bestanden++;
    }

    double schnitt = (double)summe / 8;

    printf("Durchschnitt: %.2f\n", schnitt);
    printf("Bestanden: %d von 8\n", bestanden);

    return 0;
}

Output

Durchschnitt: 2.50 Bestanden: 7 von 8

💡 Effizient

Mehrere Akkumulatoren teilen sich eine Schleife — kein doppelter Durchlauf nötig.

🧠 Quiz — Summe

Was gibt dieses Programm aus?

int arr[3] = {1, 2, 3};
int summe = 0;
for (int i = 0; i < 3; i++)
    summe += arr[i];
printf("%d", summe);

A0

B3

C6

D123

✅ Lösung — Summe

C6 — 1 + 2 + 3 = 6

Ablauf

i	arr[i]	summe
Start	—	0
0	1	0 + 1 = 1
1	2	1 + 2 = 3
2	3	3 + 3 = 6

🧠 Quiz — Zählen

Wie viele gerade Zahlen werden gezählt?

int arr[5] = {1, 4, 2, 6, 3};
int count = 0;
for (int i = 0; i < 5; i++)
    if (arr[i] % 2 == 0)
        count++;
printf("%d", count);

A1

B2

C3

D5

✅ Lösung — Zählen

C3 — gerade Zahlen sind 4, 2 und 6

Ablauf

i	arr[i]	% 2 == 0?	count
0	1	❌ Nein	0
1	4	✅ Ja	1
2	2	✅ Ja	2
3	6	✅ Ja	3
4	3	❌ Nein	3

🧠 Quiz — Produkt

Was ist der korrekte Startwert für ein Produkt?

int produkt = ???;
for (int i = 0; i < n; i++)
    produkt *= arr[i];

A0

B1

Carr[0]

D-1

✅ Lösung — Produkt

B1 — das neutrale Element der Multiplikation: 1 × x = x

💡 Warum nicht die anderen?

A) 0: 0 × x = 0 — Ergebnis immer 0!
C) arr[0]: funktioniert, aber dann muss die Schleife bei i = 1 starten
D) -1: würde das Vorzeichen umkehren

📋 Übersicht — Startwerte

Jeder Akkumulator hat seinen eigenen, passenden Startwert.

Operation	Startwert	Grund
➕ Summe	0	0 + x = x
✖️ Produkt	1	1 × x = x
🔢 Zähler	0	noch nichts gezählt
⬆️ Maximum	arr[0]	erstes Element als Vergleichswert
⬇️ Minimum	arr[0]	erstes Element als Vergleichswert

                ⚠️ Wichtig: Falscher Startwert = falsches Ergebnis. Bei Produkt nie mit 0 starten!
            

📋 Zusammenfassung — Summe

➕ Summen-Muster

int summe = 0;   // Start: 0
for (i = 0; i < n; i++)
{
    summe += arr[i];
}

📊 Für den Durchschnitt

double schnitt =
    (double)summe / n;

Cast nicht vergessen — sonst rundet C ab.

Merksatz: Summe sammelt mit +=, Start bei 0.

📋 Zusammenfassung — Zählen

🔢 Zähler-Muster

int zaehler = 0;   // Start: 0
for (i = 0; i < n; i++)
{
    if (bedingung)
    {
        zaehler++;
    }
}

✅ Typische Bedingungen

arr[i] > 5
arr[i] % 2 == 0
arr[i] == wert

Merksatz: Zähler erhöht sich nur, wenn die Bedingung stimmt.

📋 Zusammenfassung — Produkt

✖️ Produkt-Muster

int produkt = 1;   // Start: 1, NICHT 0!
for (i = 0; i < n; i++)
{
    produkt *= arr[i];
}

⚠️ Die häufigste Falle

Mit produkt = 0 bleibt das Ergebnis immer 0.

0 × x = 0

Bei Multiplikation immer mit 1 starten.

⚠️ Merke: Neutrales Element wählen — Summe → 0, Produkt → 1.

🔮 Nächste Vorlesung — Algorithmen Grundlagen III

Suchen & Sortieren

🔍 Lineare Suche
📍 Position eines Elements finden
✅ Prüfen, ob ein Element existiert
🔄 Bubble Sort (einfaches Sortieren)

                Heute gelernt: Summe · Durchschnitt · Zählen · Produkt. Das Akkumulator-Muster ist die Basis für unzählige Algorithmen.
            

Vorlesung 10

Algorithmen Grundlagen II — Akkumulieren & Zählen

📚 Rückblick & heute

🔙 Letzte Vorlesung

🎯 Heute lernen wir

🎯 Das Akkumulator-Muster

📐 Das Grundmuster — immer dieselben 2 Schritte

➕ Summe berechnen

💡 Die Idee in 3 Schritten

➕ Summe — Schritt für Schritt

➕ Summe im Code

Output

💡 Kurzschreibweise

❓ Warum summe = 0?

✅ 0 ist das neutrale Element

⚠️ Häufiger Fehler

📊 Durchschnitt berechnen

Output

⚠️ Achtung: Type Cast!

❌ Falsch

✅ Richtig

🔢 Elemente zählen

💡 Die Idee

🔢 Zählen im Code

Output

🔍 Kern

🔢 Verschiedene Bedingungen

🔢 Gerade Zahlen

🔢 Ungerade Zahlen

➕ Positive Zahlen

🎯 Bestimmter Wert

✖️ Produkt berechnen

Output

❓ Warum produkt = 1?

➕ Summe

✖️ Produkt

✖️ Praxis — Fakultät berechnen

Output

🔍 Beachte

🎯 Muster kombinieren

Output

📊 Praxis — Notenstatistik

Output

💡 Effizient

🧠 Quiz — Summe

✅ Lösung — Summe

Ablauf

🧠 Quiz — Zählen

✅ Lösung — Zählen

Ablauf

🧠 Quiz — Produkt

✅ Lösung — Produkt

💡 Warum nicht die anderen?

📋 Übersicht — Startwerte

📋 Zusammenfassung — Summe

➕ Summen-Muster

📊 Für den Durchschnitt

📋 Zusammenfassung — Zählen

🔢 Zähler-Muster

✅ Typische Bedingungen

📋 Zusammenfassung — Produkt

✖️ Produkt-Muster

⚠️ Die häufigste Falle

🔮 Nächste Vorlesung — Algorithmen Grundlagen III

Suchen & Sortieren

❓ Warum `summe = 0`?

❓ Warum `produkt = 1`?