➕ Algorithmen Grundlagen II

Akkumulieren und Zählen

Werte sammeln und zusammenfassen

Grundlagen der Programmierung

📚 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

                

🎯 Das Akkumulator-Muster

Ein Akkumulator ist eine Variable, die Werte "sammelt"

3[0]

7[1]

2[2]

5[3]

→

17 summe

📐 Das Grundmuster:

int akkumulator = startwert;  // 1. Initialisieren

for (int i = 0; i < n; i++)
{
    akkumulator = akkumulator ○ arr[i];  // 2. Kombinieren
}
// ○ kann sein: +, *, usw.

➕ Summe berechnen

Aufgabe: Berechne die Summe aller Zahlen im Array

3[0]

+

7[1]

+

2[2]

+

5[3]

= 17

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

                

➕ Summe: Schritt für Schritt

Array: {3, 7, 2, 5}

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

➕ Summe im Code

#include <stdio.h>

int main()
{
    int zahlen[4] = {3, 7, 2, 5};
    int summe = 0;  // Startwert für Addition: 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;
}

Die Summe ist: 17

💡 Kurzschreibweise: summe += zahlen[i] ist identisch mit summe = summe + zahlen[i]

❓ Warum summe = 0?

0 ist das neutrale Element der Addition:

0 + x = x

Wenn wir mit 0 starten, ist das erste Ergebnis genau das erste Array-Element.

⚠️ Häufiger Fehler:

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

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

📊 Durchschnitt berechnen

Formel: Durchschnitt = Summe ÷ Anzahl

durchschnitt = summe / n

#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 durchschnitt = (double)summe / anzahl;

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

    return 0;
}

⚠️ Achtung: Type Cast!

❌ Falsch

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

d = 4.0 (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: Um einen genauen Durchschnitt zu erhalten, müssen wir mindestens einen Wert zu double casten BEVOR wir dividieren!

🔢 Elemente zählen

Aufgabe: 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 Bedingung erfüllt → erhöhe Zähler um 1

                

🔢 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 größer als 5\n", zaehler);

    return 0;
}

3 Zahlen sind größer als 5

🔢 Verschiedene Bedingungen

Gerade Zahlen zählen

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

Ungerade Zahlen zählen

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

Positive Zahlen zählen

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

Bestimmten Wert zählen

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

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

✖️ Produkt berechnen

Statt zu addieren, können wir auch multiplizieren:

3 × 7 × 2 × 5 = 210

#include <stdio.h>

int main()
{
    int zahlen[4] = {3, 7, 2, 5};
    int produkt = 1;  // Startwert für Multiplikation: 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;
}

Das Produkt ist: 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

⚠️ Achtung: Mit produkt = 0 wäre das Ergebnis immer 0! (0 × x = 0)

✖️ Praxis: Fakultät berechnen

Fakultät n! = 1 × 2 × 3 × ... × n

Beispiel: 5! = 1 × 2 × 3 × 4 × 5 = 120

#include <stdio.h>

int main()
{
    int n = 5;
    int fakultaet = 1;

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

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

    return 0;
}

5! = 120

🎯 Muster kombinieren

Aufgabe: Berechne die Summe aller geraden Zahlen

#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 Zahlen
        {
            summe += zahlen[i];
        }
    }

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

    return 0;
}

Summe der geraden Zahlen: 14

📊 Praxis: Notenstatistik

#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;
}

Durchschnitt: 2.50 Bestanden: 7 von 8

🧠 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);

A) 0

B) 3

C) 6

D) 123

✅ Lösung: Summe

Antwort C: 6

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

Was gibt dieses Programm aus?

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);

A) 1

B) 2

C) 3

D) 5

✅ Lösung: Zählen

Antwort B: 2

Gerade Zahlen: 4 und 6 → 2 Stück

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

Oops! Da sind ja 3 gerade Zahlen (4, 2, 6)! Die richtige Antwort ist C: 3!

🧠 Quiz: Produkt

Was ist der korrekte Startwert für ein Produkt?

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

A) 0

B) 1

C) arr[0]

D) -1

✅ Lösung: Produkt

Antwort B: 1

1 ist das neutrale Element der Multiplikation: 1 × x = x

Warum nicht die anderen?

A) 0: 0 × x = 0 (Ergebnis immer 0!)
C) arr[0]: Funktioniert auch, aber dann bei i=1 starten!
D) -1: Würde das Vorzeichen umkehren

📋 Übersicht: Startwerte

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

📋 Zusammenfassung: Summe

➕ Summen-Muster

int summe = 0;                // Startwert: 0
for (int i = 0; i < n; i++)
{
    summe += arr[i];           // += addiert
}
// summe enthält die Gesamtsumme

Für Durchschnitt:

double schnitt = (double)summe / n;

📋 Zusammenfassung: Zählen

🔢 Zähler-Muster

int zaehler = 0;              // Startwert: 0
for (int i = 0; i < n; i++)
{
    if (bedingung)             // Wenn Bedingung erfüllt
    {
        zaehler++;             // Zähler erhöhen
    }
}
// zaehler enthält die Anzahl

Typische Bedingungen: arr[i] > 5, arr[i] % 2 == 0, arr[i] == wert

📋 Zusammenfassung: Produkt

✖️ Produkt-Muster

int produkt = 1;              // Startwert: 1 (NICHT 0!)
for (int i = 0; i < n; i++)
{
    produkt *= arr[i];         // *= multipliziert
}
// produkt enthält das Gesamtprodukt

⚠️ Merke: Bei Multiplikation IMMER mit 1 starten, nie mit 0!

🔮 Nächste Vorlesung

Algorithmen Grundlagen III: Suchen & Sortieren

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

Heute gelernt: Summe, Durchschnitt, Zählen, Produkt
Das Akkumulator-Muster ist die Basis für viele Algorithmen!