Anton-Bruckner-Gymnasium Straubing

Themenliste zum Wahlunterricht Informatik in 2003/2004:

Was macht eigentlich die Informatik?

Anmeckerungen an: K. Penzkofer -

(Beachte, die Seite wächst von unten nach oben!)

25. Stunde (Mi, 16.6., ab 13.15 Uhr): Test an www.bayschutt.de Erstellen weiterer baySchuTT-Tabellen, SQL-Abfragen
Mi, 26. 5., ab 13 Uhr

kein WuInf wegen Schullandheimaufenthalt

24. Stunde (19.5., ab 13 Uhr) Programmier- und Layoutfragen zu www.bayschutt.de
23. Stunde (12.5., ab 13 Uhr) Übertrag der Testdaten auf www.bayschutt.de
22. Stunde (5.5., ab 13 Uhr) Domainantrag bei IDOWA, phpmyadmin
21. Stunde (28.4., ab 13 Uhr) Arbeit am Datenbankprojekt: Bay. SchulTheaterTag
20. Stunde (21.4., ab 13 Uhr) Arbeit am Datenbankprojekt: Bay. SchulTheaterTag auf dem Bruckner WebServer Apoll
16. - 19. Stunde (Termin jeweils Mittwoch 13 Uhr) Testarbeiten am neuen Laptopklassenzimmer und der Linux-ServerFarm

15. Stunde (Termin: Mi, 3.3., ab 13 Uhr):

Leider funktioniert der Zugang zum Apoll nicht ... 'Schuld' ist wahrscheinlich die Firewall auf dem Kerberos1 .. Deshalb heute:

Firewall

........

2.2 Das TCP/IP Referenzmodell

Nachdem das OSI-Modell ein eher akademisches Modell ist und von keiner Netzwerksoftware wirklich hundertprozentig implementiert wird, ist es jetzt an der Zeit, das Modell zu betrachten, das tatsächlich heute im Internet (und allen lokalen Netzsystemen) verwendet wird, TCP/IP. Im Gegensatz zum OSI-Modell kommt TCP/IP mit nur vier Schichten aus, um den Datentransfer zu erklären:

  • Netzzugriffsschicht
  • Internet-Schicht
  • Transportschicht
  • Anwendungsschicht

