plusplanet :: Informatik_Q1

www.plusplanet.de
Schulinfos von F. Töns

17.05.2023

Bild "Informatik_Q1_Abi2024:20230516_ER_diag.png"

15.05.2023

Hausaufgabe: Fragen zur besprochenen Klausur. Wenn ihr keine Fragen habt, so habe ich welche!

Die Datenbank aus der Klausur einmal als Datenbankdatei:
abi22_restaurantgutachten.db

Und für den Direktimport nach https://sqliteonline.com/ zum Testen:
abi22_restaurantgutachten.db.sql

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;

15.05.2023

Fahrplan für heute:
• Randnotiz zu "prepared statements"
• Klausurthemen
• Alte Klausur (siehe http://www.plusplanet.de/htaccessdir2/)

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

Zum Üben von SQL-Befehlen eignet sich ggf. auch:
https://www.w3schools.com/sql/trysql.asp?filename=trysql_select_all

03.05.2023

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:
Bild "Informatik_Q1_Abi2024:20230502_ifq1_er_diagramm_patient.jpg"

Bild "Informatik_Q1_Abi2024:20230502_ifq1_er_diagramm_patient.jpg"

• Ü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).

19.04.2023

Bitte gib deine Hausaufgaben zu heute hier ein:

20.03.2023





 ____________________________________________________________

| Tauschring                                                 |

|____________________________________________________________|

|____________________________________________________________|

| + gibAus()                                                 |

| + verleihe(sache:Item, von:String, an:String):boolean      |

| + verleihEnde(sache:Item, von:String, an:String):boolean   |

|____________________________________________________________|

   |

   | - mitglieder

   |

   ---> List   ------------------------

                ContentType:Teilnehmer

               ------------------------



 _________________________

|Teilnehmer               |

|_________________________|

|+ name                   |

|_________________________|

|+ gibSachen():List<Item> |

|_________________________|

   |

   | - sachen  

   |

   ----> List   ------------------

                 ContentType:Item

                ------------------

 ___________________________

| Item                      |

|___________________________|

| + name:String             |

| + verliehenAn: String     |

|___________________________|

|___________________________|

17.03.2023

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 )

06.03.2023

Hausaufgabe:
Link zum bekannten Skript: http://www.lernsoftware-filius.de/downloads/Einfuehrung_Filius_2015.pdf
Hier sollt ihr auf S29 Nr2 und Nr3 erledigen.

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

  



Rechnereigenschaften (Normales Notebook):

>             Name: Alice

>       IP-Adresse: 192.168.1.10

>        Netzmaske: 255.255.255.0

>          Gateway: 192.168.1.1

> DomainNameServer: 192.168.10.10

> [ ] DHCP zur Konfiguration verwenden



Rechnereigenschaften (Normaler Rechner):

>             Name: TOE-DNS-Server

>       IP-Adresse: 192.168.10.10

>        Netzmaske: 255.255.255.0

>          Gateway: 192.168.10.1

> DomainNameServer: 192.168.10.10

> [ ] DHCP zur Konfiguration verwenden



Rechnereigenschaften (Normales Notebook):

>             Name: Bob

>       IP-Adresse: 192.168.2.10

>        Netzmaske: 255.255.255.0

>          Gateway: 192.168.2.1

> DomainNameServer: 192.168.10.10

> [X] DHCP zur Konfiguration verwenden



Rechnereigenschaften (Normaler Rechner):

>             Name: TOE-Webserver

>       IP-Adresse: 192.168.2.80

>        Netzmaske: 255.255.255.0

>          Gateway: 192.168.2.1

> DomainNameServer: 192.168.10.10

> [ ] DHCP zur Konfiguration verwenden



Rechnereigenschaften (Normaler Rechner):

>             Name: TOE-DHCP-Server

>       IP-Adresse: 192.168.2.20

>        Netzmaske: 255.255.255.0

>          Gateway: 192.168.2.1

> DomainNameServer: 192.168.10.10

> -------------------------------------

> DHCP-Eigenschaften: Adress-Untergrenze: 192.168.2.50

> DHCP-Eigenschaften: Adress-Obergrenze: 192.168.2.60

> DHCP-Eigenschaften: Netzmaske: 255.255.255.0

> DHCP-Eigenschaften: Gateway: 192.168.2.1

> DHCP-Eigenschaften: DNS-Server: 192.168.10.10

> [X] DHCP aktivieren





Rechnereigenschaften (Vermittlungsrechner):

>        Allgemein/Name: VermittlungsrechnerA

>     Allgemein/Gateway: (leer)

>       Netzwerkkarte 1: 192.168.1.1 mit Netzmaske 255.255.255.0

>       Netzwerkkarte 2: 192.168.2.1 mit Netzmaske 255.255.255.0

>       Netzwerkkarte 3: 192.168.3.1 mit Netzmaske 255.255.255.0

> Weiterleitungstabelle:

> Ziel:192.168.10.1 / Netzmaske:255.255.255.255 / NextGateway:127.0.0.1    / Über Schnittstelle:127.0.0.1

> Ziel:192.168.10.0 / Netzmaske:255.255.255.0   / NextGateway:192.168.10.1 / Über Schnittstelle:192.168.10.1

> usw. (Wird i.d.R. automatisch erstellt)



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.



192.168.239.123  = 11000000.10101000.11101111.01111011

255.255.224.  0  = 11111111.11111111.11100000.00000000

Netzwerkteil:    = 11000000.10101000.11100000.00000000



192.168.239.123  = 11000000.10101000.11101111.01111011

invertierte SNM  = 00000000.00000000.00011111.11111111

Geräteteil:      = 00000000.00000000.00001111.01111011



