🖥️

Array-Schreibtischtest

Informatik · Gymnasium · Klassen 10–13 · PRIMM-Methode

Algorithmen Interaktiv Kl. 10–13

🎯 Worum geht's? Klasse 10–13 · 1 Unterrichtsstunde

Nach dieser Seite kannst du …

Schleifen über Arrays Schritt für Schritt verfolgen
Inhalte und Indizes eines Arrays nach jedem Schritt angeben
typische Fehler wie einen falschen Index erkennen

Vorwissen: Variablen, Schleifen

📝 Aufgaben

Jede Aufgabe hat fünf Schritte: Predict › Run › Investigate › Modify › Make. Wähle eine Aufgabe aus – oder nutze oben die Leiste „Aufgaben: 1, 2, 3 …“.

0

⚡ Gesammelte XP

0

✅ Aufgaben abgeschlossen

0

🔥 Streak (Tage)

–

🎯 Genauigkeit

📖 Die PRIMM-Methode

Jede Aufgabe durchläuft fünf Phasen:

🔮

P – Predict

Vorhersage: Was macht der Code?

▶️

R – Run

Trace-Tabellen & Arrays befüllen.

🔍

I – Investigate

Gezielte Verständnisfragen.

✏️

M – Modify

Code für neues Ziel anpassen.

🛠️

M – Make

Eigene Methode implementieren.

🏅 Zuletzt verdiente Badges

🔮 Predict

Aufgabe 1

Analysiere die folgende Methode, ohne sie auszuführen.

Aufruf: berechne(new int[]{4, 7, 2, 9})

💡 Was gibt die Methode zurück?

▶️ Run – Trace-Tabelle

Verfolge jeden Schleifendurchlauf. Eingabe: {4, 7, 2, 9}

Schritt	i	a[i]
Start	–	–
i = 0	0	4
i = 1	1	7
i = 2	2	2
i = 3	3	9
Rückgabewert

Trage nach jedem Durchlauf den neuen Wert von x ein: alter Wert plus a[i].

🔍 Investigate

Was passiert bei einem leeren Array new int[]{}?

Wie viele Iterationen führt die Schleife für ein Array der Länge n aus?

✏️ Modify

Ändere die Methode so, dass sie das Produkt aller Elemente berechnet. Für {4, 7, 2, 9} soll 504 zurückkommen.

int berechne(int[] a) {
    int x = 0;           // anpassen
    for (int i = 0; i < a.length; i++) {
        x = x + a[i];   // anpassen
    }
    return x;
}

Eine Summe startet bei 0. Mit welchem Wert muss ein Produkt starten, damit die erste Multiplikation nichts verfälscht?

🛠️ Make

Schreibe eine Methode verarbeite, die das Maximum eines Arrays zurückgibt. Für {4, 7, 2, 9, 1} soll 9 zurückkommen.

int verarbeite(int[] a) {
    // Implementierung hier

}

Merke dir den bisher größten Wert – starte mit dem ersten Element – und vergleiche jedes weitere Element damit.

🔮 Predict

Aufgabe 2

Aufruf: transformiere(new int[]{1, 2, 3, 4, 5})

💡 Welches Array wird zurückgegeben?

▶️ Run – Ergebnis-Array

Eingabe a[]:

[0]

1

[1]

2

[2]

3

[3]

4

[4]

5

Ergebnis b[]:

[0]

[1]

[2]

[3]

[4]

Welcher Index von b wird bei i = 2 beschrieben?

Berechne für jedes i den Zielindex a.length - 1 - i: Wohin wandert a[0], wohin a[1]?

🔍 Investigate

Verändert transformiere das ursprüngliche Array a?

Was berechnet a.length − 1 − i für a.length=5, i=4?

✏️ Modify

Passe die Methode so an, dass sie nur Elemente an geraden Indizes (0, 2, 4, …) zurückgibt. Für {10, 20, 30, 40, 50} → {10, 30, 50}

