Programmieren mit Harald R. Haberstroh

Java -> Python (POS1: 2B)

2011-10-10T11:14:00.001+02:00

Wandeln Sie folgendes Java-Programm in ein Python Programm um:


public class Dreiecksbestimmung {

    public static void main(String[] args) {
      dreiecksbestimmung(3.0, 4.0, 5.0);
      dreiecksbestimmung(3.0, 3.0, 3.0);
      dreiecksbestimmung(3.0, 3.0, 5.0);
      dreiecksbestimmung(3.0, 4.5, 5.0);
      dreiecksbestimmung(1.0, 2.0, 3.0);
    }

    private static void dreiecksbestimmung(double a, double b, double c) {
      System.out.printf("a = %.2f, b = %.2f, c = %.2f: ", a, b, c);
      if (dreieck(a, b, c)) {
        if (gleichseitig(a, b, c)) {
          System.out.print("gleichseitiges ");
        } else if (gleichschenkelig(a, b, c)) {
          System.out.print("gleichschenkeliges ");
        }
        if (rechtwinkelig(a, b, c)) {
          System.out.print("rechtwinkeliges ");
        }
        System.out.println("Dreieck");
      } else {
        System.out.println("kein gültiges Dreieck");
      }
    }

    private static boolean rechtwinkelig(double a, double b, double c) {
      double a2 = a * a;
      double b2 = b * b;
      double c2 = c * c;
      return a2 + b2 == c2 || a2 + c2 == b2 || b2 + c2 == a2;
    }

    private static boolean gleichschenkelig(double a, double b, double c) {
      return a == b || a == c || b == c;
    }

    private static boolean gleichseitig(double a, double b, double c) {
      return a == b && b == c;
    }

    private static boolean dreieck(double a, double b, double c) {
      return a + b > c && a + c > b && b + c > a;
    }

}

Ergänzen Sie Ihr Programm um geeignete Doc-Strings und Kommentare!

Abgaben am CVS (POS1: 2., 3. Klassen)

2011-10-05T11:15:00.001+02:00

Nennen Sie Projekte `klasse-name-projekt`, wobei klasse "2a" für 2AHIF, "2c" für 2CHIF, "3b" für 3BHIF usw. und name Ihr Familienname sein soll (bei Namensgleichheit machen Sie bitte `klasse-name-vorname-projekt` daraus). Checken Sie die Projekte am CVS (cvs.htlwrn.ac.at, Pfad /cvs/user - user ist Ihr Login) ein.

Den Source Code müssen Sie auch in gedruckter Form abliefern. Dieses Listing sollte dann etwa so aussehen:

Das Listing sollte folgende Eigenschaften aufweisen:

Autor und Dateiname ist sofort ersichtlich

Seitennummern werden gedruckt

Syntax-Hilighting: Schlüsselworte, Kommentare usw. sollten unterschiedlich formatiert sein

Querformat mit zwei Spalten, um Papier zu sparen (Zwei Seiten auf eine drucken)

Es muss ein "fixed font" (z.B. Courier) verwendet werden, d.h. jedes Zeichen hat die selbe Breite (ausgenommen String-Konstante)

Optional sollen Zeilennummern gedruckt werden (siehe Beispiele unten).

Beispiel mit Zeilennummern:

Beispiel mit Zeilennummern, nur jede 5. Zeile bekommt eine Nummer:

Unter Linux können Sie den Befehl a2ps (ASCII to PostScript, 2 = two = to, daher a2ps) verwenden.

Beispiele:

a2ps -Phpg1 dreieck.py

Die Datei dreieck.py wird auf dem Drucker hpg1 ohne Zeilennummern gedruckt.

a2ps --line-numbers=1 -Phpg2 dreieck.py newprog.py

Die Dateien dreieck.py und newprog.py werden am Drucker hpg2 mit Zeilennummern gedruckt.

a2ps --line-numbers=5 -Phpg3 dreieck.py newprog.py

Die Dateien dreieck.py und newprog.py werden am Drucker hpg3 mit Zeilennummern gedruckt, wobei nur jede fünfte Zeilennummer gedruckt wird.

Weitere Optionen zu a2ps finden Sie in der man-Page (man a2ps).

Die meisten IDEs (z.B. eclipse oder netbeans) und viele Editoren bieten ähnliche Möglichkeiten, jedoch passt bei a2ps der Ausdruck praktisch immer, abgesehen davon, dass a2ps nur ASCII-versteht und damit Probleme mit Umlauten hat. Sind Umlaute im Source Code (nur in Kommentaren erlaubt), so kann man mit dem Tool iconv das Encoding für a2ps anpassen. Obiges Beispiel würde dann so aussehen:

iconv -f utf8 -t latin1 dreieck.py -o - | a2ps --stdin=dreieck.py --line-numbers=5 -Phpg3

a2ps benötigt noch einen Titel für stdin (Option --stdin=title), weil die Standardausgabe von iconv von a2ps gelesen wird.

Überlauf mit C-Datentypen in Python

2011-10-01T16:30:00.001+02:00

Wenn man z.B. ganze Zahlen mit nur einem Byte (8bit) darstellen will, so hat man den Bereich -128 (-2^{8 - 1}) bis +127 (2^{8 - 1} - 1) zur Verfügung, weil üblicherweise die negativen Zahlen im Zweierkomplement dargestellt werden. Hat eine ein Byte große Variable var den Wert 127, so entspricht das binär 01111111₂. Zählt man 1 dazu, so erhält man binär 10000000₂. Dieser Wert entspricht aber der Zahl -128₁₀.
-1₁₀ entspricht der binären Zahl 11111111₂ im Zweierkomplement (ansonsten wäre es 2⁸ - 1 also 255). Zählt man zu 11111111₂ 1 dazu, erhält man 100000000₂. Da der Einser ganz vorne die 9. Stelle wäre, die in 8bit nicht mehr dargestellt werden kann, so fliegt sie raus und wir bekommen 00000000₂, also 0.
Das folgende Bespiel zeigt die Verwendung eines C-Datentypen für ein Byte, wo tatsächlich immer nur 8bit verwendet werden. Allerdings kann man nicht unmittelbar mit den Werten rechnen, da diese Werte sonst einfach in den entsprechenden Python-Typ int umgewandelt werden würde und es nicht zu einem Überlauf käme.

import ctypes # see help(ctypes)

def inc(var):
    """increment var by one"""
    return type(var)(var.value + 1)

def dec(var):
    """decrement var by one"""
    return type(var)(var.value - 1)

if __name__ == '__main__':
    var = ctypes.c_byte(126) # var = 126 - one byte
    var = inc(var)           # var = 127
    print(var.value)
    var = inc(var)           # var = -128 (10000000 binary)
    print(var.value)
    
    var = ctypes.c_byte(-1)  # var = -1 - one byte (11111111 binary)
    var = inc(var)           # var = 0
    print(var.value)

Im folgenden Video wird das auch ganz schön erklärt:

vim Übung

2011-09-29T09:23:00.000+02:00

Legen Sie eine Datei mit ihren Initialen und Extension .txt an
Bsp:

  rr.txt

Einfügen von 5 Zeilen mit beliebigem Text

Einfügen von Asterix als eigene Zeile nach der 4. Zeile

Positionieren auf 3. Zeile

Am Ende der Zeile das wort xyyz einfügen

Kopieren der 3. Zeile

Einfügen dieser Zeile 85 mal nach der 5. Zeile

Suchen nach String rix

Schalten Sie die Zeilennummerierung ein

Gehe zu Zeile 70

Lösche 10 Zeilen

Kopiere Zeilen 13-45 in eine neue Datei mit Namen 'partrr.txt'

Alle Zeichen 'y' durch '§' ersetzen

Einfügen der Zeilen 5-10 aus der Datei 'partrr.txt' nach der letzten Zeile

vim Einführung

2011-09-29T09:22:00.000+02:00

Bitte lesen Sie die Vim-Einführung und bearbeiten Sie die Fragen auf dem alten Blog.

Bearbeiten Sie auch die Übungsbeispiele vim - Übung und vim - Übung 2.

Vim ist ein hervorragender Editor mit Syntaxhervorhebung und Vergleichsfunktionen, mehreren Darstellungsfenstern und vielen anderen nützlichen Funktionen. Leider ist der Einstieg damit nicht immer ganz leicht, da vim eine Weiterentwicklung des Editors vi ist, den es bereits in den 80er Jahren gab, wo Benutzerfreundlichkeit noch eine andere Bedeutung hatte als heute. Weiterhin erscheint vim im unkonfigurierten Zustand zunächst erstmal sehr langweilig und es ist mühselig eine passende Konfiguration zu erstellen.

Der vi ist praktisch auf jedem Linux-System verfügbar und kann von der Shell (Terminal) aus verwendet werden. Daher ist es praktisch, wenn man den vi(m) beherrscht, wenn man einen Server (z.B. Web-Server) über das Internet warten muss. Die wichtigsten Funkionen kann man probieren und üben mit vimtutor

Weitere Dokumentation finden Sie hier:
vim Kurzreferenz auf LinWiKi
vim Homepage www.vim.org
vim Quick Reference Card (2 Seiten)

Wir verwenden eine spezielle Konfigurationsdatei für den vim. Im Laufe dieses Schuljahres werden wir Ihnen diese Datei (eigentlich eine überarbeitete Version, denn die bisherige Version ist hauptsächlich für C-Programmierung eingerichtet) zur Verfügung stellen. Also, bleiben Sie dran oder suchen Sie auf www.vim.org/scripts nach passenden Scripts für den vim.

Bash (Shell) (POS1: 2B)

2011-09-29T09:18:00.001+02:00

Das Betriebssystem, in unserem Falle Linux, stellt eine Schnittstelle zwischen Anwendungsprogrammen und der Hardware (Tastatur, Bildschirm, Maus, Festplatten, Netzwerk,...) dar. Das Betriebssystem ist also eine virtuelle Maschine mit einfachen Aufrufen zur Bedienung der Hardware.
Eine Shell ist nun ein Anwendungsprogramm, welches Eingaben vom Benutzer in geeignete Betriebssystemaufrufe umsetzt und ggf. andere Programme aufruft (d.h. das Betriebssystem mit einem bestimmten Aufruf das Programm starten lässt).

Auch andere Betriebssysteme haben zur Bedienung Shells: Unter Windows NT/2000/XP gibt es CMD.EXE.
Die bash ist ein Interpreter mit einer vollständigen Programmiersprache. Es können damit on-the-fly kleine Programme mit Schleifen, Abfragen etc. erstellt werden, ohne dass man einen Editor dazu bemühen muss.
Da die Eingabe über die Tastatur speziell bei langen Pfadnamen (255 Zeichen für einen Dateinamen!) sehr mühsam und fehleranfällig ist, bietet die bash einige nützliche Features (einige dieser Features gibt es erstmals auch in der Shell von Windows XP):

Ergänzung der Kommandozeile

Kommandos oder Pfade brauchen nicht vollständig eingetippt werden. Meist genügen wenige Buchstaben, die dann durch Drücken der Taste TAB (Tabulator) auf den richtigen Pfad (das richtige Kommando) ergänzt werden. Falls der Pfad nicht eindeutig ergänzt werden kann, werden alle Möglichkeiten durch neuerliches Drücken von TAB angezeigt. Pfade werden immer zum nächsten Directory ergänzt oder zumindest soweit sie eindeutig sind.

History

Die letzten Befehle können mit den Cursor-Tasten ausgewählt und editiert werden.
Mit !! wird der letzte Befehl ausgeführt, mit !-2 wird der vorletzte mit !-3 der vorvorletzte usw. ausgeführt. Mit !15 wird der 15. Befehl ausgeführt.
Mit !string wird der letzte Befehl, der mit string begonnen hat, ausgeführt.
Mit !?string? wird der letzte Befehl, der string enthält ausgeführt.
Mit ^{string1^string2} wird das letzte Kommando ausgeführt, wobei string1 durch string2ersetzt wird.
Der Befehl history zeigt eine Liste der letzten Kommandos (mit deren Nummer) an.
Durch Drücken von ^r (Strg+R) kommt man in den Kommando-Suchmmodus, d.h. es wird das letzte Kommando angezeigt, welches die im folgenden getippten Buchstaben enthält. Mit weiteren ^r kommt man zum nächsten Befehl, der die Buchstaben enthält. Mit Enter wird der Befehl ausgeführt, mit den Links- und Rechts-Pfeiltasten kann der gewählte Befehl editiert werden.
Weiteres siehe unter man bash.

Beispiele (`$` stellt den Prompt dar, alles hinter `#` gilt als Kommentar):

$ vim Telegramme.c                    # editieren
$ gcc -o telegramme Telegramme.c      # compilieren
$ telegramme                          # ausführen
$ !v                                  # Wiederholung von vim
$ !gc                                 # neuerliches compilieren
$ !t                                  # Aufruf von telegramme

Job-Control

Ein laufendes Programm kann mit ^z (Strg-Z) unterbrochen werden. Danach kann mit der bash weitergearbeitet werden. mit dem Befehl fg kann das letzte unterbrochene Programm wieder fortgesetzt werden.
Es können auch mehrere Programme unterbrochen werden (z.B. vim wird unterbrochen, man fprintf aufgerufen, dieses Kommando wird unterbrochen usw.). Die unterbrochenen Programme können mit jobs aufgelistet werden. Ein bestimmtes gestopptes (unterbrochenes) Programm mit der Job-Nummer 2 kann mit fg %2 wieder in den Vordergrund gebracht werden.
Mit diesen Möglichkeiten kann leicht zwischen mehreren Programmen hin- und hergeschaltet werden.
Programme, die vermutlich länger ohne Eingaben vom Benutzer laufen werden, können durch Anhängen von & als Hintergrundprozesse gestartet werden. Ein Hintergrundprozess kann ebenfalls mit fg wieder in den Vordergrund gebracht werden.
Beispiel: es sollen alle C-Files gesucht werden und die Namen (Pfade) in einer Liste gespeichert werden ($ ist der Prompt, wird also nicht eingegeben):

$ find / -name '*.c' -print > c-files.txt &
[1] 3751                                                   # Job-Nummer und Prozess-ID wird angezeigt
$ vim Telegramme.c
[1]+ Done find . -name '*.c' -print >c-files.txt           # Benachrichtigung, dass Kommando fertig
$ less c-files.txt                                         # Anzeigen des Files

Obiges Kommando könnte mittels kill %1 oder kill 3751 (kill und Prozess-ID) vorzeitig abgebrochen werden.
Programme im Vordergrund können mit ^c (Strg+C) abgebrochen werden.

Befehlssyntax

Generell sind Unix-Kommandos wie folgt aufgebaut:

$ cmd [optionen] [argument]...

Die eckigen Klammern [ ] zeigen an, dass dieser Teil optional ist. Die drei Punkte ...bedeuten, dass der Teil davor mehrfach vorhanden sein kann.
Prinzipiell können immer mehrere Parameter angegeben werden. Optionen beginnen immer mit einem Minus (-) und werden von einem Buchstaben gefolgt. Mehrere Optionen können zusammengefasst werden. z.B. ls -a -l kann auch als ls -al eingegeben werden.
Viele (neuere, GNU-) Programme erlauben auch lange Optionen, d.h. ganze Wörter zur Bezeichnung einer Option. Solche Optionen beginnen mit zwei Minus (–). Das Kommando findist hier eine Ausnahme (s.o.).
Beispiel: ls -l und ls –format=long geben beide den Inhalt des Verzeichnisses im langen Format aus.
Generell sind Wildcards und reguläre Ausdrücke als Argumente möglich (die Shell erweitert reguläre Ausdrücke auf Listen von Parametern, d.h. das Kommando wird dann mit einer Liste aller passenden Files aufgerufen).

Wildcards

Wildcards sind Ersetzungsmuster, die von der Shell ersetzt werden. Wenn Sie z.B. alle Dateien auflisten wollen, die mit einem 'a' beginnen, dann geben Sie echo a* ein. Es werden dann Dateien der Art a, a1, abc, alloc.c aufgelistet, falls sie existieren. Der '*' steht fürkein, ein oder mehrere beliebige Zeichen. Wenn Sie Dateien suchen, die ein 'z' enthalten, dann geben Sie echo *z* ein. Tatsächlich ändert aber die Shell die Parameterliste für den Befehl echo, d.h. die Shell erzeugt eine Liste von Dateinamen, auf die das Muster zutrifft und ruft dann erst echo auf.
Nehmen Sie an, das aktuelle Verzeichnis enthielte folgende Dateien:

a.c zahlen.c anz.c anz.h anz hello.c a.out

Wenn Sie nun

echo *z*

eingeben, erzeugt die Shell folgenden Aufruf

echo zahlen.c anz.c anz.h

und führt den Befehl aus. echo braucht sich nicht darum zu kümmern!
Die Shell versteht noch andere Musterangaben. Beispielsweise:

`[aeiou]*`	alle Dateien, die mit einem Selbstlaut beginnen
`[0-9a-h]*`	alle Dateien, die mit `0` bis `9` oder `a` bis `h` beginnen
`??`	alle Dateien, die aus genau 2 Zeichen bestehen (`?` steht für ein Zeichen)
`*.[^ch]`	alle Dateien, die nicht mit `.c` oder `.h` enden
`\*`	alle Dateien, die einen Stern enthalten

Mehr dazu unter man bash.

Abkürzungen

Tilde ~
~/ ist eine Abkürzung für das Home-Verzeichnis des angemeldeten Benutzers (meist/home/user, wenn user der Loginname).
~user/ ist die Abkürzung für das Homeverzeichnis des Users user.
alias
Mit dem Befehl alias können selbst Abkürzungen zu längeren Befehlen gemacht werden:

alias md="mkdir" md ist nun eine Kurzversion von mkdir (MaKe DIRectory)

Sie können mehrere immer wieder verwendete Abkürzungen in der Datei .bashrc speichern..bashrc ist eine Datei, die automatisch beim Starten einer bash interpretiert (ausgeführt) wird.
Der Befehl alias ohne Argumente gibt die Liste der derzeit aktiven Abkürzungen aus.

Shell-Variable

Da die bash eine vollständige Programmiersprache ist, gibt es natürlich auch Variable. Diese Variable werden nicht nur für die Programmierung eingesetzt sondern auch für die Konfiguration.
Shell-Variable werden üblicherweise in Großbuchstaben geschrieben (Groß-/Kleinschreibung ist entscheidend).
Für die interaktive Verwendung wird normalerweise das Kommando export verwendet:

export PATH=~/bin:$PATH

Mit obigem Befehl wird der Suchpfad, das sind diejenigen Verzeichnisse, in denen ein Programm oder ein Kommando gespeichert ist, geändert. Es wird der Pfad ~/bin vorne angefügt. $PATH liefert den Inhalt der Variable PATH (es erfolgt reine Textersetzung).
Einige Variable sind schon vordefiniert:

`$HOME`	Homeverzeichnis
`$SHELL`	die verwendete Shell

Ein-/Ausgabeumlenkung

Die Ausgabe von Kommandos kann mit dem Größerzeichen (>) in eine Datei umgelenkt werden. Z.B.:

ls -l /usr/bin > ls.txt

Die Datei ls.txt wird erzeugt und die Ausgabe von ls darin gespeichert.
Verwendet man zwei Größerzeichen (>>), so wird die Ausgabe an die angegebene Datei angehängt.
Umgekehrt kann auch die Eingabe für ein Programm aus einer Datei erfolgen, indem man das Kleinerzeichen verwendet:

grep ^d <eingabedatei

Diese Varianten können kombiniert werden.

kommando parameter… <eingabedatei>ausgabedatei

Oft werden Kommandos direkt kombiniert, indem die Ausgabe eines Programms direkt in die Eingabe des nächsten Programms gepumpt wird. Die Programme werden mit einer pipe(pipeline) verbunden. Das dafür nötige Zeichen ist der senkrechte Strich (|):

ls -l | grep ^d

Obiger Befehl gibt alle Verzeichnisse aus, da grep mit dem Parameter ^d alle Zeilen, die mit einem 'd' beginnen, ausgibt.
Es können beliebig viele Programme mit pipes verbunden werden, es entsteht dadurch eine richtige Verarbeitungskette. Ist die Ausgabe sehr lange, so könnte im obigen Beispiel nochless verwendet werden, um in der Ausgabe blättern zu können.

ls -l | grep ^d | less

Auf diese Weise lassen sich komplexe Aufgaben einfach und effizient erledigen.
Dabei ist zu beachten, dass die Shell hier einige Arbeit übernimmt: bei der Eingabeumlenkung öffnet die Shell die Datei zum Lesen und tippt die Zeilen ein. Bei der Ausgabeumlenkung öffnet die Shell die Datei zum Schreiben und verschiebt die Ausgabe in diese Datei. Die pipe kann man sich als temporäre Datei vorstellen, in die das eine Programm schreibt und aus der das nächste Programm liest, wenngleich der Mechanismus natürlich effizienter gelöst ist.

Wichtige Kommandos

Fast alle Befehle oder Programme erlauben die Option -h, -help (ein Minus) oder –help (zwei Minus) und geben dann eine Kurzhilfe aus.

ls [optionen] [path]...

Anzeigen des Inhalts von Verzeichnissen. Die wichtigsten Optionen sind: -l um alle Informationen (langes Format) anzuzeigen, -a um alle Dateien anzuzeigen (auch die versteckten)

cp src... dest

Kopieren von Dateien. Hat cp mehr als zwei Parameter, so muss der letzte Parameter ein Verzeichnis sein.
Mit der Option -r können rekursiv ganze Verzeichnisbäume kopiert werden.

mv src... dest

Umbenennen/Verschieben von Dateien (move). Hat mv mehr als zwei Parameter, so muss der letzte Parameter ein Verzeichnis sein.

rm list...

Löschen von Dateien (remove).
Mit der Option -r können rekursiv ganze Verzeichnisbäume gelöscht werden (VORSICHT: rm -rf * löscht alles innerhalb und unterhalb des aktuellen Verzeichnises).

mkdir list...

Erstellen von Verzeichnissen.

cd [path]

Wechsel in das angegebene Verzeichnis. Wird kein Parameter angegeben, so wird ins Home-Verzeichnis gewechselt.

rmdir list...

Löschen von Verzeichnissen (nur leere Verzeichnisse).

cat [list...]

Ausgeben der angegebenen Dateien (die angegebenen Dateien werden auf diese Weise verkettet, da sie unmittelbar hintereinander ausgegeben werden)

less [list...]

Seitenweise Ausgabe der angegebenen Dateien

tar czf archiv.tgz list...

Ein komprimiertes Archiv mit dem Namen archiv.tgz aus den Dateien/Verzeichnissen list… erzeugen

tar xzf archiv.tgz

Das Archiv wieder auspacken

tar tzf archiv.tgz

Den Inhalt des Archivs ausgeben. tar bietet noch viel mehr Optionen und Möglichkeiten und war ursprünglich ein Programm zur Datensicherung auf Bänder (tape archiver).

file list...

gibt die Dateitypen aus. Unter UNIX haben die Datei-Endungen nicht die Bedeutung wie unter Windows, oft kann die Endung beliebig gewählt werden. Das Programm file öffnet nun die angegebenen Dateien und versucht aufgrund des Inhalts den Typ zu ermitteln.

touch list...

ändert die Zugriffszeit der angegebenen Dateien oder erzeugt diese, wenn sie nicht existieren (Dateien mit der Länge 0).

grep suchbegriff [list...]