......
# Alle bestehenden Regeln löschen
ipchains -F
# Voreingestellte Policies setzen
ipchains -P input DENY ipchains -P output REJECT ipchains -P forward REJECT
# Loopback ohne Einschr¨ankungen
ipchains -A input -i $LOOPBACK_INTERFACE -j ACCEPT
ipchains -A output -i $LOOPBACK_INTERFACE -j ACCEPT
# SYN_COOKIES aktivieren
echo 1 > /proc/sys/net/ipv4/tcp_syncookies
# SOURCE ADDRESS VERIFICATION aktivieren
for i in /proc/sys/net/ipv4/conf/*/rp_filter do echo 1 > $i done
# Pakete ablehnen, die vorgeben von der eigenen Adresse zu stammen
ipchains -A input -i $EXTERNAL_INTERFACE \ -s $IPADDR -j DENY -l
ipchains -A input -i $BASTION_DMZ_INTERFACE \ -s $BASTION_DMZ_IPADDR -j DENY -l
......

nach: Florian Kalhammer, Uni Magdeburg

 
In den Faschingsferien sollte der Kurs mit dem Apoll arbeiten können ....
14. Stunde (Termin: Mi., 18.2., ab 13 Uhr): Diverse Tests mit dem Apoll; auch php sollte funktionieren ...
13. Stunde (Termin: Mi., 11.2., ab 13 Uhr) Nun aber läuft er, das Web- und DatenbankServer des ABG: Er heißt Apoll und soll demnächst auch 'von draußen' erreichbar sein.
Termin: Mi., 4.2., ab 13 Uhr ausgefallen
12. Stunde (Termin: Mi., 28.1., ab 13 Uhr): Installation eines Linux-Rechner als WebServer und DatenbankServer, gescheitert an einer fehlerhaften Festplatte ....

Die MySQL-Datenbank

und

PHP

Das ER-Modell ist nun einigermaßen fertig, also wollen wir nun den MySQL-Server aufsetzen und mal mit einer kleinen Experimentierdatenbank arbeiten.

Übrigens: MySQL steht für meine "structured query language" und "PHP" für "HypertextPreProcessor"

Übrigens, von Damir Enseleit gäbe es ein SELFPHP

 

 
11. Stunde (Termin: Mi., 21.1., ab 13 Uhr)

Fertigstellen des ER-Entwurfes

Nach gründlicher Diskussion sollte heute das ER-Modell fertig gestellt werden.
Noch zu lösende Probleme:
Zuweisung der Leiterzimmer der Gruppen
Komplettierung der Attribute
Test des Modells

 

10. Stunde (Termin: Mi., 14.1., ab 13 Uhr)

Der ER-Entwurf einer Datenbank

Ein wohlüberlegter Entity-Relationship-Entwurf einer Datenbank ist ein probates Mittel, eine 'gute' Datenbank zu kriegen. Die Darstellung
der Entities: Rechtecke,
der Attribute: abgerundete Rechtecke,
der Relationships: Rauten
usw ist standardisiert.
Was da dann noch bräuchte: Ein Tool, welches aus dem ER-Entwurf die Tabellen generiert .....

  Der ER-Entwurf soll das 'Ereignis' möglichst gut 'abbilden': Also alle 'Dinge (Spielorte, Stücke, Gruppen, ...)' mit ihren 'Eigenschaften' und die 'Beziehungen zwischen den Dingen' (Gruppe spielt Stück, ...) darstellen:

Download: ER-Entwurf.cdr


9. Stunde (Termin: Mi., 7.1.2004, ab 13 Uhr)

relationale Datenbanken

Bekanntlich finden die Bay, Schultheatertage in 2004 am ABG statt. Wir sollten da mal zeigen, was wir können:

Gesamtorganisation der baySThT über Datenbank und Web!

 

Wer schon mal sich vorbereiten will:

MySQL-Handbuch

als pdf von

Guido Stepken


8. Stunde (Mi, ab 13 Uhr)

Mal was Hartes: JAVA-Programm zu 'Merge-Sort

Wenigstens einmal sollte man selber ein ganzen JAVA-Dings geschrieben haben:

Die Idee:

If n<2 then the array is already sorted. Stop now.
Otherwise, n>1, and we perform the following three steps in sequence:
Sort the left half of the the array.
Sort the right half of the the array.
Merge the now-sorted left and right halves.

Die Struktur:

class MergeSorter {
public static void sort(int[] a0) {
}
public static void mergesort(int lo, int hi) {
}
public static void merge(int lo, int hi) {
}
public static void main (String [] args) {
}
}

Der Code:

class MergeSorter {
public static int[] a, b; // temporäres Array b
public static void sort(int[] a0) {
a=a0;
int n=a.length;
b=new int[n];
mergesort(0, n-1);
}

 

public static void mergesort(int lo, int hi) {
if (lo<hi)
{
int m=(lo+hi)/2;
mergesort(lo, m);
mergesort(m+1, hi);
merge(lo, hi);
}
}
public static void merge(int lo, int hi) {
int i, j, k, m, n=hi-lo+1;
k=0;
m=(lo+hi)/2; // untere Hälfte in Array b kopieren
for (i=lo; i<=m; i++)
b[k++]=a[i]; // obere Hälfte in umgekehrter Reihenfolge in Array b kopieren
for (j=hi; j>=m+1; j--)
b[k++]=a[j];
i=0; j=n-1; k=lo; // jeweils das nächstgrößte Element zurückkopieren,
// bis i und j sich überkreuzen
while (i<=j)
if (b[i]<=b[j])
a[k++]=b[i++];
else
a[k++]=b[j--];
}
public static void main (String [] args) {
int [] zahlenfolge = {5, 7, 1, 2, 7, 11, 3, 5, 6, 4};
System.out.print("Unsortierte Zahlenfolge: ");
for (int i = 0; i < zahlenfolge.length; i = i + 1)
System.out.print(zahlenfolge[i] + " ");
System.out.println();
MergeSorter.sort(zahlenfolge);
System.out.print("Sortierte Zahlenfolge: ");
for (int i = 0; i < zahlenfolge.length; i = i + 1)
System.out.print(zahlenfolge[i] + " ");
System.out.println();
}
}

Download MergeSorter.java


7. Stunde (Mi, 10.12., 16.15):

Ein Weihnachts- und Neujahrgruß-Programm

Mit Hilfe des THREAD-Konzepts kann man Java-Applets zum Tanzen bringen:

import java.awt.*;
import java.applet.*;
public class Anim extends Applet implements Runnable {
AudioClip song;
Thread zeichnen_1, zeichnen_2;
int a, b, hoehe1, startx1, starty1, hoehe2, startx2, starty2;
Graphics g;
public void init() {
song=getAudioClip(getCodeBase(),"feuerwerk.au");
song.play();
Font zeichensatz = new Font ("SansSerif", Font.PLAIN, 20); setFont(zeichensatz);
}
public void start()

.....

 

 

 

 

 

 

 

 

wünscht das ABG SR!


6. Stunde (Mi, 3.12., 16.15):

JAVA-Applets

Ein JAVA-Applet besteht aus zwei Teilen, dem HTML-Teil und dem JAVA-Teil:

<HTML>
<HEAD>
<TITLE>Periodenlaengen</TITLE>
<META http-equiv=Content-Type content="text/html; charset=windows-1252">
</HEAD>
<BODY>
<CENTER>
<H1><FONT face=Conga><font color="#000000"> Die Dezimalbruchdarstellung<br>
von Br&uuml;chen</font><font color="#000000"></font></FONT></H1>
</CENTER>
<TABLE width="100%" border=0>
<TBODY>
<TR>
<TD width="5%">&nbsp;</TD>
<TD width="90%">
<CENTER><BR><BR>
<TABLE border=5>
<TBODY>
<TR>
<TD><APPLET height=150 width=500 code=PeriodischeBrueche.class>
Leider hat dein Browser etwas gegen Java. Wäre dem nicht so, würdest
du hier was Wunderbares erblicken.</APPLET>
</TD></TR></TBODY></TABLE></CENTER>
<FONT face="Comic Sans MS">
<P align=center>Dieses Applet berechnet blitzschnell die Periode eines Bruches<br>
im Dezimalsystem. Das Verfahren beruht auf dem Algorithmus der schr. Division</P>
</FONT></TD>
<TD width="5%">&nbsp;</TD></TR>
</TBODY>
</TABLE>
<p align="right">&nbsp;</p>
</BODY>
</HTML>

 

import java.awt.*; //Alle Pakete vom AbstractWindowToolkit
import java.applet.Applet; //Das Applet-Toolkit
import java.awt.event.*; //Der EventHandler vom AWT
import java.text.*; //Alle Pakete des Text-Toolkits
public class PeriodischeBrueche extends Applet implements ActionListener {
// Variablen, die von allen Methoden im Applet verwendet werden
private TextField eineTextZeile, nocheineTextZeile, undnocheineTextZeile;
private TextArea einTextAusgabeFenster;
private Button rechneButton;
private int zaehler, nenner; //Variable fur Bruch
private int ganzzahlquotient, rest, NKS; //Variable fur die ´Division
// Hier werden die Initialisierungen durchgefuhrt.
public void init() {
Panel p1 = new Panel(); //der Standard-Konstruktor
add(p1); //p1 in das Fenster
Label L1 = new Label("Der Bruch"); //Konstruktor fur ein Label
p1.add(L1); //L1 in das Fenster
eineTextZeile = new TextField("1",10); //Textzeilen-Konstruktor
p1.add(eineTextZeile); //eineTextZeile ins Fenster
eineTextZeile.addActionListener(this); //auf Eingabe horchen
p1.add(new Label("durch")); //wie oben, aber kurzer
nocheineTextZeile = new TextField("7",5); //w. o
p1.add(nocheineTextZeile); //w. o.
p1.add(new Label("beginnt auf")); //w. o.
nocheineTextZeile.addActionListener(this); //auch horchen!
undnocheineTextZeile = new TextField("10",5);//w. o.
p1.add(undnocheineTextZeile); //w. o.
undnocheineTextZeile.addActionListener(this); //auch horchen!
p1.add(new Label("NKS")); //wie oben, aber kurzer
rechneButton = new Button("Druck mich!"); //der Button-Konstruktor
add(rechneButton); //Button auf den Bildschirm
rechneButton.addActionListener(this); //auch horchen!
einTextAusgabeFenster = new TextArea(5, 50);//noch ein Textbereich
add(einTextAusgabeFenster); //auf den Bildschirm
}

 



//------- die Methoden der Klasse-------------------------------------
public void actionPerformed(ActionEvent ev) //falls sich am Button was tut, 'try'
{
try {
// Daten einlesen
zaehler = Integer.parseInt(eineTextZeile.getText());
nenner = Integer.parseInt(nocheineTextZeile.getText());
NKS = Integer.parseInt(undnocheineTextZeile.getText());
einTextAusgabeFenster.append("\n... seine Dezimalbruchdarstellung mit\n0,");
int i =0;
rest = zaehler;
while (i<NKS){
zaehler = rest*10;
ganzzahlquotient = zaehler/nenner;
rest = zaehler - ganzzahlquotient*nenner;
einTextAusgabeFenster.append(formatiere(ganzzahlquotient ));
i++;
}
}
catch (Exception e) //falls doch was schief geht:
{
einTextAusgabeFenster.append("\n\nAchtung! Fehler bei der Eingabe\n ("+e+")");
}
}
private String formatiere(int zahl) //Methode zur Formatierung von Zahlen
{
NumberFormat nf = NumberFormat.getInstance();
String f;
nf.setMaximumFractionDigits(0); //maximale Nachkommastellen setzen
f = nf.format(zahl); //NKS abschneiden
return f; //raus aus der Methode
}
//------- Ende der Methoden -------------------------------------

//Ende der Klasse
}

 

 


5. Stunde (Mi, 26.11., 16.15): JAVA

In diesen Stunde soll ein 'Template' für JAVA-Konsolenprogramme vorgestellt werden:

/**JAVA-Programme bestehen aus Klassen mit Konstruktoren, Variablen und Methoden, welche die Variablen manipulieren. Entwurf: k.penzkofer,ABG-SR
Der Quelltext: Test.java**/
class Test {
//Der Standardkonstruktor
Test(){ }
//eine Text-Variable
String Text;
//eine Methode Eingabe für Text(JAVA kennt keine Eingabeaufforderung)
String Eingabe(){
String s = " ";
try {
java.io.BufferedReader d = new java.io.BufferedReader( new java.io.InputStreamReader(System.in));
s = d.readLine();
}
catch (java.io.IOException e) {}
return s;
}
//ein Methode Ausgabe (Printen kann JAVA schon)
void Ausgabe(String S) {
System.out.print(S); }
//eine Methode Tuwas
String Tuwas(String S) {
S = "geloescht.";
return S;
}
}
/**Das folgenden Hauptprogramm arbeitet nun mit der Klasse Test. Dazu newt es ein Objekt T vom Typ Test und ruft dann dessen Methoden und Variablen auf.**/
class Hauptprogramm {
//so ne main-Methode muss immer sein!
public static void main(String args[]){
Test T = new Test();
T.Ausgabe("Java Konsolenprogramm\n\n");
T.Ausgabe("Gib was ein: "); T.Text = T.Eingabe(); T.Ausgabe("Eingegeben wurde "+T.Text+ ".\n"); T.Text = T.Tuwas(T.Text);
T.Ausgabe("Diese Eingabe wurde sofort wieder ... "+T.Text+"\n"); T.Ausgabe("Tschuess\n");
}
}

 