int[] transformiere(int[] a) {
    int anzahl = 0;            // anpassen
    int[] b = new int[anzahl];
    for (int i = 0; i < a.length; i++) {
        b[i] = a[i];           // anpassen
    }
    return b;
}

Wie viele gerade Indizes hat ein Array der Länge n? Außerdem brauchst du einen zweiten Zähler für die nächste freie Stelle in b.

🛠️ Make

Implementiere kombiniere: Verbindet zwei Arrays zu einem. {1,2,3} + {4,5} → {1,2,3,4,5}

int[] kombiniere(int[] a, int[] b) {
    // Implementierung hier

}

Neues Array der Länge a.length + b.length. Zwei Schleifen: erst a kopieren, dann b – ab welchem Index beginnt b?

🔮 Predict

Aufgabe 3

Aufruf: auswerten(new int[]{3, 1, 2, 3, 1, 3, 2})

💡 Was steht nach dem Aufruf in z[3]?

▶️ Run – Ergebnis-Array

Eingabe: {3, 1, 2, 3, 1, 3, 2} — trage z[] nach der Schleife ein:

[0]

[1]

[2]

[3]

[4]

[5]

Jeder Wert dient als Index: Zähle, wie oft 1, 2 und 3 vorkommen. Was steht in Feldern, die nie getroffen werden?

🔍 Investigate

Was passiert, wenn ein Wert > 5 im Array ist, z. B. werte = {6}?

Warum hat z die Größe 6 statt 5?

✏️ Modify

Ergänze findeHaeufigsten: Gibt den häufigsten Wert zurück. Für {3,1,2,3,1,3,2} → 3

int findeHaeufigsten(int[] werte) {
    int[] z = auswerten(werte);
    int maxAnzahl = 0;
    int ergebnis  = 1;
    for (int i = 1; i < z.length; i++) {
        // prüfe, ob z[i] > maxAnzahl
        // falls ja: aktualisiere maxAnzahl und ergebnis

    }
    return ergebnis;
}

Merke dir in der Schleife den größten bisher gesehenen Zähler – und den Index i, zu dem er gehört.

🛠️ Make

Implementiere zaehleVorkommen: Wie oft kommt x in a vor?

int zaehleVorkommen(int[] a, int x) {
    // Implementierung hier

}

Ein Zähler, eine Schleife, ein Vergleich mit x.

🔮 Predict

Aufgabe 4

Aufruf: durchlauf(new int[]{5, 3, 8, 1, 4})

💡 Wie sieht das Array nach einem Durchlauf aus?

▶️ Run – Trace nach jedem Schritt

i	Vergleich	Tausch?	[0]	[1]	[2]	[3]	[4]
Start	–	–	5	3	8	1	4
0	5>3?	Ja
1	5>8?	Nein
2	8>1?	Ja
3	8>4?	Ja

Vergleiche immer nur die Nachbarn a[i] und a[i+1] und tausche, wenn der linke größer ist. Arbeite mit dem schon veränderten Array weiter.

🔍 Investigate

Warum endet die Schleife bei i < a.length − 1?

Was garantiert ein einzelner Durchlauf?

✏️ Modify

Ändere die Bedingung so, dass durchlauf absteigend sortiert.

void durchlauf(int[] a) {
    for (int i = 0; i < a.length - 1; i++) {
        if (a[i] > a[i + 1]) {   // anpassen
            int t      = a[i];
            a[i]     = a[i + 1];
            a[i + 1] = t;
        }
    }
}

Die Bedingung entscheidet, wann getauscht wird. Was muss gelten, damit die großen Werte nach vorne wandern?

🛠️ Make

Implementiere den vollständigen Bubble Sort.

void sortiere(int[] a) {
    // Implementierung hier

}

Äußere Schleife läuft a.length−1 Mal; innere Schleife wie in durchlauf.