Sucht den Suchbegriff in den gegebenen Dateien oder Standardeingabe (Eintippen oder Eingabeumlenkung). Wenn nur der Dateiname gesucht ist, der den Suchbegriff enthält, dann ist die Option -l anzugeben. Der Suchbegriff kann aus regulären Ausdrücken bestehen, wodurch man komplexe Suchmuster angeben kann. Zu beachten ist allerdings, dass viele Sonderzeichen für reguläre Ausdrücke, eine spezielle Bedeutung in der Shell haben. Sie müssen daher maskiert werden, z.B. mit vorangestelltem \ oder unter einfache Hochkomma ('). Mehr dazu unter man grep bzw. man bash.

ps

Prozessstatus, listet alle Prozesse auf, die in dieser Shell gestartet wurden.

ps axu

listet alle Prozesse, aller User plus Zusatzinformationen auf. Die erste Spalte enthält den Usernamen, die zweite Spalte die Prozess-ID (PID) und die letzte Spalte den genauen Befehl.

kill [signal] pid...

Schickt den angegebenen Prozessen das TERM-Signal (Terminieren). Die wichtigen Signale sind:
-TERM, -KILL (tötet den Prozess auf alle Fälle)

killall [signal] name...

Schickt den angegebenen Prozessen das TERM-Signal (Terminieren). Die Prozesse werden durch den Befehlsnamen name (aufgerufenes Kommando) ausgewählt.
Will man z.B. alle mozilla-Prozesse killen, gibt man killall mozilla ein.

sort [list...]

gibt die Zeilen der angegebenen Dateien sortiert aus (bzw. die Zeilen der Standardeingabe).

uniq [eingabedatei] [ausgabedatei]

löscht doppelte Zeilen aus einer sortierten Eingabe.

Fortgeschrittenes

Es gibt mehrere Möglichkeiten, aus der Ausgabe eines Programms Argumente für die Kommandozeile zu machen.

Backticks:
```
$ ls `echo $HOME`
```
Hier wird zunächst der Befehl echo $HOME ausgeführt und dessen Ausgabe wird zum Argument des Befehls ls (das Home-Verzeichnis wird aufgelistet).
xargs
Das ist ein Programm, das von der Standardeingabe zeilenweise liest und jede Zeile als ein Kommandozeilenargument an das xargs übergebene Programm übergibt. Obiges Beispiel kann man also auch so schreiben:
```
echo $HOME|xargs ls
```

Hilfe

UNIX-Systeme werden normalerweise mit ausführlicher Online-Dokumentation ausgeliefert. Die Standarddokumentation entspricht den gedruckten Handbüchern und ist in mehrere Abschnitte eingeteilt:
1 Ausführbare Programme oder Shellbefehle
2 Systemaufrufe (Kernelfunktionen)
3 Bibliotheksaufrufe (Funktionen in System-Bibliotheken)
4 Spezielle Dateien (gewöhnlich in /dev)
5 Dateiformate und Konventionen, z. B. /etc/passwd
6 Spiele
7 Makropakete und Konventionen, z. B. man(7), groff(7)
8 Systemadministrationsbefehle (in der Regel nur für root)
9 Kernelroutinen [Nicht Standard]
n neu [veraltet]
l lokal [veraltet]
p öffentlich [veraltet]
o alt [veraltet]
Zu jedem Befehl (Thema) gibt es eine Seite (können auch mehrere Seiten sein) mit dem Namen des Befehls (Themas). Will man eine bestimmte Seite des Manuals lesen, so verwendet man den Befehl man (manual):

man [abschnitt] seite

Wird abschnitt weggelassen, so zeigt man die passende Seite mit der niedrigsten Abschnittsnummer an. Oft gibt es zu einem Thema in mehreren Abschnitten eine Seite. Dann muss der gewünschte Abschnitt angegeben werden.
Beispiele:

`man man`	Hilfe zu `man`
`man bash`	Hilfe zur `bash`
`man tar`	Hilfe zu `tar`
`man printf`	Hilfe zu `printf` der Shell
`man 3 printf`	Meist will man aber Hilfe zur C-Funktion `printf`

Oft weiß man nicht genau, welche Manualseite man braucht. Mit man -k schlüsselwort kann man nach Schlüsselworten suchen lassen. Die Ausgabe ist eine Liste der Befehle, auf die das Schlüsselwort zutrifft.
apropos schlüsselwort sucht nach Schlüsselworten in der Indexdatenbank der Manualseiten.
Für GNU-Programme hat sich die Dokumentation im info-Format eingebürgert:

info seite

kdehelp bietet Zugriff auf all diese Informationen sowie den Hilfetexten des KDE-Desktops.kdehelp ist auch über einen Menüpunkt des KDE-Menüs erreichbar. Bei neueren KDE-Versionen heißt das Programm khelpcenter.

Weitere Informationen

Fragen

1. Was ist eine Shell?
2. Geben Sie Beispiele verschiedener Shells!
3. Wie wird die Eingabe von langen Pfaden bei der bash erleichtert?
4. Welche Möglichkeiten gibt es frühere Befehle wieder zu verwenden? Nennen Sie 3 Arten!
5. Wie können in einer Shell mehrere Programme so gestartet werden, dass sie gleichzeitig laufen?
6. Wie funktioniert Job-Control? Was ist der Zweck?
7. Was sind Shell-Variable? Nennen Sie zwei Beispiele für die Verwendung!
8. Wie sieht die allgemeine Befehlssyntax aus?
9. Welche Bedeutung hat das Symbol ~ ?
10. Was können Sie tun, damit Sie statt ls das Kommandos dir verwenden können?
11. Was müssen Sie tun, damit dir auch beim nächsten Mal wieder funktioniert?
12. Was können Sie tun, wenn ein Programm keine Dateien lesen/schreiben kann, Sie aber mit diesem Programm dennoch Dateien bearbeiten wollen?
13. Sie haben 3 Dateien adr1, adr2 und adr3, welche Zeilen mit Namen und e-Mail-Adressen enthalten. Eine Zeile hat die Form name vorname email. Die Einträge sind nicht sortiert. Manche Namen kommen nur in einer Datei vor, andere in mehreren Dateien. Geben Sie die Kommandozeile an, die alle 3 Dateien verknüpft, sortiert, die doppelten Namen löscht und in die Datei adr ausgibt. Welcher Mechanismus muss hier verwendet werden?
14. Sie haben ein Programm myprog gestartet, welches hängen geblieben ist. Welche Möglichkeiten haben Sie, das Programm zu beenden?
15. Sie wollen wissen, welche C- oder Java-Datei im aktuellen Verzeichnis die Funktionlongjmp enthält. Geben Sie das Kommando an! Was passiert hier genau?
16. Sie wissen nicht genau, wie Befehl zum Archivieren/Zippen von Dateien heißt. Wie finden Sie die Information?

Commandline resurrected

2011-09-20T12:29:00.002+02:00

Am Anfang war die Kommandozeile
Das stimmt natürlich nicht ganz, denn davor gab es Programme durch Verdraten der Computer-Hardware, dann "Schreibmaschinen", mit denen man Lochkarten/Lochstreifen stanzen konnte, welche dann über ein Lesegerät in den Computer gelangten.

Die Ausgabe erfolgte über Endlos-Drucker.

Zur Datenspeicherung gab es Wieder Lochkarten oder Magnetbänder:

Natürlich gab es noch verschiedenste Ein- und Ausgabegeräte, aber das Wesentliche an der Arbeit mit Computern war damals, dass es nur "Stapelverarbeitung" (Batch Processing) gab (bis Anfang der 70er-Jahre, in Schulen etwas länger - bis Anfang der 80er).Der große Fortschritt waren dann Fernschreiber/Teletypes, mit denen man interaktiv am Computer arbeiten konnte. Das waren quasi Schreibmaschinen mit eingebautem Drucker. Aus dieser Zeit stammt die Kommandozeile. Der Computer druckte einen "Prompt" aus und wartete dann auf eine Eingabezeile, die er dann verarbeitete und das Ergebnis oder die Fehlermeldungen ausdruckte.

Natürlich wartete der Computer die meiste Zeit auf Eingaben. Daher wurde aus dem Batch Processing ein Multi Processing, d.h. mehrere Terminals wurden an den Computer angeschlossen und mehrere Programme konnten (scheinbar) gleichzeitig laufen.
Aus den Teletypes entwickelten sich echte Terminals (Bildschirm und Tastatur).

Man arbeitete immer mit einer Read-eval-print loop (REPL). Der Computer las einen Befehl ein, führte ihn aus, gab das Ergebnis aus und wartete auf die nächste Eingabe (wieder zurück zum Lesen).
Um effizient zu arbeiten, musste man ziemlich viele Kommandos auswendig wissen (übrigens funktionierten damals Texteditoren auch mit einer Kommandozeile, z.B. edlin unter DOS oder ed unter Unix). Die Kommandos bestanden oft nur aus wenigen Buchstaben. Jedenfalls nichts für Anfänger oder Personen, die nur ab und zu einen Computer bedienen wollten.
Durch Menü-Bedienung wurde es langsam aber sicher auch für "Laien" möglich Computer zu bedienen. Viele elektronische Geräten können über Menüs bedient werden. Die Menüführung war der Tod der Kommandozeile.
Auch in grafischen Benutzeroberflächen (GUI) gibt es jede Menge Menüs oder andere Dialoge, bei denen man etwas auswählen kann und nicht Befehle auswendig wissen muss. Durch Shortcuts (Tastenkombinationen) kann man als geübter Benutzer trotzdem relativ flink arbeiten. Manche User verwenden aber immer noch gerne Commandline Interfaces, weil sie damit schneller arbeiten können. Dazu gibt es auf praktisch allen Systemen Terminal-Emulatoren.

Im Prinzip werden moderne Systeme immer noch großteils mit Menüs bedient, aber je mehr Funktionen, desto mehr Einträge gibt es. Es wird also selbst für geübte Benutzer teilweise ziemlich mühsam, zumal man oft zur Maus greifen muss.

Optionen (Einstellungen) sind oft ziemlich umfangreich, viele Tabs, Radio-Knöpfe usw.

eclipse hat so viele Einstellungsmöglichkeiten, dass im Optionendialog schon lange eine Suchfunktion integriert ist:

Auch das Windows-Menü oder KDE-Menü hat seit einigen Jahren eine integrierte Suchfunktion, sodass man z.B. [Alt]+[F1]ecl[Enter] (KDE) drücken muss, um Eclipse zu starten. Unter Windows muss man die Windows-Taste drücken und z.B. "not" eingeben um Notepad aufzurufen. Ist der Befehl noch nicht eindeutig, so werden mögliche Alternativen angezeigt.

Übrigens gibt es so eine Art Mini-Kommandozeile ([Alt]+[F2]) schon seit es KDE gibt (1996), also lange bevor so etwas unter Windows existierte.
Bei Mobiltelefonen hat sich auch die Menüführung schon lange durchgesetzt. Selbst bei Smartphones ist es noch so, wenn man die vielen Anwendungs-Icons als Menü betrachtet:

Man muss oft einige Zeit "herumswipen", um die richtige App zu finden. Ich weiß nicht, ob es das beim iPhone gibt, aber bei Andorid kann man einfach den Such-Button drücken und dann ein paar Buchstaben tippen und man bekommt die passenden Anwendungen nebst Kontakten angezeigt.

Das geht oft viel schneller als "Swipen".
Im übrigen verwenden die meisten im Browser eine Art Kommandozeile, wenn sie oben Fragmente eines URLs eingeben. Der Browser schlägt sinnvolle Ergänzungen vor oder man ruft gleich die (Google-)Suchfunktion damit auf. Geht meist viel schneller als Bookmarks.

Natürlich unterscheidet sich diese neue Form der Kommandozeile von der ursprünglichen: man muss nicht alle "Befehle" auswendig wissen, man braucht nur etwas über das Kommando oder die Funktion wissen und das eingeben. Meist findet das System dann die gewünschte Funktion.

In eclipse wäre das dann so, dass ich, um den Sourcecode schön zu formatieren nicht im (Kontext-)Menü suchen muss oder mir das Tastenkürzel dafür (und für viele andere Funktionen) merken muss, sondern nur ein Tastenkürzel - z.B. [Strg]+[F1] - und dann brauche ich nur einfach tippen, was ich will: "format", "build", "class" (für neue Klasse anlegen, das geht aber auch jetzt schon auf anderem Weg) usw. Meist müsste ich gar nicht alles tippen.
Diese neue Form der Kommandozeile ist sowohl für Anfänger und Personen, die selten ein bestimmtes Programm verwenden, als auch für Power User, die alles mit der Tastatur bedienen wollen. Ich bin nur gespannt, wann sich so etwas noch allgemeiner durchsetzen wird.

Die Kommandozeile ist wiederauferstanden!

Programmierrichtlinien haben doch Sinn (III)

2011-06-07T10:19:00.000+02:00

Das Stück

                int recNo = 0;
                while((rf.length()-rf.getFilePointer())>recordlen)
                {
                int i = 0;
                String[] recordfields = new String[fields.size()];
                deleted = rf.readShort();
                for(Field field:fields)
                {
                    buf = new byte[field.fieldlen];
                    if(field.datentyp=='F' || field.datentyp=='C')
                    {
                        rf.read(buf, 0, field.fieldlen);
                        recordfields[i] = new String(buf,"ISO-8859-1").trim();
                    }
                    else if(field.datentyp == 'V')
                    {
                        rf.read(buf, 0, field.fieldlen);
                        recordfields[i] = new String(buf,"ISO-8859-1").trim();
                    }
                    i++;
                }
                records.add(new DataRecord(recNo,fields.size(),deleted));
                records.get(records.size()-1).setFields(recordfields);
                recNo++;
                }

wäre viel lesbarer, wenn man richtig einrückt. Es geht ganz einfach! Strg+Shift+F in Netbeans oder Eclipse.

                int recNo = 0;
                while ((rf.length() - rf.getFilePointer()) > recordlen) {
                    int i = 0;
                    String[] recordfields = new String[fields.size()];
                    deleted = rf.readShort();
                    for (Field field : fields) {
                        buf = new byte[field.fieldlen];
                        if (field.datentyp == 'F' || field.datentyp == 'C') {
                            rf.read(buf, 0, field.fieldlen);
                            recordfields[i] = new String(buf, "ISO-8859-1").trim();
                        } else if (field.datentyp == 'V') {
                            rf.read(buf, 0, field.fieldlen);
                            recordfields[i] = new String(buf, "ISO-8859-1").trim();
                        }
                        i++;
                    }
                    records.add(new DataRecord(recNo, fields.size(), deleted));
                    records.get(records.size() - 1).setFields(recordfields);
                    recNo++;
                }

Selbst wenn man in der Konsole mit vim arbeitet, kann man die Zeilen mit V und den Cursortasten markieren und anschließend = (ist-gleich) drücken.

Was ist da so schwierig dran?

Hilft beim Einarbeiten in den Source Code immens.

Fehlerbehandlung

2011-06-07T09:28:00.001+02:00

Bei folgendem Code-Stück sieht man nur die Ausgabe

RemoteException

sonst nichts. Keine weitere Information, um dem Problem auf die Schliche zu kommen.

public class Server {
    public static void main(String[] args) {
        try {
            LocateRegistry.createRegistry(1099);
            System.out.println("RMI-Registry erfolgreich gestartet");
        } catch (RemoteException ex) {
            System.out.println("Fehler beim Starten der Registry: " + ex);
        }
        try {
            DB db = new Data("fahrten.db");
            //System.out.println(((Data)db).records.size());
            DB d = (DB) UnicastRemoteObject.exportObject(db, 1099);
            System.out.println("1xx");
            Naming.rebind("Data", d);
            System.out.println("2xx");

            
            Header he = ((Data)db).getHeader();
            Header h = (Header) UnicastRemoteObject.exportObject(he, 1099);
            Naming.rebind("Header", h);


            System.out.println("Alles gebunden");


        } catch (RemoteException ex) {
            System.err.println("RemoteException");
        } catch (MalformedURLException ex) {
            System.err.println("MalformedURLException");
        }
    }
}

Ein einfaches System.err.println("RemoteException: " + ex.getMessage()); liefert schon etwas mehr hilfreiche Information;

RemoteException: remote object implements illegal remote interface; nested exception is: 
        java.lang.IllegalArgumentException: illegal remote method encountered: public abstract int data.Header.length()

In der Klasse Data findet man

public class Data implements DB, Serializable {

    private final int MAGIC_COOKIE = 4223;
    private Header header;
    private String fileName="";
    private ArrayList lockedRecNo;
    private int DataOffset; //166

Wenn man weiter sucht, findet man für Header das Interface

public interface Header extends Remote {
    public Field getField(int fID);

    public int length();

    public void addField(Field f);

}

Es fehlt schlicht und ergreifend die Implementierung zu Header. Das kann nicht funktionieren!

Die Implementierung muss UnicastRemoteObject erweitern, in Data sollte man statt private Header header; direkt die Implementierung verwenden: private Fields header;.

Die Implementierung von Fields beginnt etwa so:

public class Fields extends UnicastRemoteObject implements Header, Serializable {

    private ArrayList felder;

    public Fields() throws RemoteException {
        felder = new ArrayList(0);
    }
...

Unser Server sollte dann etwa so aussehen (ob das dann funktioniert, sei dahingestellt, aber die Exceptions sind geklärt):

public class Server {

    public static void main(String[] args) {
        DB db = null;
        try {
            db = new Data("fahrten.db");
        } catch (RemoteException ex) {
            System.err.println("RemoteException (new Data()): " + ex.getMessage());
        }
        try {
            LocateRegistry.createRegistry(1099);
            System.out.println("RMI-Registry erfolgreich gestartet");
        } catch (RemoteException ex) {
            System.out.println("Fehler beim Starten der Registry: " + ex);
        }
        try {
            DB d = (DB) UnicastRemoteObject.exportObject(db, 1099);
            Naming.rebind("Data", d);
        } catch (RemoteException ex) {
            System.err.println("RemoteException (rebind(Data)): " + ex.getMessage());
        } catch (MalformedURLException ex) {
            System.err.println("MalformedURLException: " + ex.getMessage());
        }
        try {
            Fields he = (Fields) ((Data) db).getHeader();
            Header h = (Header) UnicastRemoteObject.exportObject(he, 1099);
            try {
                Naming.rebind("Header", (Fields) h);
            } catch (MalformedURLException ex) {
                System.err.println("MalformedURLException (rebind(Header)): " + ex.getMessage());
            }
        } catch (RemoteException ex) {
            System.err.println("RemoteException: " + ex.getMessage());
        }
        System.out.println("Alles gebunden");
    }
}

Der langen Rede kurzer Sinn:

Für den Programmierer muss möglichst viel Information bereitgestellt werden. Für den Anwender hilft diese Information nichts und man muss einfache Fehlermeldungen anbieten (das ist hier auf dieser Ebene sowieso nicht möglich, denn die Software ist noch weit davon entfernt, einem Endanwender seine Dienste anzubieten).
Sinnvoll wäre es, die Exceptions zu loggen.

Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);

Am schlimmsten sind jedoch solche Konstrukte:

try {
                    while(true) {
                        records.add(read(nr));
                        nr++;
                    }
                } catch (RemoteException ex) {
                } catch (RecordNotFoundException ex) {
                }

Fehler sind praktisch unauffindbar. Auch nicht mit dem Debugger, weil man nicht einmal einen Breakpoint setzen kann, um die Variable ex zu inspizieren (die enthält ja Infos zur Exception).
Nachsatz: das alles kostet mich Stunden, die ich sinnvoller verbringen könnte. Einfach den Kandidaten durchfallen lassen, denn die Unit-Tests sind zu 93% (einer von dreizehn hat funktioniert) schief gegangen.

Listings - Source Code drucken

2011-06-06T18:58:00.001+02:00

Es sollte m.E. doch möglich sein, Listings in der folgenden - lesbaren - Form zu erzeugen:

Die Schrift ist leserlich, die Zeilen richtig eingerückt, Dateiname und Autor etc. sind ersichtlich (Ich gebe zu, dieses Bild ist schlecht...). Verwendet wurde recode und a2ps unter Linux.

Wichtig ist auch, dass man allgemeine Programmierrichtlinien befolgt.

Aber mit Office kann man auch sehr schöne Listings erzeugen:

Man muss nur Kopf- und Fußzeilen einrichten, die Schrift auf Courier New (9 oder 10pt) oder eine andere mit fixer Breite und dann zwei Seiten auf eine drucken.

Ähnliches gibt es schon unter Listings (Source-Code drucken) zu lesen.

Stattdessen bekommt man so etwas.

Der Sourcecode ist unmöglich zu lesen, weil die Einrückung bald die dargestellte Zeilenlänge erreicht. Die Schriftgröße ist aber zumindest OK.

Schlimm ist aber das folgende Listing, da würden 4 Code-Seiten auf einem Blatt Platz haben. Trotzdem sind es aber nur 2 Seiten pro Blatt. Die Schrift ist unleserlich klein.

Das ist eine Zumutung!

Autoboxing in Java

2011-06-06T13:00:00.001+02:00

Folgendes Beispiel zeigt ein Problem beim Autoboxing in Java. Der Autor des Code-Fragments will int-Werte in der LinkedList lockedRecords speichern. Das funktioniert beim Speichern in Zeile 16 auch super, weil der int-Wert recNo automatisch in ein Integer-Objekt gepackt wird.

LinkedList<Integer> lockedRecords = new LinkedList<Integer>();

    public long lock(int recNo) throws RemoteException,
            RecordNotFoundException {
        long lockCookie = 0;
        if(existsRec(recNo)){
            synchronized(records.get(recNo)){
                while(lockedRecords.contains(recNo)){
                    try {
                        records.get(recNo).wait();
                    } catch (InterruptedException ex) {
                        System.err.println("Lock Interrupted!");
                    }
                }
                if(existsRec(recNo)){
                    lockedRecords.add(recNo);
                    boolean lock_getted = true;
                    lockCookie = lockedRecords.size() -1;
                    return lockCookie;
                }
            }
        }else{
            throw new RecordNotFoundException();
        }
        return lockCookie;
    }

    public void unlock(int recNo, long lockCookie) throws RemoteException,
            RecordNotFoundException, SecurityException {
        if(recNo > 0 && recNo < records.size()){
            if(lockCookie >= 0 && lockCookie < lockedRecords.size()
                    && lockedRecords.contains((int)lockCookie)){
                synchronized(records.get(recNo)){
                    lockedRecords.remove(recNo);
                    records.get(recNo).notifyAll();
                }
            }else{
                throw new SecurityException();
            }
        }else{
            throw new RecordNotFoundException();
        }
    }

unlock() stürzt (praktisch) immer in Zeile 34 ab! Und zwar mit einer IndexOutOfBoundsException.

Warum?

Die Klasse LinkedList (sowie viele andere Klassen des Java Collection Frameworks) besitzt zwei remove()-Methoden:

E remove(int index), welche das Element mit dem Index index entfernt und eine IndexOutOfBoundsException wirft, wenn der Index nicht existiert.
boolean remove(Object o), welche das entsprechende Objekt entfernt, falls es existiert (und in diesem Fall true liefert).

Ein int-Parameter wird nicht automatisch in ein Integer-Objekt verpackt, da zuerst die zu int passende Methode verwendet wird! E remove(int index) wirft aber eine IndexOutOfBoundsException, wenn der int recNo kein gültiger Index ist. Das wäre eher zufällig passend.

Autoboxing ist also im Allgemeinen sehr praktisch, kann aber zu unerwarteten Problemen führen.

Übrigens ist eine Lösung mit Verwendung von Integer nicht zielführend, da beim Autoboxing nur bei kleinen Werten tatsächlich dasselbe Objekt verwendet wird:

Integer i1 = 23;
Integer i2 = 23;
Integer i3 = 2132321423;
Integer i4 = 2132321423;
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
System.out.println(i3 == i4);
System.out.println(i3.equals(i4));

liefert:

true
true
false
true

Programmierrichtlinien haben doch Sinn (II)

2011-06-04T12:19:00.000+02:00

Noch ein Bonmot, diesmal eine Endlosschleife:

    public int[] find(String[] criteria) throws RemoteException {
        ArrayList erg = new ArrayList();
        for(int i=0; i< records.size();i++){
            boolean match=true;
            if(criteria != null){
                for(int j=0; j< criteria.length;i++){
                    if(criteria[j] != null){
                        if(!records.get(i).getField(j).contains(criteria[j])){
                            match=false;
                            break;
                        }  }  }  }
            
            if(records.get(i).isDeleted()){
                match=false;
            }
            if(match){
                erg.add(i);
            }
        }
        int[] back = new int[erg.size()];
        for(int i=0; i< erg.size();i++){
            back[i]=(int)erg.get(i);
        }
        return back;
    }

Wo ist der Fehler? (Abgesehen von den schlecht formatierten schließenden Klammern in Zeile 11)

Programmierrichtlinien haben doch Sinn

2011-06-02T17:49:00.000+02:00

Eine Stunde Fehlersuche! Suche in einem fremden Code, der gewisse Anforderungen erfüllen muss. Der Unit-Test für eine Methode, die einen CSV-String liefern ist fehlgeschlagen. Das Feld an der Position 5 war immer leer. Der Test erwartete den String "42995";"47.01708,16.93225";"20.73708,29.96312";" 196";"201105132101";" 405";"9634090160";"O", die Methode lieferte jedoch 42995;"47.01708,16.93225";"20.73708,29.96312"; 196;201105132101;"";9634090160;"O"

OK, dieser "Fehler" war schnell gefunden. Die Methode hielt sich besser an das CSV-Format (nur Strings sind in Hochkomma eingeschlossen, Zahlen nicht) als mein Test. Das war schnell korrigiert und nun lieferte die Methode alles als String:
"42995";"47.01708,16.93225";"20.73708,29.96312";" 196";"201105132101";"";"9634090160";"O"

Fast richtig. Das ist ein wirklicher Fehler. Durchforsten und Debuggen hat ergeben, dass dieses Feld schon beim Lesen immer leer wird. Der Code dazu ist folgender (das Leerzeichen bei den Bedingungen "kleiner als" habe ich für den Blog hinzugefügt, damit da nicht ein ungültiges HTML-Tag ensteht, grundsätzlich erschwert das Fehlen solcher Leerzeichen das Lesen des Codes):

public Data(String fn) throws FileNotFoundException, IOException{
        fileName=fn;

        rf = new RandomAccessFile(fn, "rw");
            int mC=rf.readInt();
            if(mC==4223){
                int dataOffset=0;
                short count=0;

                dataOffset=rf.readInt();
                firstDataOffset=dataOffset;
                count=rf.readShort();
                information = new Header(count);
                for(int i=0;i< count;i++){
                    short fNameLength = rf.readShort();
                    byte[] roughData = new byte[fNameLength];
                    rf.read(roughData/*, (int)rf.getFilePointer(), fNameLength*/);

                    String fieldName = new String(roughData,"ISO-8859-1");
                    short fDescLength = rf.readShort();
                    roughData = new byte[fDescLength];
                    rf.read(roughData/*, (int)rf.getFilePointer(), fDescLength*/);
                    String fieldDescription = new String(roughData,"ISO-8859-1");

                    char type = (char)rf.readByte();

                    short fDataLength = rf.readShort();

                    Field f = new Field(fNameLength, fieldName, fDescLength, fieldDescription, type, fDataLength);

                    information.setHeaderField(i, f);
                }
                records = new ArrayList();
                while(dataOffset< rf.length()){
                    short flag = rf.readShort();
                    String[] data = new String[information.getLength()];
                    for(int i=0;i< data.length;i++){
                        int readLen = information.getField(i).length;
                        byte[] roughData = new byte[readLen];
                        rf.read(roughData/*, dataOffset, readLen*/);
                        switch(information.getField(i).type){
                            case'f':
                            case'F':
                                data[i] = new String(roughData,"ISO-8859-1");
                                break;
                            case'v':
                            case'V':
                                StringBuilder sb = new StringBuilder();
                                for(int j=0;i< readLen && (char)roughData[j]!='\0';j++){
                                    sb.append((char)roughData[j]);
                                }
                                data[i] = sb.toString();
                                break;
                            case'c':
                            case'C':
                                byte[] d = new byte[1];
                                d[0]=roughData[0];
                                data[i] = new String(d);
                                break;
                        }
                        dataOffset+=(2+readLen);
                    }
                    if(flag==0){
                        records.add(new RecordData(data, true, information));
                    }else{
                        records.add(new RecordData(data, false, information));
                    }

                }
                rf.close();
                information.recAnz = records.size();
            }else{
                throw new FileNotFoundException("Keine DB-Datei");
            } 
    }

Soviel konnte ich aufgrund der Rahmenbedingungen auch gleich herausfinden: das Feld mit Index 5 ist ein "V"-Feld, daher ist der Code ab Zeile 48 relevant. Der schaut eigentlich richtig aus.Erstaunlich ist jedoch, dass die "V"-Felder davor korrekt waren, das "F"-Feld auch. Aber das fehlerhafte "V"-Feld ist gleich nach dem ersten "F"-Feld. Daher war meine Hypothese: das "F"-Feld "erzeugt" den Fehler. Aber die Zeilen 44 und 45 sind korrekt.

Also nächste Hypothese: das Lesen der Daten ist fehlerhaft! Zeilen 38 bis 40. Aber die sind m.E. korrekt. Vielleicht wurde der Dateiheader falsch gelesen (dort sind die Feldlängen und Feldtypen spezifiziert).

Zeilen 5 bis 32. Aber auch dort ist nichts verdächtiges. Es ist schon zum Verzweifeln! Alles schaut richtig aus und trotzdem schlägt der Test fehl (zu Recht, denn das Ergebnis ist falsch).

Jetzt ist einmal Zurücklehnen angesagt. Das ganze mal von der Entfernung betrachten.Breakpoint auf Zeile 48 setzen und schauen, was sich tut.

Erst beim 5. Feld (0-basiert) tritt der Fehler auf. Die Schleife wird sofort verlassen, obwohl roughData tatsächlich mehr als 0 Bytes enthält, 5, um genau zu sein. readLen enthält sogar den richtigen Wert. Wie so zum Teufel ist dann die Bedingung j < readLen && roughData[j] != 0 nicht erfüllt (das Casten auf (char) hatte ich schon entfernt, weil '\0' tatsächlich den Wert 0 hat)?

Ich habe bei dem Ausdruck Leerzeichen eingebaut, die im Original nicht waren. Jetzt fällt es wie Schuppen aus den ~~Haaren~~Augen! Im Original auf Zeile 49 steht i < roughData && roughData[j] != 0. i statt j - optisch fast nicht zu unterscheiden!

i zählt die Felder, j die einzelnen Bytes in einem Feld. Daher ist ab dem Feld 5, welches eine Länge von 5 hat, der erste Teil der Bedingung nicht mehr erfüllt und es wird ein leerer String erzeugt.

Ja, Programmieranfängern wird immer gepredigt: "sprechende" Namen verwenden!

Das hätte geholfen! Statt i könnte man z.B. fieldno verwenden und statt j wäre byteno angebracht.Damit wäre der Fehler nie passiert! Die Schleife hätte gleich falsch ausgesehen:

for(int byteno=0;fieldno< readLen && roughData[byteno]!=0;byteno++){
    sb.append((char)roughData[byteno]);
}

Wenn dann noch Leerzeichen dazwischen sind, springt der Fehler sofort ins Auge, denn warum wird in der Schleife einmal fieldno und einmal byteno verwendet?

Selbst wenn man in kurzen Schleifen i und j als Laufvariable erlaubt, dann müsste aber in der äußeren Schleife immer noch ein "sprechender" Name verwendet werden. Das stäche auch ins Auge (die Leerzeichen verbessern das auch noch!):

for (int i = 0; fieldno < readLen && roughData[i] != 0; i++){
    sb.append((char)roughData[byteno]);
}

Wenn schon kurze Laufvariable, dann besser nie i und j gemeinsam verwenden sondern "unterschiedlichere" Buchstaben wie i und k oder i und m. Die kann man nicht so leicht verwechseln!

Die Variante mit "sprechenden" Namen für Schleifen, die länger als ein paar Zeilen sind, und kurze Laufvariable für kurze Schleifen (Dreizeiler) ist die beste Möglichkeit, dann das Beispiel mit i und fieldno schaut gleich irgendwie falsch aus. Zumindest schaut man sich so etwas gleich näher an.

Leerzeichen und sprechende Namen bringen's!

Siehe auch Programmierrichtlinien allgemein. Dort steht leider nichts über die Verwendung von Leerzeichen.

Java Guidelines findet man z.B. hier: http://www.oracle.com/technetwork/java/codeconv-138413.html

Google findet auch etwas: www.google.com

Aufgaben zu verketteten Listen und binären Bäumen (POS1: 2A, 2C)

2011-06-01T14:39:00.001+02:00

Arbeiten Sie die folgenden Beiträge durch:

Aufgaben zu Collections in Java (POS1: 2A, 2C)

2011-05-17T15:13:00.000+02:00

Vorarbeiten

Arbeiten Sie die Beispiele im Buch Kapitel 12 durch. Sie finden den Sourcecode dazu unter /home/teachers/hp/public/pos1-2/kap12 (unter der Linux-Umgebung!).
Machen Sie die Übung 12.8.

Beispielprojekt zu Java-Collections, Import von Projekten in Eclipse
Die Datei java-collections_1_1.zip enthält ein Eclipse-Projekt mit einem Beispiel zur Verwendung der Java-Collection-API.
Im Package simple finden Sie ein Beispiel zur Ermittlung der Worthäufigkeiten wobei im main nur ein Aufruf mit fixen Testdaten (Array) vorhanden ist.
Das Package step1 zeigt die Vorarbeiten zu dem Programm hauf mit einer eigenen Datenstruktur Data, in der ein Wort und die Häufigkeit gespeichert wird. Zusätzlich implementiert Data das Interface Comparable um eine natürliche Sortierung nach dem Wort zu ermöglichen. Das Interface Comparator wird implementiert, um nach Häufigkeiten zu sortieren. Um auch nach Häufigkeiten absteigend zu sortieren, enthält die Datei Data.java noch eine Klasse DataHaufUmgekehrt, welche ebenfalls Comparator implementiert.
Im folgenden der Ausschnitt mit dem main, welches zeigt, wie man sortiert:

public static void main(String[] args) {
    Data[] worte = new Data[] { new Data("das", 12), new Data("Haus", 3),
        new Data("Text", 23), new Data("Punkt", 2), new Data("Testdaten", 12) };
    System.out.println("unsortiert");
    for (Data d : worte) {
      System.out.println("  " + d);
    }
    Arrays.sort(worte);
    System.out.println("sortiert nach Wort");
    for (Data d : worte) {
      System.out.println("  " + d);
    }
    Arrays.sort(worte, new Data());
    System.out.println("sortiert nach Anzahl");
    for (Data d : worte) {
      System.out.println("  " + d);
    }

    Arrays.sort(worte, new DataHaufUmgekehrt());
    System.out.println("sortiert nach Anzahl absteigend");
    for (Data d : worte) {
      System.out.println("  " + d);
    }
  }

Im Paket step2 wird dann das Beispiel ausgebaut, sodass in der Klasse Hauf zwei Varianten von Maps zum Speichern der Worthäufigkeiten verwendet werden. Eine HashMap und eine TreeMap. Für die HashMap muss die Klasse Data zusätzlich noch die Methoden equals() und hashCode() implementieren (überschreiben).
Im main von Hauf werden dann Worte aus der Standardeingabe gelesen und in den zwei Maps gespeichert.

Die Datei java-collections_1_1.zip kann nach dem Download direkt in Eclipse importiert werden:

Man wählt dann die Datei aus:

Man erhält dann folgendes Projekt:

Erweiterung
Erweitern Sie das Projekt so, dass die Worthäufigkeiten in Dateien ermittelt werden können.
Aufruf: java Hauf [-h] [-o ausgabe] files...
Es sollen also keine, eine (stdin) oder mehrere Dateien verarbeitet werden können. Optional erfolgt die Ausgabe in eine Datei (Option -o). -h soll eine kurze Hilfe ausgeben.
Wird mehr als eine Datei angegeben, so sollen für jede Datei die häufigsten 10 Worte ausgegeben werden (Ausgabe Dateiname, dann die 10 häufigsten Worte) und zum Schluss die Gesamthäufigkeiten aller Worte in allen Dateien.

Nennen Sie das Projekt collectionhauf (klasse-name-collectionhauf).

Aufgabe: Interfaces (POS1: 2A, 2C)

2011-05-04T16:06:00.000+02:00

Aufgabe 1:
Implementieren Sie folgendes Interface, sodass Sie Speicher-Objekte für beliebig viele int-Werte haben können. Schreiben Sie ein passendes Testprogramm.

/**
 * Container für int-Werte.
 * 
 * @author Harald R. Haberstroh (hp)
 * 
 */
public interface IntContainerI {
    /**
     * Aufnehmen eines neuen Elements.
     * 
     * @param element
     *            neues Element, das aufgenommen werden muss (hinten)
     */
    public void add(int element);

    /**
     * Liefern eines Elements.
     * 
     * @param index
     *            gesuchtes Element
     * @return Element an dieser Stelle
     */
    public int get(int index);

    /**
     * Ganzen Container als Array.
     * 
     * @return liefert alle gespeicherten Elemente als Array
     */
    public int[] getArray();

    /**
     * Ändern eines Elements.
     * 
     * @param index
     *            Indes des Elements, das geändert werden soll
     * @param value
     *            neuer Wert
     */
    public void set(int index, int value);

    /**
     * Anzahl der gespeicherten Elemente liefern (Größe)
     * 
     * @return Größe des Containers (Anzahl der Elemente).
     */
    public int size();
}

Aufgabe 2:
Ändern Sie das Interface so, dass beliebige Objekte verwendet werden können. Nennen Sie das Interface ContainerI. Schreiben Sie eine Klasse, die das Interface implementiert und programmieren Sie passende Tests, um die neue Klasse zu testen.

Beispiele zu Gleitkommadarstellung (POS1: 1B)

2011-04-27T22:20:00.000+02:00

Hier finden Sie ein paar Übungsbeispiele zu Gleitkommazahlen sowie die dazugehörige Lösung. Zunächst Konvertierung von Dezimalzahlen in Gleitkommazahlen. Es sind die Zahlen immer alle drei Formate zu bestimmen:

-0,15087890625

Nachkommateil:
0.15087891 | 0
0.30175781 | 0
0.60351562 | 1
0.20703125 | 0
0.41406250 | 0
0.82812500 | 1
0.65625000 | 1
0.31250000 | 0
0.62500000 | 1
0.25000000 | 0
0.50000000 | 1
Gesamt: 1 ,00100110101                (die 1 steht für das Vorzeichen -)
Mantisse wäre: 1001101010
Exponent wäre: -2
Exponent umwandeln:
         2 | 0
         1 | 1
Exponent unbeschränkt positiv: 10
Exponent mit führenden Nullen: 0010
Zweierkomplement:
   Einerkomplement:            1101
                                  1
   Zweierkomplement:           1110
Exponent: 1110, Vorzeichen: 1

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
1  1  0  0  1  1  0  1  0  1  0  1  1  1  1  0 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
1  1  1  1  1  0  1  0  0  1  1  0  1  0  1  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
1  1  1  1  0  1  1  0  0  1  1  0  1  0  1  0

ganzzahliger Teil:
        33 | 1
        16 | 0
         8 | 0
         4 | 0
         2 | 0
         1 | 1
Nachkommateil:
Gesamt: 0 100001,                (die 0 steht für das Vorzeichen + - beachte den Abstand)
Mantisse wäre: 1000010000
Exponent wäre: 6
Exponent umwandeln:
         6 | 0
         3 | 1
         1 | 1
Exponent unbeschränkt positiv: 110
Exponent: 0110, Vorzeichen: 0

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
0  1  0  0  0  0  1  0  0  0  0  0  0  1  1  0 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
0  0  0  1  1  0  1  0  0  0  0  1  0  0  0  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
0  0  1  1  0  0  1  0  0  0  0  1  0  0  0  0

470,171875

ganzzahliger Teil:
       470 | 0
       235 | 1
       117 | 1
        58 | 0
        29 | 1
        14 | 0
         7 | 1
         3 | 1
         1 | 1
Nachkommateil:
0.17187500 | 0
0.34375000 | 0
0.68750000 | 1
0.37500000 | 0
0.75000000 | 1
0.50000000 | 1
Gesamt: 0 111010110,001011
Mantisse wäre: 1110101100
Exponent wäre: 9
Exponent umwandeln:
         9 | 1
         4 | 0
         2 | 0
         1 | 1
Exponent unbeschränkt positiv: 1001
Exponent: 1001, Vorzeichen: 0

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
0  1  1  1  0  1  0  1  1  0  0  0  1  0  0  1 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
0  0  1  0  0  1  1  1  1  0  1  0  1  1  0  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
0  1  0  0  1  0  1  1  1  0  1  0  1  1  0  0

-17,2145

ganzzahliger Teil:
        17 | 1
         8 | 0
         4 | 0
         2 | 0
         1 | 1
Nachkommateil:
0.21450000 | 0
0.42900000 | 0
0.85800000 | 1
0.71600000 | 1
0.43200000 | 0
0.86400000 | 1
0.72800000 | 1
0.45600000 | 0
0.91200000 | 1
0.82400000 | 1
0.64800000 | 1
0.29600000 | 0
0.59200000 | 1
0.18400000 | 0
0.36800000 | 0
0.73600000 | 1
0.47200000 | 0
0.94400000 | 1
Gesamt: 1 10001,001101101110100101
Mantisse wäre: 1000100110
Exponent wäre: 5
Exponent umwandeln:
         5 | 1
         2 | 0
         1 | 1
Exponent unbeschränkt positiv: 101
Exponent: 0101, Vorzeichen: 0

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
1  1  0  0  0  1  0  0  1  1  0  0  0  1  0  1 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
1  0  0  1  0  1  1  0  0  0  1  0  0  1  1  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
0  0  1  0  1  1  1  0  0  0  1  0  0  1  1  0

-0,015625

ganzzahliger Teil:
Nachkommateil:
0.01562500 | 0
0.03125000 | 0
0.06250000 | 0
0.12500000 | 0
0.25000000 | 0
0.50000000 | 1
Gesamt: 1 ,000001
Mantisse wäre: 1000000000
Exponent wäre: -5
Exponent umwandeln:
         5 | 1
         2 | 0
         1 | 1
Exponent unbeschränkt positiv: 101
Exponent mit führenden Nullen: 0101
Zweierkomplement:
   Einerkomplement:            1010
                                  1
   Zweierkomplement:           1011
Exponent: 1011, Vorzeichen: 1

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
1  1  0  0  0  0  0  0  0  0  0  1  1  0  1  1 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
1  1  1  0  1  1  1  0  0  0  0  0  0  0  0  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
1  1  0  1  1  1  1  0  0  0  0  0  0  0  0  0

12739

ganzzahliger Teil:
     12739 | 1
      6369 | 1
      3184 | 0
      1592 | 0
       796 | 0
       398 | 0
       199 | 1
        99 | 1
        49 | 1
        24 | 0
        12 | 0
         6 | 0
         3 | 1
         1 | 1
Nachkommateil:
Gesamt: 0 11000111000011,
Mantisse wäre: 1100011100
Exponent wäre: 14
Exponent umwandeln:
        14 | 0
         7 | 1
         3 | 1
         1 | 1
Exponent unbeschränkt positiv: 1110
Exponent: 1110, Vorzeichen: 0

vm m  m  m  m  m  m  m  m  m  m  ve e  e  e  e  
0  1  1  0  0  0  1  1  1  0  0  0  1  1  1  0 

vm ve e  e  e  e  m  m  m  m  m  m  m  m  m  m  
0  0  1  1  1  0  1  1  0  0  0  1  1  1  0  0 

ve e  e  e  e  vm m  m  m  m  m  m  m  m  m  m  
0  1  1  1  0  0  1  1  0  0  0  1  1  1  0  0

Zurückrechnen

Gegeben sind die Zahlen im 2. Format, m = 9 und e = 3:
0 0 1 0 1 1 1 1 1 1 0 0 0 0
Beide Vorzeichen positiv
Mantisse: 111110000₂
positiver Exponent: 101₂ = 5₁₀
Zahl in normierter Gleitkommadarstellung: 0,11111₂ * 2⁵ = 11111₂
Ergebnis: 31

1 0 1 1 1 1 1 0 0 1 0 1 0 1
Vorzeichen der Mantisse negativ, daher ist die Zahl negativ
Mantisse: 110010101₂
positiver Exponent: 111₂ = 7₁₀
Zahl in normierter Gleitkommadarstellung: -0,110010101₂ * 2⁷ = 1100101,01₂
Ergebnis: -101,25

1 1 1 1 0 1 0 0 1 1 0 1 0 1
beide Vorzeichen negativ, daher ist die Zahl negativ und der Exponent negativ
negative Mantisse: -100110101₂
negativer Exponent, daher Zweierkomplement des Exponenten: 010₂ = -2₁₀
Zahl in normierter Gleitkommadarstellung: -0,100110101₂ * 2^-2 = 0,00100110101₂
Ergebnis: -0.15087890625
(Vergleichen Sie das mit dem Ergebnis des Beispiels ganz oben!)

Zahlenbereich

Die Formel aus der Schulübung:

Eingesetzt für B = 2 (Binärsystem), m = 10 (von ganz oben) und e = 4 (von ganz oben):

Aufgabe zu Vererbung in Java (POS1: 2A, 2C)

2011-04-27T14:02:00.001+02:00

Implementieren Sie die Klassen aus dem Buch Kapitel 7.
Machen Sie die Übung 7.10 (Seite 87).
Zeichnen Sie zu Übung 7.10 das passende UML-Klassendiagramm.

Sehen Sie sich auch die folgenden Einträge an:

Locking- und Updateprobleme mit RMI (PR: 5A, 5B)

2011-04-20T16:19:00.000+02:00

Da bei normalen "Remote-Objekten" immer ganze Objekte übertragen werden, hat man echtes Call-By-Value. Man arbeitet also mit Kopien von Objekten. Das gilt sowohl für Objekte, die an eine Methode eines Remote-Objekts übergeben werden als auch für Objekte als Returnwerte.
Normalerweise werden innerhalb einer JVM Objekte immer als Referenz übergeben bzw. zurückgegeben. Über RMI werden die Objekte immer serialisiert und komplett übertragen.
Das wirkt sich bei unserem "Data-Beispiel" so aus, dass Updates erst "sichtbar" werden, wenn die Daten auch wieder von der Datei geladen werden. Sollte das Locking direkt in der Record-Implementierung erfolgen, so muss man bedenken, dass auch immer ein Record-Objekt übertragen wird und der Client mit einer Kopie arbeitet. Damit bekommt er immer den Lock!
Abhilfe?
Man darf dem Client nur Referenzen zur Verfügung stellen. Nur der Server arbeitet mit den "echten" Objekten. - Klar, und wie geht das?
Das herauszufinden war nicht einfach, die Java-Dokumentation von Sun (Oracle) schweigt sch diesbezüglich aus, zumindest was direkte Lösungsvorschläge und Beispielcode angeht.

Grundsätzliche Erklärung und Beispiele zur Funktionsweise von RMI hilft etwas: jGuru: Remote Method Invocation (RMI) aber die letzte zündende Idee bekommt man durch How to return object and return object reference in Java RMI

Der Unterschied liegt in der Klassendefinition. Wenn die Klasse eine Unterklasse von UnicastRemoteObject ist, so ist sie damit RMI-fähig (kann RMI-Service anbieten). In diesem Fall wird also eine Referenz zurückgegeben werden. Wenn die Klasse nur Serializable implementiert, so ist die Klasse nicht für RMI-Aufrufe geeignet (kein RMI-Service) und es wird das Objekt zurückgegeben werden.

Ein Beispiel wird in Kürze geliefert.

Serialisierungsprobleme mit RMI (PR: 5A, 5B)

2011-04-15T09:19:00.001+02:00

Remote Method Invocation funktioniert nur für Objekte, welche serialisiert werden können (die also das Interface Serializable implementieren). Wird innerhalb eines Objekts, welches über RMI gebunden werden soll, eine Referenz auf ein nicht serialisierbares Objekt benötigt, so bekommt man immer eine Exception der Art (z.B. für RandomAccessFile):

sun.rmi.registry.RegistryImpl_Stub.rebind(Unknown Source)
java.rmi.Naming.rebind(Naming.java:177)
rmi.Server.run(Server.java:43)
rmi.Server.main(Server.java:68)
error marshalling arguments; nested exception is: 
 java.io.NotSerializableException: java.io.RandomAccessFile

RandomAccessFile ist nicht serialisierbar, weil der innere Zustand so eines Objekts von der Laufzeitumgebung (Betriebssystem, Dateisystem, etc.) abhängt. Eine Referenz auf ein RandomAccessFile-Objekt muss als transient deklariert werden. Wenn nötig, dann muss der Zustand selbst gespeichert bzw. wiederhergestellt werden, z.B. in Form des Dateinamens und der Position innerhalb der Datei.
Dazu kann man die Methoden des Interfaces Serializable implementieren:

private void writeObject(java.io.ObjectOutputStream out)
    throws IOException
private void readObject(java.io.ObjectInputStream in)
    throws IOException, ClassNotFoundException;
private void readObjectNoData() 
    throws ObjectStreamException;

Für die Zwecke der Data-Klasse genügen die ersten beiden Methoden. Folgender Ausschnitt aus der Data-Klasse soll dies verdeutlichen:

public class Data implements DB, Header, Serializable {

    private static final long serialVersionUID = -8958941842720498616L;
    private transient RandomAccessFile database;
    private String filename;
    private transient Logger log = Logger.getLogger(LOGURL);
    private DBHeader header;
    private TreeMap data;
    private int lastDeleted = -1; // zuletzt gelöschter Datensatz

    private void writeObject(ObjectOutputStream stream) throws IOException {
        stream.defaultWriteObject();
        stream.writeLong(database.getFilePointer());
    }

    private void readObject(ObjectInputStream stream) throws IOException {
        try {
            stream.defaultReadObject();
        } catch (ClassNotFoundException e) {
            String msg = "Unable to find class";
            if (e.getMessage() != null)
                msg += ": " + e.getMessage();
            throw new IOException(msg);
        }
        database = new RandomAccessFile(filename, "rw");
        database.seek(stream.readLong());
        log = Logger.getLogger(LOGURL);
    }

//... weiterer Code entfernt
}

Hier ist auch der Logger transient, da auch der Logger vom Dateisystem abhängt und nicht serialisiert werden kann.

Package für Data, Header, Record (PR: 5A, 5B)

2011-04-13T13:44:00.000+02:00

Verwenden Sie unbedingt das Package data für die Klassen und Interfaces DB, Data, Header und Record. Nur so kann der Datenteil automatisch getestet werden.

Refactoring Data - Interface Record (PR: 5A, 5B)

2011-04-12T19:45:00.000+02:00

Um einfacher automatisch testen zu können, soll das Interface Record (anstatt einer Klasse Record) bei der Datenklasse Data verwendet werden.

package data;

/**
 * RuD-Übung 2011
 *
 * data.Record.java
 * @author (c) 2011, Harald R. Haberstroh
 * 1.3.2011
 */

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * @author Harald R. Haberstroh (hh)
 * 
 */
public interface Record extends Remote {
    /**
     * @return Anzahl der Felder dieses Datensatzes z.B. 8
     */
    public int getCntFields() throws RemoteException;

    /**
     * @return liefert alle Felder verkettet in einen String mit ';' getrennt
     *         z.B.
     *         "12;49.82012,17.260019;47.81497,16.260409;523;201102131510;67;2345121269;O"
     *         Strings sind unter Hochkomma zu setzen. z.B.
     *         "\"wlr1\";\"Werk Laderoboter 1\";\"   50\";\"   50\""
     */
    public String getCsvString() throws RemoteException;

    /**
     * Setzt die Felder auf die gegebenen Strings. Gegebenenfalls sind die
     * Strings abzuschneiden. Die Anzahl der Strings stimmt beim Aufruf von
     * setFields() auf alle Fälle mit getCntFields() überein (Prüfung braucht
     * nicht zu erfolgen).
     * 
     * @param fields
     *            Array mit den Feldwerten.
     * @throws RemoteException
     */
    public void setFields(String[] fields) throws RemoteException;
}

Damit kann per JUnit-Test ganz einfach der Inhalt eines Datensatzes und die Anzahl der Felder geprüft werden.
Überdies wird hier Refactoring geübt, da das Programm (die Klassen) entsprechend angepasst werden müssen (Ihre Record-Klasse muss umbenannt werden und eben das gegebene Interface implementieren).

RoboCupJunior 2011 in Wels

2011-04-11T22:08:00.000+02:00

Heuer sind wir mit 3 Teams zu diesem Bewerb gefahren und haben bei einem Bewerb sogar den dritten Platz erreicht. Hier ein paar Eindrücke:

Die ersten Bilder zeigen das Zimmer, die Vorbesprechung am Abend des Anreisetags und ein paar Bilder von Wels. Dann gibt es jede Menge Eindrücke vom Bewerb.
Weitere Informationen gibt es unter robocupjunior.at und www.robo4you.at (diese Seite ist noch im Entstehen).

Aufgabe Gruppenwechsel Ski (POS1: 2A, 2C)

2011-04-08T08:36:00.001+02:00

Schreiben Sie eine Java-Klasse Grw.java, welches aus dem Datenbestand ski.csv die beigelegte Statistik erzeugt.

Lesen Sie die csv -Datei zeilenweise und erstellen Sie aus jeder Zeile ein Objekt einer Klasse SkiDaten, die alle notwendigen Attribute (Klasse, Name, Geb.Datum,....) enthält.
Nennen Sie das Projekt grwski (also insgesamt z.B. 2ad-haberstroh-grwski).
Sollte eine neue Sortierung des Sätze notwendig sein, bitte mit OpenOffice Calc oder Excel sortieren. 1-er Kandidaten sortieren bitte mit eigenem Sortprogramm.
INFO: es handelt sich um einen zweistufigen Gruppenwechsel mit den Gruppen

KLASSE und GESCHL

und einer Gesamtdarstellung des Durchschnitts!
Eine Einführung in den Gruppenwechsel finden Sie in der Datei gruppenwechsel.pdf
Aufruf des Programms:

java Grw [-h | -o ausgabedat] [-d] eingabedatei

Die Option -d bewirkt die Ausgabe der Detailzeilen, ohne -d nur Summenzeilen ausgeben!
Beispiel Statistik:

------------------------------------------------------------------
STATISTIK zum Schuelerrennen der HTL am SKIKURS 2006 in OBERTAUERN
------------------------------------------------------------------

AMINGER                   Georg                            0.02
ELIAS                     Thomas                           0.97
GALAVICS                  Marcus                           0.15
GALLAUNER                 Alexander                        0.26
HECHER                    Markus                           0.58
HERMANN                   Gregor                           0.65
KAMPER                    Raphael                          0.55
KRIVOKUCA                 Milan                            7.73
MOSER                     Christoph                        2.34
NEPOLA                    René                             0.14
PRIELER                   Stefan                           0.63
RECHBERGER                Christian                        3.11
RIEGLER                   Mario                            0.87
SCHNEEBERGER              Joerg                            1.22
SENN                      Bernhard                         0.65
WIESSNER                  Maximilian                       1.61
ZENZ                      Markus                           2.04

die durchschnittliche Zeitdifferenz bei den MAENNERN betraegt:  1.38

die KLASSE 2AHDV   erreichte eine Durchschnittsdifferenz von  1.38 Sekunden


CMUND                     Katharina                        2.81
HARATHER                  Alice                            1.87
KONLECHNER                Viktoria                         0.39
RIEGER                    Jennifer                         0.63
RINNHOFER                 Elisabeth                        1.65
...........................................................

...........................................................
REICHHART                 Thomas                           0.30
RIEDER                    Dominik                          1.07
SCHERMANN                 Georg                            0.85
STANGL                    Stefan                           1.48
STAUFER                   Andreas                          0.47

die durchschnittliche Zeitdifferenz bei den MAENNERN betraegt:  2.38

die KLASSE 3CHDV   erreichte eine Durchschnittsdifferenz von  2.36 Sekunden
************************************************GESAMT-Differenz :  1.93

Achtung: Die obige Ausgabe stellt nur einen Ausschnitt dar (Aufruf mit Option -d) und es wurde die vorletzte Zeile (Hüpfner) gelöscht, da dort extrem abweichende Zeiten vorkommen (die Schülerin ist scheinbar gestürzt). Die Gesamt-Different würde mit dieser Zeile 11,37 Sekunden betragen.

Binäres Dateiformat für Eingabe

Erstellen Sie ein neues Programm so, dass sie statt der CSV-Eingabedatei auch eine Datei im binären Datenformat verwenden können. Die Daten sind wie folgt gespeichert (C-Datentypen):

typedef struct umsatz {
    char artikel[25];
    char verkaeufer[25];
    int  vkpreis;
    int  monat; 
} umsatz_t;

Dabei ist char artikel[25] ein maximal 24-Zeichen langer String, bei dem jedes Zeichen (ASCII) als ein Byte gespeichert wird. Das Ende des Strings wird durch das Zeichen '\0' abgeschlossen (das hat tatsächlich den Wert 0). D.h. es müssen bis zu 25 Bytes gelesen werden, wobei nur die Zeichen bis exklusive '\0' (direkt) in Java-chars umgewandelt werden können (verwenden Sie z.B. RandomAccessFile.read(byte[] buf)).
int entspricht einem 32-Bit-Integer und passt zum Java-Typ int.
Die passende Datei mit Testdaten finden Sie hier: daten.dat.

Den Inhalt dieser Datei kann man nur mit einem Programm öffnen, das die Daten binär lesen kann und sinnvoll, z.B. im Hexadezimalsystem, anzeigen kann. khexedit oder das Konsolenprogramm hexdump eignen sich dafür.

Die Ausgabe von hexdump könnte so aussehen (gekürzt):

hp@L211 $ hexdump -C daten.dat 
00000000  50 72 6f 64 30 31 00 01  4c 00 ba 01 e5 e2 e6 b7  |Prod01..L.......|
00000010  00 00 00 00 e4 98 04 08  28 4d 61 69 65 72 00 08  |........(Maier..|
00000020  a0 fc f5 b7 dc e9 b9 bf  48 e9 b9 bf f1 86 04 08  |........H.......|
00000030  90 8b f8 b7 dc 00 00 00  01 00 00 00 50 72 6f 64  |............Prod|
00000040  30 32 00 01 4c 00 ba 01  e5 e2 e6 b7 00 00 00 00  |02..L...........|
00000050  e4 98 04 08 28 4d 61 69  65 72 00 08 a0 fc f5 b7  |....(Maier......|
00000060  dc e9 b9 bf 48 e9 b9 bf  f1 86 04 08 90 8b f8 b7  |....H...........|
00000070  90 01 00 00 02 00 00 00  50 72 6f 64 30 33 00 01  |........Prod03..|
00000080  4c 00 ba 01 e5 e2 e6 b7  00 00 00 00 e4 98 04 08  |L...............|
00000090  28 48 75 62 65 72 00 08  a0 fc f5 b7 dc e9 b9 bf  |(Huber..........|

Es soll wieder ein 2-stufiger Gruppenwechsel programmiert werden (Artikel und Verkäufer).
Zum Vergleich können Sie die Daten auch im CSV-Format verwenden: daten.csv.

Versuchen Sie, die beiden Varianten, jene mit den Ski-Daten und jene mit den (binären) Umsatzdaten, so zu gestalten, dass nur geringe Teile unterschiedlich sind (am Besten austauschbare Klassen mit gleichem Namen für die Daten und für die Formatierung). Der Hauptalgorithmus bleibt ja gleich.

GUI für RMI-Client (PR: 5A, 5B)

2011-04-06T15:13:00.000+02:00

Erstellen Sie für den Client unserer RMI-Client/Server-Anwendung eine grafische Oberfläche, welche den Inhalt der Datenbank (evtl als Ausschnitt) in einer JTable darstellt. Es soll möglich sein, einzelne Werte zu ändern, Zeilen zu löschen, neue Zeilen einzufügen und zu Suchen (eigener Dialog). Bei der Suche sind nur die gefundenen Datensätze anzuzeigen.
Das GUI könnte (minimal, die Funktionen zum Löschen, Einfügen und Suchen sind in "Edit" versteckt) etwa so aussehen:

Aufrufstack (Call Stack) (POS1: 2A, 2C)

2011-04-06T12:48:00.016+02:00

Jede Laufzeitumgebung eines Programms muss beim Aufruf von Funktionen oder Methoden folgende Informationen verwalten:

Parameter
Rücksprungadresse (wohin kehrt Funktion zurück?)
lokale Variable
Objektreferenz (this- oder self-Referenz zum Objekt zu dem die Methode gehört)

Die Objektreferenz wird nur für objektorientierte Sprachen benötigt. Sie ist meist versteckt. In Python muss sie beim Erstellen der Klasse explizit angegeben werden (self). Bei einem Aufruf objekt.methode(...) wird intern dann etwas wie methode(objekt, ...) erzeugt (... stellt die Parameter der Methode dar).

Oben genannte Informationen werden auf einem Stack abgelegt, dem Aufrufstack oder Call Stack. Je nach Implementierung können noch weitere Informationen dazukommen.
Beispiele zur Darstellung finden Sie hier: Aufrufstack und Lösung zum Aufrufstack (dieses Beispiel verwendet praktisch keine Objektreferenzen, d.h. Objekte werden nicht dargestellt).

Im Folgenden finden Sie ein einfaches Beispiel mit zwei Klassen:

public class Bar {
    private Foo[] bars = new Foo[2];
    private int n = 0;
    public static void main(String[] args) {
        Bar o = new Bar();
        for (int i = 0; i < 6; i++) {
            Foo m = new Foo("" + i);
            o.add(m);
        }
    }
    public void add(Foo m) {
        bars[n] = m;
        n++;
        if (n == bars.length) {
            for (int i = 0; i < bars.length; i++) {
                System.out.println(bars[i].getName());
            }
        }
    }
}

public class Foo {
    private String name;
    public Foo() {
        this("no name");
    }
    public Foo(String name) {
        this.name = name;
    }
    public String getName() {
        return "Foo [name=" + name + "]";
    }
}

Die Aufgabenstellung wäre: zeichnen Sie den Aufrufstack und den Heap, wenn das Programm die Zeile 10 in der Klasse Foo erreicht. Das Programm soll dabei mit folgendem Aufruf gestartet worden sein: java Bar test
Bei der folgenden Darstellung werden Strings wie primitive Werte dargestellt, also direkt bei der Variable. Richtigerweise sind Strings aber Objekte.
Die Darstellung zeigt den Speicher schematisch für die Zeilen Bar:8, Bar:14 und die gesuchte Zeile Foo:10.

Clicken für weiteres Bild...

Quadcopter spielen Tennis

2011-03-31T21:58:00.000+02:00

Video: Quadrocopter spielen Tennis (0:59)

Coole Sache, diese Quad(ro)copter!

Literaturverwaltung - RandomAccessFile (POS1: 2A, 2C)

2011-03-23T14:55:00.000+01:00

Jemand will Zeitschriftenartikel, Bücher und Internet-Links für seine Recherchen verwalten. Schreiben Sie dazu eine Java-Klasse (plus eventuelle Hilfsklassen), welche es ermöglicht diese Daten in einer RandomAccess-Datei zu speichern. Folgende Daten sollen in der Klasse Eintrag erfasst werden:

autor - String(100)
titel - String(100)
erscheinungsjahr - int
verlag - String(30)
zeitschrift - String(30)
seiten - String(10)
link - String(60)

String(100) bedeutet, dass dafür maximal 100 (genau 100) Zeichen gespeichert werden soll. Sie können das so implementieren, dass kürzere Strings hinten mit Leerzeichen gefüllt werden. Längere Strings müssen abgeschnitten werden. Für eine eventuelle Anzeige/Ausgabe müssen aber die Füllzeichen entfernt werden. Die Klasse Eintrag ist mit entsprechenden Getter- und Setter-Methoden auszustatten (die bei den Strings das Abschneiden und Auffüllen bewerkstelligen).

Die Klasse Literatur für die Verwaltung der Datensätze soll folgende Methoden bereitstellen:

public void neuerEintrag(Eintrag eintrag) - fügt einen neuen Eintrag in die Datei ein.
public Eintrag lese(int nummer) - liefert den Eintrag an der Stelle nummer oder null, falls dieser Eintrag nicht existiert.
public void loescheEintrag(int nummer) - löscht den Eintrag an der Stelle nummer (tut nichts, wenn es den Eintrag nicht gibt).

Der Konstruktor der Klasse Literatur soll eine geöffnete RandomAccess-Datei als Parameter haben:

public Literatur(RandomAccessFile file)

Implementieren Sie das Löschen so, dass der jeweilige Eintrag als gelöscht markiert wird (zusätzliches Feld) und diese Änderung in der Datei gespeichert wird. Der Datensatz ist also physisch noch in der Datei. Bei der Methode lese() muss also im Falle eines gelöschten Eintrags null geliefert werden.

Umgekehrt muss bei neuerEintrag() zunächst ein gelöschter Eintrag gesucht werden. Wird ein solcher gefunden, so wird er durch den neuen ersetzt (Lösch-Markierung muss wieder zurückgesetzt werden). Wird kein gelöschter Datensatz gefunden, so ist der neue an die Datei anzuhängen.

Schreiben Sie ein kleines Testprogramm zum Testen Ihrer Klassen.

Anmerkung: Die Daten sind für eine echte Anwendung nicht ausreichend und müssten unterteilt werden, da es z.B. mehrere Autoren für einen Artikel gibt.

Hinweis: hier finden Sie eine Testklasse zum Testen der Klasse Literatur. Die Klasse Literatur muss wie diese Testklasse im Package literatur sein. Weiters muss die Library für JUnit 3 angegeben werden. Diese Testklasse trifft gewissen Annahmen zur Implementierung von Literatur und Eintrag. Bitte passen Sie entweder die Testklasse an Ihre Implementierung an oder Sie ändern Ihre Literatur bzw. Eintrag-Klassen entsprechend (z.B. nimmt der Test an, dass es eine read() und eine write()-Methode gibt, die einen Datensatz ("in sich hinein") liest bzw. einen Datensatz ("sich selbst") schreibt (jeweils an die Position, die in Literatur bestimmt wurde).

Ihre Klasse Eintrag könnte etwa so beginnen:

public class Eintrag {

  // Feldlängen
  private final static int autorLen = 100;
  private final static int titelLen = 100;
  private final static int verlagLen = 30;
  private final static int zeitschriftLen = 30;
  private final static int seitenLen = 10;
  private final static int linkLen = 60;

  // Felder
  private String autor;
  private String titel;
  private int erscheinungsjahr;
  private String verlag;
  private String zeitschrift;
  private String seiten;
  private String link;

  // gelöscht?
  private boolean istGeloescht = false;

Da eine fixe Datensatzlänge gefordert ist, müssen Sie die Länge ermitteln, indem Sie die Längen der einzelnen Felder zusammenzählen. Wir schätzen für Boolean die Länge von int (bestimmt mit Hilfe der Wrapperklasse Integer und der Konstante SIZE, welche die Länge in Bits angibt).

public static int eintragLen() {
    int len = Integer.SIZE
        / 8
        + (autorLen + titelLen + verlagLen + zeitschriftLen + seitenLen + linkLen)
        * 3 + 6 * Long.SIZE / 8 + Integer.SIZE / 8;
    return len;
  }

Der Faktor 3 entsteht durch die Verwendung der UTF-8-Kodierung. UTF-8 ist eine Kodierung des Unicodes und speichert alle Zeichen des ASCII-Codes auch in der selben Kodierung wie ASCII, daher werden dann für andere Zeichen 2, 3 bzw. 4 Bytes verwendet (Unicode verwendete in den ersteren Versionen 16 Bit, in Java werden daher Zeichen mit 16 Bit kodiert). Um ganz sicher zu sein, müsste man den Faktor 4 verwenden. Long.SIZE / 8 ist die Längeninformation, die in jedem String-Objekt gespeichert ist.

Strings werden mit file.writeUTF(string); geschrieben bzw. mit string = file.readUTF(); gelesen.

public void write(RandomAccessFile out) throws IOException {
    out.writeBoolean(istGeloescht);
    out.writeUTF(autor);
    out.writeUTF(link);
    out.writeUTF(seiten);
    out.writeUTF(titel);
    out.writeUTF(verlag);
    out.writeUTF(zeitschrift);
    out.writeInt(erscheinungsjahr);
  }

  public void read(RandomAccessFile in) throws IOException, EOFException {
    istGeloescht = in.readBoolean();
    autor = in.readUTF();
    link = in.readUTF();
    seiten = in.readUTF();
    titel = in.readUTF();
    verlag = in.readUTF();
    zeitschrift = in.readUTF();
    erscheinungsjahr = in.readInt();
  }

Die String-Felder müssen natürlich auf eine fixe Länge gebracht werden, d.h. zu lange Strings müssen abgeschnitten, zu kurze evtl. verlängert werden. Dies erledigt man am Besten in den Setter- bzw. Getter-Methoden.
Das Lesen eines Datensatzes in der Klasse Literatur könnte etwa so funktionieren:

public Eintrag lese(int nummer) throws IOException {
    long pos = nummer * Eintrag.eintragLen();
    if (pos < file.length()) {
      file.seek(pos);
      Eintrag eintrag = new Eintrag();
      eintrag.read(file);
      if (!eintrag.istGeloescht()) {
        return eintrag;
      } else {
        return null; // gelöschter Eintrag gilt als nicht vorhanden
      }
    } else {
      return null; // über die Dateilänge hinaus
    }
  }

Vervollständigen Sie mit diesen Informationen Ihre Klassen.

Nennen Sie das Projekt klasse-name-literatur (klasse ... 2a, 2b, 2c, name ... Ihr Familienname), z.B. 2a-haberstroh-literatur.

Experimente mit Queues (POS1-2: 2A, 2C, PR: 5A, 5B)

2011-03-18T08:46:00.000+01:00

Implementieren Sie im Package ringbuffer eine Klasse Queue für Integer-Werte. Implementieren Sie die Queue in Form eines Ringpuffers. Es soll die Exception QueueFullException geworfen werden, wenn der Ringpuffer voll ist und die Exception QueueEmptyException, wenn der Ringpuffer leer ist.
Als Testklasse verwenden Sie bitte die folgende Klasse QueueTest, welche zwei Threads erzeugt. Einen Sender, der zufällige "Nachrichten" (Integerwerte) in die Warteschlange steckt und einen Empfänger, der Werte aus der Warteschlange entnimmt. Beide geben jeweils die gesendete bzw. gelesene Nachricht aus. Beide Threads haben unterschiedliche zufällige Wartezeiten.
Experimentieren Sie mit unterschiedlichen Wartezeiten, sodass die Queue (Ringpuffer) voll bzw. leer werden kann. Was passiert?
Wenn die Queue nicht synchronisiert wird, was kann passieren? Können Sie das Verhalten in Experimenten nachweisen?
Bauen Sie entsprechendes synchronized in Ihre Queue ein (5. Klasse). Was muss synchronisiert werden?
Source Code

/**
 * java-queue: ringbuffer.QueueTest.java
 * 
 * 17.03.2011, Harald R. Haberstroh
 */

package ringbuffer;

import java.util.Random;

/**
 * Testen der Queue mit 2 Threads.
 * 
 * @author Harald R. Haberstroh (hp)
 * 
 */
public class QueueTest extends Thread {
  private final static int MAXRUNS = 20;
  private Queue messages;
  private Random rnd = new Random();

  public QueueTest(String name, Queue messages) {
    super(name);
    this.messages = messages;
  }

  public void run() {
    if (getName().equalsIgnoreCase("Sender")) {
      for (int i = 0; i < MAXRUNS; i++) {
        int msg = rnd.nextInt(100);
        long sleepTime = (long) rnd.nextInt(500) + 500; // 500-1000ms
        try {
          System.out.println(getName() + " sending " + msg);
          messages.put(msg);
        } catch (QueueFullException e) {
          System.err.println(getName() + ":Oops - Queue full");
        }
        try {
          sleep(sleepTime);
        } catch (InterruptedException e) {
          System.err.println(getName() + ":Oops - interrupted");
        }
      }
    } else { // Receiver
      setName("                    " + getName()); // Einrückung
      for (int i = 0; i < MAXRUNS || !messages.isEmpty(); i++) {
        long sleepTime = (long) rnd.nextInt(900) + 600; // 900-1500ms
        try {
          if (!messages.isEmpty()) {
            System.out.println(getName() + " read " + messages.get());
          }
        } catch (QueueEmptyException e) {
          System.err.println(getName() + ": Oops - Queue empty");
        }
        try {
          sleep(sleepTime);
        } catch (InterruptedException e) {
          System.err.println(getName() + ":Oops - interrupted");
        }
      }
    }
    System.out.println(getName() + " finished");
  }

  public String toString() {
    return getName();
  }

  /**
   * @param args
   */
  public static void main(String[] args) {
    Queue messages = new Queue();
    QueueTest sender = new QueueTest("Sender", messages);
    QueueTest receiver = new QueueTest("Receiver", messages);
    sender.start();
    receiver.start();
    try {
      sender.join();
      receiver.join();
    } catch (InterruptedException e) {
      System.err.println(e.getLocalizedMessage());
    }
    System.out.println(".... all finished ....");
  }

}

Beispielausgabe bei Standardeinstellung

Sender sending 73
Sender sending 46
                    Receiver read 73
Sender sending 63
                    Receiver read 46
Sender sending 11
                    Receiver read 63
Sender sending 89
Sender sending 21
                    Receiver read 11
Sender sending 99
                    Receiver read 89
Sender sending 79
Sender sending 41
                    Receiver read 21
Sender sending 17
                    Receiver read 99
Sender sending 92
                    Receiver read 79
Sender sending 89
                    Receiver read 41
Sender sending 52
                    Receiver read 17
Sender sending 60
                    Receiver read 92
Sender sending 25
                    Receiver read 89
Sender sending 82
Sender sending 60
                    Receiver read 52
Sender sending 13
Sender sending 34
                    Receiver read 60
Sender sending 10
                    Receiver read 25
Sender finished
                    Receiver read 82
                    Receiver read 60
                    Receiver read 13
                    Receiver read 34
                    Receiver read 10
                    Receiver finished
.... all finished ....

RMI-Client/Server mit Java (PR: 5A, 5B)

2011-03-16T13:08:00.001+01:00

Schreiben Sie eine Klasse Server, welche über RMI folgende Objekte bereitstellt:

rmi://localhost/Data (implementiert Interface DB)
rmi://localhost/Header (implementiert Interface Header)

localhost kann natürlich (theoretisch) jede beliebige IP-Adresse bzw. jeder beliebige Hostname sein, wenn unter dieser Adresse ein RMI-Server erreichbar ist.

Die zu öffnende Datei soll als Parameter der Kommandozeile angegeben werden. Aufruf:
java Server dateiname
Also z.B.:
java Server machines.db

Schreiben Sie weiters eine Klasse Client, welche über RMI die vom Server bereitgestellten Objekte verwendet, um einfache "Datenbank"-Zugriffe zu machen. Beim Aufruf soll über einen optionalen Kommandozeilenparameter die Adresse des Servers angegeben werden. Wird kein Parameter angegeben, so ist localhost zu verwenden. Aufruf:
java Client [hostaddress]
Also z.B.:
java Client
oder
java Client 127.0.0.1

Client soll einfach den Inhalt der Datenbank ausgeben (nur nicht gelöschte Datensätze). Die Spaltenüberschriften sind entsprechend der Informationen aus der Datei (über Header) ausgeben. Zeilen müssen gemäß der Feldlängen formatiert sein.

In weiterer Folge soll der Client eine Minute lang zufällige Datensätze auswählen und ausgeben (falls diese existieren). Zwischen zwei Zugriffen soll eine zufällige Zeit zwischen 1 und 5 Sekunden liegen (d.h. es werden mindestens 12 und höchstens 60 weitere Zeilen ausgegeben).

Binärdateien bearbeiten mit Java - Zusatz für Client (PR: 5A, 5B)

2011-03-16T13:08:00.000+01:00

Wie unter "Binärdateien bearbeiten mit Java (PR: 5A, 5B)" beschrieben, ist in der Binärdatei auch die Feldbeschreibung enthalten. An Server bzw. in der Klasse Data wird aber nur die Typ bzw. Längeninformation benötigt. Implementieren Sie das Interface Header (entweder eigene Klasse oder Klasse Data), um die nötigen Informationen für den Client, der ja die Daten darstellen soll, bereitzustellen.

package data;
/**
 * RuD-Übung 2011
 *
 * data.Header.java
 * @author (c) 2011, Harald R. Haberstroh
 * 16.3.2011
 */

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * @author Harald R. Haberstroh (hh)
 * 
 */
public interface Header extends Remote {
  /**
   * Liefert die Anzahl der Felder.
   *
   * @return Anzahl der Felder
   * @throws RemoteException
   */
  public int getNumFields() throws RemoteException;

  /**
   * Liefert den Feldnamen zur gegebenen Feldnummer
   * 
   * @param fieldNo
   *          Nummer Feldes.
   * @return Feldname
   * @throws RemoteException
   */
  public String getFieldName(int fieldNo) throws RemoteException;

  /**
   * Liefert die Beschreibung des Feldes zur gegebenen Feldnummer
   * 
   * @param fieldNo
   *          Nummer Feldes.
   * @return Feldbeschreibung
   * @throws RemoteException
   */
  public String getFieldDesc(int fieldNo) throws RemoteException;

  /**
   * Liefert den Typ des Feldes zur gegebenen Feldnummer.
   * 'F'...fix, 'V'...Variabel, 'C'...Zeichen
   * 
   * @param fieldNo
   *          Nummer Feldes.
   * @return Typ des Feldes ('F', 'V' oder 'C')
   * @throws RemoteException
   */
  public char getFieldType(int fieldNo) throws RemoteException;

  /**
   * Liefert die (maximale) Länge des Feldes zur gegebenen Feldnummer.
   * 
   * @param fieldNo
   *          Nummer Feldes.
   * @return (maximale) Feldlänge
   * @throws RemoteException
   */
  public int getFieldLen(int fieldNo) throws RemoteException;

}

Lösungen zu "Übungsbeispiele zu Sequenzen, Schleifen und Funktionen in Python" (POS1: 1B)

2011-03-10T08:37:00.001+01:00

Hier mögliche Lösungen zu der Aufgabe "Übungsbeispiele zu Sequenzen, Schleifen und Funktionen in Python (POS1: 1B)". Einige der Aufgaben enthalten Suchaufgaben. Die Funktionen dazu sind teilweise nicht "strukturiert" programmiert, das heißt, dass sie in diesen Fällen nicht nur ein return sondern mehrere Ausgänge haben. Um das zu verdeutlichen, beachten Sie folgendes Beispiel:

def isint(string):
    """prüft, ob der String eine ganze Zahl ist (Vorzeichen optional, 
    nur Ziffern).
    Prüfe nur Ziffernbereich."""
    if len(string) > 0:
        if string[0] == '+' or string[0] == '-':
            for c in string[1:]:
                if c < '0' or c > '9':
                    return False
        else:
            for c in string:
                if c < '0' or c > '9':
                    return False
    else:
        return False
    return True

Hier erfolgt ein return False aus den Schleifen über den String string, sobald ein Fehler gefunden wurde. Das vereinfacht den Algorithmus, widerspricht aber der strukturierten Programmierung, die bei Funkionen nur einen Ausgang erlaubt (bei Schleifen gilt das auch, die Schleife verlässt man nur durch die Schleifenbedingung, nicht durch break oder eben return). Beim Debuggen größerer Systeme ist es von Vorteil, wenn man sich darauf verlassen kann, dass jede Funktion nur einen Ausgang hat, denn man braucht dann nur diesen einen beobachten und nicht mehrere.
Bei obigem Beispiel müsste man while-Schleifen verwenden:

def isint(string):
    """prüft, ob der String eine ganze Zahl ist (Vorzeichen optional, 
    nur Ziffern).
    Prüfe nur Ziffernbereich."""
    ok = True
    if len(string) > 0:
        if string[0] == '+' or string[0] == '-':
            i = 1
            while ok and i < len(string):
                if string[i] < '0' or string[i] > '9':
                    ok = False
                i += 1
        else:
            i = 0
            while ok and i < len(string):
                if string[i] < '0' or string[i] > '9':
                    ok = False
                i += 1
    else:
        ok = False
    return ok

Diese Variante könne man noch "vereinfachen", weil sich die beiden Zweige mit oder ohne Vorzeichen nur im Startwert der Laufvariable i unterscheiden:

def isint(string):
    """prüft, ob der String eine ganze Zahl ist (Vorzeichen optional, 
    nur Ziffern).
    Prüfe nur Ziffernbereich."""
    ok = True
    if len(string) > 0:
        if string[0] == '+' or string[0] == '-':
            i = 1
        else:
            i = 0
        while ok and i < len(string):
            if string[i] < '0' or string[i] > '9':
                ok = False
            i += 1
    else:
        ok = False
    return ok

Die "nicht strukturierte" Variante ist aber bei weitem schneller entwickelt und durch die automatischen Tests ist auch sichergestellt, dass sie funktioniert.

Die Tests verwenden assert(), um die Ergebnisse mit den erwarteten Ergebnissen zu vergleichen. assert() bricht das Programm auf der Stelle ab, wenn die Bedingung nicht erfüllt ist. Dadurch hat man die Möglichkeit, den Fehler einzugrenzen. Passt die Bedingung, so läuft das Programm einfach weiter.

"""
author: Haberstroh, Harald
matnr:  d09666
file:   sequenzenbeispiele.py
desc:   Beispiele einfacher Funktionen mit Sequenzen (vgl. Programmierblog)
        Einige Funktionen bauen auf den anderen auf.
        
        Zu jeder Funktion (ausgenommen Hilfsfunktion) gibt es eine Testfunktion
        die die jeweilige Funktion mit Testwerten prüft.
        
        Die Funktion assert() prüft den Wahrheitswert des Parameters. Ist dieser
        True, so läuft das Programm einfach weiter. Ist er jedoch False, wird
        das Programm mit einer Fehlermeldung und Zeilennummer abgebrochen.
        Man kann dadurch feststellen, welcher Test nicht funktioniert hat.
date:   7.3.2011
class:  Lehrer
catnr:  33
"""
#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def isint(string):
    """prüft, ob der String eine ganze Zahl ist (Vorzeichen optional, 
    nur Ziffern).
    Prüfe nur Ziffernbereich."""
    if len(string) > 0:
        if string[0] == '+' or string[0] == '-':
            for c in string[1:]:
                if c < '0' or c > '9':
                    return False
        else:
            for c in string:
                if c < '0' or c > '9':
                    return False
    else:
        return False
    return True

def test_isint():
    assert(isint("") == False)
    assert(isint("a") == False)
    assert(isint("1a") == False)
    assert(isint("a1") == False)
    assert(isint("1+1") == False)
    assert(isint("1+") == False)
    assert(isint("1") == True)
    assert(isint("+1") == True)
    assert(isint("-1") == True)
    assert(isint("11212") == True)
    assert(isint("-11212") == True)
    assert(isint("+11212") == True)
    print("test_isint() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def isintb(string, basis):
    """prüft, ob der String eine ganze Zahl zur Basis basis ist (Vorzeichen
    optional, nur Ziffern).
    Baue String mit gültigen Zeichen zusammen und prüfe dann, ob jedes
    Zeichen in diesem String vorkommt."""
    if basis > 1:
        gueltig = "" # "Liste" der gültigen Zeichen für geg. Basis
        if basis > 10: # Ziffern und Buchstaben (immer groß und klein)
            for z in range(10):
                gueltig += chr(z + ord('0'))
            for z in range(basis - 10):
                gueltig += chr(z + ord('a')) # Kleinbuchstabe
                gueltig += chr(z + ord('A')) # Großbuchstabe
        else: # nur Ziffern
            for z in range(basis):
                gueltig += chr(z + ord('0'))
        if len(string) > 0:
            if string[0] == '+' or string[0] == '-': # Vorzeichen
                for c in string[1:]:
                    if c not in gueltig:
                        return False
            else:
                for c in string:
                    if c not in gueltig:
                        return False
        else:
            return False
    else:
        return False
    return True # alles OK

def test_isintb():
    assert(isintb("", 2) == False)
    assert(isintb("a", 2) == False)
    assert(isintb("1a", 2) == False)
    assert(isintb("a1", 2) == False)
    assert(isintb("1+1", 2) == False)
    assert(isintb("1+", 2) == False)
    assert(isintb("1", 2) == True)
    assert(isintb("+1", 2) == True)
    assert(isintb("-1", 2) == True)
    assert(isintb("11212", 2) == False)
    assert(isintb("-11212", 2) == False)
    assert(isintb("+11212", 2) == False)
    assert(isintb("11212", 3) == True)
    assert(isintb("-11212", 3) == True)
    assert(isintb("+11212", 3) == True)
    assert(isintb("aBCdeF", 16) == True)
    assert(isintb("-aBCdeF", 16) == True)
    assert(isintb("+aBCdeF", 16) == True)
    print("test_isintb() ok")
    
#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----

def sumdigits(zahl):
    """Berechnet die Ziffernsumme aus der gegebenen Zahl (int)"""
    sum = 0
    while zahl != 0:
        sum += zahl % 10 # Rest ist immer Einerstelle
        zahl = zahl // 10
    return sum

def test_sumdigits():
    assert(sumdigits(0) == 0)
    assert(sumdigits(1) == 1)
    assert(sumdigits(7) == 7)
    assert(sumdigits(10) == 1)
    assert(sumdigits(11) == 2)
    assert(sumdigits(123) == 6)
    assert(sumdigits(1010) == 2)
    print("test_sumdigits() ok")
    
#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def wert_der_ziffer(ziffer):
    """liefert den Wert der Ziffer ziffer (0..9, bzw. A, B, C, ...)"""
    if ord(ziffer) <= ord("9"):
        wert = ord(ziffer) - ord("0")
    else:
        wert = ord(ziffer) - ord("A") + 10
    return wert

def horner(zahl, basis):
    """berechnet Dezimalzahl aus zahl (String) zur Basis basis.
    liefert Zahl. Hornerschema!"""
    dez = 0
    for ziffer in zahl:
        dez *= basis
        dez += wert_der_ziffer(ziffer)
    return dez

def test_horner():
    assert(horner("", 10) == 0)
    assert(horner("1", 10) == 1)
    assert(horner("12", 10) == 12)
    assert(horner("123", 10) == 123)
    assert(horner("1", 2) == 1)
    assert(horner("10", 2) == 2)
    assert(horner("11", 2) == 3)
    assert(horner("4", 16) == 4)
    assert(horner("A", 16) == 10)
    assert(horner("10", 16) == 16)
    print("test_horner() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def isipv4(string):
    """Prüft, ob der gegebene String eine IPv4-Adresse enthält.
    IPv4-Adressen sind 4 Zahlen zwischen 0 und 255, die durch einen
    Punkt getrennt sind.
    Beispiele: 127.0.0.1, 193.170.149.129, 81.200.64.185
    Ungültige: 81.2010.64.185, 123.23.12, 127,0,0,1"""
    zahl = ""
    anzpunkte = 0
    anzziffer = 0
    for z in string:
        if '0' <= z <= '9': 
            zahl += z
            anzziffer += 1
        elif z == '.' and anzziffer > 0: # mindestens 1 Ziffer vor Zahl
            if not (0 <= horner(zahl, 10) <= 255):
                return False
            zahl = "" # neu beginnen
            anzziffer = 0
            anzpunkte += 1
        else:
            return False
    if anzpunkte == 3 and anzziffer > 0: # nach 3. Punkt eine Zahl!
        if not (0 <= horner(zahl, 10) <= 255):
            return False
        return True
    else:
        return False

def test_isipv4():
    assert(isipv4("127.0.0.1"))
    assert(isipv4("193.170.149.129"))
    assert(isipv4("81.200.64.185"))
    assert(not isipv4(""))
    assert(not isipv4("81.2010.64.185"))
    assert(not isipv4("123.23.12"))
    assert(not isipv4("123.23.12."))
    assert(not isipv4("123.23.12.3.3"))
    assert(not isipv4("123.23.12.3."))
    assert(not isipv4("127,0,0,1"))
    print("test_isipv4() ok")
    
#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def anz_zahlen(string):
    """ermittelt die Anzahl der ganzen Zahlen im String"""
    anzahl = 0
    in_zahl = False
    for zeichen in string:
        if zeichen in "0123456789":
            if not in_zahl:
                anzahl += 1
                in_zahl = True
        else:
            in_zahl = False
    return anzahl

def test_anz_zahlen():
    string = "das ist eine Zahl 123 und noch eine 1 und noch eine 3213x23123"
    assert(4 == anz_zahlen(string))
    assert(0 == anz_zahlen("keine"))
    assert(1 == anz_zahlen("eine Zahl 123"))
    assert(2 == anz_zahlen("zwei 23 und 324"))
    assert(3 == anz_zahlen("drei 23 34 22"))
    assert(4 == anz_zahlen("vier 234 234 234 45"))
    assert(5 == anz_zahlen("5 234 234 234 45"))
    print("test_anz_zahlen() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def sum_zahlen(string):
    """ermittelt die Summe der ganzen Zahlen im String. Eine Zahl
    ist eine ununterbrochene Folge von Ziffern.
    Beispiel: sum_zahlen("x 34 3 12k33 44 hallo 23") liefert 149"""
    summe = 0
    zahl = ""
    for zeichen in string:
        if zeichen in "0123456789":
            zahl += zeichen
        else:
            summe += horner(zahl, 10) # umrechnen und dazuzählen
            zahl = "" # neu beginnen
    if len(zahl) > 0: # zuletzt war Zahl, daher dazurechnen
        summe += horner(zahl, 10)
    return summe

def test_sum_zahlen():
    string = "das ist eine Zahl 123 und noch eine 1 und noch eine 3213x23123"
    assert(26460 == sum_zahlen(string))
    assert(0 == sum_zahlen("keine"))
    assert(123 == sum_zahlen("eine Zahl 123"))
    assert(347 == sum_zahlen("zwei 23 und 324"))
    assert(79 == sum_zahlen("drei 23 34 22"))
    assert(747 == sum_zahlen("vier 234 234 234 45"))
    assert(752 == sum_zahlen("5 234 234 234 45"))
    print("test_sum_zahlen() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def iskonto(string):
    """Prüft, ob der String eine gültige Kontonummer enthält. Dabei
    gelten folgende Regeln:
    1. genau 9 Ziffern (es dürfen Leerzeichen dazwischen sein
    2. die letzte Ziffer ist eine Prüfziffer und es gilt
       Die Kontonummer ist genau 9 Stellen lang und ist dann richtig, 
       wenn die folgendermaßen gebildete Summe auf Null endet:
       Ziffern mit ungeradem Index werden addiert(=Teilsumme1);
       Ziffern mit geradem Index werden verdoppelt und das jeweilige 
       Produkt addiert, wenn es einstellig ist, andernfalls wird die
       Quersumme des Produkts addiert(=Teilsumme2);
       Summe= teilsumme1 + Teilsumme2
    Beispiel:
       123456782 1+    3+    5+      7+     2  = 18 Teilsumme1
                   2*2+  4*2+  (1+2)+  (1+6)   = 22 Teilsumme2
                               6*2=12  8*2=16
                                               ------
                                                 40 Summe mod 10= Null
    Beispiele für Kontonummern:
       697199107 richtige Kontonummer
       723016689 richtige Kontonummer
       723016699 falsche Kontonummer
    """
    # entferne alle Leerzeichen (sind ja erlaubt)
    kontonummer = ""
    for c in string:
        if '0' <= c <= '9':
            kontonummer += c
        elif c != ' ':
            return False # nur Ziffern und Leerzeichen erlaubt!
    if len(kontonummer) != 9:
        return False
    
    summe = 0 # alles in einer Summe, aufteilen ist nicht nötig
    for i in range(len(kontonummer)):
        ziffer = ord(kontonummer[i]) - ord('0')
        if (1 + i) % 2 == 1: # ungerade
            summe += ziffer
        else: # gerade
            doppelt = ziffer * 2
            if doppelt >= 10: # Zwei Ziffern
                summe += doppelt % 10 # Einer
                summe += doppelt // 10 # Zehner
            else: # immer noch eine Ziffer
                summe += doppelt
    return summe % 10 == 0 # Summe muss durch 10 teilbar sein

def test_iskonto():
    assert(not iskonto(""))
    assert(not iskonto("a"))
    assert(not iskonto("69719a9107"))
    assert(not iskonto("69719917"))
    assert(not iskonto("723016699"))
    assert(iskonto("723016689"))
    assert(iskonto("697199107"))
    assert(iskonto("123456782"))
    assert(iskonto("12 345 6782"))
    print("test_iskonto() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def reverse_s(string):
    """liefert String in umgekehrter Reihenfolge zurück"""
    s = ""
    for c in string:
        s = c + s
    return s

def test_reverse_s():
    assert("" == reverse_s(""))
    assert("a" == reverse_s("a"))
    assert("ba" == reverse_s("ab"))
    assert("abc" == reverse_s("cba"))
    print("test_reverse() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def toupper(string):
    """liefert String in Großbuchstaben zurück"""
    s = ""
    for c in string:
        if 'a' <= c <= 'z':
            s += chr(ord(c) - ord('a') + ord('A'))
        elif c == 'ä':
            s += 'Ä'
        elif c == 'ö':
            s += 'Ö'
        elif c == 'ü':
            s += 'Ü'
        else:
            s += c
    return s

def test_toupper():
    assert("" == toupper(""))
    assert("A" == toupper("a"))
    assert("AB" == toupper("ab"))
    assert("ÄBC" == toupper("äbc"))
    assert("A" == toupper("a"))
    assert("AB" == toupper("Ab"))
    assert("ÄBC" == toupper("äBc"))
    print("test_toupper() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def tolower(string):
    """liefert String in Kleinbuchstaben zurück"""
    pass
    s = ""
    for c in string:
        if 'A' <= c <= 'Z':
            s += chr(ord(c) - ord('A') + ord('a'))
        elif c == 'Ä':
            s += 'ä'
        elif c == 'Ö':
            s += 'ö'
        elif c == 'Ü':
            s += 'ü'
        else:
            s += c
    return s

def test_tolower():
    assert("" == tolower(""))
    assert("a" == tolower("A"))
    assert("ab" == tolower("AB"))
    assert("äbc" == tolower("ÄBC"))
    assert("a" == tolower("A"))
    assert("ab" == tolower("Ab"))
    assert("äbc" == tolower("äBc"))
    print("test_tolower() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def isupper(string):
    """prüft, ob String nur Großbuchstaben enthält"""
    for c in string:
        if 'a' <= c <= 'z' or c in "äöü": # ein Kleinbuchstabe
            return False
    return True

def test_isupper():
    assert(isupper(""))
    assert(isupper("A"))
    assert(isupper("AEÄÖ"))
    assert(not isupper("a"))
    assert(not isupper("abcö"))
    assert(not isupper("AbC"))
    print("test_isupper() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def islower(string):
    """prüft, ob String nur Kleinbuchstaben enthält"""
    for c in string:
        if 'A' <= c <= 'Z' or c in "ÄÖÜ": # ein Großbuchstab
            return False
    return True

def test_islower():
    assert(islower(""))
    assert(islower("a"))
    assert(islower("aeöä"))
    assert(not islower("A"))
    assert(not islower("ABCÖ"))
    assert(not islower("AbC"))
    print("test_islower() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def ispalindrom(string):
    """Prüft, ob der String ein Palindrom ist (von vorne und hinten
    gelesen gleich)."""
    for i in range(len(string)):
        if string[i] != string[-1 - i]:
            return False
    return True

def test_ispalindrom():
    assert(ispalindrom(""))
    assert(ispalindrom("a"))
    assert(ispalindrom("aa"))
    assert(ispalindrom("aba"))
    assert(ispalindrom("abba"))
    assert(not ispalindrom("ab"))
    assert(not ispalindrom("abb"))
    assert(not ispalindrom("abab"))
    print("test_ispalindrom() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def ispalindrom_l(liste):
    """Prüft, ob die Liste von vorne und hinten gelesen gleich ist."""
    return ispalindrom(liste) # sollte äquivalent sein!

def test_ispalindrom_l():
    assert(ispalindrom_l([]))
    assert(ispalindrom_l([1]))
    assert(ispalindrom_l([1, 1]))
    assert(ispalindrom_l([1, 2, 1]))
    assert(ispalindrom_l([1, 2, 2, 1]))
    assert(not ispalindrom_l([1, 2]))
    assert(not ispalindrom_l([1, 2, 2]))
    assert(not ispalindrom_l([1, 2, 1, 2]))
    print("test_ispalindrom_l() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def reverse_l(liste):
    """liefert die Liste in umgekehrter Reihenfolge zurück"""
    l = []
    for e in liste:
        l = [e] + l
    return l

def test_reverse_l():
    assert([] == reverse_l([]))
    assert([1] == reverse_l([1]))
    assert([1, 2] == reverse_l([2, 1]))
    assert([1, 2, 3] == reverse_l([3, 2, 1]))
    print("test_reverse_l() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def sum(liste):
    """liefert die Summe aller Zahlen in der Liste"""
    summe = 0
    for e in liste:
        summe += e
    return summe

def test_sum():
    assert(0 == sum([]))
    assert(12 == sum([12]))
    assert(12 == sum([4, 8]))
    assert(12 == sum([4, 4, 4]))
    print("test_sum() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def mittelwert(liste):
    """liefert den Mittelwert (Durchschnitt) aller Zahlen in der Liste"""
    if len(liste) > 0:
        return sum(liste) / len(liste)
    else:
        return 0

def test_mittelwert():
    assert(0 == mittelwert([]))
    assert(1 == mittelwert([1]))
    assert(1.5 == mittelwert([1, 2]))
    assert(2 == mittelwert([2, 2, 2]))
    assert(2 == mittelwert([1, 2, 3]))    
    print("test_mittelwert() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def rmdups(liste):
    """(ReMove DUPlicates) liefert Liste, aus der alle Vielfachen entfernt
    (hintereinander).
    Beispiele: [1, 2, 2, 2, 5, 2, 3, 2, 2, 23] -> [1, 2, 5, 2, 3, 2, 23]
               [99, 99, 23, 99, 99, 12, 2] -> [99, 23, 99, 12, 2]
               [] -> []
               [1, 2, 4, 10] -> [1, 2, 4, 10]"""
    if len(liste) > 0:
        ret = [liste[0]]
        for e in liste:
            if ret[-1] != e: # letztes Element ungleich?
                ret.append(e)
        return ret
    else:
        return liste

def test_rmdups():
    assert([1, 2, 5, 2, 3, 2, 23] == rmdups([1, 2, 2, 2, 5, 2, 3, 2, 2, 23]))
    assert([99, 23, 99, 12, 2] == rmdups([99, 99, 23, 99, 99, 12, 2]))
    assert([] == rmdups([]))
    assert([1, 2, 4, 10] == rmdups([1, 2, 4, 10]))
    print("test_rmdups() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def isin(item, liste):
    """ist item in liste enthalten?"""
    for e in liste:
        if item == e:
            return True
    return False

def rmalldups(liste):
    """(ReMove ALL DUPlicates) liefert Liste, aus der alle Vielfachen
    entfernt (müssen nicht hintereinander stehen).
    Beispiele: [1, 2, 2, 2, 5, 2, 3, 2, 2, 23] -> [1, 2, 5, 3, 23]
               [99, 99, 23, 99, 99, 12, 2] -> [99, 23, 12, 2]
               [] -> []
               [1, 2, 4, 10] -> [1, 2, 4, 10]"""
    if len(liste) > 0:
        ret = [liste[0]]
        for e in liste:
#            if e not in ret: # schon vorhanden?
            if not isin(e, ret):
                ret.append(e)
        return ret
    else:
        return liste

def test_rmalldups():
    assert([] == rmalldups([]))
    assert([1, 2, 5, 3, 23] == rmalldups([1, 2, 2, 2, 5, 2, 3, 2, 2, 23]))
    assert([99, 23, 12, 2] == rmalldups([99, 99, 23, 99, 99, 12, 2]))
    assert([1, 2, 4, 10] == rmalldups([1, 2, 4, 10]))
    print("test_rmalldups() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def binsearch(liste, such):
    """liefert den Index von such in der sortierten Liste liste oder -1,
    wenn such in liste nicht vorkommt. Es ist die binäre Suche anzuwenden!
    """
    first = 0
    last = len(liste) - 1
    mid = (last - first) // 2 + first
    #print(first, mid, last)
    while len(liste) > 0 and first <= last:
        if such < liste[mid]:
            last =  mid - 1
        elif such > liste[mid]:
            first = mid + 1
        else:
            return mid #index found
        mid = (last - first) // 2 + first
        #print(first, mid, last)
    return -1 # not found

def test_binsearch():
    """static tests"""
    assert(binsearch([], 1) == -1)
    assert(binsearch([1], 2) == -1)
    assert(binsearch([1], 0) == -1)
    assert(binsearch([1], 1) == 0)
    assert(binsearch([1,3], 0) == -1)
    assert(binsearch([1,3], 2) == -1)
    assert(binsearch([1,3], 1) == 0)
    assert(binsearch([1,3], 3) == 1)
    assert(binsearch([1,3], 4) == -1)
    assert(binsearch([1,3,5], 2) == -1)
    assert(binsearch([1,3,5], 4) == -1)
    assert(binsearch([1,3,5], 1) == 0)
    assert(binsearch([1,3,5], 3) == 1)
    assert(binsearch([1,3,5], 5) == 2)
    assert(binsearch([1,3,5], 6) == -1)
    assert(binsearch([1,3,5,7], 0) == -1)
    assert(binsearch([1,3,5,7], 1) == 0)
    assert(binsearch([1,3,5,7], 3) == 1)
    assert(binsearch([1,3,5,7], 5) == 2)
    assert(binsearch([1,3,5,7], 7) == 3)
    assert(binsearch([1,3,5,7], 9) == -1)
    assert(binsearch([1,3,5,7], 2) == -1)
    assert(binsearch([1,3,5,7], 4) == -1)
    assert(binsearch([1,3,5,7], 6) == -1)
    import random
    for i in range(25):
        liste = [random.randint(0, 100) for i in range(100)]
        liste.sort()
        num = random.randint(0, 100)
        if num in liste:
            if binsearch(liste, num) < 0:
                print(liste)
                print("%d should be found in list" % num)
                assert(binsearch(liste, num) >= 0)
        else:
            if binsearch(liste, num) >= 0:
                print(liste)
                print("%d should not be found in list" % num)
                assert(binsearch(liste, num) < 0)
    print("test_binsearch() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def sumteilbar(liste, teiler):
    """Berechnet die Summe aller durch teiler teilbaren Zahlen der Liste"""
    summe = 0
    for e in liste:
        if e % teiler == 0:
            summe += e
    return summe

def test_sumteilbar():
    assert(0 == sumteilbar([], 2))
    assert(0 == sumteilbar([1], 2))
    assert(0 == sumteilbar([1, 3], 2))
    assert(0 == sumteilbar([1, 3, 23], 2))
    assert(2 == sumteilbar([2], 2))
    assert(2 == sumteilbar([1, 2], 2))
    assert(2 == sumteilbar([1, 2, 23], 2))
    assert(32 == sumteilbar([1, 8, 24], 2))
    assert(27 == sumteilbar([3, 8, 24], 3))
    print("test_sumteilbar() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def issorted(liste):
    """Prüft, ob die Liste sortiert ist, d.h. ob e1 <= e2 <= e3 <= ... <= en
    e1, e2, ... en sind die n Elemente der Liste mit Länge n"""
    for i in range(len(liste) - 1):
        if liste[i] > liste[i + 1]:
            return False
    return True

def test_issorted():
    assert(issorted([]))
    assert(issorted([1]))
    assert(issorted([1, 1]))
    assert(issorted([1, 3, 3, 4]))
    assert(not issorted([1, 0]))
    assert(not issorted([1, 2, 1]))
    print("test_issorted() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def printlxl(liste1, liste2):
    """gibt eine Multiplikationstabelle der beiden Listen aus.
    Zum Beispiel:
       a = [1, 2, 4, 5]
       b = [3, 2, 2]
       printlxl(a, b) gibt dann folgendes aus:
         3   2   2 
         6   4   4 
        12   8   8 
        15  10  10 
    Die erste Liste bestimmt die Anzahl der Zeilen, die zweite die Anzahl 
    der Spalten. Es wird immer ein Element der ersten Liste mit einem der
    zweiten Liste multipliziert.
    """
    erg = lxl(liste1, liste2)
    for zeile in erg:
        for spalte in zeile:
            print("%4d" % spalte, end = "")
        print()

def test_printlxl():
    a = [1, 2, 4, 5]
    b = [3, 2, 2]
    printlxl(a, b)
    print("test_printlxl() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
def lxl(liste1, liste2):
    """liefert eine Multiplikationstabelle der beiden Listen (Liste von 
    Listen).
    Zum Beispiel:
       a = [1, 2, 4, 5]
       b = [3, 2, 2]
       lxl(a, b) liefert folgende Liste zurück:
       [[3, 2, 2], [6, 4, 4], [12, 8, 8], [15, 10, 10]]
       übersichtlich formatiert:
       [[3, 2, 2], 
        [6, 4, 4], 
        [12, 8, 8], 
        [15, 10, 10]]
    Die erste Liste bestimmt die Anzahl der "Zeilen", die zweite die Anzahl 
    der "Spalten". Es wird immer ein Element der ersten Liste mit einem der
    zweiten Liste multipliziert.
    """
    erg = []
    if len(liste2) > 0:
        for a in liste1:
            zeile = []
            for b in liste2:
                zeile.append(a * b)
            erg.append(zeile)
    return erg

def test_1x1():
    a = [1, 2, 4, 5]
    b = [3, 2, 2]
    assert([[3, 2, 2], [6, 4, 4], [12, 8, 8], [15, 10, 10]] == lxl(a, b))
    assert([] == lxl([], []))
    assert([] == lxl([], [1, 2]))
    assert([] == lxl([1, 2], []))
    print("test_1x1() ok")

#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----
# Testaufrufe:
test_isint()
test_isintb()
test_sumdigits()
test_horner()
test_isipv4()
test_anz_zahlen()
test_sum_zahlen()
test_iskonto()
test_reverse_s()
test_toupper()
test_tolower()
test_isupper()
test_islower()
test_ispalindrom()
test_ispalindrom_l()
test_reverse_l()
test_sum()
test_mittelwert()
test_rmdups()
test_rmalldups()
test_binsearch()
test_sumteilbar()
test_issorted()
test_printlxl()
test_1x1()

Die Funktionen isupper() und islower() sind eigentlich nicht korrekt, denn liefert z.B. isupper("A4C") True. Man müsste also eher schreiben:

def isupper(string):
    """prüft, ob String nur Großbuchstaben enthält"""
    for c in string:
        if not ('A' <= c <= 'Z' or c in "ÄÖÜ"):
            return False
    return True

Übungsbeispiele zu Sequenzen, Schleifen und Funktionen in Python (POS1: 1B)

2011-03-06T21:34:00.001+01:00

Hier finden Sie eine Reihe von Aufgabenstellungen als Übung zur nächsten praktischen Arbeit.
Gegeben sind minimale Funktionsrümpfe mit der Aufgabenstellung als DocString.

Die Funktionen sind ohne Standardmethoden bzw. Funktionen zu implementieren (ausgenommen die Funktion len()). Sollte es eine Standardfunktion zur Lösung der Aufgabe geben, verwenden Sie diese, um das Ergebnis zu prüfen. Bereiche ([von:bis]) dürfen verwendet werden, sofern sie benötigt werden.

def isint(string)
    """prüft, ob der String eine ganze Zahl ist (Vorzeichen optional, 
    nur Ziffern)"""
    pass

def isintb(string, basis)
    """prüft, ob der String eine ganze Zahl zur Basis basis ist (Vorzeichen
    optional, nur Ziffern)"""
    pass

def isnum(string)
    """prüft, ob der String eine Zahl ist (Vorzeichen optional, Ziffern und
    Komma)"""
    pass

def horner(zahl, basis):
    """berechnet Dezimalzahl aus zahl (String) zur Basis basis.
    liefert Zahl."""
    pass

def sumdigits(zahl):
    """Berechnet die Ziffernsumme aus der gegebenen Zahl (int)"""
    pass

def sumdigits_s(string):
    """Berechnet die Ziffernsumme aus der gegebenen Zahl (str), wenn
    es überhaupt eine Zahl ist. Liefert -1, wenn keine gültige Zahl"""
    pass

def isipv4(string):
    """Prüft, ob der gegebene String eine IPv4-Adresse enthält.
    IPv4-Adressen sind 4 Zahlen zwischen 0 und 255, die durch einen
    Punkt getrennt sind.
    Beispiele: 127.0.0.1, 193.170.149.129, 81.200.64.185
    Ungültige: 81.2010.64.185, 123.23.12, 127,0,0,1"""
    pass

def anz_vokale(string):
    """Zähle die Selbstlaute im String und liefere Anzahl zurück"""
    pass

def anz_zahlen(string):
    """ermittelt die Anzahl der ganzen Zahlen im String. Eine Zahl
    ist eine ununterbrochene Folge von Ziffern.
    Beispiel: anz_zahlen("x 34 3 12k33 44 hallo 23") liefert 6"""
    pass

def sum_zahlen(string):
    """ermittelt die Summe der ganzen Zahlen im String. Eine Zahl
    ist eine ununterbrochene Folge von Ziffern.
    Beispiel: anz_zahlen("x 34 3 12k33 44 hallo 23") liefert 149"""
    pass

def iskonto(string):
    """Prüft, ob der String eine gültige Kontonummer enthält. Dabei
    gelten folgende Regeln:
    1. genau 9 Ziffern (es dürfen Leerzeichen dazwischen sein
    2. die letzte Ziffer ist eine Prüfziffer und es gilt
       Die Kontonummer ist genau 9 Stellen lang und ist dann richtig, 
       wenn die folgendermaßen gebildete Summe auf Null endet:
       Ziffern mit ungeradem Index werden addiert(=Teilsumme1);
       Ziffern mit geradem Index werden verdoppelt und das jeweilige 
       Produkt addiert, wenn es einstellig ist, andernfalls wird die
       Quersumme des Produkts addiert(=Teilsumme2);
       Summe= teilsumme1 + Teilsumme2
    Beispiel:
       123456782 1+    3+    5+      7+     2  = 18 Teilsumme1
                   2*2+  4*2+  (1+2)+  (1+6)   = 22 Teilsumme2
                               6*2=12  8*2=16
                                               ------
                                                 40 Summe mod 10= Null
    Beispiele für Kontonummern:
       697199107 richtige Kontonummer
       723016699 falsche Kontonummer
    """
    pass

def reverse_s(string):
    """liefert String in umgekehrter Reihenfolge zurück"""
    pass

def toupper(string):
    """liefert String in Großbuchstaben zurück"""
    pass

def tolower(string):
    """liefert String in Kleinbuchstaben zurück"""
    pass

def isupper(string):
    """prüft, ob String nur Großbuchstaben enthält"""
    pass

def islower(string):
    """prüft, ob String nur Kleinbuchstaben enthält"""
    pass

def ispalindrom(string):
    """Prüft, ob der String ein Palindrom ist (von vorne und hinten
    gelesen gleich)."""
    pass

def ispalindrom_l(liste):
    """Prüft, ob die Liste von vorne und hinten gelesen gleich ist."""
    pass

def reverse_l(liste):
    """liefert die Liste in umgekehrter Reihenfolge zurück"""
    pass

def sum(liste):
    """liefert die Summe aller Zahlen in der Liste"""
    pass

def mittelwert(liste):
    """liefert den Mittelwert (Durchschnitt) aller Zahlen in der Liste"""
    pass

def rmdups(liste):
    """(ReMove DUPlicates) liefert Liste, aus der alle Vielfachen entfernt
    (hintereinander).
    Beispiele: [1, 2, 2, 2, 5, 2, 3, 2, 2, 23] -> [1, 2, 5, 2, 3, 2, 23]
               [99, 99, 23, 99, 99, 12, 2] -> [99, 23, 99, 12, 2]
               [] -> []
               [1, 2, 4, 10] -> [1, 2, 4, 10]"""
    pass

def rmalldups(liste):
    """(ReMove ALL DUPlicates) liefert Liste, aus der alle Vielfachen
    entfernt (müssen nicht hintereinander stehen).
    Beispiele: [1, 2, 2, 2, 5, 2, 3, 2, 2, 23] -> [1, 2, 5, 3, 23]
               [99, 99, 23, 99, 99, 12, 2] -> [99, 23, 12, 2]
               [] -> []
               [1, 2, 4, 10] -> [1, 2, 4, 10]"""
    pass

def binsearch(liste, such):
    """liefert den Index von such in der sortierten Liste liste oder -1,
    wenn such in liste nicht vorkommt. Es ist die binäre Suche anzuwenden!
    """
    pass

def sumdigits(zahl):
    """Berechnet die Ziffernsumme aus der gegebenen Zahl (int)"""
    pass

def sumteilbar(liste, teiler):
    """Berechnet die Summe aller durch teiler teilbaren Zahlen der Liste"""
    pass

def issorted(liste):
    """Prüft, ob die Liste sortiert ist, d.h. ob e1 <= e2 <= e3 <= ... <= en
    e1, e2, ... en sind die n Elemente der Liste mit Länge n"""
    pass

def printlxl(liste1, liste2):
    """gibt eine Multiplikationstabelle der beiden Listen aus.
    Zum Beispiel:
       a = [1, 2, 4, 5]
       b = [3, 2, 2]
       printlxl(a, b) gibt dann folgendes aus:
         3   2   2 
         6   4   4 
        12   8   8 
        15  10  10 
    Die erste Liste bestimmt die Anzahl der Zeilen, die zweite die Anzahl 
    der Spalten. Es wird immer ein Element der ersten Liste mit einem der
    zweiten Liste multipliziert.
    """
    pass

def lxl(liste1, liste2):
    """liefert eine Multiplikationstabelle der beiden Listen (Liste von 
    Listen).
    Zum Beispiel:
       a = [1, 2, 4, 5]
       b = [3, 2, 2]
       lxl(a, b) liefert folgende Liste zurück:
       [[3, 2, 2], [6, 4, 4], [12, 8, 8], [15, 10, 10]]
       übersichtlich formatiert:
       [[3, 2, 2], 
        [6, 4, 4], 
        [12, 8, 8], 
        [15, 10, 10]]
    Die erste Liste bestimmt die Anzahl der "Zeilen", die zweite die Anzahl 
    der "Spalten". Es wird immer ein Element der ersten Liste mit einem der
    zweiten Liste multipliziert.
    """
    pass

Schreiben Sie zu den Funktionen jeweils passende Testprogramme.

SAR (ROB: 2C)

2011-03-04T14:14:00.000+01:00

SAR steht normalerweise für "Search and Rescue" - hier soll es "Search and Remove" heißen.
Ein Roboter soll in einem hellen rechteckigen Feld, das mit einer schwarzen Linie umgeben ist, einen Klotz finden und auf einer dunklen (schwarzen) Fläche in einem der Ecken abstellen. Das Feld sieht etwa so aus:

Finden Sie eine geeignete Strategie, den Klotz aufzuspüren.
Wie kann der Klotz transportiert werden?
Wie findet man die markierte Ecke (Fläche) zum Ablegen?

Java Übungen und Aufgabe (POS1: 2A, 2C)

2011-03-04T10:26:00.000+01:00

Klassen, Objekte

Erzeugen Sie eine Klasse SomeMaths, welche eine statische Konstante PI enthält sowie eine statische Methode double getSquare(double x), welche das Quadrat von x liefert.

Erstellen Sie weiters eine Klasse Circle, welche eine Kreis simuliert. Circle hat ein Attribut radius sowie die Methoden getCircumference(), welche den Umfang liefert, und getArea(), welche die Fläche berechnet. Die Methoden sollen sich der Konstante PI und der Methode getSquare() von SomeMaths bedienen.
Eine dritte Klasse CircleExercise soll im main() drei Kreise vom Typ Circle erzeugen und jeweils den Radius, den Umfang und die Fläche ausgeben.
Das UML-Diagramm sieht etwa so aus:

Arrays

Erzeugen Sie eine Klasse DreieckArray, welche ein privates zweidimensionales Array feld für Integers enthält. Dieses Feld soll "dreieckig" sein und mit folgenden Werten initialisiert werden:

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

Die Methoden sind public und sollen folgendes tun:

void create(int zeilen, int spalten) soll ein neues Feld mit den gegebenen Zeilen und Spalten erzeugen (rechteckig).

int[][] getArray() soll das Feld zurückliefern.

int[] summen() soll ein eindimensionales Feld mit den Zeilensummen liefern.

boolean set(int zeile, int spalte, int wert) soll den Wert an der gegebenen Stelle im Feld feld setzen und bei erfolg true zurückliefern. Bei ungültigen Indizes soll false zurückgeliefert werden.

Schreiben Sie eine Klasse TestDreieckArray, in der zwei Objekte von DreieckArray in der Methode main() angelegt werden. Machen Sie zum Testen passende Aufrufe der Methoden (z.B. gültige und ungültige set() usw.).

Streams, Strings

Schreiben Sie eine Klasse ReadFile, welche eine eine auf der Kommandozeile angegebene Datei öffnet und in einen String einliest. Verwenden Sie dazu drei Methoden String liesString(InputStream fileInputStream), String liesStringBuffer(InputStream fileInputStream) und String liesStringBuilder(InputStream fileInputStream) und messen Sie die Zeiten, die mit den einzelnen Methoden benötigt werden um die Datei zu lesen.
Von der Datei soll jeweils mit read() ein Zeichen gelesen werden. Die Methode liesString() hängt das gelesene Zeichen jeweils an einen String an, die Methode liesStringBuffer() verwendet einen StringBuffer und liesStringBuilder() verwendet einen StringBuilder. Das gelesene Zeichen wird dann immer mit append() an den StringBuffer bzw. StringBuilder angehängt.
Testen Sie mit unterschiedlich großen Dateien (kleine, mittlere, große, ganz große). Sie werden unterschiedliche Zeiten messen bei den verschiedenen Methoden. Erklären Sie die Unterschiede!
Verwenden Sie System.currentTimeMillis() (liefert long), um die aktuelle Zeit in ms zu erhalten.

Random, Calendar, Kommandozeile, Streams

Es sollen Testdaten der Form

Datum Von-Zeit Bis-Zeit
Datum Von-Zeit Bis-Zeit
...

erzeugt werden. Wobei ein Datum die Form JJJJ-MM-TT und Von-Zeit und Bis-Zeit die Form HH:MM haben soll. Weiters sollen folgende Bedingungen erfüllt sein:

Verwenden Sie java.util.Random um die Testdaten zu bekommen.
Bis-Zeit soll immer nach Von-Zeit kommen (also später)
Eine Zeile mit Datum, Von-Zeit und Bis-Zeit soll immer nach jenem Zeitbereich der vorhergehenden Zeile kommen (die Zeiten sind also sortiert).
Zwischen zwei Zeilen sollen nicht mehr als 36 Stunden liegen (Bis-Zeit bis Von-Zeit)

Beispiel:

2011-03-04 10:24 10:45
2011-03-04 11:33 12:56
2011-03-05 12:33 17:23

Das Programm soll folgendermaßen aufgerufen werden:

java CalenderTest [-h] [startdatum] [startzeit] [datei] anzahl
   -h         ... Ausgabe dieser Hilfe und Ende
   startdatum ... JJJJ-MM-TT (optional)
   startzeit  ... HH:MM (optional)
   datei      ... Name der Ausgabedatei (optional)
   anzahl     ... Anzahl der zu erzeugenden Zeilen

Wird kein startdatum angegeben, so ist der heutige Tag als Startwert zu verwenden.
Wird kein startzeit angegeben, so ist die aktuelle Uhrzeit als Startwert zu verwenden. Diese Startwerte sind in der ersten Ausgabezeile zu sehen.
Wenn kein Dateiname datei angegeben, so ist die Standardausgabe zu verwenden.
Die Anzahl der zu erzeugenden Zeilen muss mindestens 1 sein!

Fehlermeldungen sind auf System.err auszugeben.

Nennen Sie das Projekt calendertest (klasse-name-calendertest).

Prüfen Sie Ihr Wissen (POS1: 2A, 2C)

2011-03-02T14:43:00.000+01:00

Sie finden an dieser Stelle eine Reihe von Fragen und Aufgaben, die Sie etwa Mitte des zweiten Jahrgangs Informatik beantworten bzw. lösen können sollten.

Theorie

Was ist ein Dictionary in Python?
Was bedeutet der Begriff "Sequenz" in Python? Geben Sie einige Beispiele.
Wie wird eine Funktion in Python definiert?
Welche Arten der Parameterübergabe gibt es in Python?
Wie kann eine Python-Funktion mehr als einen Wert (Parameter) ändern bzw. zurückliefern?
Geben Sie ein Beispiel für eine kürzest mögliche Funktion in Python an!
Was ist eine Variable?
Was versteht man unter "Duck Typing"?
Wie werden in Python for-Schleifen gebildet?
Was ist ein Python-Modul? Wofür werden Module verwendet?
Wie kann eine (Text-)Datei gelesen werden?
Wie kann man in Python Kommandozeilenparameter auswerten?
Welche Grunddatentypen kennen Sie? Geben Sie auch den Speicherbedarf und den Wertebereich an.
Was versteht man unter den Eigenschaften eines Objekts? Wie spiegelt sich das in einer Klasse wieder?
Welche Kontrollstrukturen kennen Sie?
Was ist ein Array?
Geben Sie ein Beispiel eines eindimensionalen Arrays in Java an.
Wie kann man ein eindimensionales Array in Java initialisieren?
Geben Sie ein Beispiel eines zweidimensionalen Arrays in Java an.
Wie kann man ein zweidimensionales Array in Java initialisieren?
Kann man in Java ein zweidimensionales Array definieren, welches "nicht rechteckig" (rechteckig bedeutet hier: alle Zeilen gleich lang) ist?
Geben Sie einen Algorithmus (ohne Programmdetails) an, um alle Elemente eines eindimensionalen Arrays zu ermitteln, die ein bestimmtes Kriterium (z.B. ist größer als ein bestimmter Wert) erfüllen.
Geben Sie einen Algorithmus (ohne Programmdetails) an, um alle Elemente eines zweidimensionalen Arrays zu ermitteln, die ein bestimmtes Kriterium erfüllen.
Geben Sie einen Algorithmus (ohne Programmdetails) an, um das Maximum aller Werte eines eindimensionalen Arrays zu ermitteln.
Geben Sie einen Algorithmus (ohne Programmdetails) an, um das Minimum aller Werte eines eindimensionalen Arrays zu ermitteln.
Geben Sie einen Algorithmus (ohne Programmdetails) an, um das Maximum aller Werte eines zweidimensionalen Arrays zu ermitteln.
Geben Sie einen Algorithmus (ohne Programmdetails) an, um das Minimum aller Werte eines zweidimensionalen Arrays zu ermitteln.
Was ist eine Funktion? Geben Sie ein Beispiel in Java inklusive der Verwendung der Funktion.
Was ist eine Methode? Geben Sie ein Beispiel in Java inklusive der Verwendung der Funktion.
Was ist der Unterschied zwischen einer Variable eines Grunddatentyps und einer Variable vom Typ einer Klasse?
Was ist eine Klasse?
Was ist ein Objekt? Erklären Sie den Zusammenhang zwischen Objekt und Klasse.
Was sind Strings?
Wie kann man Strings vergleichen?
Wozu benötigt man Kommentare?
Wozu benötigt man Programmierrichtlinien?
Vergleichen Sie Java mit Python.
Woran soll Sie die Geschichte "Shlemiel the Painter" erinnern?
Was muss grundsätzlich (ohne Programmdetails) gemacht werden, um von einer Datei zu lesen?
Was muss grundsätzlich (ohne Programmdetails) gemacht werden, um in eine Datei zu schreiben?
Geben Sie einen Algorithmus (ohne Programmdetails) an, um alle Zeilen einer Textdatei zu ermitteln, die ein bestimmtes Kriterium (z.B. enthält einen bestimmten String) erfüllen.
Welche Arten von Programm(ier)fehlern kennen Sie? Wie findet man diese Fehler?
Wieviele main()-Methoden muss eine Java-Klasse besitzen?
Wieviele main()-Methoden kann eine Java-Klasse maximal haben?
Wieviele Klassen können in einer einzelnen Java-Datei implementiert werden?
Welchen Wert hat die Variable einInteger? Begründen Sie Ihre Antwort!
```
int einInteger = Integer.MAX_VALUE + 1;
```
Was versteht man unter impliziter bzw. expliziter Typumwandlung? Nennen Sie jeweils mindestens ein Beispiel.

Praxis:
In diesem Blog und auch im alten Blog gibt es bereits eine Reihe von Aufgaben. Vergleichen Sie Ihre Lösungen mit jenen Ihrer MitschülerInnen.
Hier noch ein paar "Grundübungen":

Erstellen Sie ein Pythonprogramm, welches das Maximum einer Sequenz ermittelt. Definieren Sie dazu eine fixe Testsequenz mit folgenden Werten [-1, -23, -2, -32,-89, -100, -1, -99]. Finden Sie weitere Beispieltestdaten.
Erstellen Sie ein Pythonprogramm, welches das Minimum einer Sequenz ermittelt. Definieren Sie dazu eine fixe Testsequenz mit folgenden Werten [1, 23, 2, 32, 89,100, 1, 99]. Finden Sie weitere Beispieltestdaten.
Erstellen Sie ein Javaprogramm, welches das Maximum einer Sequenz ermittelt. Definieren Sie dazu eine fixe Testsequenz mit folgenden Werten [-1, -23, -2, -32,-89, -100, -1, -99]. Finden Sie weitere Beispieltestdaten.
Erstellen Sie ein Javaprogramm, welches das Minimum einer Sequenz ermittelt. Definieren Sie dazu eine fixe Testsequenz mit folgenden Werten [1, 23, 2, 32, 89,100, 1, 99]. Finden Sie weitere Beispieltestdaten.
Erstellen Sie ein Pythonprogramm, welches die Häufigkeit von Elementen einer Sequenz (Liste) ermittelt. Definieren Sie dazu eine Testsequenz mit folgenden Werten [1, 2,-3, 4, 2, 1, 10, -3, 4, 2, 2, 10] bzw. ["hallo", "du", "test", "du","Maus", "test", "Test"]. Das Ergebnis soll eine Liste von unterschiedlichen Werten sein und wie oft sie vorkommen.

Betrachten Sie die Methode dividiere im folgenden Programm. lässt sich das Programm übersetzen? Falls nicht, dann korrigieren Sie die Fehler:

public class DivisionApp {
  public static void main(String[] args) {
    int ergebnis = dividiere(40, 5);
    System.out.println("Ergebnis: " + ergebnis);
  }

  public static int dividiere(int divident, int divisor) {
    if (divisor > 0) {
      return divident / divisor;
    }
  }
}

Folgende Ausgabe soll erzeugt werden: 1 3 5 7 9. Lösen Sie die Aufgabe
- mithilfe einer while-Schleife
- mithilfe einer do-while-Schleife
- mithilfe einer for-Schleife und des Modulo-Operators
- mithilfe einer for-Schleife ohne den Modulo-Operator
Folgende Ausgabe soll erzeugt werden: 1 2 4 7 11 16 22 29 37. Lösen Sie die Aufgabe
- mithilfe einer do-while-Schleife
- mithilfe einer for-Schleife
Schreiben Sie ein Java-Programm, welches mithilfe eines Stacks folgende Werte in umgekehrter Reihenfolge ausgibt: 23 21 20 18 17 13 11 5 3
Schreiben Sie ein Java-Programm, welches mithilfe einer Queue folgende Werte in derselben Reihenfolge ausgibt: 23 21 20 18 17 13 11 5 3
Schreiben Sie auf Basis der letzten beiden Beispiele Programme, die Strings statt der Integer-Werte verwenden können.

Klammerprüfung mittels Stack (POS1: 2A, 2C)

2011-03-02T14:11:00.000+01:00

Schreiben Sie ein Java-Programm, welches zeichenweise von der Standardeingabe liest und prüft, ob die eingegebenen Klammern eine gültige Klammerung mit ([{}]) ergeben.
Beispiele für korrekte Klammerung:

()([])[[([])]]{}
x{abc(sdf(c))asd}asx
()
[]
((()))
{{{(())}}}

Beispiele für falsche Klammerung:

(()
[])
(([)])

Das Programm soll nur ausgeben, ob die Klammerung korrekt ist. Das Programm soll alle Klammern bis EOF prüfen (bei den Beispielen oben ist jeweils eine Zeile eine Eingabe!).
Verwenden Sie für die Implementierung einen (selbstprogrammierten) Stack (eigene Klasse):

void push(char elem);   // Element oben auf Stack
char pop();             // oberstes Element
boolean isEmpty();      // false wenn nicht leer

Erweiterung um Programmargumente und Dateien

Erweitern Sie das Programm so, dass eine Hilfe ausgegeben werden kann, mehrere Eingabedateien und optional eine Ausgabedatei angegeben werden kann. Eine Eingabedatei entspricht einem Klammerausdruck (der natürlich aus mehreren Zeilen bestehen kann). Wird keine Eingabedatei angegeben, so ist von stdin zu lesen.

Aufruf:

java Klammer [-h|-o out] [eingabedateien...]
  -h             ... Hilfe
  -o out         ... Ausgabe in die Datei out
  eingabedateien ... optional mehrere Eingabedateien

Detaillierte Fehlermeldungen

Erweitern Sie das Programm um die Ausgabe einer detaillierten Fehlermeldung. Welcher Fehler wurde gefunden? Wo wurde der Fehler gefunden (Zeile/Spalte)?
mögliche Fehler

falsche Klammer-Zu
zu viele Klammern-Zu
zu wenig Klammern-Zu

Binärdateien bearbeiten mit Java (PR: 5A, 5B)

2011-03-01T20:06:00.002+01:00

Entwickeln Sie sie eine Klasse Data, die das Interface DB implementiert. Die Klasse Data soll die Methoden zum Bearbeiten (Lesen, Schreiben) binärer Dateien nach dem unten beschriebenen Datenformat bereitstellen.

package data;
/**
 * RuD-Übung 2011
 *
 * data.DB.java
 * @author (c) 2011, Harald R. Haberstroh
 * 1.3.2011
 */


import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * @author Harald R. Haberstroh (hh)
 * 
 */
public interface DB extends Remote {
  /**
   * Sperre den gegebenen Datensatz. Ist der Datensatz bereits gesperrt, dann
   * wait().
   * 
   * @param recNo
   *          Nummer des zu sperrenden Datensatzes.
   * @return Sperr-Identifikation.
   * @throws RemoteException
   * @throws RecordNotFoundException
   *           ungültige Datensatznummer
   */
  public long lock(int recNo) throws RemoteException, RecordNotFoundException;

  /**
   * Hebe Sperre wieder auf. notify().
   * 
   * @param recNo
   *          Nummer des gesperrten Datensatzes
   * @param lockCookie
   *          Sperr-Identfikation.
   * @throws RemoteException
   * @throws RecordNotFoundException
   *           ungültige Datensatznummer
   * @throws SecurityException
   *           ungültiges lockCookie oder nicht gelockt
   */
  public void unlock(int recNo, long lockCookie) throws RemoteException,
      RecordNotFoundException, SecurityException;

  /**
   * lege neuen Datensatz an.
   * 
   * @param record
   *          Neuer Datensatz
   * @return Nummer des neuen Datensatzes
   * @throws RemoteException
   */
  public int create(Record record) throws RemoteException;

  /**
   * lösche Datensatz. Sperre wird aufgehoben, notify();
   * 
   * @param recNo
   *          Nummer des Datensatzes.
   * @param lockCookie
   *          Sperr-Identfikation.
   * @throws RemoteException
   * @throws RecordNotFoundException
   *           ungültige Datensatznummer
   * @throws SecurityException
   *           ungültiges lockCookie oder nicht gelockt
   */
  public void delete(int recNo, long lockCookie) throws RemoteException,
      RecordNotFoundException, SecurityException;

  /**
   * ändere Datensatz (überschreibe mit dem gegebenen Datensatz).
   * 
   * @param record
   *          neuer Datensatz
   * @param recNo
   *          Nummer des gesperrten Datensatzes
   * @param lockCookie
   *          Sperr-Identfikation.
   * @throws RemoteException
   * @throws RecordNotFoundException
   *           ungültige Datensatznummer
   * @throws SecurityException
   *           ungültiges lockCookie oder nicht gelockt
   */
  public void update(Record record, int recNo, long lockCookie)
      throws RemoteException, RecordNotFoundException, SecurityException;

  /**
   * suche Datensätze.
   * 
   * @param criteria
   *          String-Array mit Kriterien, null matcht alles, sonst
   *          Stringrepräsentation des Suchkriteriums (entspricht den Daten in
   *          Record).
   * @return Array von Recordnummern
   * @throws RemoteException
   */
  public int[] find(String[] criteria) throws RemoteException;

  /**
   * lese Datensatz.
   * 
   * @param recNo
   *          Nummer des zu lesenden Datensatzes.
   * @return Record
   * @throws RemoteException
   * @throws RecordNotFoundException
   *           Datensatz existiert nicht.
   */
  public Record read(int recNo) throws RemoteException, RecordNotFoundException;
}

Die Klasse Data muss zusätzlich einen Konstruktor Data(String dateiname) bereitstellen, der die Datei dateiname (z.B. "machines.db") öffnet und zur Bearbeitung mit den im Interface DB definierten Methoden bereitstellt. Der Konstruktor muss die nötigen Exceptions werfen, wenn die Datei nicht geöffnet werden kann.
Der Parameter String[] criteria der Methode find() enthält das Suchkriterium, wobei jedem Feld ein String zugeordnet ist. Soll also nur nach einem Namen (siehe unten) gesucht werden, so muss criteria[1] den gesuchten Namen (bzw. einen Teil davon) enthalten. Alle anderen Elemente des Arrays müssen dann null sein. Soll nach mehreren Kriterien selektiert werden, so sind die entsprechenden Felder mit Werten zu belegen.
find() liefert dann ein Array mit den Indizes der passenden Datensätze.
Die Datensatznummer recNo ist immer der Index innerhalb der Datei!
Gelöschte Datensätze werden einfach als gelöscht markiert (s.u.) und müssen beim Anlegen neuer Datensätze zuerst verwendet werden (erst wenn kein gelöschter Datensatz existiert, wird die Datei vergrößert).
RecordNotFoundException wird immer dann geworfen, wenn recNo auf einen gelöschten Datensatz weist oder, wenn der Datensatz gar nicht existiert. Lösen Sie das Problem, dass nur mit der einfachen RecordNotFoundException das Dateiende nicht ermittelt werden kann, in geeigneter Weise.

Record muss in geeigneter Weise implementiert werden.

Datensätze sollen gesperrt werden können (die Klasse Data kann von mehreren parallelen Threads verwendet werden). Dazu soll die Methode lock() eine (beliebige) dem Datensatz zuordenbare Zahl (Lockcookie bzw. Sperr-Identifikation) liefern und den Satz sperren. Die Methoden, die eine Sperre benötigen müssen dann anhand dieses Lockcookies überprüfen, ob der Datensatz gesperrt ist und die entsprechende Operation ausführen. Ist der Datensatz nicht gesperrt oder das Lockcookie ungültig, so ist eine SecurityException zu werfen. Die Methode unlock() hebt die Sperre wieder auf. Nach einem delete() braucht man (kann man) kein unlock() machen.

Datenformat

Die Strings sind kodiert mit dem Encoding ISO-8859-1, d.h. jedes Zeichen ist einem Byte kodiert und es sind nur ASCII-Zeichen sowie die westeuropäischen Erweiterungen erlaubt. Es gibt Strings fixer Länge (werden mit Leerzeichen aufgefüllt) und Strings variabler Länge (werden wie C-Strings mit '\0' abgeschlossen) mit einer Obergrenze.
Die Datei mit den (Test-)Daten hat folgendes Format:
Die Datei beginnt mit einem Header:

4 Bytes Magic Cookie, Wert 4242
4 Offset in Bytes zu den eigentlichen Daten
2 Bytes Anzahl Felder pro Datensatz
Pro Feld gibt es folgenden Eintrag:
2 Bytes Länge Feldname
n Bytes Feldname
2 Bytes Länge Feldbeschreibung
n Bytes Feldbeschreibung für die Tabellenansicht
1 Byte  Datentyp: 'F' ... fix, 'V' ... variabel, 'C' ... ein Zeichen
2 Bytes Feldlänge
Nach den Feldbeschreibungen, d.h. ab dem Offset, finden sich die eigentlichen Datensätze gemäß der Beschreibungen im Header:
2 Bytes Flag Gelöscht (== 0 ... gelöscht, != 0 ... aktiv)
n Bytes Daten gemäß der Datensatzbeschreibung

Testdatei machines.db

Diese Datei enthält nur die Geräte (und deren grafische Koordinaten):

Feldname	Feldbeschreibung	(maximale) Länge	Typ	Bemerkung
id	Geräte-Id	10	String `'\0'` terminiert	z.B. `"z23"`
name	Gerätename	100	String `'\0'` terminiert	Gerätebeschreibung, z.B. `"Laderoboter Halle B"`
x	x	5	String fixe Länge	z.B. `" 50"` (vorne mit Leerzeichen aufgefüllt)
y	y	5	String fixe Länge	z.B. `" 200"`

Testen der Klasse Data

Schreiben Sie passende Tests um die Klasse Data zu testen. Der erste Test soll einfach die Datei machines.db in lesbarer Form auf der Konsole ausgeben.
Die weiteren Tests sollen natürlich die gesamte Funktionalität und das Locking testen.

Downloads

Interface DB.java
Testdatei machines.db

Abgabe

Nennen Sie das Projekt klasse-name-data also z.B. 5ad-meier-data und checken Sie es am CVS ein. Termin wird noch bekanntgegeben.

Wie geht's weiter

Die Datenklasse soll dann später in einem Client-/Server-System zum Einsatz kommen, wo mehrere grafische Clients eine Binärdatei bearbeiten sollen. Die Angabe dazu folgt...

Schwerpunkt Programmieren (PR: 5A, 5B)

2011-02-23T11:43:00.000+01:00

Der letztmögliche Abgabetermin für die Ausarbeitung ist der 8. April 2011, damit noch genügend Zeit bleibt, die Ausarbeitung zu besprechen.

JavaFX
eclipse plugins schreiben
Funktionale Programmierung
Logikbasierte Programmierung
Objective C
Algorithmen für Textsuche
Closures - Definition, Verwendung, Beispiele (Programmiersprachen)
Garbage Collector - Algorithmen und Implementierung

Zu allen Themen gibt es Informationen im Internet. Die Links zur Wikipedia sind nur allererste Einstiege, da dort selbst oft die Qualität in Frage gestellt wird.

Ein wichtiger Aspekt beim Schwerpunktthema ist natürlich die eigene Recherche und das Erarbeiten in ein völlig neues Gebiet.

Ausarbeitung in etwa 10 bis 20 Seiten plus Sourcecode mit Beispielen.

Weitere Literatur:

Steve Holzner: Eclipse Cookbook (O'Reilly)
Rechenberg, Pomberger (Hrsg.): Informatik Handbuch (Hanser)
Hans Werner Lang: Algorithmen in Java (Oldenbourg)
Robert Sedgewick: Algorithmen in C (Addison-Wesley)
Alfred V. Aho, Jeffrey D. Ullman: Informatik - Datenstrukturen und Konzepte der Abstraktion (Thomson Publishing)
Christian Wagenknecht: Programmierparadigmen (Teubner)

Links:

Hilfe zu Eclipse: http://help.eclipse.org/helios/index.jsp
JavaFX: http://www.javafx.com/, http://download.oracle.com/javafx/tutorials.html

Weitere Informationen, sobald ich welche habe, gibt es dann hier.

Python -> Java (POS1: 2A, 2C)

2011-01-27T16:07:00.000+01:00

Schreiben Sie folgendes Pythonprogramm in Java um (ergänzen Sie den fehlenden Header):

from sys import argv, stderr, stdin, stdout

def count(inStream):
  anz = 0
  imWort = False
  zeichen = inStream.read(1)
  eof = zeichen == ""
  while not eof:
    if imWort:
      if " \n\t".find(zeichen) >= 0:
        imWort = False
    else:
      if " \n\t".find(zeichen) == -1:
        imWort = True
        anz = anz + 1      
    zeichen = inStream.read(1)
    eof = zeichen == ""
  return anz

if __name__ == "__main__":
  outStream = stdout
  if len(argv) == 1:
    inStream = stdin
  elif len(argv) >= 2:
    inStream = open(argv[1], "r")
  if len(argv) == 3:
    outStream = open(argv[2], "w")
  anz = count(inStream)
  ausgabe = "Anzahl = %d\n" % anz
  outStream.write(ausgabe)

Was macht das Programm?
Was kann man über die Einhaltung Programmierrichtlinien bei diesem Programm sagen (abgesehen vom fehlenden Header)?

Zählen von Zeichen aus einer Menge (POS1: 2A, 2C)

2011-01-27T15:37:00.001+01:00

Schreiben Sie ein Java-Programm, das aus der Eingabe (Dateien oder stdin) die Zeichen aus einer Menge von Zeichen zählt. Die Menge der Zeichen wird als Kommandozeilenargument angegeben. Weitere Argumente sind die Dateien, die gelesen werden. Ist nur ein Parameter angegeben, so soll aus stdin gelesen werden. Kein Parameter ergibt eine Fehlermeldung. Groß-/Kleinschreibung ist nicht zu berücksichtigen.
Aufrufbeispiele (die Startklasse ist in diesem Beispiel Count):

~/workspace/count/bin > java Count aeiou file1.txt file2.txt
a -> 23
e -> 30
i -> 14
o -> 12
u -> 17
~/workspace/count/bin > java Count
Fehler: mindestens die Menge der Zeichen angeben!
~/workspace/count/bin > java Count -h
Bestimmen der Häufigkeiten einer Menge von Zeichen.
Aufruf: java Count [-h] zeichenmenge [dateien...]
~/workspace/count/bin > java Count abc
das ist der Text. Beispiel
zweite Zeile.
^D
a -> 1
b -> 1
c -> 0
~/workspace/count/bin >

Nennen Sie das Projekt count (dann natürlich klasse-familienname-java-count), wobei name Ihr Familienname und klasse Ihre Klasse ist (z.B. 2ad-haberstroh-java-count).

Ermittle die Top-10 der Worte in einem Text (POS1: 2A, 2C)

2011-01-22T12:28:00.001+01:00

Aufgabe 1

Schreiben Sie eine Funktion hauf(string), welche die 10 häufigsten Worte im String string ermittelt und als Liste von Tupeln der Art (wort, anzahl) zurück liefert (Länge der Liste ist <= 10). Die Liste muss so sortiert sein, dass das Häufigste Wort ganz am Anfang ist. Haben Worte die selben Häufigkeiten, so haben diese alphabetisch sortiert zu sein.

Aufgabe 2

Schreiben Sie eine Funktion histogramm(liste, weite = 60), welche aus der übergebenen Liste ein Histogramm erzeugt und als String zurück liefert. Eine „Zeile“ soll so aussehen:

das            123 ************

Wobei für das Wort 14 Zeichen, die Anzahl 3 Zeichen vorgesehen werden müssen. Dahinter ist eine Anzahl Sternchen, die der Anzahl bezogen auf das Maximum (höchste Anzahl in der Liste) und der Weite entspricht (round(anzahl / max * weite)).

Aufgabe 3

Schreiben Sie eine Funktion main(), welche alle auf der Kommandozeile angegebenen Dateien öffnet und die Gesamthäufigkeiten ermittelt (also hauf() mit dem gesamten gelesenen Text aufruft) und mit den ermittelten Daten das Histogramm ausgibt.
Sind keine Dateien angegeben, so ist von stdin zu lesen (bis EOF).
Beispielaufruf mit den Testdaten vom /vorgabe-Verzeichnis:

hp@l111~/workspace/python$ python3 haufdiagramm.py testdaten.txt
der            89 ************************************************************
die            61 *****************************************
und            43 *****************************
Histogramm     40 ***************************
in             28 *******************
für            17 ***********
ist            17 ***********
den            16 ***********
das            15 **********
ein            14 *********

Mögliche Lösung

Ich werde die einzelnen Funktionen erklären:

import sys

Dieser Import wird für die Kommandozeilenargumente benötigt.

Folgende Funktion ermittelt die Wort-Häufigkeiten, sortiert das Ergebnis nach Häufigkeit und liefert die ersten 10 Elemente.

def hauf(string):
    """ermittelt die 10 häufigsten Worte in 'string' und liefert Liste mit 
    Tupel (wort, anzahl)"""
    dict = {}
    for wort in string.split():

split() ohne Parameter zerlegt einen String in eine Liste von "Worten", wobei ein "Wort" eine Folge von Zeichen ohne Leerzeichen, Tabulator und Zeilenumbruch ist. Mit anderen Worten Leerzeichen, Tabulatoren und Zeilenumbrüche sind die Trenner.

        wort = wort.rstrip('.,;?!")') # Satzzeichen entfernen
        wort = wort.lstrip('"(') # Hochkomma und Klammer dürfen vorne stehen

lstrip() und rstrip() entfernen alle Zeichen in Klammer llinks bzw. rechts. In unserem Fall alle Satzzeichen, die unmittelbar vor einem Wort bzw. nach einem Wort stehen dürfen.
Die beiden Zeilen könnte man natürlich auch zusammenfassen zu: wort = wort.rstrip('.,;?!")').lstrip('"(').
Die folgende erste Zeile prüft, ob der String auch tatsächlich ein Wort ist (nur Buchstaben).

        if wort.isalpha():
            if wort in dict:
                dict[wort] += 1
            else:
                dict[wort] = 1

Obige 4 letzte Zeilen prüfen zunächst, ob das Wort bereits im Dictionary enthalten ist. Wenn ja, dann wird die gespeicherte Anzahl erhöht, wenn nein, dann wird unter diesem Wort eine 1 gespeichert.

        l = list(dict.items())

Erzeugt eine Liste mit Tupeln (wort, anzahl) aus dem Dictionary.

        l.sort(key=lambda x: (-x[1], x[0]))

sort() sortiert eine Liste nach der natürlichen Reihenfolge. Mit dem Parameter key kann eine Funktion übergeben werden, anhand deren Returnwert sortiert werden soll. Die Funktion wird jeweils mit einem Listenelement aufgerufen. Man könnte also eine Funktion schreiben, die jeweils das zweite Element des Tupels (die Liste besteht in diesem Fall ja aus Tupeln der Art (wort, anzahl)) zurückliefert. Da absteigend sortiert werden soll, muss entweder der Wert mit -1 multipliziert werden (-[x1]) oder man muss beim Sortieren sort(reverse=True) aufrufen. Den Namen dieser Funktion übergibt man dann per key=sortfunktion.
Diese Funktion könnte so aussehen: def sortierfunktion(x):return (-x[1], x[0])
lambda x: definiert eine anonyme Funktion (Funktion ohne Namen) mit dem Parameter x, die gleich an Ort und Stelle definiert und übergeben werden kann.

    l = l[0:10]
    return l

Die letzten beiden Zeilen schneiden die ersten 10 Elemente der Liste aus und liefern sie zurück.
Das könnte man auch nur mit einer Anweisung machen: return l[:10].

def stars(num, max, width):
    """liefert String mit so vielen Sternen, wie num / max * width"""
    return "*" * round(num / max * width)

Dazu braucht man nicht allzu viel sagen.

Die folgende Funktion erzeugt das in Aufgabe 2 geforderte Histogramm.

Um einen passenden Maßstab für die geforderte Weite weite=60 zu finden, wird das Maximum der Werte ermittelt. Das muss natürlich das zweite Element des ersten Tupels der Liste sein, wenn überhaupt Tupel in der Liste sind.

def histogramm(liste, weite=60):
    """erzeugt Histogramm und liefert es zurück"""
    if len(liste) > 0:
        max = liste[0][1]
    ret = ""
    for wort, anzahl in liste:

Diese Schleife geht jedes Tupel der Liste durch, wobei die Tupel gleich in wort und anzahl "ausgepackt" wird.

        ret += "%-14s%3d %s\n" % (wort, anzahl, stars(anzahl, max, weite))

Hier wird jede Zeile an den String ret angehängt, wobei Stringformatierung angewendet wird.

    return ret

Die folgenden beiden Funktionen dient nur zum Testen mit fixen Strings und liefert einen String mit vorgegebenen Anzahlen von Worten.

def teststr():
    """liefert Testeingabe"""
    s = "Häufigkeit " * 50 + "das " * 123 + "die, " * 100 + "Haus " * 40
    s += "Maus " * 38 + "Koffer " * 34 + "Kilogramm " * 22 + "Punkt " * 18
    s += "Genau " * 16 + "Zehn " * 10
    s += "nichts " * 5 + "23 " * 50 + "ziemlich " * 3
    return s 

def test():
    """Testen..."""
    liste = hauf(teststr())
    print(histogramm(liste, 12.3))

Diese Funktion prüft, ob überhaupt Kommandozeilenargumente vorhanden sind. Gibt es welche, so werden alle Argumente als Dateien zum Lesen geöffnet und mit read() komplett gelesen und an den String eingabe angehängt.
Gibt es keine Dateinamen auf der Kommandozeile, so wird mittels eingabe = sys.stdin.read() von der Standardeingabe gelesen.
Die letzte Zeile ruft die beiden Hauptfunktionen auf und gibt das Ergebnis aus.
Es fehlt allerdings noch die Überprüfung, ob eine Datei überhaupt existiert bzw. geöffnet werden kann. Diesen Teil möge der Leser selber ergänzen.

def main():
    """öffnet Datei oder liest von stdin"""
    if len(sys.argv) > 1:
        eingabe = ""
        for arg in sys.argv[1:]:
            f = open(arg)
            eingabe += " " + f.read()
            f.close()
    else:
        eingabe = sys.stdin.read()
    print(histogramm(hauf(eingabe)))

Die folgenden Zeilen dienen zum Aufrufen der Funktion main() (bzw. test() zum Testen), sofern dieses Script als Programm aufgerufen wurde.

if __name__ == '__main__':
#    test()
    main()

Vollständiges Programm (ohne Header)

import sys

def hauf(string):
    """ermittelt die 10 häufigsten Worte in 'string' und liefert Liste mit 
    Tupel (wort, anzahl)"""
    dict = {}
    for wort in string.split():
        wort = wort.rstrip('.,;?!")') # Satzzeichen entfernen
        wort = wort.lstrip('"(') # Hochkomma und Klammer dürfen vorne stehen
        if wort.isalpha():
            if wort in dict:
                dict[wort] += 1
            else:
                dict[wort] = 1
    l = list(dict.items())
    l.sort(key=lambda x: (-x[1], x[0]))
    l = l[0:10]
    return l

def stars(num, max, width):
    """liefert String mit so vielen Sternen, wie num / max * width"""
    return "*" * round(num / max * width)

def histogramm(liste, weite=60):
    """erzeugt Histogramm und liefert es zurück"""
    if len(liste) > 0:
        max = liste[0][1]
    ret = ""
    for wort, anzahl in liste:
        ret += "%-14s%3d %s\n" % (wort, anzahl, stars(anzahl, max, weite))
    return ret

def teststr():
    """liefert Testeingabe"""
    s = "Häufigkeit " * 50 + "das " * 123 + "die, " * 100 + "Haus " * 40
    s += "Maus " * 38 + "Koffer " * 34 + "Kilogramm " * 22 + "Punkt " * 18
    s += "Genau " * 16 + "Zehn " * 10
    s += "nichts " * 5 + "23 " * 50 + "ziemlich " * 3
    return s 

def test():
    """Testen..."""
    liste = hauf(teststr())
    print(histogramm(liste, 12.3))

def main():
    """öffnet Datei oder liest von stdin"""
    if len(sys.argv) > 1:
        eingabe = ""
        for arg in sys.argv[1:]:
            f = open(arg)
            eingabe += " " + f.read()
            f.close()
    else:
        eingabe = sys.stdin.read()
    print(histogramm(hauf(eingabe)))
    
if __name__ == '__main__':
#    test()
    main()

Ganze Zahlen zählen (Schleife, Sequenzen, Funktionen POS1: 1BHIF)

2011-01-14T12:32:00.000+01:00

Schreiben Sie ein Programm anzzahlen.py, welches eine Zeile einliest und in dieser Zeile zähle, wieviele ganze Zahlen vorkommen. Jedes Zeichen, das keine Ziffer ist, gilt als nicht zu einer Zahl gehörend.
Beispiel:
Eingabe:

das ist eine Zahl 123 und noch eine 1 und noch zwei 3213x23123

Ausgabe:

4 Zahlen gefunden.

Das Programm soll richtige Sätze ausgeben, also "Keine Zahlen gefunden.", wenn in der Eingabe keine Zahlen sind oder "Eine Zahl gefunden.", wenn eine Zahl in der Eingabe war. Ab 4 soll dann die Zahl ausgegeben werden, z.B. "6 Zahlen gefunden."

Mögliche Lösung:

"""
author: Haberstroh, Harald
matnr:  d09666
file:   anzzahlen.py
desc:   Zähle ganze Zahlen
        Beispiel:
            das ist eine Zahl 123 und noch eine 1 und noch zwei 3213x23123
        Ausgabe:
            4 Zahlen gefunden
date:   14.1.2011
class:  Lehrer
catnr:  33
"""
#---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----

def anz_zahlen(string):
    """ermittelt die Anzahl der ganzen Zahlen im String"""
    anzahl = 0
    in_zahl = False
    for zeichen in string:
        if zeichen in "0123456789":
            if not in_zahl:
                anzahl += 1
                in_zahl = True
        else:
            in_zahl = False
    return anzahl

def ausgabe(anzahl):
    """gibt deutschen Satz aus mit Anzahl"""
    if anzahl == 0:
        print("Keine Zahl gefunden.")
    elif anzahl == 1:
        print("Eine Zahl gefunden.")
    elif anzahl == 2:
        print("Zwei Zahlen gefunden.")
    elif anzahl == 3:
        print("Drei Zahlen gefunden.")
    else:
        print(anzahl, "Zahlen gefunden.")
        
def main():
    """EVA Eingave Verarbeitung Ausgabe - das Hauptprogramm"""
    string = input("> ")
    anzahl = anz_zahlen(string)
    ausgabe(anzahl)

def test():
    """Testen von anz_zahlen() und ausgabe()"""
    string = "das ist eine Zahl 123 und noch eine 1 und noch eine 3213x23123"
    anzahl = anz_zahlen(string)
    ausgabe(anzahl)
    ausgabe(anz_zahlen("keine"))
    ausgabe(anz_zahlen("eine Zahl 123"))
    ausgabe(anz_zahlen("zwei 23 und 324"))
    ausgabe(anz_zahlen("drei 23 34 22"))
    ausgabe(anz_zahlen("vier 234 234 234 45"))
    ausgabe(anz_zahlen("5 234 234 234 45"))

    
if __name__ == '__main__':
    main()
#    test()

Beachten Sie, dass ich hier eine eigene Funktion test() gemacht habe, um viele Testfälle immer wieder leicht probieren zu können. Statt main() muss dann nur test() aufgerufen werden.
Das Programm wäre auch ohne die Funktion test() fertig und korrekt. test() half nur bei der Entwicklung bei der Fehlersuche.

Beispiele zeichenweise Bearbeitung, Java (POS-1: 2A, 2C)

2011-01-13T15:58:00.002+01:00

Anzahl der Strings in der Eingabe ermitteln

Schreiben Sie ein Programm, welches die Anzahl der Strings in der Eingabe ermittelt. Strings sind beliebige Zeichenketten zwischen Hochkomma (z.B. ein string). Verwenden Sie Schalter zum Erkennen von Strings (Zustand "InString", wenn man innerhalb eines Strings ist und "OutString", wenn gerade kein String gelesen wird).

Anzahl der Zahlen ermitteln

Schreiben Sie ein Programm, welches die Anzahl der Zahlen in der Eingabe ermittelt (ganze Zahlen, müssen durch Leerzeichen, Tabulatoren oder Zeilenumbrüchen von anderen Eingaben getrennt sein).

Ziffern zählen

Schreiben Sie ein Java-Programm, welches die Anzahl der Ziffern in der Standardeingabe ermittelt und ausgibt.

Vokale zählen

Schreiben Sie ein Java-Programm, welches die Anzahl der Vokale in der Standardeingabe ermittelt und ausgibt.

Zeichen, Worte und Zeilen zählen

Schreiben Sie ein Java-Programm, welches die Anzahl der Zeichen, Worte und Zeilen in der Standardeingabe ermittelt und ausgibt.

Java Einführung (POS1: 2A, 2C)

2011-01-12T14:04:00.001+01:00

Schreiben Sie ein einfaches Java Programm, welches "Hello World" ausgibt. Nennen Sie das Programm Hello.java.
Verwenden Sie dazu einen Texteditor und übersetzen Sie das Programm auf der Kommandozeile.
Schreiben Sie ein einfaches Java-Programm, welches das kleine Einmaleins ausgibt. Welchen Namen könnte das Programm haben?

  X    1    2    3    4    5    6    7    8    9   10  
  1    1    2    3    4    5    6    7    8    9   10
  2    2    4    6    8   10   12   14   16   18   20
  3    3    6    9   12   15   18   21   24   27   30
  4    4    8   12   16   20   24   28   32   36   40
  5    5   10   15   20   25   30   35   40   45   50
  6    6   12   18   24   30   36   42   48   54   60
  7    7   14   21   28   35   42   49   56   63   70
  8    8   16   24   32   40   48   56   64   72   80
  9    9   18   27   36   45   54   63   72   81   90
 10   10   20   30   40   50   60   70   80   90  100

Verwenden Sie wieder einen Texteditor und den Java-Compiler auf der Kommandozeile.

TIOBE-Index: Python ist Programmiersprache 2010

2011-01-10T17:19:00.000+01:00

Die Programmiersprache Python konnte unter den im TIOBE-Index gelisteten Sprachen im vergangenen Jahr den größten Zuwachs verzeichnen. Den zweitgrößten Zuwachs hatte Objective-C wegen iPhone- und iPad-Entwicklung. Objective-C galt daher lange Zeit als Kandidat für die Sprache des Jahres 2010.
Detaillierte Informationen gibt es hier und hier.

Dynamische Speicherverwaltung in C (PR: 5A, 5B)

2010-12-15T12:20:00.000+01:00

Implementieren Sie eine einfache dynamische Speicherverwaltung, die nach dem in der folgenden Skizze gezeigten Prinzip funktioniert.

Diese Speicherverwaltung soll es ermöglichen, Speicher in beliebiger Reihenfolge zu allozieren und wieder freizugeben. Siehe auch Dynamische Speicherverwaltung
Schreiben Sie ein Modul heap für die Speicherverwaltung selbst, welches folgende Funktionen enthält (exportiert):

void *halloc(size_t size); zum Anfordern von Speicher der Größe size
void hfree(void *p); zum Freigeben des Speichers, auf den der Zeigern p zeigt.

Erstellen Sie eine weitere Version des Moduls heap, welches bei jedem Aufruf von halloc() bzw. hfree() den gesamten Speicher in lesbarer Form auf stderr ausgibt, damit man das Allozieren der Speicherblöcke sehen kann (die Größe des Heaps sollte dabei eher klein gewählt werden!).
Schreiben Sie weiters ein Modul, welches Ihre Speicherverwaltung testet durch Anfordern von Speicher, belegen und lesen des allozierten Speichers und wieder Freigeben des Speichers in verschiedenen Varianten.
Erstellen Sie dazu eine Liste von Testfällen und beschreiben Sie das Ergebnis der Tests (die Speicherauszüge bekommen Sie mit obiger Variante des Moduls).
Beispiele von Testfällen:
n. Test: allozieren eines Strings der Länge HEAPSIZE - sizeof(heap_t), füllen des Strings mit lauter 'A' und ausgeben des Strings. OK
n+1. Test: freigeben des Speichers aus Test n. OK

Zu jedem Test ist anzugeben, ob der Test erfolgreich war. Falls ein Test nicht erfolgreich war, so ist festzustellen, warum und ggf. der Fehler zu beheben. Wird am Programm etwas verändert, so müssen alle Tests noch einmal gemacht werden!
Schreiben Sie ein passendes Makefile, mit dem man alternativ die normale Variante von heap und die Testvariante von heap erzeugen kann!
Organisieren Sie sich in Kleingruppen und versuchen Sie die einzelnen Funktionen gemeinsam zu entwerfen und zu programmieren. Welche Hilfsfunktionen braucht z.B. das halloc()?
Erweitern Sie die Speicherverwaltung um eine "Garbage Collection", die freie Speicherbereiche, die hintereinanderliegen zusammenfasst.
Erstellen Sie eine geeignete Verzeichnisstruktur und verwenden Sie CVS.
Tauschen Sie die Module mit anderen Gruppen aus (das müßte ganz einfach sein, da die Schnittstellen immer gleich sind (s.o.).
Abgabe:
Nennen Sie das Projekt 5ad-name-heap bzw. 5bd-name-heap und checken Sie es ein.
Beantworten Sie weiters folgende Fragen (die Antworten müssen in der Datei heap.txt gespeichert werden):

Was passiert, wenn man einen String der Länge n alloziert und einen String der Länge n speichert?
Was passiert, wenn man einen String der Länge n alloziert und einen String der Länge n + 1 speichert?
Sie allozieren einen String der Länge 11 und speichern "0123456789" und geben den String wieder frei. Danach allozieren Sie einen String der Länge 20 und geben diesen String aus. Was passiert? (die Speicheranforderungen bzw. die Freigabe muss unmittelbar hintereinander erfolgen).
Welche Speicheranforderungen benötigen mehr Speicher - 10 Strings der Länge 100 oder 100 Strings der Länge 10? Begründen Sie die Antwort.
Wie könnten Sie im Modul heap sicherstellen, dass bei einem Aufruf von hfree(p); der Parameter p tatsächlich auf einen mit halloc() allozierten Speicherbereich zeigt?

heap.txt muss auch die Liste der Testfälle mit ihren Ergebnissen enthalten.
Geben Sie einen Ausdruck der ausgearbeiteten Fragen ab!

Diagramm erstellen (POS1: 2AHIF, 2CHIF)

2010-12-10T09:45:00.000+01:00

Erstellen Sie ein Python-Programm zum Darstellen von Daten in einem Diagramm. Die Daten stammen aus einer Textdatei mit Zeilen mit Datum und Wert. Zum Beispiel:

10.9.2010 70
11.10.2010 36
10.11.2010 50
11.11.2010 70
1.12.2010 30

Auf der X-Achse soll das Datum aufgetragen werden und auf der Y-Achse der jeweilige Wert.

Wählen Sie einen passenden Maßstab. Das erste Datum soll der Null-Punkt auf der X-Achse sein.
Verwenden Sie die Turtle-Grafik (from turtle import *). Hilfe zur Turtle-Grafik finden Sie in einer Python-Konsole mit:

import turtle
help(turtle)

Damit Sie passende Testdaten bekommen, schreiben Sie auch einen Testdatengenerator, der 3 Parameter auf der Kommandozeile hat:

Name der Datei
Anfangsdatum
Anzahl der Datensätze

Die Datumswerte generierern Sie so, dass, beginnend mit dem Anfangsdatum, immer eine zufällige Anzahl von Tagen zwischen 1 und 31 dazugezählt werden soll. Die Werte sollen zufällige ganze Zahlen zwischen 0 und 100 (inclusive) sein.

Nennen Sie das Projekt 2x-name-python-diagramm, den Testdatengenerator testdaten.py und das Diagramm diagramm.py.

Wurzelberechnung (POS1: 1BHIF)

2010-12-03T12:27:00.002+01:00

Man kann die Wurzel einer Zahl berechnen mit folgender Formel

x_n = (x_n-1 + a / x_n-1) / 2

Man beginnt damit, dass a und x₀ gleich der Zahl, aus der man die Wurzel ziehen will, setzt und x₁ berechnet. Dann berechnet man x₂ usw. bis sich die beiden letzten Werte nur mehr gering unterscheiden (z.B. die Differenz kleiner 0,0000001 ist).

Schreiben Sie eine Funktion wurzel(zahl, genauigkeit), welche nach obiger Methode die Wurzel berechnet.

Erstellen Sie ein Programm wurzel.py, welche eine Tabelle der Wurzeln der Zahlen 1 bis 20 bei den Genauigkeiten 0.01, 0.0001 sowie 0.0000001 ausgibt:

 1:  1.0000000  1.0000000  1.0000000
 2:  1.4142157  1.4142136  1.4142136
 3:  1.7320508  1.7320508  1.7320508
 4:  2.0000001  2.0000000  2.0000000
 5:  2.2360689  2.2360680  2.2360680
 6:  2.4494944  2.4494897  2.4494897
 7:  2.6457670  2.6457513  2.6457513
 8:  2.8284271  2.8284271  2.8284271
 9:  3.0000000  3.0000000  3.0000000
10:  3.1622777  3.1622777  3.1622777
11:  3.3166248  3.3166248  3.3166248
12:  3.4641017  3.4641016  3.4641016
13:  3.6055514  3.6055513  3.6055513
14:  3.7416576  3.7416574  3.7416574
15:  3.8729837  3.8729833  3.8729833
16:  4.0000006  4.0000000  4.0000000
17:  4.1231067  4.1231056  4.1231056
18:  4.2426425  4.2426407  4.2426407
19:  4.3589018  4.3588989  4.3588989
20:  4.4721402  4.4721360  4.4721360

Musterlösung zu Übungsbeispiele für Python vom 1.12.2010 (POS1: 1BHIF)

2010-12-03T10:30:00.003+01:00

Prüfen, ob durch die Angabe dreier Längen ein Dreieck gegeben ist.
Zwei Seiten müssen immer länger als die dritte sein. Man muss dies für alle Möglichkeiten prüfen, denn z.B.
a = 3, b = 4, c = 1
Da stimmt zwar a + b > c (7 > 1) und b + c > a (4 > 3), jedoch nicht a + c > b (4 == 4)!
Bei der Lösung wird eine Schleife verwendet.

def ist_dreieck(a, b, c):
    """liefert True, wenn durch a, b und c ein gültiges Dreieck definiert
    ist"""
    i = 3
    while i > 0:
        if a + b <= c:
            return False # kein Dreieck
        a, b, c = b, c, a
        i = i - 1
    return True

Man könnte das Problem natürlich auch durch logische Verknüpfung der Prüfungen lösen:

def ist_dreieck(a, b, c):
    """liefert True, wenn durch a, b und c ein gültiges Dreieck definiert
    ist"""
    if a + b > c and b + c > a and c + a > b:
        ret = True
    else:
        ret = False
    return ret

Oder gleich so:

def ist_dreieck(a, b, c):
    """liefert True, wenn durch a, b und c ein gültiges Dreieck definiert
    ist"""
    return a + b > c and b + c > a and c + a > b

Bei der zweiten Aufgabe soll geprüft werden, ob durch zwei Seiten und einem Winkel ein Quadrat gegeben ist. Die beiden Seiten müssen gleich lang sein (und größer 0) und der Winkel 90°:

def ist_quadrat(a, b, w):
    """liefert True, wenn durch a und b sowie dem Winkel w ein 
    Quadrat definiert ist"""
    quadrat = False
    if a > 0:
        if a == b:
            if w == 90:
                quadrat = True
    # else entfällt, da die Variable quadrat schon mit False vorbelegt ist.
    return quadrat

Oder wieder kürzer mit logischer Verknüpfung:

def ist_quadrat(a, b, w):
    """liefert True, wenn durch a und b sowie dem Winkel w ein 
    Quadrat definiert ist"""
    return a == b and w == 90 and a > 0

Die Schaltjahrprüfung könnte so erfolgen:

def ist_schaltjahr(jahr):
    """liefert True, wenn das gegebene Jahr ein Schaltjahr ist.
    Seit Ende 1582 gilt der Gregorianische Kalender, bei dem folgende Regel
    für die Schaltjahrbestimmung anzuwenden sind:
        In allen Jahren, deren Jahreszahl durch vier teilbar ist, ist der 
        29. Februar ein Schalttag und damit ist dieses Jahr ein Schaltjahr.
        Eine Ausnahme bilden allerdings die vollen Jahrhundertjahre 1700, 
        1800, 1900 usw., auch Säkularjahre genannt. Hiervon erhalten nur 
        diejenigen einen Schalttag, deren Jahreszahl durch 400 teilbar ist. 
        Jedes vierte Säkularjahr ist somit ein Schaltjahr.
    Für alle Jahre <= 1582 liefert die Funktion False, weil da das
    Schaltjahr nicht definiert ist, sonst gilt obige Regel."""
    if jahr <= 1582:
        schaltjahr = False
    elif jahr % 400 == 0:
        schaltjahr = True
    elif jahr % 100 == 0:
        schaltjahr = False
    elif jahr % 4 == 0:
        schaltjahr = True
    else:
        schaltjahr = False
    return schaltjahr

Jahre bis 1582 können keine Schaltjahre sein, da der Gregorianische Kalender erst im Jahr 1582 definiert wurde. Zum Test der Schaltjahrprüfung noch ein paar Worte, aber zunächst die Testfunktion, die ein paar Jahreszahlen prüft, von denen man weiß, dass sie kein Schaltjahr sind sowie Zahlen, bei denen bekannt ist, dass sie Schaltjahre sind:

def test_ist_schaltjahr():
    for jahr in (1000, 1580, 1581, 1582, 1900, 1999, 2003):
        assert not ist_schaltjahr(jahr)
    for jahr in (1996, 2000, 2004):
        assert ist_schaltjahr(jahr)
    print("ist_schaltjahr ok")

Die Anweisung assert ist für Programmierer und dient zum Prüfen der Bedingung, die gleich dahinter folgt, gedacht. Zum Beispiel:

assert 3 < 4

Die Bedingung ist wahr, daher läuft das Programm weiter. Ist die Bedingung hingegen falsch, so wird das Programm mit einer Fehlermeldung abgebrochen:

>>> assert 3 > 4
Traceback (most recent call last):
  File "", line 1, in 
    assert 3 > 4
AssertionError

Zusätzlich kann ein Text als Fehlermeldung angegeben werden:

>>> assert 3 > 4, "3 ist nicht größer als 4"
Traceback (most recent call last):
  File "", line 1, in 
    assert 3 > 4, "3 ist nicht größer als 4"
AssertionError: 3 ist nicht größer als 4

Angewendet auf obige Testfunktion bedeutet das, dass immer, wenn assert not ist_schaltjahr(jahr) die Funktion ist_schaltjahr(jahr) den Wert False leifern muss und wenn assert ist_schaltjahr(jahr) steht, True geleifert werden muss, damit das Programm nicht abgebrochen wird. Der nächste Punkt ist die for jahr in (1000, 1580, 1581, 1582, 1900, 1999, 2003):-Zeile. Die Variable jahr bekommt der Reihe nach die Werte 1000, 1580, 1581, 1582, 1900, 1999, 2003 und der eingerückte Code-Block (die eine Zeile) wird ausgeführt. Das ist die for-Schleife, welche im Buch im Kapitel 7 auch erklärt wird. Die Funktion test_ist_schaltjahr() prüft also zunächst ein paar Jahre, die kein Schaltjahr sind und ein paar Schaltjahre. Die Fibonaccizahlen können wie folgt ermittelt werden:

def fib(n):
    """liefert die Fibonaccizahl zu n. Die Zahlen sind wie definiert:
        fib(0) -> 0
        fib(1) -> 1
        fib(2) -> 1
        fib(3) -> 2
        fib(4) -> 3
        fib(5) -> 5
        fib(6) -> 8
        ...
        fib(10) -> 55
        ...
        fib(15) -> 610"""
    f = 0
    a = 0
    b = 1
    i = 0
    while i < n:
        f = a + b
        b, a = a, f
        i += 1
    return f

Für n = 0 und n = 1 sind die (Anfangs-)Werte vordefiniert. fib(0) = 0 und fib(1) = 1. Danach gilt die Regel, dass die n. Fibonaccizahl die Summe der beiden Vorgänger ist, also fib(n - 1) + fib(n - 2) (Siehe dazu auch Wikipedia: Fibonacci-Folge). Die Variable f hat immer den Wert der aktuellen Fibonaccizahl und ist daher mit 0 initialisiert. Die Variable a und b haben immer den Wert der beiden Vorgänger. Sie können das leicht sehen, wenn Sie print(...)-Anweisungen einfügen und sich dadurch den Ablauf der Berechnung anzeigen lassen:

def fib(n):
    """liefert die Fibonaccizahl zu n."""
    f = 0
    a = 0
    b = 1
    i = 0
    while i < n:
        f = a + b
        print(i, ":  f =", f, "a =", a, "b =", b) # Testausgabe
        b, a = a, f
        i += 1
    return f

print(fib(10))

..gibt dann folgendes aus:

0 :  f = 1 a = 0 b = 1
1 :  f = 1 a = 1 b = 0
2 :  f = 2 a = 1 b = 1
3 :  f = 3 a = 2 b = 1
4 :  f = 5 a = 3 b = 2
5 :  f = 8 a = 5 b = 3
6 :  f = 13 a = 8 b = 5
7 :  f = 21 a = 13 b = 8
8 :  f = 34 a = 21 b = 13
9 :  f = 55 a = 34 b = 21
55

Die Ausgabe einer Tabelle mithilfe der Funktion fib() ist einfach (oder doch etwas kompliziert, weil die eckigen Klammern dazukommen):

def fibtab(n):
    """erzeugt eine Tabelle der Fibonaccizahlen bis inclusive n.
    z.B. gibt fibtab(10) folgendes aus:
        [0, 1, 1, 2, 3, 5, 8]
    oder fibtab(100):
        [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
    Hinweis:
        verwenden Sie als Zeilenumbruch ", " beim print, also
            print(wert, end=', ')
        außer natürlich beim letzten Wert, hier ist "]" gefordert.
    """
    i = 0
    print("[", end = "")
    f = fib(i)
    while f <= n:
        print(f, end = "")
        i += 1
        f = fib(i)
        if f > n:
            print("]")
        else:
            print(", ", end = "")

Wir müssen sicherstellen, dass zunächst "[" ohne Zeilenumbruch ausgegeben wird. Die Funktion print(...) hat einen optionalen Parameter end, der angibt, was zum Schluss ausgegeben werden soll. Standardmäßig ist das "\n", was einen Zeilenumbruch bewirkt. Setzt man den Wert end = "", so wird ein Leerstring, also nichts, ausgegeben. In der Schleife muss man noch prüfen, ob man das Ende erreicht hat und in diesem Fall "]" (mit Zeilenumbruch) ausgibt. Im Normalfall wird ein Komma ohne Zeilenumbruch ausgegeben (letzte Zeile). Beachten Sie, dass der Parameter n hier die Grenze der Fibonaccizahl angibt und nicht die wievielte (wie bei fib(n)). Die Lösung zum Beispiel, die Summe der Vielfachen von 3 und 5 kleiner als ein Maximum:

def sum_3_5(max):
    """
    bilde Summe der Vielfachen von 3 und 5 kleiner als max.
    Beispielsweise liefert sum_3_5(10) 23, weil
        die Vielfachen von 3 < 10 sind
            3 + 6 + 9 = 18
        die Vielfachen von 5 < 10 sind
            5
        18 + 5 = 23
    sum_3_5(20) liefert 78, weil
        3+  6+9+   12+15+18=63
          5+    10+        =15 (15 ist in obiger Liste schon enthalten!)
    sum_3_5(25) liefert 143, weil
        3+  6+9+   12+   18+   21+24=93 (Vielfache von 5 stehen darunter)
          5+    10+   15+   20      =50
    sum_3_5(100) liefert 2318 (ohne Beweis)
    """
    summe = 0
    i = 0
    while i < max:
        if i % 5 == 0:
            summe += i
        elif i % 3 == 0:
            summe += i
        i += 1
    return summe

Die Laufvariable i wird immer dann zur summe dazugezählt, wenn sie durch 5 teilbar ist oder wenn sie durch 3 teilbar ist. Der Operator % berechnet den Rest der Division. Ist der Rest 0, so ist die erste durch die zweite Zahl teilbar. Das Beispiel zum finden des nächstkleineren bzw. gleichen Quadrats kann so mit einer Probiermethode gelöst werden:

def minquad(zahl):
    """finde die nächstkleinere oder gleichgroße ganze Zahl, die eine 
    Quadratzahl ist. Beispiele:
        minquad(16) -> 16 (weil 4 * 4 = 16 <= 16)
        minquad(24) -> 24 (weil 4 * 4 = 16 <= 14)
        minquad(25) -> 25 (weil 5 * 5 = 25 <= 25)
        minquad(26) -> 25 (weil 5 * 5 = 25 <= 26)
    """
    i = 0
    mq = 0
    while i ** 2 <= zahl:
        mq = i ** 2
        i += 1
    return mq

i ** 2 bedeutet i². Man könnte natürlich auch i * i schreiben. Diese Funktion prüft einfach sukzessive alle Quadrate, bis eines gefunden wurde, das größer als die gegebene Zahl ist. Der Wert davor (die Variable mq) ist natürlich das Ergebnis, weil das der größte Wert war, für den die Bedingung gilt. Es geht natürlich schneller und einfacher, wenn man sich eine Formel überlegt:

from math import sqrt
from math import floor
def minquad(zahl):
    """finde die nächstkleinere oder gleichgroße ganze Zahl, die eine 
    Quadratzahl ist. Beispiele:
        minquad(16) -> 16 (weil 4 * 4 = 16 <= 16)
        minquad(24) -> 16 (weil 4 * 4 = 16 <= 24)
        minquad(25) -> 25 (weil 5 * 5 = 25 <= 25)
        minquad(26) -> 25 (weil 5 * 5 = 25 <= 26)
    """
    return int(floor(sqrt(zahl))) ** 2

Die Funktion floor(x) liefert die nächstkleinere ganze Zahl zu x (bei positiven Zahlen schneidet dir Funktion die Nachkommastellen der übergebenen Zahl ab). Z.B:

>>> from math import floor
>>> floor(3.14)
3
>>> floor(3)
3
>>> floor(-3.14)
-4

Wenn man die nächstkleinere ganze Zahl der Wurzel quadriert, hat man das gewünschte Ergebnis. Die Turtle-Funktion zum Dreieckzeichnen könnte wie folgt aussehen und braucht nicht weiter erklärt werden:

def dreieck(a, w):
    """zeichnet ein gleichseitiges Dreieck der Seitenlänge a, gedreht um
    den Winkel w. w = 0 bedeutet, dass die eine Seite horizional ist. w = 90
    bedeutet, dass das Dreieck nach LINKS um 90° gedreht ist, d.h. eine Seite
    ist vertikal.
    Das Dreieck soll rechts neben des angegebenen Punktes gezeichnet werden.
    """
    # nehme an Turtle sieht nach oben (wie auch beim Starten)
    right(90 - w)
    pendown()
    for i in range(3):
        forward(a)
        left(120)
    penup()
    left(90 - w)

Um ein Dreieck an eine bestimmte Position zu setzen, kann zusätzlich die Funktion setpos(x, y), welche die Turtle an die Postion x,y setzt, verwendet werden:

def dreieck_an_pos(a, w, x, y):
    """zeichnet ein Dreieck mit Hilfe der Funktion dreieck(a, w) an der 
    Position x, y."""
    penup()
    setpos(x, y)
    dreieck(a, w)

Abgesehen von den Turtle-Funktionen können Sie die Funktionen direkt auf der Website http://codepad.org testen. Dort können Sie auch andere Programmiersprachen probieren. Die Python-Version ist leider nicht aktuell, daher könnte es sein, dass einiges doch nicht direkt so funktioniert. Diese einfachen Beispiele funktionieren aber.
Hier ist zu minquad(zahl) zu sehen:

Datum in C selbst gebastelt

2010-12-02T12:20:00.001+01:00

Datumsberechnungen sind immer wieder eine Quelle großer langwieriger, fehleranfälliger Programmteile. Vor allem in Sprachen, die solche Datumsoperationen nicht unterstützen. Sie sind auch immer wieder geeignet, Programmieren zu üben. Hier die Musterlösung zu einem einfachen Kalenderprogramm in C, bei dem ein Großteil der Datumsfunktionen selbstgestrickt sind. Viel Spaß damit!
Verwendung:
Ohne Parameter gibt es einfach das aktuelle Monat mit Markierung < 2> für den heutigen Tag und : 8: als Markierung für österreichische Feiertage. Danach wird die Liste der Feiertage ausgegeben.

$ ./cal 
Dezember 2010

    Montag       6  13  20  27     
  Dienstag       7  14  21  28     
  Mittwoch   1 : 8: 15  22  29     
Donnerstag < 2>  9  16  23  30     
   Freitag   3  10  17 :24::31:    
   Samstag   4  11  18 :25:        
   Sonntag : 5::12::19::26:    

 5.12. 2. Advent
 8.12. Maria Empfängnis
12.12. 3. Advent
19.12. 4. Advent
24.12. Heiligabend
25.12. Christtag
26.12. Stefanitag
31.12. Silvester :-)

Here comes the Source...

/*
 * File:    cal.c
 *
 * Zweck:   Kalenderprogramm
 *          ...für ein gegebenes Monat.
 *          mit/ohne argc/argv
 *
 * Autor:   Harald Haberstroh
 *
 * Algorithmus:
 *
 * History: 2002-09-29
 *          2003-10-15, Feiertage + Argumente von main()
 *          2004-11-05, Liste der Feiertage
 */

/*--------------------------- includes ------------------------------*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>

/*--------------------------- defines -------------------------------*/
#define  WOCHENTAG   3                 /* Wochentag des 1.1.1582 */
#define  MONTAG 0
#define  DIENSTAG 1
#define  MITTWOCH 2
#define  DONNERSTAG 3
#define  FREITAG 4
#define  SAMSTAG 5
#define  SONNTAG 6

/*--------------------------- typedefs ------------------------------*/

/*--------------------------- globals -------------------------------*/
enum {
   KEIN = 0,
   NEUJAHR,
   HL3KOENIGE,
   ASCHERMITTWOCH,
   PALMSONNTAG,
   KARFREITAG,
   OSTERSONNTAG,
   OSTERMONTAG,
   STAATSFEIERTAG,
   MUTTERTAG,
   PFINGSTSONNTAG,
   PFINGSTMONTAG,
   DREIFALTIGKEITSSONNTAG,
   FRONLEICHNAM,
   MARIAHIMMELFAHRT,
   NATIONALFEIERTAG,
   REFORMATIONSTAG,
   ALLERHEILIGEN,
   ALLERSEELEN,
   MARIAEMPFAENGNIS,
   ADVENT1,
   ADVENT2,
   ADVENT3,
   ADVENT4,
   HEILIGABEND,
   CHRISTIANI,
   STEFANI,
   SILVESTER
};

/*-------------------------- prototypes -----------------------------*/
void printFeiertage(int jahr, int monat);
int tagemonat( int jahr, int monat );
int sonntag( int jahr, int monat, int tag );
void tag2datum( int tagzahl, int *jahr, int *monat, int *tag );
void ostern( int jahr, int *monat, int *tag );
int feiertag(int jahr, int monat, int tag);
int anzProMonat(int jahr, int monat);
void printcal(int start, int anz, int heute, int monat, int jahr);
int schaltjahr( int Jahr );
int Anzahl_Tage( int Jahr, int Monat, int Tag );

/*----------------------------- main --------------------------------*/
int main( int argc, char *argv[] )
{
   int tage, tag, monat, jahr, start;
   struct tm *zeit;
   time_t   sec;

   if (argc == 2 && strcmp(argv[1], "-i") == 0)
   {                                   /* interaktiv */
      printf("Jahr> ");scanf("%d", &jahr);
      printf("Monat> ");scanf("%d", &monat);
      printf("Tag (0 für kein bestimmter)> ");scanf("%d", &tag);
      if (tag == 0)
      {
         tag = 1;
         if (1 <= monat && monat <= 12 &&
             1582 < jahr && jahr < 3000)
         {
            tage = Anzahl_Tage( jahr, monat, 1);
            start = (tage + WOCHENTAG) % 7;
            printcal(start, anzProMonat(jahr, monat), 0, monat, jahr);
            return 0;
         }
         else
         {
            fprintf(stderr, "Monat zwischen 1 und 12 und Jahr zwischen "
                            "1583 und 2999\n");
            return 2;
         }
      }
      if (1 <= monat && monat <= 12 &&
          1582 < jahr && jahr < 3000 &&
          1 <= tag && tag <= anzProMonat(jahr,monat))
      {
         tage = Anzahl_Tage( jahr, monat, 1);
         start = (tage + WOCHENTAG) % 7;
         printcal(start, anzProMonat(jahr, monat), tag, monat, jahr);
         return 0;
      }
      else
      {
         fprintf(stderr, "Monat zwischen 1 und 12 und Jahr zwischen "
                         "1583 und 2999\n"
                         "[Tag zwischen 1 und Anzahl für dieses Monat]\n");
         return 2;
      }
   }
   else if (argc == 3)                      /* Monat, Jahr */
   {
      monat = atoi(argv[1]);
      jahr = atoi(argv[2]);
      tag = 1;
      if (1 <= monat && monat <= 12 &&
          1582 < jahr && jahr < 3000)
      {
         tage = Anzahl_Tage( jahr, monat, 1);
         start = (tage + WOCHENTAG) % 7;
         printcal(start, anzProMonat(jahr, monat), 0, monat, jahr);
         return 0;
      }
      else
      {
         fprintf(stderr, "Monat zwischen 1 und 12 und Jahr zwischen "
                         "1583 und 2999\n");
         return 2;
      }
   }
   else if (argc == 4)                 /* ganzes Datum */
   {
      monat = atoi(argv[2]);
      jahr = atoi(argv[3]);
      tag = atoi(argv[1]);
      if (1 <= monat && monat <= 12 &&
          1582 < jahr && jahr < 3000 &&
          1 <= tag && tag <= anzProMonat(jahr,monat))
      {
         tage = Anzahl_Tage( jahr, monat, 1);
         start = (tage + WOCHENTAG) % 7;
         printcal(start, anzProMonat(jahr, monat), tag, monat, jahr);
         return 0;
      }
      else
      {
         fprintf(stderr, "Monat zwischen 1 und 12 und Jahr zwischen "
                         "1583 und 2999\n"
                         "[Tag zwischen 1 und Anzahl für dieses Monat]\n");
         return 2;
      }
   }
   else if (argc == 1)                 /* aktuelles Monat */
   {
      time(&sec);
      zeit = localtime(&sec);
      tag = zeit->tm_mday;
      monat = zeit->tm_mon + 1;
      jahr = zeit->tm_year + 1900;
      tage = Anzahl_Tage( jahr, monat, 1);
      start = (tage + WOCHENTAG) % 7;
      printcal(start, anzProMonat(jahr, monat), tag, monat, jahr);
      return 0;
   }
   else
   {
      fprintf(stderr, "Aufruf:\n%s [[tag] monat jahr]\n", argv[0]);
      return 1;
   }
}

/*-------------------------- functions ------------------------------*/
/** Kalender ausgeben
 *  start ... Wochentag des 1. dieses Monats
 *  anz   ... Anzahl der Tage dieses Monats
 *  heute ... Datum des heutigen Tages, 0, falls in einem anderen Monat
 *  monat ... Monat (1..12)
 *  jahr
 */
void printcal(int start, int anz, int heute, int monat, int jahr)
{
   char *tage[] = { "Montag", "Dienstag", "Mittwoch", "Donnerstag",
                    "Freitag", "Samstag", "Sonntag" };
   char *monate[] = { "Jänner", "Februar", "März", "April",
                      "Mai", "Juni", "Juli", "August",
                      "September", "Oktober", "November", "Dezember" };
   int i;
   int tag;

   printf("%s %d\n\n", monate[monat-1], jahr);
   for (i = 0; i < 7; i++)
   {
      printf("%10s ", tage[i]);
      for (tag = i + 1 - start; tag < anz + 7 + start; tag += 7)
         if (tag == heute && feiertag(jahr, monat, tag)
               && tag >= 1 && tag <= anz)
            printf("[%2d]", tag);
         else if (tag == heute && tag >= 1 && tag <= anz)
            printf("<%2d>", tag);
         else if (feiertag(jahr, monat, tag) && tag >= 1 && tag <= anz)
            printf(":%2d:", tag);
         else if (tag >= 1 && tag <= anz)
            printf("%3d ", tag);
         else
            printf("    ");
      printf("\n");
   }
   printf("\n");
   printFeiertage(jahr, monat);
}

/*
 * Function schaltjahr
 *
 * Zweck:   Liefert 1, wenn angegebenes Jahr ein Schaltjahr ist
 *
 * Algorithmus:
 *          ab 1582 gilt folgende Regel für Schaltjahre:
 *             Ist die Jahreszahl durch 400 teilbar oder
 *             ist die Jahreszahl durch 4 teilbar aber nicht durch 100
 *             dann ist das Jahr ein Schaltjahr
 *
 * Parameter:
 *       IN: Jahr
 *      OUT:
 *
 * Return-Wert: 1 ... Schaltjahr
 *              0 ... sonst
 */
int schaltjahr( int Jahr )
{
   if ( Jahr % 400 == 0 )
      return 1;
   else if ( Jahr % 100 == 0 )
      return 0;
   else if ( Jahr % 4 == 0 )
      return 1;
   else 
      return 0;
}

int anzProMonat(int jahr, int monat)
{
   switch(monat)
   {
      case 2:
         return 28 + schaltjahr(jahr);
         break;
      case 4:
      case 6:
      case 9:
      case 11:
         return 30;
         break;
      default:
         return 31;
   }
}

/*
 * Function Anzahl_Tage
 *
 * Zweck:    Bestimmt die Anzahl der Tage ab 1.1.1582
 *
 * Algorithmus:
 *           Tag + Anzahl Tage für Monate + Anzahl Tage für Jahre
 *
 * Parameter:
 *       IN: Jahr, Monat, Tag
 *      OUT:
 *
 * Return-Wert: Anzahl der Tage ab 1.1.1582
 */
int Anzahl_Tage( int Jahr, int Monat, int Tag )
{
   int   j;
   int   m;
   int   tage = Tag; /* Monatstag */

   /*
    * Tage für Jahre berechnen
    */
   for ( j = 1582; j < Jahr; j++ )
      tage += 365 + schaltjahr( j );

   /*
    * Tage für Monate berechnen
    */
   for ( m = 1; m < Monat; m++ )
      switch( m )
      {
         case 2:
            tage += 28 + schaltjahr( Jahr );
            break;
         case 4:
         case 6:
         case 9:
         case 11:
            tage += 30;
            break;
         default:
            tage += 31;
      }
   return( tage );
}

/** Bestimmt Feiertag.
 *  @param jahr
 *  @param monat
 *  @param tag
 *  @return Nummer des Feiertags, 0 sonst
 */
int feiertag(int jahr, int monat, int tag)
{
   int tagzahl, j, m, t;
   ostern(jahr, &m, &t);
   tagzahl = Anzahl_Tage(jahr, m, t);
   
   if (monat == m && tag == t)         /* Ostern */
      return OSTERSONNTAG;
   tag2datum(tagzahl + 1, &j, &m, &t);
   if (monat == m && tag == t)         /* Ostern */
      return OSTERMONTAG;
   tag2datum(tagzahl - 46, &j, &m, &t);
   if (monat == m && tag == t)         /* Aschermittwoch */
      return ASCHERMITTWOCH;
   tag2datum(tagzahl - 7, &j, &m, &t);
   if (monat == m && tag == t)         /* Palmsonntag */
      return PALMSONNTAG;
   tag2datum(tagzahl - 2, &j, &m, &t);
   if (monat == m && tag == t)         /* Karfreitag */
      return KARFREITAG;
   tag2datum(tagzahl + 49, &j, &m, &t);
   if (monat == m && tag == t)         /* Pfingstsonntag */
      return PFINGSTSONNTAG;
   tag2datum(tagzahl + 50, &j, &m, &t);
   if (monat == m && tag == t)         /* Pfingstmontag */
      return PFINGSTMONTAG;
   tag2datum(tagzahl + 56, &j, &m, &t);
   if (monat == m && tag == t)         /* Dreifaltigkeitssonntag */
      return DREIFALTIGKEITSSONNTAG;
   tag2datum(tagzahl + 60, &j, &m, &t);
   if (monat == m && tag == t)         /* Fronleichnam */
      return FRONLEICHNAM;

   if (monat == 1 && tag == 1)         /* Neujahr */
      return NEUJAHR;
   if (monat == 1 && tag == 6)         /* Heilige 3 Könige */
      return HL3KOENIGE;
   if (monat == 5 && tag == 1)         /* Staatsfeiertag */
      return STAATSFEIERTAG;
   tag2datum(sonntag(jahr, 5, 13), &j, &m, &t);
   if (monat == 5 && tag == t)         /* Muttertag FIXME */
      return MUTTERTAG;
   if (monat == 8 && tag == 15)        /* Mariahimmelfahrt */
      return MARIAHIMMELFAHRT;
   if (monat == 10 && tag == 26)       /* Nationalfeiertag */
      return NATIONALFEIERTAG;
   if (monat == 10 && tag == 31)       /* Reformationstag */
      return REFORMATIONSTAG;
   if (monat == 11 && tag == 1)        /* Allerheiligen */
      return ALLERHEILIGEN;
   if (monat == 11 && tag == 2)        /* Allersselen */
      return ALLERSEELEN;
   if (monat == 11)
   {
      if (sonntag(jahr, 12, 24) == Anzahl_Tage(jahr, 12, 24))
         tagzahl = sonntag(jahr, 12, 24) - 21;
      else
         tagzahl = sonntag(jahr, 12, 24) - 28;
      tag2datum(tagzahl, &j, &m, &t);
      if (tag == t && m == 11)         /* 1. Advent */
         return ADVENT1;
   }
   if (monat == 12)
   {
      if (tag == 8)                    /* Maria Emfängnis */
         return MARIAEMPFAENGNIS;

      if (sonntag(jahr, 12, 24) == Anzahl_Tage(jahr, 12, 24))
         tagzahl = sonntag(jahr, 12, 24) - 21;
      else
         tagzahl = sonntag(jahr, 12, 24) - 28;
      tag2datum(tagzahl, &j, &m, &t);
      if (tag == t && m == 12)         /* 1. Advent */
         return ADVENT1;
      tag2datum(tagzahl+7, &j, &m, &t);
      if (tag == t)                    /* 2. Advent */
         return ADVENT2;
      tag2datum(tagzahl+14, &j, &m, &t);
      if (tag == t)                    /* 3. Advent */
         return ADVENT3;
      tag2datum(tagzahl+21, &j, &m, &t);
      if (tag == t)                    /* 4. Advent */
         return ADVENT4;
      if (tag == 24)                   /* Hl. Abend */
         return HEILIGABEND;
      if (tag == 25)                   /* Christiani */
         return CHRISTIANI;
      if (tag == 26)                   /* Stefanitag */
         return STEFANI;
      if (tag == 31)                   /* Silvester :-) */
         return SILVESTER;
   }

   return KEIN;                        /* Kein Feiertag */
}

void ostern( int jahr, int *monat, int *tag )
{
   int a = jahr % 19;
   int b = jahr / 100;
   int c = jahr % 100;
   int d = b / 4;
   int e = b % 4;
   int f = ( b + 8 ) / 25;
   int g = ( b - f + 1 ) / 3;
   int h = ( 19 * a + b - d - g + 15 ) % 30;
   int i = c / 4;
   int k = c % 4;
   int l = ( 32 + 2 * e + 2 * i -h -k ) % 7;
   int m = ( a + 11 * h + 22 * l ) / 451;
   int p = ( h + l - 7 * m + 114 ) % 31;

   *monat = ( h + l - 7 * m + 114 ) / 31;
   *tag = p + 1;
}
void tag2datum( int tagzahl, int *jahr, int *monat, int *tag )
{
   /*
    * Jahr berechnen
    */
   *jahr = 1582;
   while ( tagzahl > 365 + schaltjahr( *jahr ) )
   {
      tagzahl -= 365 + schaltjahr( *jahr );
      (*jahr)++;
   }
   /*
    * Monat
    */
   for ( *monat = 1; tagzahl > tagemonat( *jahr, *monat ); (*monat)++ )
      tagzahl -= tagemonat( *jahr, *monat );
   /*
    * Tag
    */
   *tag = tagzahl;
}

int sonntag( int jahr, int monat, int tag )
{
   int tagzahl = Anzahl_Tage( jahr, monat, tag );
   int wt = ( DONNERSTAG + tagzahl ) % 7;
   if ( wt == SONNTAG ) /* bereits Sonntag */
      return tagzahl;
   else
      return tagzahl + ( SONNTAG - wt );
}
int tagemonat( int jahr, int monat )
{
   switch( monat )
   {
      case 2:
         return 28 + schaltjahr( jahr );
         break;
      case 4:
      case 6:
      case 9:
      case 11:
         return 30;
         break;
      default:
         return 31;
   }
}

/** gib eine Liste der Feiertage aus.
 *  @param jahr IN
 *  @param monat OUT
 */
void printFeiertage(int jahr, int monat)
{
   int i;
   char *bez = "";
   for (i = 1; i <= tagemonat(jahr, monat); i++)
   {
      bez = "";
      switch (feiertag(jahr, monat, i))
      {
         case NEUJAHR:
            bez = "Neujahr";
            break;
         case HL3KOENIGE:
            bez = "Heilige Dreikönige";
            break;
         case ASCHERMITTWOCH:
            bez = "Aschermittwoch";
            break;
         case PALMSONNTAG:
            bez = "Palmsonntag";
            break;
         case KARFREITAG:
            bez = "Karfreitag";
            break;
         case OSTERSONNTAG:
            bez = "Ostersonntag";
            break;
         case OSTERMONTAG:
            bez = "Ostermontag";
            break;
         case STAATSFEIERTAG:
            bez = "Staatsfeiertag";
            break;
         case MUTTERTAG:
            bez = "Muttertag";
            break;
         case PFINGSTSONNTAG:
            bez = "Pfingstsonntag";
            break;
         case PFINGSTMONTAG:
            bez = "Pfingstmontag";
            break;
         case DREIFALTIGKEITSSONNTAG:
            bez = "Dreifaltigkeitssonntag";
            break;
         case FRONLEICHNAM:
            bez = "Fronleichnam";
            break;
         case MARIAHIMMELFAHRT:
            bez = "Maria Himmelfahrt";
            break;
         case NATIONALFEIERTAG:
            bez = "Nationalfeiertag";
            break;
         case REFORMATIONSTAG:
            bez = "Reformationstag";
            break;
         case ALLERHEILIGEN:
            bez = "Allerheiligen";
            break;
         case ALLERSEELEN:
            bez = "Allerseelen";
            break;
         case MARIAEMPFAENGNIS:
            bez = "Maria Empfängnis";
            break;
         case ADVENT1:
            bez = "1. Advent";
            break;
         case ADVENT2:
            bez = "2. Advent";
            break;
         case ADVENT3:
            bez = "3. Advent";
            break;
         case ADVENT4:
            bez = "4. Advent";
            break;
         case HEILIGABEND:
            bez = "Heiligabend";
            break;
         case CHRISTIANI:
            bez = "Christtag";
            break;
         case STEFANI:
            bez = "Stefanitag";
            break;
         case SILVESTER:
            bez = "Silvester :-)";
            break;
      }
      if (strlen(bez) > 0)
         printf("%2d.%d. %s\n", i, monat, bez);
   }
}

Übungsbeispiele für Python (POS1: 1BHIF)

2010-12-01T15:12:00.001+01:00

Vervollständigen Sie die folgenden Funktionsdefinitionen und schreiben Sie passende Testaufrufe.

def ist_dreieck(a, b, c):
    """liefert True, wenn durch a, b und c ein gültiges Dreieck definiert
    ist"""
    return True

def ist_quadrat(a, b, w):
    """liefert True, wenn durch a und b sowie dem Winkel w ein 
    Quadrat definiert ist"""
    return True

def ist_schaltjahr(jahr):
    """liefert True, wenn das gegebene Jahr ein Schaltjahr ist.
    Seit Ende 1582 gilt der Gregorianische Kalender, bei dem folgende 
    Regel für die Schaltjahrbestimmung anzuwenden sind:
        In allen Jahren, deren Jahreszahl durch vier teilbar ist, ist
        der 29. Februar ein Schalttag und damit ist dieses Jahr ein 
        Schaltjahr.
        Eine Ausnahme bilden allerdings die vollen Jahrhundertjahre 1700, 
        1800, 1900 usw., auch Säkularjahre genannt. Hiervon erhalten nur 
        diejenigen einen Schalttag, deren Jahreszahl durch 400 teilbar
        ist. Jedes vierte Säkularjahr ist somit ein Schaltjahr.
    Für alle Jahre <= 1582 liefert die Funktion False, weil da das
    Schaltjahr nicht definiert ist, sonst gilt obige Regel."""
    return False

def fib(n):
    """liefert die Fibonaccizahl zu n. Die Zahlen sind wie definiert:
        fib(0) -> 0
        fib(1) -> 1
        fib(2) -> 1
        fib(3) -> 2
        fib(4) -> 3
        fib(5) -> 5
        fib(6) -> 8
        ...
        fib(10) -> 55
        ...
        fib(15) -> 610"""
    return 1

def fibtab(n):
    """erzeugt eine Tabelle der Fibonaccizahlen bis inclusive n.
    z.B. gibt fibtab(10) folgendes aus:
        [0, 1, 1, 2, 3, 5, 8]
    oder fibtab(100):
        [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
    Hinweis:
        verwenden Sie als Zeilenumbruch ", " beim print, also
            print(wert, end=', ')
        außer natürlich beim letzten Wert, hier ist "]" gefordert.
    """
    print("[0, 1, 1, 2, 3, 5, 8]")

def sum_3_5(max):
    """
    bilde Summe der Vielfachen von 3 und 5 kleiner als max.
    Beispielsweise liefert sum_3_5(10) 23, weil
        die Vielfachen von 3 < 10 sind
            3 + 6 + 9 = 18
        die Vielfachen von 5 < 10 sind
            5
        18 + 5 = 23
    sum_3_5(20) liefert 78, weil
        3+  6+9+   12+15+18=63
          5+    10+        =15 (15 ist in obiger Liste schon enthalten!)
    sum_3_5(25) liefert 143, weil
        3+  6+9+   12+   18+   21+24=93 (Vielfache von 5 stehen darunter)
          5+    10+   15+   20+     =50
    sum_3_5(100) liefert 2318 (ohne Beweis)
    """
    return 23

def minquad(zahl):
    """finde die nächstkleinere oder gleichgroße ganze Zahl, die eine 
    Quadratzahl ist. Beispiele:
        minquad(16) -> 16 (weil 4 * 4 = 16 <= 16)
        minquad(24) -> 16 (weil 4 * 4 = 16 <= 24)
        minquad(25) -> 25 (weil 5 * 5 = 25 <= 25)
        minquad(26) -> 25 (weil 5 * 5 = 25 <= 26)
    """
    return zahl

def dreieck(a, w):
    """zeichnet ein gleichseitiges Dreieck der Seitenlänge a, gedreht um
    den Winkel w. w = 0 bedeutet, dass die eine Seite horizional ist. 
    w = 90 bedeutet, dass das Dreieck nach LINKS um 90° gedreht ist, d.h.
    eine Seite ist vertikal.
    Das Dreieck soll rechts neben des angegebenen Punktes gezeichnet
    werden.
    """
    pass

def dreieck_an_pos(a, w, x, y):
    """zeichnet ein Dreieck mit Hilfe der Funktion dreieck(a, w) an der 
    Position x, y."""
    pass

Hier folgt ein Beispielaufruf für die Schaltjahrfunktion:

def test_ist_schaltjahr():
    for jahr in (1000, 1581, 1582, 1900, 1999, 2003):
        assert not ist_schaltjahr(jahr)
    for jahr in (1996, 2000, 2004):
        assert ist_schaltjahr(jahr)
    print("ist_schaltjahr ok")

Sollte ist_schaltjahr() richtig implementiert sein, dann müsste "ist_schaltjahr ok" ausgegeben werden. Andernfalls wird das Programm bei einer der assert-Anweisungen abgebrochen werden. assert verwendet man als Programmierer um Bedingungen zu prüfen, die, falls sie nicht erfüllt sind, auf einen Programmierfehler hinweisen. Als Bedingung kann alles rechts neben dem assert stehen, das True ("alles ok") oder False liefert. Die Testaufrufe für alle Funktionen sollten dann etwa so zusammengefasst werden:

def main():
    """Hauptprogamm zum Testen aller Funktionen"""
    test_ist_dreieck()
    test_ist_quadrat()
    test_ist_schaltjahr()
    test_fib()
    test_sum_3_5()
    test_minquad()
    test_dreieck()
    test_dreieck_an_pos()

Dieses main() muss natürlich auch erst aufgerufen werden (keine Einrückung):

main()

Wenn Sie das Programm laufen lassen, dann sieht sie Ausgabe, wenn alles funktioniert (sinngemäß) so aus:

ist_dreieck ok
ist_quadrat ok
ist_schaltjahr ok
fib ok
sum_3_5 ok
minquad ok

Die Funktionen test_dreieck() sowie test_dreieck_an_pos() bewirken eine Zeichnung der folgenden Art (je nach Aufrufe):

Hier waren es die Aufrufe:

def test_dreieck():
    reset()
    dreieck(60, 0)
    dreieck(60, 90)
    dreieck(60, -60)

def test_dreieck_an_pos():
    dreieck_an_pos(70, 0, 50, 50)
    dreieck_an_pos(70, 180, -50, -50)

Es ist also "optische Kontrolle" nötig.

Multiple-Choice-Tests bearbeiten

2010-11-26T11:13:00.000+01:00

Optionale Aufgabe (freiwillig)!
Schreiben Sie ein Programm, das eine Datenstruktur, mit der man Multiple-Choice-Tests erzeugen kann, aus einer Textdatei erstellt. Das Format der Textdatei soll anhand eines Beispiels gezeigt werden:

Das ist der einleitende Text, der einfach in einen String Namens "einleitung"
gelesen werden soll. Mit allen Zeichen und Zeilenumbrüchen. Diese Einleitung
endet mit zwei leeren Zeilen.


Das ist die erste Frage. Der Text dieser Frage kann sich auch über mehrere
Zeilen erstrecken. Allerdings soll so ein Text ohne die Zeilenumbrüche
übernommen werden (Zeilenümbrüche durch Leerzeichen ersetzen). Die weiteren
Informationen sind durch mindestens zwei Leerzeichen eingerückt gleich nach
diesem Text. Optional darf eine Leerzeile stehen.

  Optionaler Text, der wie die Einleitung mit allen Umbrüchen so übernommen
  werden soll, wie er in der Datei ist, jedoch ohne die Einrückung. Alle
  weiteren Informationen kommen wieder eingerückt, optional mit einer 
  Leerzeile abgetrennt. Die Punkte für diese Frage sind in runde Klammern
  zu setzen (am Anfang der Zeile mit Einrückung). Gibt es keine Punkte,
  so ist 1 zu verwenden.
  Optional kann in { } eine Zahl > 0 und <= 1 angegeben werden, welche
  als "Faktor" zu interpretieren ist. Wieder nur mit passender Einrückung.
  (Der Faktor soll angeben, welcher Anteil an richtigen und falschen
  Antworten dann bei der Erzeugung der Tests verwendet werden soll, 0.5 
  bedeutet die Hälfte).
  (2)
  {0.75}

  [X] Das ist eine richtige Antwort.
  [ ] Das ist eine falsche Antwort.

  [X] Das ist eine richtige Antwort, die sich
      über mehrere Zeilen erstrecken kann.
  [ ] Das ist eine falsche Antwort, die sich
      über mehrere Zeilen erstrecken kann.
      Die Einrückung ist wieder wesentlich. Die
      Zeilenumbrüche und die Einrückung sind
      zu entfernen.


Das ist die nächste Frage, sie wird mit zwei Leerzeilen von der 
vorigen abgetrennt. Es muss keine weitere Information angegeben
sein. In diesem Fall wäre es eine 1-Punkte-Frage ohne Auswahl-
möglichkeiten, also eine direkt zu beantwortende Frage.


Die Dritte Frage. Ist nun eine 1-Punkte Frage ohne Faktor und
ohne Text.
  [ ] Falsche Lösung.
  [X] Richtige Lösung.
  [ ] Falsche Lösung.

Am Ende der Datei brauchen natürlich keine Leerzeilen mehr sein. Das Programm soll solche Dateien einlesen und folgende Variable setzen: einleitung mit dem einleitenden Text. fragen, einer Liste von Fragen. Jede Frage ist ein Dictionary mit folgenden Schlüssel und Werten:

"frage" mit dem Text der Frage.
"text" mit dem optionalen Text (oder eben nicht).
"punkte" mit den gelesenen Punkten oder 1.
"faktor" mit dem gelesenen Faktor (oder gar nicht).
"richtig" mit einer Liste der richtigen Antworten (ohne "[X]").
"falsch" mit einer Liste der richtigen Antworten (ohne "[ ]").

Verwalten einer Hitliste (POS1: 2AHIF, 2CHIF)

2010-11-12T07:33:00.004+01:00

Erstellen Sie ein Pythonprogramm, welches Musik-Charts verwalten kann. Das Use Case Diagramm zeigt die möglichen Anwendungsfälle.

Songs eingeben

Titel und Interpret sind einzugeben.

Voting erfassen

Zu einem bestimmten Titel soll die Anzahl der Stimmen (das Voting) eingegeben werden. Die Auswahl des Titels könnte z.B. über eine Suche erfolgen.

Hitliste ausgeben

Die Liste der Songs (Titel, Interpret, Voting) soll in der Reihenfolge des Votings (mehr Stimmen zuerst) ausgegeben werden.

Songs aus Datei lesen

Die Liste der Songs (Titel, Interpret - ohne Voting) soll aus einer Datei gelesen werden. Das Dateiformat kann beliebig gewählt werden. z.B. Zeilen in der Form Titel;Interpret.

Songs in Datei speichern

Die Liste der Songs (Titel, Interpret - ohne Voting) soll in einer Datei gespeichert werden. Dateiformat wie oben.

Hitliste speichern

Die Hitliste (Titel, Interpret und Voting) soll in einer Datei gespeichert werden. Das Dateiformat kann beliebig gewählt werden. z.B. Zeilen in der Form Titel;Interpret;Voting.

Hitliste laden

Die Hitliste (Titel, Interpret und Voting) soll aus einer Datei gelesen werden. Das Dateiformat wie oben.

Beispielsitzung

$ python charts.py
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 1
Titel>>> Peter Gunn
Interpret>>> Emerson, Lake & Palmer
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 1
Titel>>> Haitian Fight Song
Interpret>>> Charles Mingus
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 5
Dateiname [songs.txt] >>>
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 4
Dateiname [songs.txt] >>>
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 3
Peter Gunn                     Emerson, Lake & Palmer         0
Haitian Fight Song             Charles Mingus                 0
Gamma Ray                      Birth Control                  0
Spectrum                       Billy Cobham                   0
Take Five                      Dave Brubek                    0
Overnite Sensation             Frank Zappa                    0
Sing, Sing, Sing               Gene Krupa                     0
Bahamut                        Hazmat Modine                  0
Cantaloupe Island              Herbie Hankock                 0
Blue Train                     John Coltraine                 0
North Carolina                 Les McCann                     0
Pressure                       Mary Broadcast Band            0
Mile Stones                    Miles Davis                    0
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 2
Titel (oder Teil)>>> Peter
Voting für Peter Gunn >>> 23
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 3
Peter Gunn                     Emerson, Lake & Palmer         23
Haitian Fight Song             Charles Mingus                 0
Gamma Ray                      Birth Control                  0
Spectrum                       Billy Cobham                   0
Take Five                      Dave Brubek                    0
Overnite Sensation             Frank Zappa                    0
Sing, Sing, Sing               Gene Krupa                     0
Bahamut                        Hazmat Modine                  0
Cantaloupe Island              Herbie Hankock                 0
Blue Train                     John Coltraine                 0
North Carolina                 Les McCann                     0
Pressure                       Mary Broadcast Band            0
Mile Stones                    Miles Davis                    0
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 2
Titel (oder Teil)>>> Gamm
Voting für Gamma Ray >>> 25
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 3
Gamma Ray                      Birth Control                  25
Peter Gunn                     Emerson, Lake & Palmer         23
Haitian Fight Song             Charles Mingus                 0
Spectrum                       Billy Cobham                   0
Take Five                      Dave Brubek                    0
Overnite Sensation             Frank Zappa                    0
Sing, Sing, Sing               Gene Krupa                     0
Bahamut                        Hazmat Modine                  0
Cantaloupe Island              Herbie Hankock                 0
Blue Train                     John Coltraine                 0
North Carolina                 Les McCann                     0
Pressure                       Mary Broadcast Band            0
Mile Stones                    Miles Davis                    0
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 7
Dateiname [charts.txt] >>>
0 Ende
1 Songs eingeben
2 Voting erfassen
3 Hitliste
4 Songs aus Datei lesen
5 Songs in Datei speichern
6 Hitliste aus Datei lesen
7 Hitliste in Datei speichern
>>> 0
$

Abgabe

Nennen Sie das Projekt 2x-name-python-charts, wobei x "a" für 2AHIF und "c" für 2CHIF und name Ihr Familienname sein soll (bei Namensgleichheit machen Sie bitte 2x-name-vorname-python-charts daraus). Das Programm selbst soll charts.py heißen.

Erzeugen Sie Testdaten (Dateien mit Songs und Hitlisten), sodass das Programm nach dem Auschecken direkt getestet werden kann.

Checken Sie das Projekt am CVS ein und "commiten" Sie Ihre letzte Version.

Code-Kata

2010-11-11T16:00:00.001+01:00

Beim Karate (z.B. Karatedo Doshinkan) gibt es Kata (dt. "Form", siehe auch Kata auf Wikipedia), eine spezielle Übungsform, bei der man als Training gegen einen oder mehrere (vorgestellte) Gegner kämpft. Dabei ist der Bewegungsablauf aber stilisiert und fix vorgegeben. Das oftmalige Wiederholen der Bewegungsabläufe in Form von Kata ist unerlässlich für den persönlichen Fortschritt. Denn nur Übung macht den Meister.

Auch Programmieren beherrscht man nur durch ständiges Training. Nur durch Üben wird man auch hier zum Meister. Aber nicht nur durch den Kampf (Programmieren für das Geschäft) sondern auch durch Katas. Diese Idee für's Programmieren hat Dave Thomas von den Pragmatischen Programmieren (meines Wissens) erstmalig aufgegriffen und publiziert: Code Kata

Sehr empfehlenswert für alle, die Programmieren meistern wollen.

Die Idee der Code Kata fasziniert und berührt mich besonders, da ich selber jahrelang trainiert habe.

Programmieren mit Harald R. Haberstroh

Java -> Python (POS1: 2B)

Abgaben am CVS (POS1: 2., 3. Klassen)

Überlauf mit C-Datentypen in Python

vim Übung

vim Einführung

Bash (Shell) (POS1: 2B)

Ergänzung der Kommandozeile

History

Beispiele ($ stellt den Prompt dar, alles hinter # gilt als Kommentar):

Job-Control

Befehlssyntax

Wildcards

Abkürzungen

Shell-Variable

Ein-/Ausgabeumlenkung

Wichtige Kommandos

Fortgeschrittenes

Hilfe

Weitere Informationen

Fragen

Commandline resurrected

Programmierrichtlinien haben doch Sinn (III)

Fehlerbehandlung

Listings - Source Code drucken

Autoboxing in Java

Programmierrichtlinien haben doch Sinn (II)

Programmierrichtlinien haben doch Sinn

Aufgaben zu verketteten Listen und binären Bäumen (POS1: 2A, 2C)

Aufgaben zu Collections in Java (POS1: 2A, 2C)

Aufgabe: Interfaces (POS1: 2A, 2C)

Beispiele zu Gleitkommadarstellung (POS1: 1B)

Zurückrechnen

Zahlenbereich

Aufgabe zu Vererbung in Java (POS1: 2A, 2C)

Locking- und Updateprobleme mit RMI (PR: 5A, 5B)

Serialisierungsprobleme mit RMI (PR: 5A, 5B)

Package für Data, Header, Record (PR: 5A, 5B)

Refactoring Data - Interface Record (PR: 5A, 5B)

RoboCupJunior 2011 in Wels

Aufgabe Gruppenwechsel Ski (POS1: 2A, 2C)

Binäres Dateiformat für Eingabe

GUI für RMI-Client (PR: 5A, 5B)

Aufrufstack (Call Stack) (POS1: 2A, 2C)

Quadcopter spielen Tennis

Literaturverwaltung - RandomAccessFile (POS1: 2A, 2C)

Experimente mit Queues (POS1-2: 2A, 2C, PR: 5A, 5B)

RMI-Client/Server mit Java (PR: 5A, 5B)

Binärdateien bearbeiten mit Java - Zusatz für Client (PR: 5A, 5B)

Lösungen zu "Übungsbeispiele zu Sequenzen, Schleifen und Funktionen in Python" (POS1: 1B)

Übungsbeispiele zu Sequenzen, Schleifen und Funktionen in Python (POS1: 1B)

SAR (ROB: 2C)

Java Übungen und Aufgabe (POS1: 2A, 2C)

Klassen, Objekte

Arrays

Streams, Strings

Random, Calendar, Kommandozeile, Streams

Prüfen Sie Ihr Wissen (POS1: 2A, 2C)

Klammerprüfung mittels Stack (POS1: 2A, 2C)

Erweiterung um Programmargumente und Dateien

Detaillierte Fehlermeldungen

Binärdateien bearbeiten mit Java (PR: 5A, 5B)

Datenformat

Testdatei machines.db

Testen der Klasse Data

Downloads

Abgabe

Wie geht's weiter

Schwerpunkt Programmieren (PR: 5A, 5B)

Python -> Java (POS1: 2A, 2C)

Zählen von Zeichen aus einer Menge (POS1: 2A, 2C)

Ermittle die Top-10 der Worte in einem Text (POS1: 2A, 2C)

Aufgabe 1

Aufgabe 2

Aufgabe 3

Mögliche Lösung

Vollständiges Programm (ohne Header)

Ganze Zahlen zählen (Schleife, Sequenzen, Funktionen POS1: 1BHIF)

Beispiele zeichenweise Bearbeitung, Java (POS-1: 2A, 2C)

Anzahl der Strings in der Eingabe ermitteln

Beispiele (`$` stellt den Prompt dar, alles hinter `#` gilt als Kommentar):