# Operationalisierte Lernziele

[Operatorenliste](https://www.nibis.de/nli1/gohrgs/operatoren/operatoren_ab_2010_2011/operatoren_informatik.pdf)

Was wir wollen: ggT über einfaches runterzählen. Anschließend Algorithmus mit Modulo vorführen. Beide Algorithmen per Hand durchführen und darüber zur Laufzeit gehen.

## Einfache mathematische Algorithmen

[Referenz](https://www.ruhr-uni-bochum.de/imperia/md/content/stochastik/stoppel/stochalg.pdf)

#### Studenten:
- beschreiben die Komponenten eines Flussdiagrams
- beschreiben den Aufbau eines Flussdiagrams
- entwerfen ein Flussdiagramm zur Beschreibung einfacher Aussagenlogischer wenn-dann Sätze. Bsp. "Wenn Peter Mathe mag, schreibt er nur Einsen"
- entwerfen ein Flussdiagramm zu bekannten einfachen mathematischen Funktionen z.B. des Betrags
- können Flussdiagramme in Struktogramme/Pseudocode überführen
- können Struktogramme in Implemtationen in abbozza (?) überführen
- Implementieren einfache mathematische Algorithmen (mit Hilfe eines Parsons-Puzzle)

### Euklidischer Algorithmus
#### Studenten:
- erklären den Aufbau eines euklidischen Algorithmus
- entwerfen fehlende Teile eines euklidischen Algorithmus

Zunächst Einführung in den euklidischen Algorithmus, für diejenigen, die den Ablauf nicht kennen:
Der euklidische Algorithmus führt in drei Schritten zur Lösung:
- Größere durch kleine Zahl dividieren
- Divisor durch Rest dividieren
- Ergebnis in mathematischer Schreibweise notieren

Die Student*innen sollen daraus ein Flussdiagramm entwerfen und mit dessen Hilfe den Algorithmus implementieren:

int h;
if (a == 0) return abs(b);
if (b == 0) return abs(a);

do {
    h = a % b;
    a = b;
    b = h;
} while (b != 0);

return abs(a);

## Entscheidungsbäume
#### Studenten:

- Beschränkung auf binär -> evtl. Studenten nach Beispiel eigenen Baum erstellen lassen
- Problemorientiert: Täterfindung
- Merkmale der Täterbeschreibung: (Haare, Augenfarbe, etc.)
- kurzer theoretischer Input
- Textaufgabe - selbst Entscheidungsbaum erstellen
- Überleitung wie programmiert man die einzelnen Komponenten
- Implementierung des Entscheidungsbaumes
- Übergang bzw. kurzer Ausblick KI

## Insertion Sort
#### Studenten:
- erklären die Funktionsweise von Insertion Sort
- erstellen ein Struktogramm zur Beschreibung von Insertion Sort
- Implementieren Insertion Sort anhand eines Struktograms
- Weg zum Algorithmus in den Vordergrund stellen bzw. Vorgehen kleinschrittig erklären
- Selection Sort meist intuitiver?
- Beispiel vorführen (z.B. über Video), dann Beschreibung, dann Parson Puzzle.
- Nach Parson Puzzle anderen Sortieralgorithmus komplett selber bauen.

void sort(int arr[]) 
    { 
        for (int i = 1; i < arr.length; i++) {  
            for ( int j = i; (j>0) && (liste[j-1] > liste[j]); j--){
                temp = liste[j-1];
		        liste[j-1] = liste[j];
		        liste[j] = temp;
            }
        } 
    } 

Parson Puzzle:

/* 1A */  temp = liste[j-1];
/* 1B */  temp = liste[j];

/* 2A */  liste[j] = liste[j-1];
/* 2B */  liste[j-1] = liste[j];

/* 3A */  liste[j+1] = temp; 
/* 3B */  liste[j] = temp;

/* 4A */  for (int i = 1; i < arr.length; i++)
/* 4B */  for (int i = 0; i > arr.length; i--)

/* 5A */  for ( int j = arr.length; (j>=0) && (liste[j] > liste[j-1]); j--)
/* 5B */  for ( int j = i; (j>0) && (liste[j-1] > liste[j]); j--)

## Laufzeit
#### Studenten:
- bestimmen die Laufzeit eines Pseudocodebeispiels
- beurteilen die Effektivität eines bestimmten Pseudocodebeispiels bezogen auf die Laufzeit
- entwickeln Laufzeiteffizientere Alternativen