4. Stunde (Mi, 12.11., 16.15-17.00): 'JAVA'

Die von SUN Microsystems eigentlich für die Programmierung von Kaffeemaschinen o.ä. entwickelte Programmiersprache ist inzwischen ein anerkannter Standard. Man sollte also eigentlich JAVA können ...

Zuerst bietet JAVA natürlich nur eine Konsole:

static void quicksort(int [] feld, int links, int rechts)
{
int w = feld[links], i = links, j = rechts; if (i < j)
{
do
{
/* Suche von links nach dem ersten Element, das groesser oder gleich w ist*/
while(w > feld[i]) i = i + 1;
/* Suche von rechts nach dem ersten Element, das kleiner als w ist*/ while(w < feld[j]) j = j - 1;
/*Vertauschung von a[i] und a[j]*/
if (i <= j)
{
tausche_element(feld, i, j); i = i + 1; j = j - 1;
}
}
while (i <= j);
/* Rekursive Aufrufe zur Behandlung der beiden Teilfelder */ quicksort(feld, links, j); quicksort(feld, i, rechts);
}
}

 

Richtig heiß wird es mit JAVA-Applets:

 

http://www.cs.princeton.edu/~ah/alg_anim/version1/QuickSort.html

 


3. Stunde (Mi, 5.11., 16.15-17.00): 'Algorithmen'