🔮 Predict

Aufgabe 5

Aufruf: markiere(20)

💡 Welche der folgenden Zahlen ist keine Primzahl ≤ 20?

▶️ Run – m[] für n = 10

Trage true/false ein (oder t/f):

[0]

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

0 und 1 sind keine Primzahlen. Streiche dann die Vielfachen von 2 (ab 4) und von 3 (ab 9).

🔍 Investigate

Warum beginnt die äußere Schleife bei p = 2?

Warum startet die innere Schleife bei k = p * p?

✏️ Modify

Ergänze sammlePrimzahlen: Alle Primzahlen bis n in einem Array zurückgeben.

int[] sammlePrimzahlen(int n) {
    boolean[] m = markiere(n);

    // 1. Zähle die Primzahlen
    int anzahl = 0;
    // dein Code

    // 2. Fülle das Ergebnis-Array
    int[] erg = new int[anzahl];
    // dein Code

    return erg;
}

Gehe zweimal über m: Beim ersten Mal zählen, beim zweiten Mal jede Zahl i mit m[i] == true ins Ergebnis schreiben – mit eigenem Zähler für die Position.

🛠️ Make

Implementiere pruefeZahl: Probedivision, kein Sieb.

boolean pruefeZahl(int n) {
    // Implementierung hier

}

n≤1→false, n==2→true. Schleife bis i*i≤n, prüfe n%i==0.

🔮 Predict

Aufgabe 6

Aufruf: bearbeite(new int[]{1, 2, 3, 4, 5, 6})

💡 Was steht nach dem Aufruf im Array?

▶️ Run – Trace (Two-Pointer)

l, r: Werte nach l++/r--

Tausch	l	r	[0]	[1]	[2]	[3]	[4]	[5]
Start	0	5	1	2	3	4	5	6
1.
2.
3.

Nach jedem Tausch rücken beide Zeiger: l eins nach rechts, r eins nach links. Die Schleife endet, wenn sie sich treffen.

🔍 Investigate

Warum while (l < r) und nicht while (l <= r)?

Wie viele Tauschoperationen für ein Array der Länge n?

✏️ Modify

Ergänze eine Bedingung: nur tauschen, wenn a[l] < 4.

void bearbeite(int[] a) {
    int l = 0;
    int r = a.length - 1;
    while (l < r) {
        // Bedingung ergänzen: nur tauschen, wenn a[l] < 4
        int t  = a[l];
        a[l]   = a[r];
        a[r]   = t;
        l++;
        r--;
    }
}

Die Bedingung muss nur den Tauschblock umschließen – die Zeiger sollen trotzdem weiterrücken.

🛠️ Make

Implementiere pruefeSymmetrie: {1,2,3,2,1}→true, {1,2,3}→false

boolean pruefeSymmetrie(int[] a) {
    // Implementierung hier

}

Vergleiche mit zwei Zeigern von außen nach innen. Schon ein Unterschied genügt für false.

🔮 Predict

Aufgabe 7

Aufruf: gleite(new int[]{1, 3, 5, 2, 4}, 3)

💡 Was steht in erg[0]?

▶️ Run – Ergebnis-Array

i	Fenster	erg[i]
0	1+3+5
1	3+5+2
2	5+2+4

Jedes Fenster umfasst k = 3 Nachbarn ab Index i. Addiere sie.

🔍 Investigate

Welche Länge hat erg für Länge 5 und k=3?

Wie nennt man diese Technik?

✏️ Modify

Passe gleite an: statt Summe das Maximum jedes Fensters.

int[] gleite(int[] a, int k) {
    int[] erg = new int[a.length - k + 1];
    for (int i = 0; i < erg.length; i++) {
        int s = 0;            // anpassen: Maximum statt Summe
        for (int j = i; j < i + k; j++) {
            s += a[j];        // anpassen
        }
        erg[i] = s;
    }
    return erg;
}

