Informatik 5: Algorithmen entwerfen und implementieren
Worum geht es? Algorithmen beschreiben präzise Lösungswege und können in Programme umgesetzt werden. Du lernst Probleme zu zerlegen, Abläufe darzustellen, Kontrollstrukturen, Variablen, Ein- und Ausgaben zu verwenden sowie Programme schrittweise zu entwickeln, zu testen und zu verbessern.
Lernziele
Nach diesem Kapitel kannst du:
- Algorithmen erklären, Beispiele nennen, Schritte begründen
- Abläufe zerlegen, Reihenfolgen planen, Teilprobleme bilden
- Muster erkennen, Regeln ableiten, Lösungen übertragen
- Anweisungen formulieren, Bedingungen nutzen, Wiederholungen nutzen
- Darstellungen wechseln, Ablaufpläne lesen, Pseudocode schreiben
- Programme umsetzen, Blöcke verwenden, Code schreiben
- Eingaben verarbeiten, Ausgaben erzeugen, Variablen nutzen
- Programme testen, Fehler finden, Korrekturen vornehmen
- Ergebnisse prüfen, Sonderfälle beachten, Verbesserungen begründen
- Werkzeuge nutzen, IDE bedienen, Dateien speichern
Anschluss an die Digitale Grundbildung
Erste Programmiererfahrungen und Kontrollstrukturen kennst du aus der Digitalen Grundbildung. Nun entwickelst du Algorithmen präziser, setzt sie in einer Programmiersprache um und arbeitest systematisch mit Testen, Debugging und iterativer Verbesserung.
Lerninhalte
Was ein Algorithmus ist
Ein tragfähiges Grundverständnis entsteht dann, wenn Algorithmen nicht nur als Fachwort erscheinen, sondern als eindeutige Handlungsanleitungen verstanden werden, die in Alltag, Mathematik und Informatik wiederkehren und durch ihre klare Schrittfolge Probleme lösbar machen.
Ein Algorithmus ist eine eindeutige, endliche und ausführbare Folge von Schritten zur Lösung eines Problems.
Alltagsbeispiele
Rezept, Schulweg, Packliste, Spielregel, Tanzfolge, Bastelanleitung
Merkmale
eindeutig, endlich, geordnet, ausführbar, prüfbar, wiederholbar Ein Kochrezept ist nur dann ein guter Algorithmus, wenn die Schritte vollständig und in richtiger Reihenfolge formuliert sind. Eine Wegbeschreibung funktioniert nur, wenn links und rechts, Startpunkt und Ziel klar benannt sind. Dasselbe gilt später für digitale Abläufe, etwa das Sortieren von Zahlen oder das Steuern einer Figur in Scratch.
Probleme analysieren und zerlegen
Der Weg zu einem brauchbaren Algorithmus beginnt meist nicht mit fertigem Code, sondern mit einer genauen Problemanalyse, weil größere Aufgaben erst durch Zerlegung, Ordnung und Priorisierung in überschaubare und bearbeitbare Teilschritte verwandelt werden.
Computational Thinking beschreibt genau diesen Prozess: Probleme werden zerlegt, Muster erkannt und klare Lösungsschritte definiert. Solche Verfahren sind auch außerhalb der Informatik nützlich.
Bevor programmiert wird, sollte daher geklärt werden: Was ist das Ziel, welche Eingaben gibt es, welche Teilaufgaben entstehen und wann ist das Ergebnis richtig?
Arbeitsschritte
analysieren, zerlegen, ordnen, planen, prüfen, verbessern
Beispiele
Quizspiel, Taschenrechner, Ampelsteuerung, Umfrage, Punktesystem, Labyrinth Ein Quizspiel lässt sich etwa in Fragen anzeigen, Antwort prüfen, Punkte zählen und Ende anzeigen zerlegen. Ein Taschenrechner benötigt Eingabe, Rechenart, Berechnung und Ausgabe. Eine Ampelsteuerung braucht Zustände, Zeitabstände und Wechselregeln. Solche Teilaufgaben erleichtern das spätere Formulieren eines klaren Algorithmus.
Algorithmen beschreiben und darstellen
Die Qualität eines Lösungswegs zeigt sich besonders deutlich in seiner Darstellung, weil erst klar formulierte oder visualisierte Abläufe erkennen lassen, ob Schritte fehlen, Bedingungen ungenau bleiben oder Wiederholungen sinnvoll geordnet wurden.
Algorithmen können in Alltagssprache, als Stichwortfolge, in Pseudocode, als Ablaufdiagramm oder in einer Blocksprache beschrieben werden. Sie lassen sich zunächst unabhängig von einer konkreten Programmiersprache darstellen – visuell, symbolisch oder textuell. Der Wechsel zwischen Darstellungsformen hilft dabei, den Lösungsweg zu verstehen, bevor er als Code umgesetzt wird.
Darstellungsformen
Textform, Stichwortfolge, Pseudocode, Flussdiagramm, Blocksprache, Quellcode
Darstellungselemente
Start, Ende, Eingabe, Ausgabe, Bedingung, Wiederholung Beispiel Pseudocode für eine Zahlenprüfung: Zahl eingeben, wenn Zahl größer als 10 dann „groß“ ausgeben, sonst „klein“ ausgeben. Dasselbe kann als Diagramm mit Entscheidungsfeld oder als Blöcke in Scratch dargestellt werden. Durch den Vergleich mehrerer Darstellungen wird deutlich, dass derselbe Algorithmus unterschiedlich notiert, aber gleich gedacht werden kann.
Kontrollstrukturen verstehen
Kontrollstrukturen machen Programme flexibel und leistungsfähig, weil sie festlegen, in welcher Reihenfolge Anweisungen ausgeführt werden, wann Entscheidungen getroffen werden und welche Schritte mehrfach wiederholt werden sollen.
Darauf bauen später komplexere Programme auf.
Grundformen
Sequenz, Auswahl, Wiederholung
Bedingungen
wenn, sonst, sonst wenn, gleich, größer, kleiner
Wiederholungen
solange, wiederhole, zähle, jede Runde, bis, mehrfach Eine Sequenz ist etwa: Figur starten, Frage anzeigen, Antwort lesen. Eine Auswahl lautet: Wenn Antwort richtig, dann Punkt erhöhen, sonst Meldung zeigen. Eine Wiederholung kann bedeuten: Wiederhole zehnmal einen Schritt oder solange, bis alle Fragen beantwortet sind. In Spielen, Simulationen und Robotik treten diese Strukturen ständig auf.
Variablen, Eingaben und Ausgaben
Programme werden erst dann wirklich interaktiv und anpassbar, wenn sie Werte speichern, verändern und auf Eingaben reagieren können, denn ohne Variablen und Datenverarbeitung bleiben viele Algorithmen starr und wenig alltagsnah.
Eine Variable speichert einen Wert, der sich während der Programmausführung ändern kann, etwa Punktestand, Name, Anzahl oder Temperatur. Eingaben liefern Daten an das Programm, Ausgaben machen Ergebnisse sichtbar. Variablen, Eingaben und Ausgaben bilden damit zentrale Grundlagen vieler Programme.
Variablenbeispiele
Punkte, Leben, Name, Alter, Zeit, Zähler
Eingaben
Taste, Zahl, Text, Klick, Sensor, Antwort
Ausgaben
Text, Bild, Ton, Zahl, Farbe, Bewegung Ein Punktespiel erhöht nach jeder richtigen Antwort die Variable Punkte. Ein Temperaturprogramm liest Messwerte ein und zeigt den aktuellen Wert an. Ein Scratch-Projekt fragt nach dem Namen und begrüßt die Person mit personalisierter Ausgabe. Solche Beispiele machen deutlich, warum Datenhaltung und Algorithmus zusammengehören.
Vom Algorithmus zum Programm
Die Umsetzung in einer Programmiersprache gelingt besonders gut, wenn nicht die Syntax allein im Mittelpunkt steht, sondern der vorher entwickelte Lösungsweg Schritt für Schritt in ausführbare Befehle übertragen wird.
Für den Einstieg eignen sich beispielsweise Scratch, Code.org, MakeCode oder Python. Ein Wechsel von Block- zu Textsprachen kann helfen, bekannte algorithmische Strukturen in einer neuen Schreibweise wiederzuerkennen.
Blocksprachen
Scratch, MakeCode, Blockly, Tynker, OpenRoberta, AppInventor
Textsprachen
Python, JavaScript, HTML, CSS, C, Java
Werkzeuge
IDE, Editor, Blockansicht, Simulator, Konsole, Projektfenster Ein Algorithmus zum Zählen von Treffern kann zunächst als Blockfolge in Scratch gebaut werden. Danach kann derselbe Gedanke in Python mit Variablen, Eingabe und Ausgabe notiert werden. Diese Übersetzung vom Plan zur Ausführung ist der Kern des Implementierens.
Einfache Programmbeispiele
Lernende verstehen Algorithmen tiefer, wenn sie an kleinen, überschaubaren Programmen arbeiten, weil dort Zusammenhänge zwischen Idee, Darstellung, Code und Ergebnis schnell sichtbar werden und Veränderungen unmittelbare Auswirkungen zeigen.
Typische Einstiegsprogramme sind „Hallo Welt“, Zählprogramme, Rechenprogramme, Farbwechsel, kleine Dialoge, Quizfragen oder einfache Bewegungsabläufe. Solche Mini-Beispiele reduzieren Komplexität, machen die Wirkung einzelner Befehle schnell sichtbar und eignen sich gut zum anschließenden Testen und Debuggen.
Programmiddeen
Hallo Welt, Quiz, Würfel, Countdown, Reaktionstest, Taschenrechner
Spielideen
Punkte sammeln, Hindernisse, Fangspiel, Labyrinth, Zufallszahl, Fragenrunde Ein Quizprogramm kann aus Frage anzeigen, Antwort prüfen und Punktestand ausgeben bestehen. Ein Countdown nutzt eine Zählvariable und eine Wiederholung. Ein Labyrinthspiel benötigt Tasteneingaben, Kollisionserkennung und eine Endbedingung. Gerade solche kleinen Beispiele sind gut geeignet, um Algorithmen sichtbar werden zu lassen.
Testen und Debuggen
Programmieren umfasst immer auch das Überprüfen und Verbessern, weil selbst einfache Programme trotz guter Planung Fehler enthalten können und erst durch systematisches Testen verlässlich und nachvollziehbar funktionieren.
Testen und Debuggen gehören zum Programmierprozess. Testen heißt nicht nur „läuft irgendwie“, sondern bewusst unterschiedliche Fälle auszuprobieren, erwartete und tatsächliche Ergebnisse zu vergleichen und Fehlerquellen systematisch zu verstehen.
Fehlerarten
Syntaxfehler, Logikfehler, Eingabefehler, Tippfehler, Reihenfolgefehler, Grenzfall
Testideen
Normalfall, Sonderfall, Nullwert, Grenzwert, Falscheingabe, Wiederholung Wenn ein Quiz bei richtiger Antwort keinen Punkt zählt, liegt möglicherweise ein Logikfehler vor.
Wenn ein Python-Befehl wegen eines fehlenden Doppelpunkts nicht startet, ist das eher ein Syntaxfehler. Wenn ein Programm bei leeren Eingaben abstürzt, wurde ein Sonderfall nicht bedacht. Solche Unterschiede sollen Schülerinnen und Schüler benennen und beheben können.
Entwicklungsumgebung sinnvoll nutzen
Eine Entwicklungsumgebung unterstützt das algorithmische Arbeiten besonders dann, wenn ihre Funktionen nicht als Technikballast erscheinen, sondern als Werkzeuge zum Schreiben, Ausführen, Beobachten und Verbessern von Programmen genutzt werden.
Solche Umgebungen bieten Eingabefeld, Startfunktion, Ausgabe, oft auch Fehlermeldungen, Speicheroptionen und teilweise Debugging-Hilfen. Zu den grundlegenden Arbeitsroutinen gehören: Projekt anlegen, Datei speichern, Programm ausführen, Meldungen lesen und Ergebnisse dokumentieren.
IDE-Funktionen
schreiben, speichern, starten, stoppen, testen, dokumentieren
Hilfen
Fehlermeldung, Konsole, Vorschau, Simulator, Blockansicht, Codeansicht Ein Scratch-Projekt wird gespeichert, ausprobiert und bei Bedarf verändert. In Thonny kann ein Python-Programm ausgeführt und die Ausgabe unten kontrolliert werden. MakeCode erlaubt zusätzlich den Wechsel zwischen Blöcken und Python oder JavaScript, was den Übergang zwischen Darstellungsformen unterstützt.
Iteratives Entwickeln und Verbessern
Gute Programme entstehen selten in einem einzigen Schritt, sondern durch wiederholtes Planen, Umsetzen, Prüfen und Verändern, weshalb iterative Entwicklung eine zentrale informatische Arbeitsweise und zugleich eine realistische Lernerfahrung darstellt.
Sinnvoll ist ein Vorgehen in kleinen Entwicklungszyklen: Idee formulieren, eine Mini-Version umsetzen, testen, Rückmeldung einarbeiten und anschließend erweitern. Dadurch bleiben Programme überschaubar und Fehler lassen sich früher erkennen.
Entwicklungsschritte
planen, bauen, testen, verbessern, erweitern, sichern
Projektbeispiele
Minispiel, Story, Ampel, Rechenapp, Quiz, Sensorprojekt Ein Quiz kann zuerst nur eine Frage enthalten. Danach kommen Punktestand, mehrere Fragen, Zeitlimit oder Rückmeldungen dazu. Ein Spiel startet mit einer beweglichen Figur und wird später um Gegner, Punkte und Endbildschirm ergänzt. Iteration bedeutet also, Programme bewusst wachsen zu lassen.
Weiterführende Links
Passende LearningSnacks
Übungen
Alltagsalgorithmus präzisieren
Die Schülerinnen und Schüler erhalten eine einfache Alltagssituation, etwa Schulranzen packen, Tee zubereiten, ein Heft abgeben oder sich in einer Lernplattform anmelden. Zuerst formulieren sie einen Algorithmus in Alltagssprache. Danach führt eine Partnerin oder ein Partner die Schritte wortwörtlich aus oder prüft sie auf Unklarheiten.
Anschließend wird der Algorithmus überarbeitet. Unpräzise Formulierungen, fehlende Zwischenschritte oder falsche Reihenfolgen werden ergänzt. In der Besprechung wird deutlich, dass ein brauchbarer Algorithmus eindeutig, ausführbar und vollständig sein muss.
Material
Aufgabenkarten, Schreibblatt, Stifte
Produkte
Algorithmus, Partnerprüfung, Überarbeitung
Fokus
Eindeutigkeit, Reihenfolge, Vollständigkeit, Präzision
Ablaufplan und Pseudocode vergleichen
Ihr erhaltet einen einfachen Algorithmus vor, etwa eine Zahl prüfen, einen Punktestand erhöhen oder mehrere Eingaben vergleichen. Die Schülerinnen und Schüler stellen denselben Ablauf zuerst als Ablaufdiagramm und danach als Pseudocode dar. Anschließend markieren sie Gemeinsamkeiten und Unterschiede beider Formen.
Im zweiten Schritt erklären sie, welche Darstellung ihnen beim Planen, Prüfen oder Umsetzen hilfreicher erscheint und warum. So wird geübt, dass Algorithmen unabhängig von einer einzelnen Programmiersprache gedacht und beschrieben werden können.
Material
Vorlage, Symbolkarte, Arbeitsblatt
Produkte
Ablaufplan, Pseudocode, Vergleich
Fokus
Darstellung, Übersetzung, Struktur, Verständnis
Bedingungen entwerfen
Die Schülerinnen und Schüler bearbeiten Situationen wie „Antwort richtig oder falsch“, „Temperatur über oder unter einem Wert“, „Passwort korrekt oder nicht korrekt“ oder „Punktestand erreicht oder nicht erreicht“. Zunächst formulieren sie Entscheidungsregeln in Alltagssprache und stellen diese anschließend als Wenn-Dann-Struktur dar.
Danach setzen sie die Bedingung in einer Blocksprache oder einer einfachen Textsprache um.
In der Auswertung prüfen sie mit verschiedenen Eingaben, ob das Programm in allen Fällen die passende Ausgabe liefert. So wird die Funktionsweise von Auswahlstrukturen mit unmittelbarem Rückbezug auf das Ergebnis erfahrbar.
Material
Fallkarten, Rechner, Programmiertool
Produkte
Regel, Bedingungscode, Testprotokoll
Fokus
Wenn, sonst, Entscheidung, Reaktion
Wiederholungen nutzen
Das Verständnis von Schleifen vertieft sich besonders dann, wenn wiederkehrende Abläufe nicht einzeln ausgeschrieben, sondern bewusst als Muster erkannt und ökonomisch in einer Wiederholungsstruktur umgesetzt werden.
Die Schülerinnen und Schüler erhalten Aufgaben mit mehrfach wiederkehrenden Schritten, etwa eine Figur zehnmal bewegen, eine Reihe von Zahlen ausgeben, mehrere ähnliche Fragen nacheinander stellen oder eine Farbe mehrmals wechseln. Zuerst notieren sie die Wiederholungen vollständig. Danach ersetzen sie die langen Schrittfolgen durch eine passende Schleife.
Im zweiten Schritt implementieren sie die Lösung in einer Programmiersprache und vergleichen die ursprüngliche mit der verkürzten Version. In der Reflexion begründen sie, warum Wiederholungen Programme kürzer, übersichtlicher und leichter veränderbar machen.
Material
Auftragskarten, Blocksprache, Texteditor
Produkte
Schrittfolge, Schleife, Vergleich
Fokus
Wiederholung, Muster, Verkürzung, Struktur
Ein Miniprogramm planen und umsetzen
Besonders hoher Lernertrag entsteht, wenn ein kleines Programm von der Idee bis zur Ausführung vollständig durchlaufen wird, weil dabei alle zentralen Phasen algorithmischen Arbeitens in einem überschaubaren und motivierenden Projekt zusammenkommen.
Die Schülerinnen und Schüler wählen oder erhalten ein Mini-Projekt, etwa ein Begrüßungsprogramm, ein einfaches Quiz, einen Reaktionstest, einen Würfel oder einen Taschenrechner mit einer Rechenart. Zuerst planen sie Ziel, Eingaben, Ausgaben und nötige Schritte. Danach entwerfen sie einen Ablaufplan oder Pseudocode.
Im Anschluss setzen sie das Projekt in einer Blocksprache oder Textsprache um. Nach einem ersten Test überarbeiten sie Fehler und ergänzen gegebenenfalls kleine Verbesserungen. So wird deutlich, dass ein funktionierendes Programm aus Planung, Implementierung und Verbesserung entsteht.
Material
Rechner, IDE, Projektblatt, Vorlage
Produkte
Plan, Programm, Testfassung
Fokus
Planung, Umsetzung, Ausgabe, Verbesserung
Debugging-Werkstatt
Ihr untersucht kurze Programme mit typischen Fehlern, etwa fehlende Klammern, falsche Bedingungen, vertauschte Reihenfolgen, unpassende Variablennamen oder fehlerhafte Schleifen. Die Schülerinnen und Schüler untersuchen zunächst, ob das Programm überhaupt startet und welches Verhalten auftritt.
Danach markieren sie die problematische Stelle, beschreiben die Fehlerursache und formulieren eine Korrektur. In der Sicherung werden die Fehlerarten gemeinsam geordnet, etwa Syntaxfehler, Logikfehler oder Eingabefehler. So wird Debugging als bewusster Prüf- und Verbesserungsprozess geübt.
Material: Fehlerprogramme, Rechner, Analyseblatt
Produkte: Fehlerliste, Korrektur, Begründung
Fokus: Syntax, Logik, Diagnose, Korrektur
Pair Programming mit Rollenwechsel
Die Schülerinnen und Schüler arbeiten in Paaren an einer kleinen Programmieraufgabe. Eine Person übernimmt die Rolle des Drivers und schreibt den Code oder setzt die Blöcke, die andere übernimmt die Rolle des Navigators und achtet auf Ziel, Logik und mögliche Fehler.
Nach einer festgelegten Zeit wechseln die Rollen.
Am Ende reflektieren die Paare, welche Rolle ihnen leichter gefallen ist, an welchen Stellen der Rollenwechsel hilfreich war und wie sich die Zusammenarbeit auf Genauigkeit und Problemlösen ausgewirkt hat. Dadurch wird Programmieren als kommunikative und strukturierte Arbeitsweise erfahrbar.
Material
Partneraufgabe, Timer, Rechner
Produkte
Programm, Rollenprotokoll, Reflexion
Fokus
Kooperation, Rollen, Prüfung, Abstimmung
Algorithmus und Code erklären
Besonders hoher Lernertrag entsteht, wenn ein selbst entwickelter Algorithmus für andere verständlich erklärt werden muss, weil dabei Denkweg, Darstellungsform und Programmcode bewusst aufeinander bezogen und in klare Fachsprache übersetzt werden.
Die Schülerinnen und Schüler wählen ein kleines eigenes Programm oder eine vorgegebene Lösung und erstellen dazu ein Erklärprodukt. Dieses soll mindestens den Zweck des Programms, den Algorithmus in vereinfachter Form, die verwendeten Kontrollstrukturen und ein Beispiel für Ein- und Ausgabe enthalten. Möglich sind Poster, Erklärkarten oder ein kurzer Screencast.
In der Präsentation erläutern die Lernenden, wie der Algorithmus aufgebaut ist, welche Befehle besonders wichtig sind und wie sie ihr Programm getestet haben. Die Mitschülerinnen und Mitschüler geben Rückmeldung, ob die Erklärung logisch, verständlich und fachlich korrekt ist.
Material
Eigenes Programm, Vorlage, Präsentationsmedium
Produkte
Erklärprodukt, Präsentation, Feedback
Fokus
Erklärung, Fachsprache, Zusammenhang, Reflexion
Kompetenzcheck
Überprüfe am Ende selbst:
| Ich kann … | Ja | Noch üben |
|---|---|---|
| algorithmen erklären, Beispiele nennen und Schritte begründen. | ☐ | ☐ |
| abläufe zerlegen, Reihenfolgen planen und Teilprobleme bilden. | ☐ | ☐ |
| muster erkennen, Regeln ableiten und Lösungen übertragen. | ☐ | ☐ |
| anweisungen formulieren, Bedingungen nutzen und Wiederholungen nutzen. | ☐ | ☐ |
| darstellungen wechseln, Ablaufpläne lesen und Pseudocode schreiben. | ☐ | ☐ |
| programme umsetzen, Blöcke verwenden und Code schreiben. | ☐ | ☐ |
| eingaben verarbeiten, Ausgaben erzeugen und Variablen nutzen. | ☐ | ☐ |
| programme testen, Fehler finden und Korrekturen vornehmen. | ☐ | ☐ |
| ergebnisse prüfen, Sonderfälle beachten und Verbesserungen begründen. | ☐ | ☐ |
| werkzeuge nutzen, IDE bedienen und Dateien speichern. | ☐ | ☐ |