Die Manipulation von Daten erfolgt mit Hilfe mehr oder minder guter Algorithmen, also Rechenvorschriften im weitesten Sinne. Die Informatik verlangt von den Algorithmen, dass sie schnell sind, auf jeden Fall zu einem Ende kommen und dass tun, was sie versprechen..

Ein allgegenwärtiges Beispiel:
Die rekursive Berechnung der Fakultät

Ein sehr altes Beispiel:
Der euklidische Algorithmus für die Bestimmung des ggT

Ein ziemlich verrücktes Beispiel:
Die 91-Funktion von McCarthy

Ein Spiel-Beispiel:
Die Türme von Ha, noi!

Der Quelltext hierzu in JAVA:

class Rekursionen {
public static void main(String [] args) {
System.out.println("Ein paar beruehmte Rekursionen ...");
//Fakultaet ueber Methode der entspr.Klasse
System.out.println("Die Fakultaet von 15 ist: "+fak.rek_fak(15));
/**
terminiert rek_fak?
ABSTIEGSFUNKTION h(x) = x
Es gilt: h(x) > 0 fuer alle x>1
h(x-1) = x-1 < x fuer alle nat. Zahlen x>0
Also: rek_fak terminiert!
**/
//ggT ueber Konstruktor
ggT mein_ggT;
mein_ggT = new ggT(40,220);
/**terminiert rek_ggT?
ABSTIEGSFUNKTION h(n,m) = 2*max(n,m) = 2*n (oE)
Es gilt: h(n,m) > 0 fr alle n,m>1
h(n-m,m) = 2*m < 2*n fuer alle nat. Zahlen n>0
Also: rek_ggT terminiert!**/
//Hanoi ueber Konstruktor
System.out.println("Die Tuerme von Ha, noi");
Hanoi meinHanoi;
meinHanoi = new Hanoi(4);
System.out.println("Die beruehmte 91-Funktion von McCarthy");
//Aufruf ueber eine Methode der Klasse McCarthy
for (int i=98; i<103;i++) System.out.println(i+"|-> "+McCarthy.rek_McCarthy(i));
//Aufruf ueber einen Konstruktor der Klasse McCarthy
McCarthy MC95;
MC95 = new McCarthy(95);
McCarthy MC105;
MC105 = new McCarthy(105);
}
}
class fak {
fak(int n){
rek_fak(n);
}
public static int rek_fak(int n) {
if (n==1) return 1;
else return rek_fak(n-1)*n;
}
}

 


