Erstes Thema: Maschinensprache/Assembler mit dem Johnny-Modellcomputer
• Die Funktionsweise der Maschine und alle Befehle kennen. Assemblercode muss gelesen (und deren Wirkung vorhergesagt) werden können. Eigener Code in Assembler muss erstellt werden können.
Links dazu:
Unterrichtsreihe dazu: https://www.inf-schule.de/rechner/johnny
Direkter Download des Projekts https://sourceforge.net/projects/johnnysimulator/
Die Version mit dem eingebauten "Pixelbildschirm" habe ich selbst compiliert. Diese Version müsst ihr von mir (oder von den Rechnern aus dem Informatikraum beziehen)
Drittes Thema: Formale Sprachen (fast nur Wiederholung aus der letzten Klausur)
• Mit Hilfe folgender Anleitung ( http://www.plusplanet.de/miscrawhtml/20230905_04_Theoretische_Informatik.html ) reguläre Ausdrücke formulieren und Lesen können.
• Skript "Formale Sprachen" (siehe den ersten Verweis auf der bekannten Seite http://www.gierhardt.de/informatik/theorie/index.html
) bis Seite 35. Dabei haben wir einige Aufgaben daraus bearbeitet und gelöst. (So z.B. S10 Nr2 und 3, S16 Nr 2 und 3, S23 Nr4 und Nr7) Allerdings haben wir kleine Teile des Skripts praktisch nicht bearbeitet (So z.B. die das Java-Programms auf S6f oder die Einführung in endliche Automaten mit dem Marienkäfer Kara auf S20.)
• Implementation eines Automaten in Java oder JavaScript (es kommt mir nur auf Pseudocode und passende if-then-else-Anweisungen an) bzw. aus einem Quelltext das Automatendiagramm erstellen.
• Im Skript wird der Algorithmus "Umwandlung eines NEA in einen DEA" erklärt. Vielleicht etwas umständlicher als bei uns (Ein gutes Erklärvideo dazu ist auch https://www.youtube.com/watch?v=fwwmUuoOFnI wobei wir eine Tabelle verwendet haben, die im Video einfach "im Kopf" gemacht wird). Im Skript fehlt aber der Algorithmus zur "Minimierung von DEA". Diesen haben wir auch im Unterricht gehabt. (Ein gutes Erklärvideo dazu ist z.B. https://youtu.be/2FNTDtabQz4?t=402 )
• Lesen und Konstruieren von Programmcode für eine Turingmaschine http://math.hws.edu/eck/js/turing-machine/TM.html. Bedeutung der "Busy Beaver"-Programme für die Informatik. Im bekannten Skript steht dazu etwas auf Seite 44 bis 49 (wobei ich mich bei der Schreibweise für Turingmaschinen an die Struktur aus der o.g. Webseite halte. Die Tabellen aus dem Skript sind ja leicht anders)
22.11.2023
Mögliche Aufgaben für die Erstellung von Microcode:
• NOP
• DEC ACCU (DEA)
• INC ACCU (INA)
• Verdopple den Inhalt des Akkus (Operand egal)
• Verdopple den Inhalt einer Speicherstelle
• LDI XXX (Load indirect (also Lade den Wert, der an der Speicherstelle steht, die in Speicherstelle XXX steht)
• STI XXX (Save, Analog zu LDI XXX)
Beendigung des Themas "Formale Sprachen" und "Theoretische Informatik":
• Betrachtung von S14 // S35,36 // S41 S43 //
• TM und Busy Beaver http://math.hws.edu/eck/js/turing-machine/TM.html
Hinweis: Die Raute ist das "leere Symbol"
Aufgabe 1:
Konstruiere eine TM, die an einem Wort aus beliebig vielen Nullen sowohl links als auch rechts eine Null anhängt.
Aufgabe 2:
Konstruiere eine TM, welche bei einer binären Zahl ganz rechts beginnt und ganz links ein parity-bit anhängt (1 für ungerade Anzahl an Einsen, 0 für gerade Anzahl an Einsen)
Aufgabe 3:
Konstruiere eine TM, welche mit möglichst wenigen Zuständen möglichst viele Einsen aufs Band schreibt UND(!) irgendwann anhält! Beginne mit 2 Zuständen. Es ist möglich damit 4 Einsen zu schreiben. (Nullen interessieren hier nicht.)
02.10.2023
Klausurthemen zur kommenden Klausur
Erstes Thema: Datenbanken
• SQL-Befehle formulieren und lesen können
• Konzept "kartesisches Produkt" für Table-Joins verstehen
• ER-Diagramme lesen und erstellen können
• Datenbankschema lesen und erstellen können
• Aus einem ER-Diagramm ein Datenbankschema erstellen können (und umgekehrt - was aber eher ungewöhnlich wäre)
• Auf das Konzept "Normalform" werden wir in der Klausur verzichten.
• Vokabeln: ER-Diagramm (Entity und Entitymenge, Attribut und Attributwert, Primärschlüssel, Relationship, Kardinalitäten (nämlich 1:1, 1:n und m:n)), Normalisierung, Transformationsregeln zur Überführung in ein relationales Datenbankschema (Tabelle, Attribut, Datensatz, Primärschlüssel, Fremdschlüssel)
Übungsmaterial
• Seiten bis 161 im Buch (Datei "db_buch.pdf unter dem Link http://www.plusplanet.de/htaccessdir2/ wobei ihr die Zugangsdaten über Moodle bekommen habt)
• Die SQL-Befehls-Übersichten (siehe sqlite_tutorial_create_insert.pdf und sqlite_tutorial_select.pdf unter dem o.g. Link)
Zweites Thema: Formale Sprachen
• Mit Hilfe folgender Anleitung ( http://www.plusplanet.de/miscrawhtml/20230905_04_Theoretische_Informatik.html ) reguläre Ausdrücke formulieren und Lesen können.
• Skript "Formale Sprachen" (siehe den ersten Verweis auf der bekannten Seite http://www.gierhardt.de/informatik/theorie/index.html
) bis Seite 35. Dabei haben wir einige Aufgaben daraus bearbeitet und gelöst. (So z.B. S10 Nr2 und 3, S16 Nr 2 und 3, S23 Nr4 und Nr7) Allerdings haben wir kleine Teile des Skripts praktisch nicht bearbeitet (So z.B. die das Java-Programms auf S6f oder die Einführung in endliche Automaten mit dem Marienkäfer Kara auf S20.)
• Implementation eines Automaten in Java oder JavaScript (es kommt mir nur auf Pseudocode und passende if-then-else-Anweisungen an) bzw. aus einem Quelltext das Automatendiagramm erstellen.
• Im Skript wird der Algorithmus "Umwandlung eines NEA in einen DEA" erklärt. Vielleicht etwas umständlicher als bei uns (Ein gutes Erklärvideo dazu ist auch https://www.youtube.com/watch?v=fwwmUuoOFnI wobei wir eine Tabelle verwendet haben, die im Video einfach "im Kopf" gemacht wird). Im Skript fehlt aber der Algorithmus zur "Minimierung von DEA". Diesen haben wir auch im Unterricht gehabt. (Ein gutes Erklärvideo dazu ist z.B. https://youtu.be/2FNTDtabQz4?t=402 )
Außerdem haben wir uns in der Stunde folgende Grammatiken angeschaut:
Aufgabe 1 von Seite 16
Ziffer = 0|1|2|...|9
Buchstabe = a|b|c|...|z
Bezeichner = Buchstabe {Buchstabe | Ziffer}
Ist diese Sprache regulär?
Versuch der Formulierung einer regulären Grammatik:
N = {S,Z,E}
T = {a,b...z,0..9}
Startsymbol: S
S --> aZ | bZ | .... | zZ
Z --> aZ | bZ | .... | zZ | 0Z | 1Z ... 9Z |
a | b | .....| z | 0 | 1 .... 9
Also ist die Sprache regulär.
---------------
Beispiel einer ziemlich einfachen, langweiligen Sprache:
Alphabet = {1,2,3,4,5,6,7,8,9,0}
N = {A,B,C,D}
T = Alphabet
S = A
Regeln
A --> 2B
B --> 4C
C --> D
D --> 9
Erzeugung eines Wortes:
A --> 2B --> 24C --> 24D --> 249
Es lässt sich nur dieses eine Wort erzeugen!
---------------
Noch ein Beispiel einer ziemlich einfachen, langweiligen Sprache:
Alphabet = {1,2,3,4,5,6,7,8,9,0}
N = {A,B,C,D}
T = Alphabet
S = A
Regeln
A --> 2B
B --> 3C | 4C
C --> D
D --> 9
Erzeugung von Wörtern:
A --> 2B --> 23C --> 23D --> 239
A --> 2B --> 24C --> 24D --> 249
Diese Sprache besteht aus genau zwei Wörtern, nämlich 239 und 249.
---------------
Beispiel einer Sprache mit unendlich vielen Wörtern
Alphabet = {1,2,3,4,5,6,7,8,9,0}
N = {A,B,C,D}
T = Alphabet
S = A
Regeln
A --> 2B
B --> 3B | 4B | D
D --> 9
Hier nun drei unterschiedliche Erzeugungen von Wörtern der Sprache:
A --> 2B --> 2D --> 29
A --> 2B --> 23B --> 233B --> 233D --> 2339
A --> 2B --> 23B --> 234B --> 2343B --> 2343D --> 23439
Die Sprache besteht also aus den Worten die mit 2 beginnen und auf 9 enden. Außerdem dürfen dazwischen beliebig viele dreien und vieren in beliebiger Reihenfolge auftauchen.
---------------
Auf Seite 13 des Skripts finden wir:
2.2.2 Beispiel 2:
Eine Grammatik G = (N, T, S, P) ist wie folgt gegeben:
N = {s, A,B}
T = {0, 1}
S = S
Regeln:
S --> 1S | 0A
A --> 1S | 0B
B --> 1S | 0B | 0
Eine gültige Ableitung ist z. B.
S −> 1S −> 10A −> 100B −> 1000
S -> 1S -> 11S -> 110A -> 1100B -> 11000
S -> 0A -> 00B -> ...(mehrmals B anw.) -> 00000
11111111111000
Offenbar besteht diese Sprache aus jenen Binärzahlen, die mindestens drei Nullen am Ende besitzen.
05.09.2023
Fahrplan für heute:
1) HA: Aufgabe 3 zu den regulären Ausdrucken
Zwei Methoden zum komfortablen Datei-einlesen und ausgeben.
static String readFile(String fn){
String erg = "";
Scanner scanner = null;
try {
scanner = new Scanner( new File(fn) );
String text = scanner.useDelimiter("\\A").next();
erg = text;
} catch (Exception e) {
System.out.println(e);
} finally {
scanner.close(); // Put this call in a finally block
}
return erg;
}
static void writeFile(String fn, String content) {
PrintWriter out = null;
try {
out = new PrintWriter(fn);
out.println(content);
out.close();
} catch(Exception e) {
System.out.println(e);
} finally {
out.close();
}
}
Codeschnipsel zum bauen einer Methode, die Zeilenweise einliest
scanner.useDelimiter(";|\r?\n|\r"); // Zeilenumbruch
while (scanner.hasNext() ) {
String s1 = scanner.next();
}
17.05.2023
15.05.2023
Hausaufgabe: Fragen zur besprochenen Klausur. Wenn ihr keine Fragen habt, so habe ich welche!
Eine Select-Anweisung mit einem Left outer Join, die Aufgabe b iii löst:
Select Restaurant.Name, Restaurant.PLZ, Restaurant.Ortsname, bewertet.RestaurantID
From Restaurant
Left Outer Join bewertet
on Restaurant.ID = bewertet.RestaurantID
where restaurantID is null;
Klausurthemen: "Datenbanken"
• SQL-Befehle formulieren und lesen können
• Konzept "kartesisches Produkt" für Table-Joins verstehen
• ER-Diagramme lesen und erstellen können
• Datenbankschema lesen und erstellen können
• Aus einem ER-Diagramm ein Datenbankschema erstellen können (und umgekehrt - was aber eher ungewöhnlich wäre)
• Konzept "SQL-Injection" verstehen.
• 1. bis 3. Normalform verstehen und anwenden können (Die Beispiele auf Wikipedia erklären das Konzept sehr gut: https://de.wikipedia.org/wiki/Normalisierung_(Datenbank)#Erste_Normalform_(1NF) https://de.wikipedia.org/wiki/Normalisierung_(Datenbank)#Zweite_Normalform_(2NF) https://de.wikipedia.org/wiki/Normalisierung_(Datenbank)#Dritte_Normalform_(3NF)
• Vokabeln: ER-Diagramm (Entity und Entitymenge, Attribut und Attributwert, Primärschlüssel, Relationship, Kardinalitäten (nämlich 1:1, 1:n und m:n)), Normalisierung, Transformationsregeln zur Überführung in ein relationales Datenbankschema (Tabelle, Attribut, Datensatz, Primärschlüssel, Fremdschlüssel)
Übungsmaterial
• Seiten bis 161 im Buch
• Altklausur
• Die SQL-Befehls-Übersichten
Zu heute hattet ihr die Hausaufgabe, ein ER-Diagramm für die Schul-DB zu entwickeln. Dies muss noch in ein Schema überführt werden. (Siehe S159 bis 161). Das verschieben wir auf später.
Für die heutige Stunde macht ihr folgendes: Eine Klinik möchte ihre Patienten und deren Diagnosen (es können mehrere pro Patient sein!) in einer Datenbank organisieren. Folgendes ER-Diagramm wurde dazu angelegt:
• Überführe das Modell (Siehe S159 bis 161) in ein Schema.
• Schreibe für das Schema eine SQL-Anweisung, die aus der so konstruierten Datenbank alle Lungenentzündungen aus Düsseldorf ermittelt.
Bitte gib die Ergebnisse der Stunde hier ein:
26.04.2023
Konstruktion einer "Schuldatenbank", die alle möglichen Anwendungsfälle in der Schule abdecken soll.
Brainstorming Begriffe:
Pausenaufsicht, Aufsicht, Stundenplan, Ordnungsdienst, Vertretung und Vertretungsplan, Zeugnisse, Noten, Einkaufsliste Schulmaterialien, Moodle und Schulwebsite, Schüler, Lehrer, Lehrerverteilung auf die Klassen, Räume und Raumverteilung, Schulleitung, Hausmeister, Klausurplan
Attribute der Entitätsklasse "Schüler":
- Name
- Alter
- Adresse
- Jahrgangsstufe
- aktuelle Kurse
Attribute der Entitätsklasse "Lehrer":
- Name
- Alter
- Adresse
- unterrichtet welche Fächer?
- Funktionstelle/Rolle (z.B. Stufenkoordination)
Attribute der Entitätsklasse "Kurs":
- Name (IFG1 in Q1)
- unterrichtenden Lehrer
- Fach
Attribute der Entitätsklasse "Fach":
- Name
- Aufgabenfeld (AFI ...)
- Lehrplan
Attribute der Entitätsklasse "Raum":
- Name
- Fachgebundenheit
- Ausstattung
24.04.2023
Hausaufgabe zu Mittwoch dem 26.04.2023
Unter dem Link http://www.plusplanet.de/htaccessdir2/ findet ihr (neben Altlasten für Mathekurse) auch das PDF mit dem Namen db_buch.pdf . Die Zugangsdaten habt ihr über Moodle bekommen.
In diesem Buch lest Ihr bitte S153 bis 161 Mitte. Ich weiß, dass ihr dabei nicht alles im Detail verstehen könnt. Aber die wesentlichen Ideen und Themen solltet ihr schon vorbereiten.
24.04.2023
Auszug aus dem Kernlehrplan zum Thema "Datenbanken":
Die Schülerinnen und Schüler...
• ermitteln für anwendungsbezogene Problemstellungen Entitäten, zugehörige Attribute, Relationen und Kardinalitäten (M),
• stellen Entitäten mit ihren Attributen und die Beziehungen zwischen Entitäten mit Kardinalitäten in einem Entity-Relationship-Diagramm grafisch dar (D),
• modifizieren eine Datenbankmodellierung (M),
• modellieren zu einem Entity-Relationship-Diagramm ein relationales Datenbankschema (M),
• bestimmen Primär- und Sekundärschlüssel (M),
• analysieren und erläutern eine Datenbankmodellierung (A),
• erläutern die Eigenschaften normalisierter Datenbankschemata (A),
• überprüfen Datenbankschemata auf vorgegebene Normalisierungseigenschaften(D),
• überführen Datenbankschemata in die 1. bis 3. Normalform (M).
Notiz zur Klausur:
Wir haben mit den Klassen List, Stack und Queue ja bereits im Unterricht gearbeitet. Falls ihr am Wochenende noch zuhause damit arbeiten wollt, so könnt ihr die Klassen vom Schulministerium herunterladen: https://www.schulentwicklung.nrw.de/lehrplaene/upload/klp_SII/if/MaterialZABI/2020-03-11_Implementationen_von_Klassen_fuer_das_Zentralabitur_ab_2018.zip
In dieser Zip-Datei sind alle Klassen drin (in Unterverzeichnissen organisiert), die man in der Oberstufe benötigt. Für unsere Klausur sind nur folgende Klassen aus der Zipdatei wichtig:
01 Datenstrukturklassen --> 01 linear --> List.java
01 Datenstrukturklassen --> 01 linear --> Queue.java
01 Datenstrukturklassen --> 01 linear --> Stack.java
14.03.2023
Rückmeldungen von Euch zur letzten Stunde:
Ich habe die Aufgabenstellungen alle verstanden. Jedoch hätte Probleme gehabt die Aufgaben zu lösen, wo man selbst eine Methode schreiben muss und bei den Letzten Aufgaben, in dem man argumentieren muss.
-In der Abiturprüfung 2021 spricht die Aufgabe b) von einem double-object als auch den typen double. Ich würde gerne wissen, wo der unterschied genau liegt, denn dass es einen Typen double gibt wusste ich bereits, nur verstehe ich nicht was es mit dem double-object auf sich hat.
-Die Vererbung hatten wir in der EF nicht bearbeitet, weshalb ich dort Probleme beim Programmier Verständnis habe. Trotzdessen verstehe ich das Prinzip, nur fehlt mir die Praxis dazu.
im Bezug auf die letzte Stunde würde ich sagen, dass mein Problem das übersetzen von Texten oder ähnlichem, zu einem vollständigem funktionierendem Programm ist.
11.03.2023
Klausurvorbereitung zur Klausur am 20.03.2023
Thema 1: Netzwerkarchitektur mit Filius
• Struktur der Netzwerke, die im Skript in den Aufgaben vorkommen: Aufgaben ab Seite 9 ff: Aufgabe 1 -12 (Aufgaben zu Email und P2P auslassen) und Aufgabe 21 (DHCP)
• Umrechnung von Binär- in Dezimalzahlen (und umgekehrt), um Aufgaben zum IPv4-Adresssystem (IP-Adresse, Subnetzmaske, Netzwerkteil und Geräteteil) bearbeiten zu können
Thema 2: Lineare Datenstrukturen: Arrays, Listen, Stacks und Queues
• Eigenschaften o.g. Datenstrukturen kennen und damit umgehen können
• In dem unten verlinkten Dokumenten folgende Aufgaben lösen können:
Dokumentation_ZA-IF_GK-LK_ab_2018_2021_12_22(1).pdf: Seite 4-9 passiv verstehen, Seite 18-21 passiv verstehen
IF21_x_G_HT_GG.pdf: HT1 a,b,c (nicht d),e
IF22_x_G_HT_GG.pdf: HT1 a,b,c (nicht d),(nicht e)
20230311_ifq1_dateien.zip
(Hinweis zum Kennwort: Jeweilige Position unserer Informatikstunden während der Woche. Beispiel: Wenn wir Dienstags in der 3. Stunde, Mittwochs in der 4. Stunde und Donnerstags in der 2. Stunde Informatik hätten, sähe das Kennwort folgendermaßen aus: di3mi4do2 )
Unterrichtsreihe Netzwerktechnik
Hinweise zum Rechnen mit Zahlensystemen im GTR: www.plusplanet.de/video/20230306_gtr_zahlensysteme_binaersystem.mp4 Training zu Aufgabenformaten für Filius: Aufgabe 1: Gegeben ist die IP-Adresse 192.168.239.123 und die Subnetzmaske 255.255.224.0. Bestimme den Netzwerkteil und den Geräteteil der Adresse. Aufgabe 2: Gegeben ist der Netzwerkteil 192.168.240.0 und der Geräteteil 0.0.1.233. Gib die zugehörige IP-Adresse an und alle dazu passenden Subnetzmasken an. Aufgabe 3: Baue in Filius folgendes Netzwerk nach:
Mit diesen Informationen kann ein Filius-Netzwerk aufgebaut werden
===================================================================
Netzstruktur:
Alice --+
| (Netzwerk 192.168.1.0)
|
|
+-- Switch ----- VermittlungsrechnerA ---+
| | (Netzwerk 192.168.2.0)
| |
(Netzwerk 192.168.10.0) | +---- Switch ---- Bob
| |
TOE-DNS-Server +------ TOE-DHCP-Server
|
+------ TOE-Webserver
Installiertes Programm "DNS-Server" auf Rechner mit Namen "TOE-DNS-Server"
> Tabelle:
> Hostname: www.plusplanet.de / IP-Adresse: 192.168.2.80
Installiertes Programm "Echo-Server" auf Rechner mit Namen "Bob"
> Port: 55555
Installiertes Programm "Einfacher-Client" auf Rechner mit Namen "Alice"
> Server-Adresse: 192.168.2.10
> Server-Port: 55555
Aufgabe 4 (eher umfangreich): Installiere ein "Modem" in deinem Rechner und im Rechner deines Sitznachbarn und versucht von einem Rechner eine Webseite vom anderen Rechner zu laden. Aufgabe 4 (alternativ): Konstruiere eine Netzwerk und benutze in der "Befehlsfenster"-Software den Befehl traceroute. Konstruiere das Netz so, dass traceroute mindestens drei hops ausgibt.
Lösungen zu Nr1 und Nr2:
Aufgabe 1: Gegeben ist die IP-Adresse 192.168.239.123 und die Subnetzmaske 255.255.224.0. Bestimme den Netzwerkteil und den Geräteteil der Adresse.
Aufgabe 2: Gegeben ist der Netzwerkteil 192.168.240.0 und der Geräteteil 0.0.1.233. Gib die zugehörige IP-Adresse an und alle dazu passenden Subnetzmasken an.
Unterrichtsreihe Netzwerktechnik
Kurzüberblick Lehrplan: Siehe Kategorie "Verschiedenes" in der Navigationsleiste links.
• Klärung des Begriffs HTTP
• Lies das Filius-Skript und experimentiere mit der Filius-Software. ( Bearbeite dann die Übungen ab Seite 9 ff: Aufgabe 1 -12 (Aufgaben zu Email und P2P auslassen) und Aufgabe 21 (DHCP))
Kläre für dich folgende Fragen:
• Worin unterscheiden sich die vier Schichten der Internetprotokollfamilie (Anwendungsschicht, Transportschicht, Internetschicht, Netzzugangsschicht) und welche Aufgaben haben sie?
• Welche Dienste, die man in Filius simulieren kann (Webseiten, ping, dns...) arbeiten auf welchen der vier Schichten? (Dazu kann man sich in Filius den Datenaustausch eines Gerätes anschauen)
• Wie baut man einfache Netze (in Filius) auf?
13.02.2023
Begriffs-Sammlung zum Thema Netzwerke
IP-Adresse und TCP/IP: Wenn eine Netzwerkverbindung über TCP/IP (Transmission Control Protocol/Internet Protocol) aufgebaut werden soll, so benötigen wir i.d.R. einen Server. Dieser Server ist eine Software auf einem Rechner mit IP-Adresse (z.B. 192.168.1.2) der auf einem Port (z.B. 80 ) lauscht, also auf eingehende Verbindungsanfragen wartet. Ein Client ist eine Software, die sich zu der oben genannten Adresse verbinden kann.
Erst wenn die Verbindung aufgebaut ist, können Nachrichten ausgetauscht werden.
HTTP: Hypertext Transfer Protocol
Übertragung von Hyptertext/Webseiten-Daten über die Anwendungsschicht zur Darstellung im Webbrowser.
Vorgang: Client schickt eine HTTP-Anfrage an einen Server, der Server antwortet entsprechend.
DDOS (HA. für Mo)
IP-Spoofing (HA. für Flo)
Netzwerk Server und Client: Im Zusammenhang mit Internetverbindungen gibt es immer ein Rechner, der eine Verbindung aufbauen will (i.d.R. der Client) und ein Rechner, der eine eingehende Verbindungsanfragen akzeptiert (i.d.R. der Server). Beispielsweise ist ein Webbrowser (wie Firefox) ein (HTTP-)Client und das "Webseitenauslieferungsprogramm" ein HTTP-Server (oder Webserver, oft die Software "Apache"). Port: Bei TCP/IP-Verbindungen wird nicht nur die Adresse des Quell- und Zielrechners benötigt. Auch wird ein sogenannter Port (auf beiden Seiten) benötigt. Ein Port ist eine Zahl zwischen 0 und 65535. Vereinfacht kann man sich Ports als "Türnummer" vorstellen. Beispielsweise wartet ein Webserver standardmäßig auf Port 80 auf eingehende Verbindungen. Oft schreibt man 192.168.0.22:80 wenn man sowohl IP-Adresse als auch Port zusammenfassen möchte.
Problem: Klausur ist schlecht ausgefallen. Man kann vermuten, dass auch die Nicht-Klausurschreiberinnen nicht alles gekonnt hätten. Offenbar kommen so einige Dinge, die wir im Unterricht behandeln, nicht so bei Euch an, wie ich mir das wünsche. Andererseits bin ich natürlich an den Lehrplan gebunden.
Was meines Erachtens bei Euch nur schlecht funktioniert:(*)
• Zu einem Problem ein eigenes Vorgehen entwerfen und programmieren (z.B. "ermittle die zweitgrößte Zahl aus einem Array" oder "ermittle, wie oft jedes Arrayelement im Array vorkommt")
• bestehenden Java-Programmcode lesen und verstehen.
Bitte bearbeitet die folgenden zwei Aufgaben über mein Rückmeldeformular:
Aufgabe 3:
Lies bzw. überfliege noch einmal mein Java-Einführungsskript. 20220114_TOE_Java_Einfuehrung.pdf Notiere alle Begriffe oder Konzepte, die deiner Meinung in einer "Vokabelliste für Informatik" erklärt werden müssten. Erstelle dazu eine einfache Textdatei und sortiere die Begriffe (nur ein Begriff pro Zeile!) danach, wie wichtig Du Sie findest (wichtigste Begriffe zuerst!).
Beispiel: Liste von Maxi Mustermann:
• Objekt
• if
• Reset
• Unterschied Array und Liste
• Referenz
Aufgabe 4 (ggf. Hausaufgabe)
Informiere Dich in der Wikipedia über die Datenstruktur "Stapelspeicher" und beantworte folgende Fragen:
a) Wie funktioniert ein Stapelspeicher?
b) Welche Operationen stellt die Datenstruktur zur Verfügung und was bewirken sie?
Informiere Dich in der Wikipedia über die Datenstruktur "Warteschlange (Datenstruktur)" und beantworte folgende Fragen:
c) Wie funktioniert ein Warteschlange?
d) Welche Operationen stellt die Datenstruktur zur Verfügung und was bewirken sie?
19.11.2022
Lieber IF-Q1-Kurs,
Für die letzte Stunde vor den Ferien bereitet ihr bitte Folgendes vor:
Informiere Dich in der Wikipedia über die Datenstruktur "Stapelspeicher" und beantworte folgende Fragen:
a) Wie funktioniert ein Stapelspeicher? b) Welche Operationen stellt die Datenstruktur zur Verfügung und was bewirken sie?
Informiere Dich in der Wikipedia über die Datenstruktur "Warteschlange (Datenstruktur)" und beantworte folgende Fragen:
c) Wie funktioniert ein Warteschlange? d) Welche Operationen stellt die Datenstruktur zur Verfügung und was bewirken sie?
Klausurthemen Grundlagen
• Konzepte Objekt, Klasse, Eigenschaft, Methode verstehen
• einfache Algorithmen (z.B. Primzahltest, Mittelwert oder Spannweite eines Arrays, größtes Element eines Arrays, Sortieren mit Bubble-Sort), selbst schreiben und "auf Papier" ausführen können.
• Zu Programmen bzw. Objektbeziehungen ein Diagramm des Speicherlayouts zeichnen ("Wölkchen") und umgekehrt.
Neue Themen:
• Komplexität von Algorithmen
• Sortierverfahren: "in place" und "stabil"
• Prinzip "Rekursion" verstehen. Z.B. Fibonaccizahlen oder Fakultät selbst schreiben können.
• Idee hinter "rekursivem Array-Reverse" verstehen.
• Mergesort: Verfahren verstehen und kleinere Teile davon selbstständig ergänzen können oder Fehler finden können
• Sowohl beim "rekursivem Array-Reverse" als auch bei "Mergesort" wird intensiv mit Arrays und trickreicher Indexmanipulation gearbeitet. Da sollte man einen Überblick behalten.
• Konzept "verkettete Liste" am Beispiel unserer Klasse StringListe verstehen. Einzelne Methoden (wie z.B. insertAfterCurrent) selbst schreiben können.
Hier die gesamte Klasse, die Mergesort enthält und testet.
import java.util.Arrays;
public class StartklasseSuS {
public static int zahlen[] = new int[8];
public static void main() {
populate(zahlen);
if(zahlen.length < 60) {
System.out.println("Das Array sieht anfangs so aus: "+Arrays.toString(zahlen));
} else {
System.out.println("Das Array hat eine Länge von "+zahlen.length);
}
System.out.println("Ist das array sortiert? "+isSorted(zahlen));
long start = System.currentTimeMillis();
boolean doMergesort = true;
if(doMergesort) {
System.out.println("Es wird nun mit Mergesort sortiert!");
zahlen = mergesort(zahlen);
} else {
System.out.println("Es wird nun mit Bubblesort sortiert!");
zahlen = bubblesort(zahlen);
}
long end = System.currentTimeMillis();
System.out.println("Benoetigte Zeit in ms: "+(end-start));
if(zahlen.length < 60) {
System.out.println("Das Array sieht am Ende so aus: "+Arrays.toString(zahlen));
} else {
System.out.println("Das Array hat eine Länge von "+zahlen.length+" und eine sortierte Version wird daher nicht mehr ausgegeben.");
}
System.out.println("Ist das array sortiert? "+isSorted(zahlen));
int suchElem = 30;
int idx = binSearch(suchElem);
System.out.println("Das Element "+suchElem+" besitzt den Index "+idx);
}
public static boolean isSorted(int[] a) {
boolean result = true;
for(int i = 0; i < a.length-1; i++) {
if(a[i] > a[i+1]) {
result = false;
}
}
return result;
}
public static void populate(int[] z) {
for(int i = 0; i < z.length; i++) {
z[i] = (int) (Math.random()*3000);
}
}
// Gibt den Index der ersten Vorkommens des Elementes e zurück. Bei nicht-gefundenem Element wird -1 zurückgegeben
public static int binSearch(int e) {
int start = 0;
int ende = zahlen.length-1;
int mitte = (ende+start)/2;
while(true) {
if(e == zahlen[mitte]) {
return mitte;
}
if(e < zahlen[mitte]) {
// untere Hälfte benutzen
ende = mitte-1;
mitte = (ende+start)/2;
} else {
// obere Hälfte benutzen
start = mitte+1;
mitte = (ende+start)/2;
}
if(start>ende) {
break;
}
}
return -1;
}
public static int[] bubblesort(int[] a) {
for(int i = 0; i < a.length; i++) {
for(int j = 0; j < a.length-1; j++) {
if(a[j] > a[j+1]) {
int hilf = a[j];
a[j] = a[j+1];
a[j+1] = hilf;
}
}
}
return a;
}
public static int[] mergesort(int[] a) {
int[] b = new int[a.length];
// left begin, left end, right begin, right end
int lb = 0, le = a.length/2 -1, rb = le+1, re = a.length-1;
mergesort(a,b,lb,le,rb,re);
return a;
}
/*
* mergesort sortiert das teilarray von lb bis re, dabei wird array b als
* hilfsspeicher genutzt.
* @param a zu sortierendes Array
* @param b hilfsarray mit gleicher größe wie a
* @param lb "left begin" index
* @param le "left end" index
* @param rb "right begin" index
* @param re "right end" index
*/
public static void mergesort(int[] a, int[] b, int lb, int le, int rb, int re) {
// Diagnosetools
System.out.println("------------------------");
System.out.println("Mergesortaufruf mit lb="+lb+"; le="+le+" und rb="+rb+"; re="+re);
String teilarr1 = arrToString(a,lb,le);
String teilarr2 = arrToString(a,rb,re);
System.out.println("Teil 1: "+teilarr1+" Teil 2: "+teilarr2);
if(lb < le) {
int mitte = (lb+le)/2;
mergesort(a,b,lb,mitte,mitte+1,le);
}
if(rb < re) {
int mitte = (rb+re)/2;
mergesort(a,b,rb,mitte,mitte+1,re);
}
// Diagnosetools
System.out.println("------------------------");
System.out.println("Start der Zusammenführung zweier Teile mit lb="+lb+"; le="+le+" und rb="+rb+"; re="+re);
teilarr1 = arrToString(a,lb,le);
teilarr2 = arrToString(a,rb,re);
System.out.println("Teil 1: "+teilarr1+" Teil 2: "+teilarr2);
// ###################
// ###################
// ###################
// Merge-phase fehlt!
// ###################
// ###################
// ###################
//for(int i = lb; i <= re; i++) { // Dummy-Schleife, die nur provisorisch das Hilfsarray füllt. Hier muss gearbeitet werden!
// b[i] = a[i];
//}
int indexLinks = lb;
int indexRechts = rb;
int indexNeu = lb;
while(( indexLinks <= le ) && (indexRechts <= re)) {
if(a[indexLinks] < a[indexRechts]) {
b[indexNeu] = a[indexLinks];
indexLinks++;
} else {
b[indexNeu] = a[indexRechts];
indexRechts++;
}
indexNeu++;
}
// feststellen, welcher reststapel noch übertragen werden muss
if(indexLinks<=le) { // im linken Stapel sind noch Elemente
for(int i = indexLinks; i <= le ; i++) {
b[indexNeu] = a[indexLinks];
indexNeu++;
indexLinks++;
}
}
if(indexRechts<=re) { // im rechts Stapel sind noch Elemente
for(int i = indexRechts; i <= re ; i++) {
b[indexNeu] = a[indexRechts];
indexNeu++;
indexRechts++;
}
}
// ###################
// ###################
// ###################
// Ende der Merge-phase!
// ###################
// ###################
// ###################
// Rückkopie nach array a:
for(int i = lb; i <= re; i++) {
a[i] = b[i];
}
// Diagnosetools
System.out.println("Nach der Mergephase sieht das Array von lb="+lb+" bis re="+re+" so aus:");
String teilarr = arrToString(a,lb,re);
System.out.println("Zusammengeführter Teil: "+teilarr);
return;
}
// Stringdarstellung eines Teilarrays von index b bis einschließlich index e
public static String arrToString(int[] arr,int b, int e) {
String result = "[ ";
for(int i = b; i <= e; i++) {
result += ""+i+": "+arr[i];
if(i != e) { // noch nicht letzter durchgang
result += " | ";
}
}
result += " ]";
return result;
}
}
24.10.2022
Hausaufgabe und "EVA zu Hause":
Beantworte folgende Fragen:
- was bedeutet "in place" und "stabil" bei Sortierverfahren?
- wie arbeiten BubbleSort und Mergesort (in place? stabil?)
- Verschaffe dir einen Überblick über die Landau-Symbole (Stichwort Komplexität)
Grober Pseudocode für rekursiv implementierten Mergesort (mit angedeutetem Aufruf bei 8 Elementen):
mergesort(array, von 1 , bis 8) {
falls array teilbar
aufruf mergesort(array, 5 bis 8)
aufruf mergesort(array, 1 bis 4)
ansonsten
return
// zusammenführungsphase:
betrachte "obere" Elemente der Teilstapel
if(linkes Element < rechtes Element) {
linkes Element in neues Array einfügen
} else {
linkes Element in neues Array einfügen
}
Sonderfall: linke oder rechte Liste leer:
Rest der rechten oder linken Liste übernehmen
}
Komplexitätsbetrachtungen zum Problem "Spannweite"
public class Haupt {
public static void spannweite() {
int[] arr = {9,2,6,3,77,43};
int minElem = sucheMinElem(arr);
int maxElem = sucheMaxElem(arr);
int ergebnis = maxElem - minElem;
}
public static int sucheMinElem(int[] arr){
int min = arr[0];
for(int i=0; i<arr.length;i++) {
if(arr[i] < min) {
min = arr[i];
}
}
return min;
}
public static int sucheMaxElem(int[] arr){
int max = arr[0];
for(int i=0; i<arr.length;i++) {
if(arr[i] > max) {
max = arr[i];
}
}
return max;
}
}
// Problemgröße n=6
// Hauptprogramm: 4 Schritte
// Erster Methodenaufruf: 20
// Zweiter Methodenaufruf: 20
// Insgesamt: 44 Schritte
//
// Problemgröße n=7
// Hauptprogramm: 4 Schritte
// Erster Methodenaufruf: 23
// Zweiter Methodenaufruf: 23
// Insgesamt: 50 Schritte
//
// Problemgröße n=8
// Hauptprogramm: 4 Schritte
// Erster Methodenaufruf: 26
// Zweiter Methodenaufruf: 26
// Insgesamt: 56 Schritte
//
// Problemgröße n=9
// Insgesamt: 62 Schritte
//
// Problemgröße n:
// Insgesamt: 4 + 3·n+2 + 3·n+2
// = 4+2(3n+2)
// = 4+6n+4
// = 6n+8
//
// Das Spannweitenproblem liegt also in der
// Komplexitätsklasse n.
// (Man spricht auch von "lineare Komplexität")
27.09.2022
Link zu den Security-Rätseln: https://0xf.at/
Gebt eure Ergebnisse über folgendes Rückmeldeformular ein:
20.09.2022
Klausurthemen:
• Konzepte Objekt, Klasse, Eigenschaft, Methode verstehen
• einfache Algorithmen (z.B. Primzahltest, Mittelwert oder Spannweite eines Arrays, größtes Element eines Arrays, Sortieren mit Bubble-Sort), selbst schreiben und "auf Papier" ausführen können.
• Zu Programmen bzw. Objektbeziehungen ein Diagramm des Speicherlayouts zeichnen ("Wölkchen") und umgekehrt. (siehe Aufgabe unten)
Decke jeweils eines der beiden verdeckten Elemente auf und generiere daraus das andere:
Ereuge ein Speicherdiagramm für das Ende der Main-Methode:
public class Auto {
int baujahr;
String kennzeichen;
public static void main() {
Auto[] arr = new Auto[5];
Auto z = new Auto(2003,"N-AB 333");
arr[1] = new Auto(2002,"D-FM 222");
arr[2] = new Auto(2006,"M-AT 666");
arr[3] = z;
arr[4] = z;
// Zeichne die bis hier aufgebaute
// Datenstruktur in einem Diagramm
}
}
Schreibe ein Programm, welches folgendes Speicherdiagramm erzeugen könnte:
Aufgabe: Versuche vorherzusagen, welche Ausgabe die folgende (ziemlich sinnlose) Funktion erzeugt. Erst das Ergebnis notieren, dann ausführen! Sage das Ergebnis auch für andere Wörter als "hey" voraus!
private void increaseDBSize() {
Device[] oldDevices = this.devices;
this.devices = new Device[oldDevices.length + 10];
for(int i = 0; i < oldDevices.length; i++) {
this.devices[i] = oldDevices[i];
}
}
public String getDeviceList() {
String result = "";
for(int i = 0; i < numDevices; i++) {
result += devices[i].devName+" - "+devices[i].type+" \n";
}
return result;
}
public String getAllDevicesFromLocation(String loc) {
String result = "";
for(int i = 0; i < numDevices; i++) {
if(devices[i].loc.equals(loc)) {
result += devices[i].devName+" - "+devices[i].type+" \n";
}
}
return result;
}
public int numberOfDevicesInRoom(String loc) {
int result = 0;
for(int i = 0; i < numDevices; i++) {
if(devices[i].loc.equals(loc)) {
result++;
}
}
return result;
}
}
29.08.2022
Miniprojekt für die nächsten Stunden
public class Haupt {
public static void main(String[] args) {
gbgIT = new InventarTool();
// Gerät SerienNr Raum Art Anschaffungsjahr
// device sn location type year
gbgIT.add("Dell Optiplex 7010", "AO802310","E35" , "DesktopPc" , 2014);
gbgIT.add("Dell Optiplex ABCD", "XY620382","R135", "DesktopPc" , 2022);
gbgIT.add("Terra 2220W" , "TNsi922" ,"E35" , "19'' Monitor", 2015);
System.out.println("Geräte aus R35: \n" + gbgIT.getAllDevicesFromLocation("E35"));
System.out.println("Geräteliste nach Raum: \n" + gbgIT.numberOfDevicesInRoom("E35"));
gbgIT.sortByRoom();
System.out.println("Geräteliste nach Raum: \n" + gbgIT.getDeviceList() );
}
}
15.08.2022
• Begrüßung, Leistungsbewertung, Themen im Schuljahr
• Welche Rechner und welche Programme habt ihr benutzt?
• Wer programmiert hobbymäßig?
Programmgerüst zum 15.08.2022
Wir kümmern uns zunächst um ein paar Informatikprobleme, die immer wieder auftauchen. Füge den folgenden Quelltext in ein neues Projekt ein und schreibe die angedeuteten Methoden.
public class Haupt {
public static void main() {
int[] a = {10,20,30,40,50,60,70,80};
zufallsbelegung(a);
printArray(a);
// Linksrotation des Arrays:
// alle Elemente werden eine Position nach links geschoben.
// Das Element beim Index 0 wird an die letzte Position gesetzt
// Beispiel: Array {2,4,9,5,6} -> {4,9,5,6,2}
a = rotiereLinks(a);
printArray(a);
// Entscheidung, ob ein Element existiert
// Beispiel: im Array {2,4,9,5,6} liefert der Aufruf hatElement(a,4) das Ergebnis "true"
// System.out.println("Array enthaelt Element 4: "+hatElement(a,4));
// Berechnung des Mittelwerts des Array:
// Der Mittelwert eines Arrays kann man folgendermaßen berechnen:
// (Summe aller Elemente) ÷ (Anzahl der Elemente)
// Beispiel: Array {2,4,9,5,6} hat den Mittelwert 5,2
// System.out.println("Mittelwert "+mittelwert(a));
// Feld umkehren
// Beispiel: Array {2,4,9,5,6} ist umgekehrt {6,5,9,4,2}
// a = arrayUmkehren(a);
// printArray(a);
// Berechnung der Spannweite des Arrays:
// Die Spannweite ist die Differenz zwischen dem größten und kleinsten Element
// Beispiel: Array {2,4,9,5,6} hat die Spannweite 7
// System.out.println("Spannweite "+spannweite(a));
// Enthält Mehrfachwerte
// Beispiel: Array {2,4,9,5,6} enthält keine mehrfachen Elemente
// Beispiel: Array {2,6,9,5,6} enthält Elemente mehrfach! (in diesem Fall die 6)
// System.out.println("Array enthaelt Mehrfachwerte: "+hatMehrfachwerte(a));
// Anzahl Primzahlen
// Beispiel: Array {2,4,9,5,7} enthält zwei Primzahl (nämlich 5 und 7)
// System.out.println("Array enthaelt "+anzPrim(a)+" Primzahlen");
}
public static void zufallsbelegung(int[] a) {
for(int i = 0; i < a.length; i++) {
a[i] = (int)(Math.random() * 100);
}
}
public static int[] rotiereLinks(int[] a) {
int hilf = a[0];
for(int i = 1; i < a.length; i++) {
a[i-1] = a[i];
}
a[a.length - 1] = hilf;
return a;
}
public static void printArray(int[] a) {
System.out.println("--- Arrayausgabe ---");
for(int i = 0; i < a.length; i++) {
System.out.println("idx: "+i+" Wert:"+a[i]);
}
System.out.println("--------------------");
}
}
Bitte nutzt folgendes Rückmeldeformular:
25.04.2023
"Geparkte" Information zum Unterricht
Begriffe aus dem db_buch.pdf
- Vermeidung von Redundanzen
- Konsistenz und Integrität
- Transaktionen
- Objekte in DBMS (Formular, Abfrage, Bericht zunächst für uns nicht wichtig)
- Entity: "Gerresheim" oder "Android"
- Entitymenge/Entitätsmenge: Bei unserer Umfrage: Teilnahme, Stadteil, OS
- Attribute der Entitymenge OS sind z.B. Name, aber ggf. auch Version
- Primärschlüssel ist eine Teilmenge der Attribute, die die Entity eindeutig identifiziert
- Relationship: Beziehung zwischen Entitymengen
- Relationships haben Kardinalitäten: 1:1 oder 1:n oder m:n
- ER-Modell ist ein Diagramm, aus dem die Entitymengen, Attribute, Relationships und deren Kardinalitäten ersichtlich sind
- Normalisierung, um die 1. , 2. und 3. Normalform zu erzeugen
- Normalformen: Gute Beispiele bei https://de.wikipedia.org/wiki/Normalisierung_(Datenbank)#Zweite_Normalform_(2NF)
- 1. Normalform: alle Attribute sind atomar
- 2. Normalform: (nur bei mehreren Schlüsselattributen): Ist das Geburtsjahr des Interpreten nicht von der CDID abhängig
- 3. Normalform: (Zur Vermeidung von Redundanz): Geburtsjahr eines Interpreten hängt nur indirekt von der CDID ab.
- Transformation in ein relationales Modell / Datenbankschema
- Begriffe in einem relationalen Modell: Eine "Tabelle" ist 2D-Anordnung von Elementen, deren Spalten "Attribute" oder "Felder" heißen. Eine Zeile ist ein "Datensatz" (oder Tupel). Der Primärschlüssel ist eine Teilmenge der Attribute und identifiziert einen Datensatz. Fremdschlüssel sind Attributmengen, die in anderen Tabellen Primärschlüssel sind.
- Transformationsregeln: Entitymengen->Tabelle, 1:1-Relationen werden in eine Tabelle zusammengelegt, 1:n-Relationen werden in zwei Tabellen (mit Fremdschlüssel) aufgeteilt, m:n-Relationen werden mit einer Hilfstabelle abgebildet.
Sammlung von Begriffen aus der Schullandschaft (Ziel: eine umfassende Datenbank für alle schulischen Anwendungsfälle)