Algorithmen, Problemlösungsstrategien und strukturiertes Denken

Algorithmus

Ein Algorithmus ist eine klare, schrittweise Anweisung oder eine Reihe von Regeln zur Lösung eines Problems oder zur Durchführung einer Aufgabe. Er wird in der Informatik verwendet, um Berechnungen durchzuführen, Daten zu verarbeiten oder Entscheidungen zu treffen. Algorithmen bestehen aus einer Folge von Operationen, die in einer bestimmten Reihenfolge ausgeführt werden, und führen bei korrekter Implementierung immer zu einem eindeutigen Ergebnis.

Ein einfaches Beispiel für einen Algorithmus wäre ein Kochrezept, bei dem eine Reihe von Schritten genau befolgt werden muss, um das gewünschte Ergebnis (das Gericht) zu erzielen. In der Informatik werden Algorithmen typischerweise in Programmiersprachen geschrieben und von Computern ausgeführt. Sie sind zentral für die Funktionsweise von Software und spielen eine wichtige Rolle in Bereichen wie Datenanalyse, künstlicher Intelligenz, Verschlüsselung und vielen mehr.

Zerlegung von Problemen (Decomposition)

Decomposition ist eine Methode, die verwendet wird, um komplexe Probleme oder Systeme in kleinere, besser handhabbare Teile zu zerlegen. Dies ermöglicht es, jedes Teilproblem einzeln zu analysieren, zu verstehen und zu lösen. In der Informatik ist Decomposition ein wesentlicher Bestandteil des algorithmischen Denkens, da es die Strukturierung von Problemen und das Erstellen von Lösungen erleichtert.

Beispiele für Decomposition:

  1. In der Programmierung: Ein großes Softwareprojekt wird in kleinere Module oder Funktionen zerlegt, die unabhängig voneinander entwickelt und getestet werden können.

  2. Im Alltag: Ein komplexes Projekt wie das Organisieren einer Veranstaltung wird in kleinere Aufgaben wie das Buchen eines Veranstaltungsortes, Einladungen verschicken und das Planen des Essens zerlegt.

Decomposition hilft dabei, die Komplexität eines Problems zu reduzieren, den Überblick zu behalten und effizientere Lösungen zu finden.

Abstraktion

Das Wesentliche eines Problems erkennen und unnötige Details ignorieren.

Pseudocode

Pseudocode ist eine vereinfachte und informelle Darstellung eines Algorithmus oder Programmablaufs, die sich an der Syntax von Programmiersprachen orientiert, aber keine strengen Regeln einer bestimmten Sprache befolgt. Pseudocode dient dazu, die Logik eines Programms oder einer Funktion in allgemein verständlicher Weise zu beschreiben, ohne sich auf die Details der Programmierung konzentrieren zu müssen.

Wichtige Merkmale von Pseudocode:

  1. Einfache Sprache: Pseudocode verwendet eine Mischung aus natürlicher Sprache und Programmierkonzepten (wie Schleifen oder Bedingungen), die für Menschen verständlich sind.
  2. Keine spezifische Syntax: Anders als Programmiersprachen gibt es keine festen Regeln oder Syntax. Die Hauptidee ist, die Logik zu erklären.
  3. Keine Ausführbarkeit: Pseudocode kann nicht direkt von einem Computer ausgeführt werden. Er dient nur als Entwurf oder Plan für den eigentlichen Code.

Beispiel:
Pseudocode für das Finden der größten Zahl in einer Liste könnte so aussehen:

  1. Setze größteZahl auf den ersten Wert in der Liste
  2. Für jedes Element in der Liste:
  • Wenn das Element größer ist als größteZahl:
  • Setze größteZahl auf dieses Element

3. Gib größteZahl zurück

Das Ziel von Pseudocode ist, die Logik klar zu vermitteln, bevor sie in eine Programmiersprache übersetzt wird.

Debugging und Fehlersuche

Debugging in der Informatik ist der Prozess, durch den Fehler (sogenannte Bugs) in einem Computerprogramm identifiziert, analysiert und behoben werden. Es ist ein zentraler Teil der Softwareentwicklung, da es nahezu unmöglich ist, Code zu schreiben, der von Anfang an fehlerfrei ist. Debugging sorgt dafür, dass ein Programm wie gewünscht funktioniert.

Hauptphasen des Debugging:

  1. Fehlererkennung: Ein Fehler wird entdeckt, entweder durch unerwartetes Verhalten des Programms, durch eine Fehlermeldung oder durch einen Test, der fehlschlägt.
  2. Fehleranalyse: Der Entwickelnde untersucht, wo genau im Code der Fehler liegt und was ihn verursacht.
  3. Fehlerbehebung: Nachdem der Fehler lokalisiert und verstanden wurde, wird der Code entsprechend geändert, um das Problem zu lösen.
  4. Testen der Lösung: Nach der Korrektur wird das Programm erneut ausgeführt, um sicherzustellen, dass der Fehler behoben wurde und keine neuen Fehler entstanden sind.