class ggT {
ggT(int n, int m){
if (n*m==0) System.out.println("Der ggT von "+n+" und "+m+" ist: "+"n*m= "+n*m+": Das geht nicht!");
else
System.out.println("Der ggT von "+n+" und "+m+" ist: "+ggT.rek_ggT(n,m));
}
public static int rek_ggT(int n, int m) {
if (n==m) return n;
else if (n<m) return rek_ggT(n,m-n);
else return rek_ggT(m,n-m);
}
}
class Hanoi {
String Ausgang="A", Lager="L", Ziel="Z";
//Der TurmKonstruktor
Hanoi(int n) {
rek_Hanoi(n, Ausgang,Ziel,Lager);
}
//Die Rekursion
static void rek_Hanoi(int n, String a, String b, String c){
//uebertraegt n Scheiben von a nach b mit Hilfe von c
if (n>0){
rek_Hanoi(n-1,a,c,b); //(n-1)-Turm von Ausgang nach Lager ber Ziel
zieheScheibe(a,b); //groáe Scheibe schieben
rek_Hanoi(n-1,c,b,a); //(n-1)-Turm von Lager nach Ziel ber Ausgang
}
}
//Das ScheibenZiehen
public static void zieheScheibe(String X,String Y){
System.out.println("Ziehe Scheibe von "+X+" nach "+Y);
}
}
class McCarthy {
//Konstruktor mit Aufruf der rekusiven Funktion
McCarthy(int n){
System.out.println(n+"|-> "+rek_McCarthy(n));
}
public static int rek_McCarthy(int n){
if (n>100)
return n-10;
else {
//System.out.print("Rek-Aufruf /");
return rek_McCarthy(rek_McCarthy(n+11));
}
}
}

 