Merkhilfe: "Auseinanderschneiden gemäß Subnetzmaske"

192.168.239.123  = 11000000.10101000.111    01111.01111011

255.255.224.  0  = 11111111.11111111.111    00000.00000000



Aufgabe 1b: Gegeben ist die IP-Adresse 192.158.239.133 und die Subnetzmaske 255.255.240.0. Bestimme den Netzwerkteil und den Geräteteil der Adresse.



192.158.239.133  = 11000000.10011110.11101111.10000101

255.255.240.0    = 11111111.11111111.11110000.00000000

Netzwerkteil:    = 11000000.10011110.11100000.00000000

                 =    192  .   158  .   224  .   0

Geräteteil:      = 00000000.00000000.00001111.10000101

                      0    .   0    .    15  .   133





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.



Netzwerkteil:    = 192.168.240.  0

Geräteteil:      =   0.  0.  1.233

192.168.240.  0  = 11000000.10101000.11110000.00000000

  0.  0.  1.233  = 00000000.00000000.00000001.11101001

Unklare Grenze bei der Subnetzmaske:     ???

                   11111111.11111111.1111   0.00000000

Mögliche SNM     = 11111111.11111111.11110000.00000000

Mögliche SNM     = 11111111.11111111.11111000.00000000

Mögliche SNM     = 11111111.11111111.11111100.00000000

Mögliche SNM     = 11111111.11111111.11111110.00000000



Dazugehörige IP-Adresse:  

                   11000000.10101000.11110001.11101001

        		      192  .   168  .   241  .   233

27.02.2023

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))

• Bearbeite folgendes Blatt: 00000000_jgst13_200_IF13_Networking_Grundlagen_Luecke.pdf

Lies folgenden Artikel: https://de.wikipedia.org/wiki/Internetprotokollfamilie#TCP/IP-Referenzmodell

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.

IPv4 und IPv6
DNS
Proxies
(Datenbank)

00000000_jgst13_200_IF13_Networking_Grundlagen_Luecke.pdf

09.01.2023

Lieber Informatikkurs

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?

Viel Erfolg und bis morgen
Frank Töns

22.11.2022

Hier die Version unseres StringListe-Wunschzettelprojektes nach der Stunde am Dienstag:
20221122_q1_stringliste_nach_u.zip

22.11.2022

Klausurthemen IFQ1

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.

21.11.2022

StringListe nach dem Unterricht am Montag:
20221121_q1_stringliste_nach_u.zip

15.11.2022

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

}

18.10.2022

Zum Begriff "Komplexität von Algorithmen"
20221016_komplexitaetsueberblick.pdf

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 Auto(int b, String k) {

        this.baujahr = b;

        this.kennzeichen = k;

    }

    

    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

    }

}

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!



public static void machJenes() {

    String ausgabeText = "";

    String eingabeText = "hey";



    int z = 6;

    for(int i=0; i < eingabeText.length() ; i++) {

        z = (z+19)%eingabeText.length();



        if( i%2 == 0 ) {

            ausgabeText = ausgabeText + eingabeText.charAt(z);

        } else {

            ausgabeText = ausgabeText + eingabeText.charAt(z) + "*";

        }

    }



    ausgabeText = "Hier das Ergebnis:\n"+ausgabeText;

    System.out.println(ausgabeText);

}

19.09.2022

Überfliege das Grundlagenskript und notiere Dinge, die Du nicht verstehst:
20220114_TOE_Java_Einfuehrung.pdf

Hier ein Beispiel für einen Primzahltest



public class Haupt {



    public static void main() {

        for(int i = -5; i < 25;i++) {

            System.out.println("Die Zahl "+i+" ist prim: "+primzahltest(i));

        }

    }



    public static boolean primzahltest(int z) {

        if(z <= 1) {

            return false;  // nur positive Zahlen 

        }

        for(int i = 2; i < z-1; i++) {

            if(z%i == 0) {

                return false;

            }

        }

        return true;

    }

}

12.09.2022

Denkanstöße für heute:



public class Haupt {



    public static void main() {

        int[] arr = {5,7,2,9,1};



        for(int i = 0; i < arr.length; i++) {

            System.out.println("Index: "+i+" Inhalt "+arr[i]);

        }



        for(int i = 0; i < arr.length-1; i++) {

            for(int j = 0; j < arr.length-1; j++) {

                if(arr[j] > arr[j]) {

                    int hilf = arr[j];

                    arr[j] = arr[j+1];

                    arr[j+1] = hilf;

                }

            }

        }



        for(int i = 0; i < arr.length; i++) {

            System.out.println("Index: "+i+" Inhalt "+arr[i]);

        }

    }

}

05.09.2022

Speicherlayout, Referenztypen und atomare Datentypen:
20171012_Referenzen_Arrays_Speicherlayout.pdf

Denkanstöße für heute:



public class InventarTool {

    int numDevices = 0;

    Device[] devices;

    

    public void add(String devName, String sn, String loc , String type, int year) {

        Device d = new Device();

        d.devName = devName;

        d.sn = sn;

        d.loc = loc;

        d.type = type;

        d.year = year;

        

        if(devices == null) {

            devices = new Device[5];

        }

        

        if (devices.length == numDevices) {

            // aufblasen!

            increaseDBSize();

        } 

        devices[numDevices] = d;

        numDevices ++;

    }

    

    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äteliste:\n" + gbgIT.getDeviceList() );

		

		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 gerader Zahlen

        // Beispiel: Array {2,4,9,5,6} enthält 3 gerade Zahlen (nämlich 2,4 und 6)

        // System.out.println("Array enthaelt "+anzGerade(a)+" gerade Zahlen");

        

        // 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)