Aufgabe (60 Minuten)

Entwicklung eines Rechtsberatungs-Bots für Vertragsrecht

Hintergrund

Ihr Ziel ist es, einen Rechtsberatungs-Bot zu entwickeln, der einfache Anfragen im Bereich des Vertragsrechts beantworten kann. Der Bot soll grundlegende Fragen beantworten, z.B. ob ein Vertrag zustande gekommen ist, ob ein Rücktrittsrecht besteht oder ob eine Vertragsklausel ungültig ist. Dabei arbeitet der Bot auf Basis einer vereinfachten Logik von "Ja" und "Nein"-Fragen.

Aufgabenstellung

In 2-3er Gruppen sollt ihr die Entwicklung des Bots anhand folgender Schritte planen. Das Ziel ist es, den Algorithmus so zu gestalten, dass er standardisierte Entscheidungen zu den Anfragen trifft.

1. Algorithmisches Denken (10 - 15 Minuten)

Erstellt einen Algorithmus, der die folgenden Fragen Schritt für Schritt beantwortet:

  1. Vertragsschluss:

    • Wurde ein Angebot gemacht? (Ja/Nein)
    • Wurde das Angebot angenommen? (Ja/Nein)
    • Besteht Geschäftsfähigkeit der Parteien? (Ja/Nein)

  2. Rücktrittsrecht:

    • Ist ein gesetzliches Rücktrittsrecht vorhanden? (Ja/Nein)
    • Wurde eine Rücktrittsfrist eingehalten? (Ja/Nein)

  3. Ungültige Klauseln:

    • Ist eine Vertragsklausel sittenwidrig? (Ja/Nein)
    • Verstößt die Klausel gegen geltendes Recht? (Ja/Nein)

Denkt darüber nach, wie diese Fragen in einer Abfolge von Entscheidungen angeordnet werden könnten, um schrittweise zu einem Ergebnis zu kommen (Vertrag ist gültig, Rücktrittsrecht besteht, Klausel ist ungültig etc.).

2. Decomposition (10 Minuten)

Zerlegt das Problem in kleinere Teilprobleme:

  • Denkt an die logische Struktur: Wie soll der Bot Schritt für Schritt die Fragen beantworten? Was muss er zuerst klären (z.B. ob ein Vertrag zustande gekommen ist), bevor er weitere Punkte prüfen kann?
  • Teilt die Aufgaben in der Gruppe auf: Einer könnte sich um den Vertragsschluss kümmern, der andere um das Rücktrittsrecht, der dritte um die ungültigen Klauseln.

3. Abstraktion (5 Minuten)

Vereinfacht das Problem, indem ihr komplexe juristische Sachverhalte in einfache, binäre Entscheidungsprozesse umformuliert. Welche juristischen Feinheiten könnt ihr ignorieren, um den Prozess für den Bot verständlich und umsetzbar zu machen?

4. Erstellen von Pseudocode (20 Minuten)

Schreibt den Pseudocode für euren Algorithmus auf. Der Pseudocode sollte Schritt für Schritt die Entscheidungsstruktur des Bots widerspiegeln.

1. Prüfe, ob ein Angebot gemacht wurde:
a. Wenn Ja, prüfe, ob das Angebot angenommen wurde:
i. Wenn Ja, prüfe, ob die Parteien geschäftsfähig sind:
- Wenn Ja, Vertrag ist zustande gekommen
- Wenn Nein, Vertrag ist nicht zustande gekommen
2. Prüfe, ob ein Rücktrittsrecht besteht:
a. ...
3. Prüfe, ob eine Klausel ungültig ist:
a. ...

Debugging mit Pseudocode einer anderen Gruppe (15 Minuten)

Tauscht euren Pseudocode mit einer anderen Gruppe aus. Ihr sollt nun den Pseudocode der anderen Gruppe durchgehen und ihn debuggen:

  • Versucht, Fehler in der Logik oder in der Struktur zu finden.
  • Gebt der anderen Gruppe Feedback, wie sie ihren Pseudocode verbessern kann.
  • Diskutiert mögliche Alternativen und Lösungen für die gefundenen Probleme.

Ergebnis

Am Ende der Übung sollte jede Gruppe einen verbesserten und funktionierenden Pseudocode haben, der einen einfachen Vertragsprüfungsprozess abbildet.