Übrigens, eine freie IDE für JAVA gibt es unter http://www.jcreator.com . Die Dateigröße beträgt ca 2 MB.


2. Stunde (Mi, 22.10., 16.15-17.00): 'Datenstrukturen'

Eine wichtige Aufgabe der Informatik ist, Daten zu speichern und zu verarbeiten. 'Listen' und 'Bäume' sind dazu ein wichtiges Hilfsmittel.
Mit Hilfe einer funktionalen Programmiersprache wie etwa Haskell werden einfache Operationen mit Bäumen behandelt..

Binäre Bäume sehen z.B. so aus

So stellt dieser Baum etwa den Ausdruck
(a + b/c) * (d - e*f)
dar.

 

Ein paar Haskell-Fingerübungen:

Links zu Haskell:

http://www.haskell.org/hugs

http://www.cs.uu.nl/~andres/haskell

http://dasbruckner.de/penzkofer/WuInf/Baeume.hs


1. Stunde (Mi, 8.10., 13.45-14.30): 'Automaten'

Ein 'Automat' ist eine Maschine, welche durch bestimmte Eingaben (aus dem 'Alphabet') in (andere) Zustände wechselt. U.U. gelangt er dann irgendwann in einen Endzustand: Er hat die Eingaben verstanden!

Einfache Automaten, etwa zur Überprüfung der Eingabe von Zahlen in wiss. Darstellung sehen so aus:

Das 'Alphabet': {0, 1...9, . , E, +, -}:

 

 

Ein Getränkeautomat:

Links zur 'Automatentheorie':

http://www.lehrer.uni-karlsruhe.de/~za268/inf_seminar/automaten.html

http://www.zitadelle.juel.nw.schule.de/if/java/P1.2/Automat/Zahlautomat.html