Starte s nicht mit 0, sondern mit dem ersten Wert des Fensters – und ersetze die Addition durch einen Vergleich.

🛠️ Make

Implementiere findePosition: Index des Maximums (kleinster Index bei Gleichstand). {3,7,7,2}→1

int findePosition(int[] a) {
    // Implementierung hier

}

Merke dir den Index des bisher größten Elements. Mit > (statt >=) bleibt bei Gleichstand der kleinere Index.

🔮 Predict

Aufgabe 8

Aufruf: suche(new int[]{1, 4, 6, 8, 11}, 10)

💡 Was gibt die Methode zurück?

▶️ Run – Trace (Two-Sum)

Schritt	l	r	a[l]	a[r]	s	Aktion
1
2
3
4

Aktion: l++, r-- oder true

Ist die Summe zu klein, muss sie größer werden (l++), ist sie zu groß, kleiner (r--). Das klappt, weil das Array sortiert ist.

🔍 Investigate

Warum funktioniert der Algorithmus nur bei sortierten Arrays?

Wie viele Vergleiche im schlechtesten Fall?

✏️ Modify

Ändere suche: gibt den Index des linken Partners zurück (oder −1).

boolean suche(int[] a, int ziel) {
    int l = 0;
    int r = a.length - 1;
    while (l < r) {
        int s = a[l] + a[r];
        if      (s == ziel) return true;  // anpassen
        else if (s <  ziel) l++;
        else                r--;
    }
    return false;                         // anpassen
}

Statt true/false soll eine Zahl zurückkommen. Was ändert sich am Rückgabetyp und an den beiden return-Zeilen?

🛠️ Make

Implementiere binaerSuche: Index von ziel im sortierten Array, oder −1.

int binaerSuche(int[] a, int ziel) {
    // Implementierung hier

}

Halte die Grenzen l und r fest und schau in die Mitte. Ist der Wert dort zu klein, suchst du rechts weiter, sonst links. Wann ist nichts mehr übrig?

🔮 Predict

Aufgabe 9 – Insertion Sort

Aufruf: insertionSort(new int[]{5, 2, 8, 1, 3})

💡 Welches Array liegt nach vollständiger Ausführung vor?

▶️ Run – Trace nach jedem Durchlauf

Trage den Zustand des Arrays nach jedem Außenschleifendurchlauf ein. Eingabe: {5, 2, 8, 1, 3}

i	a[0]	a[1]	a[2]	a[3]	a[4]
Start	5	2	8	1	3
1
2
3
4

In Durchlauf i wird a[i] als key gemerkt; größere Elemente links davon rücken eine Stelle nach rechts, dann kommt key in die Lücke.

🔍 Investigate

Wie viele Vergleiche führt Insertion Sort im besten Fall (bereits sortiertes Array) durch?

Was ist der wesentliche Unterschied zwischen Insertion Sort und Bubble Sort?

✏️ Modify

Ändere Insertion Sort so, dass er absteigend sortiert (größtes Element zuerst).

void insertionSort(int[] a) {
    for (int i = 1; i < a.length; i++) {
        int key = a[i];
        int j = i - 1;
        while (j >= 0 && a[j] > key) {  // anpassen
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = key;
    }
}

Die Bedingung der while-Schleife entscheidet, welche Elemente nach rechts geschoben werden. Was muss sich ändern, damit die großen vorne landen?

🛠️ Make

Schreibe eine Methode selectionSort, die ein Array durch Selection Sort aufsteigend sortiert: finde in jedem Durchlauf das Minimum des unsortierten Rests und tausche es an die richtige Stelle.

void selectionSort(int[] a) {
    // Implementierung hier

}

Äußere Schleife: die Position i, die gefüllt wird. Innere Schleife: den Index des kleinsten Elements im Rest suchen. Danach a[i] mit diesem Element tauschen.

🔮 Predict

Aufgabe 10 – Merge (Zusammenführen)

Aufruf: merge(new int[]{1,3,5}, new int[]{2,4,6})

💡 Welches Array wird zurückgegeben?

▶️ Run – Merge-Trace

Verfolge jeden Schritt der while-Schleife. Eingabe: a={1,3,5}, b={2,4,6}

Schritt	i	Verglichen
1		a[0]=1 vs b[0]=2
2		a[1]=3 vs b[0]=2
3		a[1]=3 vs b[1]=4
4		a[2]=5 vs b[1]=4
5		a[2]=5 vs b[2]=6
6	3	b[2]=6 (Rest)

Vergleiche immer a[i] mit b[j]; das kleinere kommt nach c, und nur sein Zeiger rückt weiter. Ist ein Array aufgebraucht, wird der Rest des anderen übernommen.

🔍 Investigate

Welche Voraussetzung müssen a und b erfüllen, damit merge korrekt funktioniert?

Welche Zeitkomplexität hat merge für zwei Arrays der Länge m und n?

✏️ Modify

Ändere merge so, dass Duplikate aus dem Ergebnis-Array entfernt werden: tritt ein Wert in a und b auf, soll er nur einmal ins Ergebnis.

int[] merge(int[] a, int[] b) {
    int[] c = new int[a.length + b.length];
    int i = 0, j = 0, k = 0;
    while (i < a.length && j < b.length) {
        if (a[i] <= b[j]) c[k++] = a[i++];
        else               c[k++] = b[j++];
    }
    while (i < a.length) c[k++] = a[i++];
    while (j < b.length) c[k++] = b[j++];
    return c;
}

Behandle den Fall a[i] == b[j] getrennt: Wert einmal übernehmen und beide Zeiger weiterrücken. Am Ende ist c zu lang – Arrays.copyOf(c, k) kürzt es.

🛠️ Make

Implementiere mergeSort: teile das Array rekursiv in zwei Hälften, sortiere sie einzeln und führe sie mit merge zusammen. Für {5, 2, 8, 1, 3} soll {1, 2, 3, 5, 8} zurückkommen.

int[] mergeSort(int[] a) {
    // Basisfall: Array der Länge 0 oder 1 ist bereits sortiert

    // Teile in linke und rechte Hälfte

    // Sortiere rekursiv

    // Führe zusammen mit merge()

}

Basisfall: Länge 0 oder 1. Sonst in der Mitte teilen (Arrays.copyOfRange), beide Hälften rekursiv sortieren und mit merge zusammenführen.

🏅 Deine Badges

Verdiente Badges leuchten auf – noch nicht erreichte zeigen dir, was als nächstes wartet.

📊 Statistik

↺ Fortschritt zurücksetzen

Achtung: Alle gespeicherten Ergebnisse werden unwiderruflich gelöscht.

📄 Arbeitsblatt erstellen

Wähle aus, welche Bereiche auf das Arbeitsblatt kommen. Es enthält dann alle … Aufgaben dieser Seite aus diesen Bereichen – mit Kästchen zum Ankreuzen, leeren Tabellen und Platz zum Schreiben, ohne Lösungen und Tipps.

Bereiche für das Arbeitsblatt 🔮 Predict – vorhersagen, was der Code macht ▶️ Run – Werte Zeile für Zeile in die Tabelle eintragen 🔍 Investigate – untersuchen, warum der Code so arbeitet ✏️ Modify – Code gezielt verändern 🛠️ Make – eigene Methode schreiben

Aufgabe gelöst!

Array-Schreibtischtest

📝 Aufgaben

📖 Die PRIMM-Methode

P – Predict

R – Run

I – Investigate

M – Modify

M – Make

🏅 Zuletzt verdiente Badges

🏅 Deine Badges

📊 Statistik

↺ Fortschritt zurücksetzen

📄 Arbeitsblatt erstellen