Dokumentation zur L¨osung der Aufgaben des 22...

Dokumentation zur Losung derAufgaben des 22. Bundeswettbewerb

Informatik

Moritz Beller

Marcel Schmittfull

16. November 2003

Inhaltsverzeichnis

1 Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Raff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.1 Programmbesprechung . . . . . . . . . . . . . . . . . . . . . . . . 42.2 Ergebnisse fur versch. Tageskurs-Tabellen . . . . . . . . . . . . . 72.3 Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 Keuch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.1 Bewusstes Alarmauslosen . . . . . . . . . . . . . . . . . . . . . . 123.2 Zellservererweiterungen . . . . . . . . . . . . . . . . . . . . . . . . 133.3 Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4 Flitz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.1 Das soziale Verhalten . . . . . . . . . . . . . . . . . . . . . . . . . 224.2 Die drei Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . 244.3 Quellcode und Programmhinweis . . . . . . . . . . . . . . . . . . 26

5 Babbel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375.1 Teilaufgabe Eins . . . . . . . . . . . . . . . . . . . . . . . . . . . 375.2 Teilaufgabe Zwei . . . . . . . . . . . . . . . . . . . . . . . . . . . 385.3 Teilaufgabe Drei . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

2

1. VORWORT 22. BwInf, 1. Runde 3

1 Vorwort

Wahrend der Arbeiten an den gestellten Aufgaben stand fur die Autoren vor allem dasgeschickte Losen dieser im Vordergrund. Dabei mussten sie oft einsehen, dass Kompro-misse zwischen der eigentlichen Aufgabenstellung und der praktischen Durchfuhrbarkeitunabdingbar waren, um die Aufgaben in einem sinnvollen Zeitrahmen losen zu konnen.Bei gegebener Stelle weisen die Autoren darauf bei der Programmbesprechung detail-lierter hin.

Leider war es ihnen auch nicht moglich, alle Aufgaben im gegebenen Zeitraum zulosen. Sie entschlossen sich deshalb, die Aufgabe

”Grab“ nicht zu realisieren.

Um eine maximale Dynamik zu erhalten, wurden verschiedene Programmiersprachenverwendet. Fur Aufgabe

”Raff“ wurde Perl, fur

”Keuch“ und

”Flitz“ Java eingesetzt.

Dies hatte zumeist praktische Grunde und liegt daran, dass sich einige Probleme mitbereits bestehenden Programmstucken erganzten oder die eine Programmiersprache of-fensichtlich besser geeignet war als die andere. Es ist also keinesfalls Willkur, sondernhat nachvollziehbare Grunde.

Es sei der Stadtbucherei Schweinfurt gedankt fur ihre freundliche Erlaubnis, die hiervorliegende Dokumentation mit ihrem Laserdrucker aufs Papier bringen zu durfen. Eben-falls herzlichen Dank aussprechen mochten die Autoren den vielen Entwicklern vonLATEX, ohne die die Dokumentation ebenfalls nicht – zumindest in dieser Form – moglichgewesen ware.

Marcel Schmittfull,Moritz Beller

Marcel Schmittfull, Moritz Beller

2. RAFF 22. BwInf, 1. Runde 4

2 Raff

2.1 Programmbesprechung

Das Programm kann uber zwei verschiedene Moglichkeiten aufgerufen werden: Entwedermit oder ohne einen optionalen Parameter fur die Kursdatei:perl raff.pl -kursdatei.txt

Wird kein Parameter angegeben, so sucht das Programm automatisch im aktuellen Ver-zeichnis nach einer Kursdatei kurse.txt.perl raff.pl

Diese muss fur ein erfolgreiches Einlesen in der folgenden Art aufgebaut sein:

Aufbau der Kursdatei1 Waehrung1 Umtauschkurs Waehrung22 Waehrung3 Umtauschkurs Waehrung43 . . .

Beispielkursdatei1 Euro 1 . 9 5 583 DM2 US−Dol la r 0 . 4 1 1 Euro3 DM 0 . 8 US−Dol la r

Die Suche nach dem besten Tauschzyklus besteht darin, dass alle moglichen Tauschrei-henfolgen der Reihe nach durchprobiert und hierauf miteinander verglichen werden. Umalle moglichen Tauschreihenfolgen zu erhalten, werden alle moglichen Permutationen derWahrungsindizes generiert und in ein Array $alleZyklen gespeichert. Bei zum Beispieldrei bzw. vier Wahrungen wird also folgende Liste von Permutationen erzeugt:

3

2 1 0

0 1 2

0 2 1

1 0 2

1 2 0

2 0 1

2 1 0

4

3 2 1 0

0 1 2 3

0 1 3 2

0 2 1 3

0 2 3 1

0 3 1 2

0 3 2 1

1 0 3 2

1 0 2 3

1 2 3 0

1 2 0 3

1 3 2 0

1 3 0 2

. . .



Aus dem Schulunterricht ist bekannt, dass es bei n Indizes bzw. Wahrungen genaun! := 1 · 2 · 3 · · ·n verschiedene Permutationen gibt. Betrachtet man also eine Zifferin der s-ten Spalte, wenn die Spalten wie in den Tabellen gezeigt gezahlt werden, sogibt es genau s! Permutationen mit dieser Ziffer an der s-ten Stelle. Somit kann dieListe der Permutationen dadurch generiert werden, dass die Spalten s in einer Schleifedurchlaufen werden, in der wiederum jeweils alle Zeilen durchlaufen werden. Dann wirdin einer Spalte s jeder Indexwert genau s! Zeilen zugewiesen. Beispielsweise wird in derobigen Tabelle mit der Wahrungsanzahl 4 in der 3. Spalte jeder Indexwert 1, 2, . . . ingenau 3! = 6 Zeilen geschrieben. In der 2. Spalte wird jeder Indexwert nur noch 2! = 2Mal wiederholt und schließlich in der 1. Spalte nur noch 1! = 1 Mal. Fugt man dieserVorgehensweise noch die Bedingung hinzu, dass innerhalb einer Zeile jeder Index nur einMal vorkommen darf, erhalt man folgenden Algorithmus.

83 # Aktue l l e r Index84 $a = 0 ;85 # Hi l f s v a r i a b l e , d i e verh inder t , dass e ine Z i f f e r doppe l t in e iner Ze i l e vorkommt .86 $zahlKamSchonVor = 0 ;87 # Durchlaufe a l l e Spa l ten . . .88 for ( $ spa l t e = 0 ; $ spa l t e < $anzahlWaehrungen ; $ spa l t e++) {89 # Setze $a am Anfang j ede r Spa l t e auf 090 $a = 0 ;91 # Durchlaufe a l l e Ze i l en . . .92 for ( $ z e i l e = 0 ; $ z e i l e < f a ku l t a e t ( $anzahlWaehrungen ) ; $ z e i l e++) {93 # f a l l s uner l aub t e s $a94 i f ( $zahlKamSchonVor == 1 | | ( $ z e i l e != 0 && $ z e i l e % f a ku l t a e t (

$anzahlWaehrungen−$spa l t e −1) == 0) ) {95 # gehe zu naechstem $a96 $a = naechst ( $a ) ;97 }98 # se t z e H i l f s v a r i a b l e wieder zurueck99 $zahlKamSchonVor = 0 ;

100 # ueberprue fe a l l e vorhergehenden Spa l ten danach , ob $a b e r e i t s vorkam101 for ( $k = 0 ; $k < $ spa l t e ; $k++) {102 i f ( $a == $a l l eZyk l en [ $ z e i l e ] [ $k ] ) {103 $zahlKamSchonVor = 1 ;104 # durch lau f e s e l b e Ze i l e nochmals105 $ z e i l e −−;106 }107 }108 # spe i che re $a in das $a l l eZy k l en Array109 $a l l eZyk l en [ $ z e i l e ] [ $ spa l t e ] = $a unless $zahlKamSchonVor == 1;110 }111 }

Hierbei lauten die Subfunktionen naechst und fakultaet wie folgt.

168 sub naechst {169 my $p = shi f t ;170 return undef i f $p >= $anzahlWaehrungen ;171 return 0 i f $p == $anzahlWaehrungen−1;172 return $p+1;173 }174

175 sub f a ku l t a e t {176 my $n = shi f t ;177 return undef i f $n < 0;178 return 1 i f $n == 0;179 return $n ∗ f a ku l t a e t ( $n − 1) ;180 }



Nun mussen nur noch die einzelnen Permutationen bzw. Reihenfolgen der Reihe nachdurchprobiert werden.

114 # Durchlaufe a l l e Zyk lenmoeg l i chke i ten , suche dabe i den Zyk lus mit115 # groesstem Gewinn pro Tausch und spe i che re d iesen Zyk lus .116 $maximalerGewinnProTausch = 0 ;117 for ( $ i =0; $i<f a ku l t a e t ( $anzahlWaehrungen ) ; $ i++) {118 # Produkt der Kurse von Tausch zu Tausch119 $aktue l l e sKurseProdukt = 1 ;120 $be r e i t sE r f a s s t eRue ck t au s chS t e l l e J = 0 ;121 # Durchlaufe den a k t u e l l e n Zyk lus Tausch fuer Tausch122 for ( $ j =0; $j<$anzahlWaehrungen ; $ j++) {123 # Fa l l s b e r e i t s mindestens ein Tausch gemacht wurde124 i f ( $j >1) {125 # und f a l l s es moegl ich i s t , zu e r s t e r Waehrung zurueck zu tauschen126 i f ( $kurs [ $a l l eZyk l en [ $ i ] [ $ j ] ] [ $ a l l eZyk l en [ $ i ] [ 0 ] ] ) {127 # und d i e s e Rueck tauschmoeg l i chke i t vorher noch n i ch t e r f a s s t wurde128 i f ( $ j > $be r e i t sE r f a s s t eRue ck t au s chS t e l l e J ) {129 $be r e i t sE r f a s s t eRue ck t au s chS t e l l e J = $ j ;130 # berechne Kurseprodukt131 $aktue l l e sKurseProdukt ∗= $kurs [ $a l l eZyk l en [ $ i ] [ $ j ] ] [ $ a l l eZyk l en [ $ i

] [ 0 ] ] ;132 # wenn aktue l l e sKurseProduk t maximal133 i f ( $aktue l l e sKurseProdukt /( $ j+1) >= $maximalerGewinnProTausch ) {134 # es wurde ein Zyk lus gefunden135 $zyklusGefunden = 1 ;136 # spe i che re d iesen Zyk lus137 $bes te rZyk lus = $ i ;138 # und die S t e l l e , an der wieder zur Ausgangswaehrung gewaechse l t wird139 $ruecktauschSte l l eDesBestenZyk lus = $ j ;140 # und den neuen maximalen Gewinn pro Tausch141 $maximalerGewinnProTausch = $aktue l l e sKurseProdukt /( $ j+1) ;142 }143 }144 }145 }146 # Abbruch , f a l l s Kurs j −> j +1 n i ch t vorhanden147 last i f ( ! $ a l l eZyk l en [ $ i ] [ $ j + 1 ] | | ! $kurs [ $a l l eZyk l en [ $ i ] [ $ j ] ] [ $ a l l eZyk l en [ $ i ] [

$ j +1 ] ] ) ;148 # sons t : berechne ak tue l l e sKurseProduk t149 $aktue l l e sKurseProdukt ∗= $kurs [ $a l l eZyk l en [ $ i ] [ $ j ] ] [ $ a l l eZyk l en [ $ i ] [ $ j +1 ] ] ;150 }151 }

Dabei ist ein Zyklus ist so definiert, dass ausschließlich die erste und die letzte Wahrungaquivalent sind. Befindet sich also innerhalb eines Zykluses eine Wiederholung zweierWahrungen, so handelt es sich nicht um einen korrekten Zyklus. Folglich kann man dasarithmetische Mittel verwenden:

141 $maximalerGewinnProTausch = $aktue l l e sKurseProdukt /( $ j+1) ;

Als die Autoren beinahe die Erledigung der Aufgabe abgeschlossen hatten und test-weise die Kurstabelle eingaben, fiel ihnen auf, dass die Kurstabelle Gebrauch von ver-schiedenen Plural-Formen macht. (Entenpeseta wird zu Entepeseten. Froschkrone wirdzu Froschkronen.) Nun ware es moglich gewesen, die Ahnlichkeit zweier Wahrungenmit umstandlichen Berechnungen, wie sie beispielsweise von Suchmaschinen angewendetwerden (

”Soundex-Verfahren“) zu erfahren und aufgrund dieser Ergebnisse zu entschei-

den, ob es sich um den Plural eines bereits in der eingelesenen Kurstabelle befindlichenSingulars handelt. Dies ware jedoch sicherlich nicht im Sinne der Aufgabenstellung gewe-



sen und hatte zudem zu einer unnotigen Verkomplizierung der Aufgabe gefuhrt. Deshalbfugten wir, um die originale Kurstabelle unverandert einlesen zu konnen, die folgende Zei-le Code ein, die die ersten vier Buchstaben einer Wahrung als

”ID“ benutzt, um so dem

oben angesprochenen Singluar/Plural-Problem auf adaquate Weise beizukommen. Sieist standardmaßig im Code deaktiviert, kann jedoch durch Entfernen des #-Kommentars(wie in der folgenden Zeile geschehen) aktiviert werden.

25 $ =˜ s / ( .{1 , 4} ) . ∗ ? ( . ∗ ? ) ( . { 1 , 4 } ) .∗?/ $1 $2 $3 / ; # Ermoegliche S ing luar /P lura l

2.2 Ergebnisse fur versch. Tageskurs-Tabellen

Die Ausgaben von raff.pl wurden in eine Datei umgeleitet und deren Inhalt in die Listing-Kasten kopiert. Als letztes ist die in der Aufgabenstellung geforderte Tagekurstabellerealisiert.

Tageskurstabelle I1 NY−City−Do l l a r s 5 . 5 Yen2 NY−City−Do l l a r s 0 . 4 Pfund3 NY−City−Do l l a r s 0 . 1 5 Cola−Mark4 Yen 0 . 0 4 NY−City−Do l l a r s5 Cola−Mark 5 . 2 Yen6 Yen 0 . 8 Cola−Mark7 Cola−Mark 7 . 8 Pfund8 Pfund 4 . 5 Yen9 Pfund 1 . 5 NY−City−Do l l a r s

Bester Tauschzyklus: NY-City-Dollars -> Yen -> Cola-Mark -> Pfund ->

NY-City-Dollars

Durchschnittlicher Gewinn pro Tausch: 12.87

Tageskurstabelle II1 Marcel−Mark 9 . 8 Moritz−Mark2 Marcel−Mark 0 . 7 8 9 4 Marc−Mark3 Moritz−Mark 0 . 5 6 Marcel−Mark4 Marc−Mark 5 . 5 Moritz−Mark5 Marc−Mark 0 . 9 Marcel−Mark

Bester Tauschzyklus: Marcel-Mark -> Marc-Mark -> Moritz-Mark ->

Marcel-Mark


Tageskurstabelle III1 Baerenta l e r 2 . 7 0 Mausmark2 Entenpeseten 0 . 7 5 Kroetendo l l a r3 Entenpeseten 0 . 7 0 Froschkronen4 Entenpeseten 1 . 8 0 Wolfspfunde5 Froschkronen 1 . 1 0 Kroetendo l l a r6 Froschkronen 1 . 1 0 Entenpeseten



7 Kroetendo l l a r 2 . 0 0 Wolfspfunde8 Kroetendo l l a r 1 . 9 0 Wolfspfunde9 Kroetendo l l a r 1 . 0 5 Froschkronen

10 Mausmark 1 . 3 0 Entenpeseten11 Mausmark 0 . 9 0 Kroetendo l l a r12 Wolfspfunde 0 . 7 0 Entenpeseten13 Wolfspfunde 0 . 2 0 Baerenta l e r14 Wolfspfunde 0 . 5 0 Mausmark

Bester Tauschzyklus: Wolfspfunde -> Mausmark -> Entenpeseten ->

Krotendollar -> Wolfspfunde


2.3 Quellcode

Obwohl auszugsweise bereits weiter oben zu Dokumentationszwecken verwendet, ent-schloss man sich der Lesbarkeit und Einfachheit halber den Quelltext voll wiederzuge-ben.

1 #! / usr / bin / p e r l −w2

3 ### Aufgabe 1 ” Raff ” , 2 2 . Bundeswettbewerb In format ik4 ### Copyright (C) 2003 by Moritz Be l l e r (NOSPAMmomo@NOSPAM4momo. de )5 ### and Marcel S c hm i t t f u l l ( marcel−sl@NOSPAMgmx. de )6

7 # Bestimmt Kur s t a b e l l enda t e i8 # Aufruf ueber Argument : r a f f . p l −KURSDATEI9 $ f i l e = $ARGV[ 0 ] ;

10 # Ansonsten a l s Standard kurse . t x t11 i f ( !$ARGV[ 0 ] ) { $ f i l e = ” kurse . txt ” ; }12

13 # Dek larat ion von Variab len14 $kurs = [ ] ;15 $a l l eZyk l en = [ ] ;16 $anzahlWaehrungen = 0 ;17 $anzahlWaehrungen = 0 ;18

19 # Lie s t $ f i l e e in20 do read in ( $ f i l e ) ;21

22 # Ermit te ln der Datei−Struk tur23 foreach ( @ f i l e Z e i l e n ) {24 i f ( $ =˜ m/ ( . ∗ ? ) ( . ∗ ? ) ( . ∗ ? ) /) { # Pruefe , ob Format e ingeha l t en25 # $ =˜ s /( .{1 ,4} ) . ∗ ? ( . ∗ ? ) ( .{1 , 4} ) .∗?/ $1 $2 $3 /; # Ermoegliche S ingu lar /P lura l26 my $name = $1 ;27

28 my $ e x i s t s = 0 ;29 foreach ( @bezeichnung ) {30 i f ( $ eq $name) {31 $ e x i s t s = 1 ;32 }33 }34

35 i f ( ! $ e x i s t s ) {36 push( @bezeichnung , $name) ;37 }38 }39 }40

41 # Vere in facht das Auslesen der Kur s t a b e l l e42 foreach ( @bezeichnung ) {43 foreach ( @ f i l e Z e i l e n ) {44 $ =˜ s/ $bezeichnung [ $anzahlWaehrungen ] / $anzahlWaehrungen / ;



45 }46 $anzahlWaehrungen ++;47 }48

49 # Weisst Werte aus der Kur s t a b e l l e dem 2d−Array50 # $kurs zu .51 foreach ( @ f i l e Z e i l e n ) {52 # Pruefe , ob Format e ingeha l t en53 i f ( $ =˜ m/ ( . ∗ ? ) ( . ∗ ? ) ( . ∗ ) /) {54 # Pruefe , ob ein Kurs de r s e l b en Waehrungen b e r e i t s e i n g e l e s en55 # i s t und s ch r e i b e nur neuen kurs , wenn er be s s e r ( g roe s s e r ) a l s56 # der b e r e i t s e i n g e l e s ene kurs i s t .57 i f ( $kurs [ $1 ] [ $3 ] && $2>$kurs [ $1 ] [ $3 ] ) {58 $kurs [ $1 ] [ $3 ] = $2 ;59 }60 else {61 $kurs [ $1 ] [ $3 ] = $2 ;62 }63 }64 }65

66 # Speichere a l l e moegl ichen Zyklen fuer Waehrungstausche nach67 # folgendem Muster in das zweid imensiona le $a l l eZy k l en Array :68 #69 # 0 1 2 370 # 0 1 3 271 # 0 2 1 372 # 0 2 3 173 # 0 3 1 274 # 0 3 2 175 # 1 0 3 276 # 1 0 2 377 # 1 2 3 078 # 1 2 0 379 # 1 3 2 080 # 1 3 0 281 # . . .82

83 # Aktue l l e r Index84 $a = 0 ;85 # Hi l f s v a r i a b l e , d i e verh inder t , dass e ine Z i f f e r doppe l t in e iner Ze i l e vorkommt .86 $zahlKamSchonVor = 0 ;87 # Durchlaufe a l l e Spa l ten . . .88 for ( $ spa l t e = 0 ; $ spa l t e < $anzahlWaehrungen ; $ spa l t e++) {89 # Setze $a am Anfang j ede r Spa l t e auf 090 $a = 0 ;91 # Durchlaufe a l l e Ze i l en . . .92 for ( $ z e i l e = 0 ; $ z e i l e < f a ku l t a e t ( $anzahlWaehrungen ) ; $ z e i l e++) {93 # f a l l s uner l aub t e s $a94 i f ( $zahlKamSchonVor == 1 | | ( $ z e i l e != 0 && $ z e i l e % f a ku l t a e t (

$anzahlWaehrungen−$spa l t e −1) == 0) ) {95 # gehe zu naechstem $a96 $a = naechst ( $a ) ;97 }98 # se t z e H i l f s v a r i a b l e wieder zurueck99 $zahlKamSchonVor = 0 ;

100 # ueberprue fe a l l e vorhergehenden Spa l ten danach , ob $a b e r e i t s vorkam101 for ( $k = 0 ; $k < $ spa l t e ; $k++) {102 i f ( $a == $a l l eZyk l en [ $ z e i l e ] [ $k ] ) {103 $zahlKamSchonVor = 1 ;104 # durch lau f e s e l b e Ze i l e nochmals105 $ z e i l e −−;106 }107 }108 # spe i che re $a in das $a l l eZy k l en Array109 $a l l eZyk l en [ $ z e i l e ] [ $ spa l t e ] = $a unless $zahlKamSchonVor == 1;110 }111 }



112

113

114 # Durchlaufe a l l e Zyk lenmoeg l i chke i ten , suche dabe i den Zyk lus mit115 # groesstem Gewinn pro Tausch und spe i che re d iesen Zyk lus .116 $maximalerGewinnProTausch = 0 ;117 for ( $ i =0; $i<f a ku l t a e t ( $anzahlWaehrungen ) ; $ i++) {118 # Produkt der Kurse von Tausch zu Tausch119 $aktue l l e sKurseProdukt = 1 ;120 $be r e i t sE r f a s s t eRue ck t au s chS t e l l e J = 0 ;121 # Durchlaufe den a k t u e l l e n Zyk lus Tausch fuer Tausch122 for ( $ j =0; $j<$anzahlWaehrungen ; $ j++) {123 # Fa l l s b e r e i t s mindestens ein Tausch gemacht wurde124 i f ( $j >1) {125 # und f a l l s es moegl ich i s t , zu e r s t e r Waehrung zurueck zu tauschen126 i f ( $kurs [ $a l l eZyk l en [ $ i ] [ $ j ] ] [ $ a l l eZyk l en [ $ i ] [ 0 ] ] ) {127 # und d i e s e Rueck tauschmoeg l i chke i t vorher noch n i ch t e r f a s s t wurde128 i f ( $ j > $be r e i t sE r f a s s t eRue ck t au s chS t e l l e J ) {129 $be r e i t sE r f a s s t eRue ck t au s chS t e l l e J = $ j ;130 # berechne Kurseprodukt131 $aktue l l e sKurseProdukt ∗= $kurs [ $a l l eZyk l en [ $ i ] [ $ j ] ] [ $ a l l eZyk l en [ $ i

] [ 0 ] ] ;132 # wenn aktue l l e sKurseProduk t maximal133 i f ( $aktue l l e sKurseProdukt /( $ j+1) >= $maximalerGewinnProTausch ) {134 # es wurde ein Zyk lus gefunden135 $zyklusGefunden = 1 ;136 # spe i che re d iesen Zyk lus137 $bes te rZyk lus = $ i ;138 # und die S t e l l e , an der wieder zur Ausgangswaehrung gewaechse l t wird139 $ruecktauschSte l l eDesBestenZyk lus = $ j ;140 # und den neuen maximalen Gewinn pro Tausch141 $maximalerGewinnProTausch = $aktue l l e sKurseProdukt /( $ j+1) ;142 }143 }144 }145 }146 # Abbruch , f a l l s Kurs j −> j +1 n i ch t vorhanden147 last i f ( ! $ a l l eZyk l en [ $ i ] [ $ j + 1 ] | | ! $kurs [ $a l l eZyk l en [ $ i ] [ $ j ] ] [ $ a l l eZyk l en [ $ i ] [

$ j +1 ] ] ) ;148 # sons t : berechne ak tue l l e sKurseProduk t149 $aktue l l e sKurseProdukt ∗= $kurs [ $a l l eZyk l en [ $ i ] [ $ j ] ] [ $ a l l eZyk l en [ $ i ] [ $ j +1 ] ] ;150 }151 }152

153 # Printe Ergebnis154

155 i f ( $zyklusGefunden ) {156 print ”\nBester Tauschzyklus : ” ;157 for ( $ i =0; $i<$ruecktauschSte l l eDesBestenZyk lus +1; $ i++) {158 print $bezeichnung [ $a l l eZyk l en [ $bes te rZyk lus ] [ $ i ] ] . ” −> ” ;159 }160 print $bezeichnung [ $a l l eZyk l en [ $bes te rZyk lus ] [ 0 ] ] ;161 print ”\n” ;162 print ” Dur ch s chn i t t l i c h e r Gewinn pro Tausch : ” . $maximalerGewinnProTausch ;163 print ”\n” ;164 }165 else { print ”\nKein be s t e r Zyklus gefunden !\n” ; }166

167

168 sub naechst {169 my $p = shi f t ;170 return undef i f $p >= $anzahlWaehrungen ;171 return 0 i f $p == $anzahlWaehrungen−1;172 return $p+1;173 }174

175 sub f a ku l t a e t {176 my $n = shi f t ;177 return undef i f $n < 0;



178 return 1 i f $n == 0;179 return $n ∗ f a ku l t a e t ( $n − 1) ;180 }181

182 sub do read in {183 open(DATEI, ”<$ [ 0 ] ” ) | | die ”Error 404 − F i l e not found” ;184 while(<DATEI>)185 { push( @ f i l eZ e i l e n , ” $ ” ) ; }186 close (DATEI) ;187 }


3. KEUCH 22. BwInf, 1. Runde 12

3 Keuch

Durch seine Programmierung in Java ist ein Einsatz der Alarmstrategie auf allen verfugba-ren Betriebssystemen gewahrleistet – selbst auf Palms und Handys sollte nach geringemPortierungsaufwand eine lauffahige Verision ohne weiteres moglich sein.

Keuch ist komplett objektorientiert, es existieren eine Schadstoff-, eine Server- undeine Handyklasse. Uber eine Messfunktion greift ein Handy-Objekt auf die Umwelt zuund holt sich die aktuellen Messwerte. Die Serverklasse nimmt dabei eine passive Rollean und wird vom Handy-Objekt bei Bedarf angesprochen.

Es gibt zwei Moglichkeiten, Keuch aufzurufen: Zum einen mit allen Parameternjava Keuch [anzahlHandys] [anzahlServer] [handyKapazitaet] [etliche]

[einige] [groessereAnzahl] [kurzeZeit] [schlafDauer] [zeigeAlleHandys]

[angezeigtesHandy] [zeigeServerlog] [soundAn]

und zum anderen mit der vorgegebenen Standard-Konfiguration default.java Keuch default

3.1 Bewusstes Alarmauslosen

Ein Problem der Alarmstrategie des Servers besteht darin, dass durch eine relativ geringeZahl an

”Storern“ das komplette System durcheinander geraten kann.

Die mutwilligen Angreifer mussten nur durch Herabsetzen der eigenen GrenzwerteGelb-Nachrichten an den Server verschicken. Dieser leitet dann jede einzelne einkom-mende Gelb-Nachricht an zehn weitere zufallige Handy-Besitzer. Es kann also leicht eine

”Denial-of-Server-Attack“ ausgefuhrt werden, indem der zustandige Zellserver mit einer

Vielzahl an Gelb-Nachrichten von verschiedenen”manipulierten“, das heißt mit extrem

niedrigen Grenzwerten versehenen, Handys”uberflutet“ wird und somit an alle Handys

in seiner Zelle eine Rot-Meldung verschickt. Dazu braucht man nur genugend manipu-lierte Handys, die eine so große Zahl Gelb-Nachrichten in kurzer Zeit an den Serverweiterleiten konnen, dass dieser eine Rot-Mitteilung erzeugt, die an alle Handy-Besitzerin der Zelle gelangt.

Um solchen mutwilligen Angriffen nicht weiter nichts entgegensetzen zu konnen, mussenwir die Alarmstrategie des Servers dahingehend verandern, dass nur jeweils eine Gelb-Nachricht pro Schadstoff und definierbarem Zeitraum von einem Handy versandt werdendarf. Das heißt dann ganz konkret, dass Handy1 innerhalb von einer Stunde nur eineGelb-Warnmeldung fur den Stoff Ozon, eine Warnmeldung fur Stickstoff usw. verschi-cken darf. Da es allerdings aus Sicht der Sicherheit bedenklich ware, diese Sperre in einemClient – sprich Handy – zu realisieren, da findige Hacker sicher bald eine Umgehung derSoftware eingerichtet hatten, musste der Server fur alle einkommenden Gelbnachrich-ten prufen, ob innerhalb der letzten 60 Minuten bereits eine Warnmeldung von diesemHandy fur diesen Schadstoff abgeschickt worden ist und entsprechend darauf reagieren:Entweder als Reaktion das Zulassen der Gelbnachricht, womit die Speicherung der Zeitund ein Gelbnachrichten-Versand an zehn zufallige weitere Handys einhergeht oder dieAblehnung der Gelbnachricht.

Zusatzlich zu dieser ersten Sicherheitsvorkehrung muss der Server uber jede Grenz-wertanderung auf einem Client informiert werden und soll bei einer zweiten Grenz-



wertanderung innerhalb von 24 Stunden den Anderungswunsch nicht akzeptieren. Diesbedeutet, dass Handy1 bei einem Anderungsversuch von den Grenzwerten von Ozon erstbeim Server anfragt, ob ihm diese Aktion uberhaupt gestattet ist. Dafur benotigen wirfur jedes Handy auf dem Server ein 2d-Array lastChange, das die letzte Aktualisierungfur die jeweiligen Schadstoffe abspeichert. Wenn dies der Fall ist, setzt der Server dieVariable lastChange fur die letzte Anderung des Grenzwertes von Ozon auf Handy1.Will Handy1 beispielsweise nach funf Minuten wieder eine Grenzwertveranderung er-reichen, so muss es erneut eine Anfrage an den Server richten. Dieser liest den Inhaltvon lastChange fur Ozon ein und erkennt, dass die letzte Anderung erst funf Minutenzuruckliegt. Der Anderungwunsch wird zuruckgewiesen. So kann vermieden werden, dasseine wiederholte Grenzwertmanipulation stattfindet.

3.2 Zellservererweiterungen

Eine sinnvolle Erweiterung ware sicherlich, dass ein Zellserver bei Empfang einiger Rot-Nachricht fur denselben Schadstoff innerhalb kurzer Zeit, Rot-Meldungen an alle Be-nutzer in seinem System und an vier weitere, benachbarte Zellenserver verschickt. Soware nicht nur eine Zellserver-interne sondern auch eine Kommunikation der Serveruntereinander denkbar. Ernsthafte Schadstoffprobleme – reprasentiert durch die Rot-Meldungen – gelangen in kurzer Zeit an alle fur die Nachricht relevanten Stellen.

Ebenfalls einen großen Nutzen hatte eine interaktive Veranderbarkeit der Strategieva-riablen – bei Nacht zum Beispiel sollten zwei Gelb-Warnungen viel mehr zahlen als umdie Mittagszeit, wenn fast alle Handys am System angeschlossen sind. Das heiß, dasseine Art Punkte-System, abhangig von der derzeit auf dem Server eingeloggten Zahl anHandys, eingefuhrt werden musste.

Einige =Handyzahl

20(1)

Großere Zahl =Handyzahl

10(2)

Die Gleichungen (1) und (2) regulieren einfach anhand der am Server angemeldetenHandyzahl die Strategievariablen

”einige“ und

”großere“. Bei nur einer geringen Zahl an

Handys kann naturlich auch nur eine geringe Zahl an Gelbnachrichten verschickt werden.Die Gleichungen reagieren auf diesen Sachverhalt, indem sie die benotigten Meldungender Zahl der gemeldeten Handys anpassen. Fur den Idealfall der Vollauslastung des Ser-vers (

∧= 100 angemeldeten Handys) hat

”einige“ den Wert funf, bei Wenigbeanspruchung

(z.B. zwolf Handys) den Wert 1,2 inne.”Großere“ verhalt sich analog dazu.

Kurze Zeit =1

Handyzahl· 1000 Zeitschritte (3)

In Gleichung (3) definieren wir, dass die reziproke Handyzahl multipliziert mit 1000Zeiteinheiten (1 Zeiteinheit

∧= beispielsweise einer Sekunde) die Strategievariable

”kurze

Zeit“ liefert.



3.3 Quellcode

Handy.java1 import java . u t i l .Random ;2 import java . awt . ∗ ;3

4 public class Handy {5

6 // Index des Handys7 int index ;8 // Array mit a l l e n Schads to f f en9 Schads to f f [ ] s c h ad s t o f f e ;

10 // Server b e i dem das Handy im Moment e i n g e l o g g t i s t11 Server meinServer ;12 // Al l e Server13 Server [ ] a l l e S e r v e r ;14 // S t r a t e g i e v a r i a b l e n15 int kurzeZe i t , e t l i c h e ;16 // H i l f s v a r i a b l e n17 int i , j , summeGelbs , angezeigtesHandy ;18 double h i l f 1 , h i l f 2 ;19 boolean ze igeAl leHandys , soundAn ;20 // Z u f a l l s o b j e k t21 Random random ;22

23 // Konstruktor24 public Handy ( int index , Server [ ] a l l e S e r v e r , S chads to f f [ ] s chad s t o f f e , int

kurzeZe i t , int e t l i c h e , Random random) {25 // Speichere Index26 this . index = index ;27 // Speichere S c h a d s t o f f l i s t e28 this . s c h ad s t o f f e = s chad s t o f f e ;29 // Speichere S t r a t e g i e v a r i a b l e n30 this . ku rzeZe i t = kurzeZe i t ;31 this . e t l i c h e = e t l i c h e ;32 // Erzeuge Z u f a l l s o b j e k t33 this . random = random ;34 this . a l l e S e r v e r = a l l e S e r v e r ;35 // Handy l o g g t s i c h in z u f a e l l i g e n Server ein ( waere in der Rea l i t a e t36 // der naeheste Server , wird h i e r aber per Zu f a l l e rm i t t e l t . )37 i f ( a l l e S e r v e r . l ength > 0)38 l o g i n ( a l l e S e r v e r [ random . next Int ( a l l e S e r v e r . length −1) ] ) ;39 }40

41 // Login be i Server42 void l o g i n ( Server a ) {43 meinServer = a ;44 meinServer . l o g i n ( this ) ;45 }46

47 // Aendere Grenzwerte48 void aendereGrenzwert ( Schads to f f s , double grenzwert ) {49 s . grenzwert = grenzwert ;50 }51

52

53 /∗ Naechster Z e i t s c h r i t t ∗/54 public void na e c h s t e r Z e i t s c h r i t t ( boolean ze igeAl leHandys , int angezeigtesHandy

, Server [ ] a l l e S e r v e r , boolean soundAn) {55 this . ze igeAl leHandys = ze igeAl leHandys ;56 this . angezeigtesHandy = angezeigtesHandy ;57 this . soundAn = soundAn ;58 messeAktue l l enLuf tgeha l t ( ) ;59 pruefeGrenzwerte ( ) ;60 prue feGe lbs ( ) ;



61 i f ( random . next Int (10) == 1) {62 meinServer . l ogout ( this ) ;63 l o g i n ( a l l e S e r v e r [ random . next Int ( a l l e S e r v e r . length −1) ] ) ;64 }65 // Bearbe i t e Ze i t Array66 for ( i =0; i<s c h ad s t o f f e . l ength ; i++) {67 for ( j =0; j<s c h ad s t o f f e [ i ] . ge lbNachr ichten . length −1; j++) {68 s c h ad s t o f f e [ i ] . ge lbNachr ichten [ j ] = s ch ad s t o f f e [ i ] . ge lbNachr ichten [ j +1] ;69 }70 }71 }72

73 // Messe a k t u e l l e n Lu f t g e ha l t ( gehoer t n i ch t zur Alarmstrateg ie , i s t74 // aber fuer e ine Simulat ion der S t r a t e g i e noe t i g ) .75 void messeAktue l l enLuf tgeha l t ( ) {76 for ( i =0; i<s c h ad s t o f f e . l ength ; i++) {77 // Zu f a l l sw e r t fuer Simulat ion . .78 h i l f 1 = random . nextDouble ( ) /10 ;79 i f ( random . next Int (100) < 55)80 h i l f 2 = 1 ;81 else82 h i l f 2 = −1;83 i f ( s c h ad s t o f f e [ i ] . a k t u e l l e r Lu f t g e h a l t == 0)84 h i l f 1 = s chad s t o f f e [ i ] . a k t u e l l e r Lu f t g e h a l t + h i l f 1 ∗ h i l f 2 ∗ s c h ad s t o f f e [ i ] .

grenzwert ;85 else86 h i l f 1 = s chad s t o f f e [ i ] . a k t u e l l e r Lu f t g e h a l t + h i l f 1 ∗ h i l f 2 ∗ s c h ad s t o f f e [ i ] .

a k t u e l l e r Lu f t g e h a l t ;87 i f ( h i l f 1 < 0)88 h i l f 1 = 0 . ;89 else90 h i l f 1 = Math . r i n t ( h i l f 1 ∗100 . ) / 1 0 0 . ;91 s c h ad s t o f f e [ i ] . a k t u e l l e r Lu f t g e h a l t = h i l f 1 ;92 }93 }94

95 // Ueberpruefe , ob i rgendwe lche Grenzwerte u e b e r s c h r i t t e n s ind und reag i e r e96 // demenstprechend .97 void pruefeGrenzwerte ( ) {98 for ( i =0; i<s c h ad s t o f f e . l ength ; i++) {99 i f ( s c h ad s t o f f e [ i ] . a k t u e l l e r Lu f t g e h a l t > s c h ad s t o f f e [ i ] . grenzwert ) {

100 grenzwer tUeber schr i t t en ( s c h ad s t o f f e [ i ] ) ;101 }102 }103 }104

105 // Ueberpruefe , ob ” E t l i c h e ” Gelb−Nachrichten in ” kurzer Ze i t ” entstanden106 void prue feGe lbs ( ) {107 for ( i =0; i<s c h ad s t o f f e . l ength ; i++) {108 summeGelbs = 0 ;109 for ( j =0; j<kurzeZe i t ; j++) {110 summeGelbs += s chad s t o f f e [ i ] . ge lbNachr ichten [ j ] ;111 }112 i f ( summeGelbs > e t l i c h e ) {113 e t l i cheGe lb InKurze rZe i t ( s c h ad s t o f f e [ i ] ) ;114 }115 }116 }117

118 /∗ Tae t i g k e i t en des Handys ∗/119

120 void grenzwer tUeber schr i t t en ( Schads to f f s ) {121 i f ( ze igeAl leHandys == true | | angezeigtesHandy == this . index ) {122 // aku s t i s c h e Warnung123 beep ( ) ;124 // op t i s che Warnung125 System . out . p r i n t l n ( this . index+” : Grenzwertueberschre i tung von ”+s . name+” (

a k t u e l l ”+s . a k t u e l l e r Lu f t g e h a l t+” , Grenzwert ”+s . grenzwert+” ) ” ) ;



126 }127 // Gelb−Nachricht an Server128 meinServer . gelbVonHandy ( s , this ) ;129 }130

131 // Eine Gelb−Nachricht vom Server132 public void einGelbVonServer ( Schads to f f s ) {133 i f ( ze igeAl leHandys == true | | angezeigtesHandy == this . index ) {134 // aku s t i s c h e Warnung135 beep ( ) ;136 // op t i s che Warnung137 s . ge lbNachr ichten [ s . ge lbNachr ichten . length −1] += 1;138 }139 }140

141 // ” E t l i c h e ” Gelb−Nachrichten in ” kurzer Ze i t ”142 void e t l i cheGe lb InKurze rZe i t ( Schads to f f s ) {143 i f ( ze igeAl leHandys == true | | angezeigtesHandy == this . index ) {144 // aku s t i s c h e Warnung145 beep ( ) ;146 // op t i s che Warnung147 // messeAk tue l l enLu f t geha l t ( ) ;148 System . out . p r i n t l n ( this . index+” : Gelb−Nachricht f u e r ”+s . name+” ( a k t u e l l ”+s

. a k t u e l l e r Lu f t g e h a l t+” , Grenzwert ”+s . grenzwert+” ) ” ) ;149 }150 }151

152 // Rot−Nachricht von Server153 public void rotVonServer ( Schads to f f s ) {154 i f ( ze igeAl leHandys == true | | angezeigtesHandy == this . index ) {155 // aku s t i s c h e Warnung156 beep ( ) ;157 // op t i s che Warnung158 // messeAk tue l l enLu f t geha l t ( ) ;159 System . out . p r i n t l n ( this . index+” : Rot−Nachricht f u e r ”+s . name+” ( a k t u e l l ”+

this . s c h ad s t o f f e [ s . index ] . a k t u e l l e r Lu f t g e h a l t+” , Grenzwert ”+this .s c h ad s t o f f e [ s . index ] . grenzwert+” ) ” ) ;

160 }161 }162

163 void beep ( ) {164 i f ( soundAn) {165 Too lk i t . g e tDe fau l tToo lk i t ( ) . beep ( ) ;166 Thread me = Thread . currentThread ( ) ;167 me. s e tP r i o r i t y ( Thread .MIN PRIORITY) ;168 //me. s e tP r i o r i t y (Thread .MAX PRIORITY) ;169 try {170 me. s l e e p (80) ;171 }172 catch ( Inte r ruptedExcept ion e ) {173 return ;174 }175 }176 }177 }

Server.java1 import java . u t i l . Vector ;2 import java . u t i l .Random ;3

4 public class Server {5

6 // L i s t e a l l e r im Moment e i n g e l o g g t en Handys7 public Handy [ ] e inge loggteHandys ;8 // L i s t e der Schads t o f f e



9 Schads to f f [ ] s c h ad s t o f f e ;10 // Al l e Server11 Server [ ] a l l e S e r v e r ;12 // L i s t e der benachbarten Server13 public Server [ ] nachbarServer ;14

15 // Server Index16 public int index ;17

18 // Z u f a l l s o b j e k t19 Random random = new Random( ) ;20

21 // S t r a t e g i e v a r i a b l e n22 int e i n i g e ;23 int kurzeZe i t ;24 int groes se reAnzah l ;25

26 // H i l f s v a r i a b l e n27 int i , j , k , a , summeGelbs ;28 int momentanEingeloggteHandys ;29 boolean ze igeServe rLog ;30

31 // Konstruktor32 public Server ( Schads to f f [ ] s chad s t o f f e , int handyKapazitaet , int e i n i g e , int

kurzeZe i t , int groessereAnzahl , int index , Random random) {33 this . s c h ad s t o f f e = s chad s t o f f e ;34 this . e i n i g e = e i n i g e ;35 this . ku rzeZe i t = kurzeZe i t ;36 this . g roe s se reAnzah l = groes se reAnzah l ;37 // handyKapazitaet i s t maximale Anzahl e i n g e l o g g t e r Handys38 e inge loggteHandys = new Handy [ handyKapazitaet ] ;39 this . random = random ;40 this . index = index ;41 }42

43 // Login e ines Handys44 public void l o g i n ( Handy h) {45 i f ( momentanEingeloggteHandys < e inge loggteHandys . length −1) {46 e inge loggteHandys [ momentanEingeloggteHandys ] = h ;47 momentanEingeloggteHandys++;48 i f ( ze igeServe rLog )49 System . out . p r i n t l n ( ”Login Handy ”+h . index+” auf Server ”+this . index ) ;50 }51 }52

53 // Logout e ines Handys54 public void l ogout ( Handy h) {55 for ( i =0; i<momentanEingeloggteHandys ; i++) {56 i f ( e inge loggteHandys [ i ] . equa l s (h) ) {57 for ( j=i ; j<momentanEingeloggteHandys−i ; j++) {58 e inge loggteHandys [ j ] = e inge loggteHandys [ j +1] ;59 }60 momentanEingeloggteHandys−−;61 i f ( ze igeServe rLog )62 System . out . p r i n t l n ( ”Logout Handy ”+einge loggteHandys [ i ] . index+” von

Server ”+this . index ) ;63 break ;64 }65 }66 }67

68 /∗ ∗ Naechster Z e i t s c h r i t t ∗ ∗/69 public void na e c h s t e r Z e i t s c h r i t t ( boolean ze igeServe rLog ) {70 this . z e i geServerLog = ze igeServerLog ;71 prue feGe lbs ( ) ;72 // Im Gelb−Nachrichten−Array j ede s Schad s t o f f s wird der a e l t e s t e Werte73 // an S t e l l e 0 g e l o e s c h t und a l l e anderen Werte ( von S t e l l e 1 b i s74 // leng th −2) um eins nach l i n k s verschoben . An S t e l l e l eng th −1 s t e h t 0



75 // ( Anfangswert fuer d iesen Z e i t s c h r i t t , der dann durch Handys76 // veraender t werden kann .77 for ( i =0; i<s c h ad s t o f f e . l ength ; i++) {78 for ( j =0; j<s c h ad s t o f f e [ i ] . ge lbNachr ichten . length −1; j++)79 s c h ad s t o f f e [ i ] . ge lbNachr ichten [ j ] = s ch ad s t o f f e [ i ] . ge lbNachr ichten [ j +1] ;80 s c h ad s t o f f e [ i ] . ge lbNachr ichten [ s c h ad s t o f f e [ i ] . ge lbNachr ichten . length −1] = 0;81 }82 }83

84 // Ueberpruefe , ob ” groe s s e re Anzahl ” Gelb−Nachrichten in ” kurzer Ze i t ”ents tanden

85 void prue feGe lbs ( ) {86 for ( i =0; i<this . s c h ad s t o f f e . l ength ; i++) {87 summeGelbs = 0 ;88 for ( j =0; j<kurzeZe i t ; j++) {89 summeGelbs += this . s c h ad s t o f f e [ i ] . ge lbNachr ichten [ j ] ;90 }91 i f ( summeGelbs > groes se reAnzah l ) {92 // Rot an a l l e Handys93 i f ( momentanEingeloggteHandys > 0)94 for ( k=0; k<momentanEingeloggteHandys ; k++)95 e inge loggteHandys [ k ] . rotVonServer ( s c h ad s t o f f e [ i ] ) ;96 // Rot an a l l e Nachbarserver97 i f ( nachbarServer . l ength > 0)98 for ( k=0; k<nachbarServer . l ength ; k++)99 i f ( nachbarServer [ k ] ! = null )

100 nachbarServer [ k ] . rotVonServerAnNachbar ( s c h ad s t o f f e [ i ] ) ;101 }102 }103 }104

105

106 /∗ Server muss a r be i t en ∗/107

108 // Gelb−Nachricht von einem Handy109 public void gelbVonHandy ( Schads to f f s , Handy absender ) {110 // merke Gelb−Nachricht111 this . s c h ad s t o f f e [ s . index ] . ge lbNachr ichten [ this . s c h ad s t o f f e [ s . index ] .

ge lbNachr ichten . length −1] += 1;112 // Sende Gelb−Nachricht an ” e i n i g e ” Handys113 for ( i =0; i<e i n i g e ; i++) {114 i f ( momentanEingeloggteHandys > 1) {115 a = random . next Int ( momentanEingeloggteHandys−1) ;116 // Gelb dar f nur an andere Handys a l s Absender g e s c h i c k t117 // werden !118 i f ( a != absender . index ) {119 e inge loggteHandys [ a ] . e inGelbVonServer ( s ) ;120 }121 }122 else i−−;123 }124 }125

126 // Rot−Nachricht von anderem Server127 void rotVonServerAnNachbar ( Schads to f f s ) {128 // ke ine Angaben in Aufgabens te l l ung129 ;130 }131 }

Schadstoff.java1 public class Schads to f f {2

3 // Name des Schad s t o f f4 public St r ing name ;



5 // Index6 public int index ;7 // Grenzwert8 public double grenzwert ;9 // Ak tue l l e r Lu f t g e ha l t

10 public double ak t u e l l e r Lu f t g e h a l t ;11 // Speicher−Array der l e t z t e n Nachrichten12 public int [ ] ge lbNachr ichten ;13 // S t r a t e g i e v a r i a b l e n14 int kurzeZe i t ;15

16 // Konstruktor17 public Schads to f f ( S t r ing name , int index , double defaultGrenzwert , int

kurzeZe i t ) {18 this . name = name ;19 this . index = index ;20 this . grenzwert = defau l tGrenzwert ;21 this . ku rzeZe i t = kurzeZe i t ;22 ge lbNachr ichten = new int [ ku rzeZe i t ] ;23 }24 }

Keuch.java1 import java . u t i l .Random ;2 import java . awt . ∗ ;3

4 public class Keuch {5

6 public stat ic void main ( St r ing [ ] a rgs ) {7

8 // H i l f s v a r i a b l e n9 int i , j ;

10

11 // Z u f a l l s o b j e k t12 Random random = new Random( ) ;13

14 // Anzahl der Handys und Server15 int anzahlHandys = 990 ;16 int anzah lServer = 10 ;17 // Maximale Anzahl g l e i c h z e i t i g auf einem Server e i n g e l o g g t e r Handys .18 int handyKapazitaet = 100 ;19

20 /∗ S t r a t e g i e v a r i a b l e n ∗/21 // Handy22 int e t l i c h e = 300 ; // Warnung ab ” e t l i c h e ” Gelb−Nachrichten23 // Server24 int e i n i g e = 2 ; // Gelb an ” e i n i g e ” Handys wei tersenden25 int groes se reAnzah l = 30 ; // Warnung ab ” groe s s e re Anzahl ” Gelb−Nachrichten26 // Handy und Server27 int kurzeZe i t = 20 ;28

29 // Ze i t zwischen Messungen der Schad s t o f f b e l a s t ung in ms30 int sch la fDauer = 10 ;31

32 // Schadstoffnamen und de f au l t−Grenzwerte33 St r ing [ ] schadstoffNamen = new St r ing [ ] { ” S t i c k s t o f f o x i d e ” , ”Ozon” , ”

Kohlenmonoxid” , ”Schwefelmonoxid” , ” B l e i ” , ” Schwebete i l chen ” , ”Russ” , ”Benzol” , ” Schwe f e ld i ox id ” , ” S t i c k s t o f f d i o x i d ” } ;

34 double [ ] de fau l tGrenzwerte = new double[ ] { 0 . 2 , 0 . 0 5 , 5 5 . , 1 3 . , 0 . 1 , 0 . 2 , 8 . , 1 0 . , 5 . , 9 . } ;

35 int anzah lSchads to f f e = schadstoffNamen . l ength ;36

37 // Sons t i g e r Input38 boolean ze igeAl leHandys = true ;39 int angezeigtesHandy = 1 ;



40 boolean z e i g e S e r v e r l o g = fa l se ;41 boolean soundAn = fa l se ;42

43 // Ein lesen der Argumente aus der HTML Datei44 i f ( args . l ength == 1 && args [ 0 ] . equa l s ( ” d e f au l t ” ) ) {45 // de f au l t , mache n i ch t s46 ;47 }48 else i f ( args . l ength != 12 ) {49 System . out . p r i n t l n ( ”\nKeuch Parametereingabe : java Keuch [ anzahlHandys ] [

anzah lServer ] [ handyKapazitaet ] [ e t l i c h e ] [ e i n i g e ] [ g roes se reAnzah l ] [ku rzeZe i t ] [ s ch la fDauer ] [ ze igeAl leHandys ] [ angezeigtesHandy ] [z e i g e S e r v e r l o g ] [ soundAn ]\n\ nBe i s p i e l : java Keuch990 10 1 0 0 3 00 2 30 2 0 1 0 t rue 1 f a l s e f a l s e \n\ nAl te rnat iv : java Keuch

de f au l t ” ) ;50 System . e x i t (0 ) ;51 }52 else {53 System . out . p r i n t l n ( ”anzahlHandys ”+(anzahlHandys = In t eg e r . pa r s e In t ( args [ 0 ] )

) ) ;54 System . out . p r i n t l n ( ” anzah lServer ”+(anzah lServer = In t eg e r . pa r s e In t ( args

[ 1 ] ) ) ) ;55 System . out . p r i n t l n ( ”handyKapazitaet ”+(handyKapazitaet = In t eg e r . pa r s e In t (

args [ 2 ] ) ) ) ;56 System . out . p r i n t l n ( ” e t l i c h e ”+( e t l i c h e = In t eg e r . pa r s e In t ( args [ 3 ] ) ) ) ;57 System . out . p r i n t l n ( ” e i n i g e ”+( e i n i g e = In t eg e r . pa r s e In t ( args [ 4 ] ) ) ) ;58 System . out . p r i n t l n ( ” groes se reAnzah l ”+(groes se reAnzah l = In t eg e r . pa r s e In t (

args [ 5 ] ) ) ) ;59 System . out . p r i n t l n ( ” kurzeZe i t ”+(kurzeZe i t = In t eg e r . pa r s e In t ( args [ 6 ] ) ) ) ;60 System . out . p r i n t l n ( ” sch la fDauer ”+(sch la fDauer = In t eg e r . pa r s e In t ( args [ 7 ] ) ) )

;61 i f ( args [ 8 ] . equa l s ( ” t rue ” ) )62 ze igeAl leHandys = true ;63 else64 ze igeAl leHandys = fa l se ;65 System . out . p r i n t l n ( ” ze igeAl leHandys ”+ze igeAl leHandys ) ;66 System . out . p r i n t l n ( ” angezeigtesHandy ”+(angezeigtesHandy = In t eg e r . pa r s e In t (

args [ 9 ] ) ) ) ;67 i f ( args [ 1 0 ] . equa l s ( ” t rue ” ) )68 z e i g e S e r v e r l o g = true ;69 else70 z e i g e S e r v e r l o g = fa l se ;71 System . out . p r i n t l n ( ” z e i g e S e r v e r l o g ”+z e i g e S e r v e r l o g ) ;72 i f ( args [ 1 1 ] . equa l s ( ” t rue ” ) )73 soundAn = true ;74 else75 soundAn = fa l se ;76 System . out . p r i n t l n ( ”soundAn ”+soundAn) ;77 }78 System . out . p r i n t l n ( ”\n∗∗∗∗∗∗∗∗∗∗∗∗\nSTART\n∗∗∗∗∗∗∗∗∗∗∗∗\n” ) ;79

80

81 // Erzeuge Schads t o f f L i s ten fuer Handys und Server82 Schads to f f [ ] [ ] handySchadsto f fe = new Schads to f f [ anzahlHandys ] [ anzah lSchads to f f e

] ;83 Schads to f f [ ] [ ] s e r v e r S chad s t o f f e = new Schads to f f [ anzah lServer ] [

anzah lSchads to f f e ] ;84 for ( i =0; i<anzah lSchads to f f e ; i++) {85 for ( j =0; j<anzahlHandys ; j++) {86 handySchadsto f fe [ j ] [ i ] = new Schads to f f ( schadstoffNamen [ i ] , i ,

de fau l tGrenzwerte [ i ] , ku rzeZe i t ) ;87 }88 for ( j =0; j<anzah lServer ; j++) {89 s e r v e r S chad s t o f f e [ j ] [ i ] = new Schads to f f ( schadstoffNamen [ i ] , i ,

de fau l tGrenzwerte [ i ] , ku rzeZe i t ) ;90 }91 }92



93 // Erzeuge Server Objekte94 Server [ ] a l l e S e r v e r = new Server [ anzah lServer ] ;95 for ( i =0; i<anzah lServer ; i++)96 a l l e S e r v e r [ i ] = new Server ( s e r v e r S chad s t o f f e [ i ] , handyKapazitaet , e i n i g e ,

kurzeZe i t , groessereAnzahl , i , random) ;97

98 // Sage jedem Server se ine Nachbarn99 for ( i =0; i<anzah lServer ; i++) {

100 a l l e S e r v e r [ i ] . nachbarServer = new Server [ anzahlServer −1] ;101 for ( j =0; j<anzah lServer ; j++) {102 i f ( j<i )103 a l l e S e r v e r [ i ] . nachbarServer [ j ] = a l l e S e r v e r [ j ] ;104 i f ( j>i )105 a l l e S e r v e r [ i ] . nachbarServer [ j −1] = a l l e S e r v e r [ j ] ;106 }107 }108

109 // Erzeuge Handy Objekte110 Handy [ ] handys = new Handy [ anzahlHandys ] ;111 for ( i =0; i<anzahlHandys ; i++)112 handys [ i ] = new Handy( i , a l l e S e r v e r , handySchadstof fe [ i ] , kurzeZe i t , e t l i c h e

, random) ;113

114 // Timer115 Thread me = Thread . currentThread ( ) ;116 me. s e tP r i o r i t y ( Thread .MIN PRIORITY) ;117 try {118 while ( true ) {119 System . out . p r i n t l n ( ”\n∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗\ nNaechster Z e i t s c h r i t t \n

∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗∗\n” ) ;120 me. s l e e p ( sch la fDauer ) ;121 // naechs ter Z e i t s c h r i t t auf Server122 for ( i =0; i<a l l e S e r v e r . l ength ; i++) {123 a l l e S e r v e r [ i ] . n a e c h s t e r Z e i t s c h r i t t ( z e i g e S e r v e r l o g ) ;124 }125 // und im Handy126 for ( i =0; i<handys . l ength ; i++) {127 handys [ i ] . n a e c h s t e r Z e i t s c h r i t t ( ze igeAl leHandys , angezeigtesHandy ,

a l l e S e r v e r , soundAn) ;128 }129 }130 }131 catch ( Inte r ruptedExcept ion e ) {132 return ;133 }134 }135 }


4. FLITZ 22. BwInf, 1. Runde 22

4 Flitz

Wie in der Aufgabe gefordert, wurde ein Fisch mittels eines im Programm einstellbarenKreises realisiert. Da diese lieblosen Korper leider nur recht funktionell die Bewegungender eigentlich hochentwickelten, putzigen Fische widerspiegeln, soll durch die folgendeAbbildung ein wenig kaschiert werden.1 Es kann nicht gesagt werden, dass der verwendeteAlgorithmus den schnellsten Weg zur optimalen Endsituation liefert; er soll vielmehr dassoziale Verhalten der Fische moglichst realitatsgetreu abbilden und den angestrebtenDemonstrationseffekt abbilden. Als Mindestvoraussetzung wird eine aktuelle Javaversionbenotigt. Der Rechner sollte jedoch zudem mindestens uber eine 1,8 GHz-CPU (getestetwurden sowohl Intel- als auch AMD-Prozessoren) und 256 MB Ram, besser 512 MB,verfugen, damit die Animation ansprechend schnell lauft.

Abbildung 1: Im virtuellen Fischteich geht es munter zu . . .

4.1 Das soziale Verhalten

Das soziale Verhalten der Fische soll durch die Bewegung dieser modelliert werden.Hierzu soll ein Fisch-Objekt folgende Membervariablen und -funktionen besitzen.

• int x, y Koordinaten des Fisches

• int[] freunde, feinde Liste der Feinde, die der Fisch mag bzw. nicht mag.

• Color farbe Farbe des Fischs.

• void schwimme (int xZiel, int yZiel) {

1Man beachte den enormen Wusel-Faktor des Programms, der sich anschickt Spiele wie ”Die Siedler“zu uberragen!



x = xZiel;

y = yZiel;

}Nun zur zeitlichen Bewegung der Fische. Es soll jeder Fisch gleich schnell sein, d.h. je-

der Fisch kann innerhalb eines Zeitschrittes nur in eines seiner Nachbarkastchen schwim-men: Ein Fisch kann also (0, 0) oder (1, 0) oder (1, 1) oder (0, 1) oder (−1, 1) oder (−1, 0)

Abbildung 2: Bewegungsmoglichkeiten eines Fisches.

oder (−1,−1) oder (0,−1) oder (1,−1) schwimmen. Welche dieser neun Moglichkeitenein Fisch wahlt, ist abhangig von den Positionen der Fische, die er meidet, und denPositionen der Fische, zu denen er sich angezogen fuhlt. Diese Abhangigkeit soll darinbestehen, dass eine Art durchschnittliche Schwimmrichtung bestimmt wird, d.h. wennein Fisch zwei Freunde in der Richtung (1, 0) und (0, 1) besitzt, wird er im nachstenZeitschritt nach (1, 1) schwimmen. Somit bevorzugt es der Fisch in einen Bereich mitmoglichst vielen Freunden zu schwimmen, als sich lediglich zu einem einzelnen Freundzu begeben. Diese Modellierung hat folgende Vorteile. Auch wenn die Goldfische

”ihre

Eigenheiten“ haben, kann angenommen werden, dass sie sich am wohlsten fuhlen, wennsie sich in der Nahe moglichst vieler Freunde aufhalten. Schwimmt jeder Fisch immer inseine durchschnittliche Schwimmrichtung, so finden sich recht schnell Freundepaare und-gruppen, d.h. Fische, die sich alle gegenseitig zueinander hingezogen fuhlen. Auf deranderen Seite stoßen sich Feinde ab, wenn bei der durchschnittlichen Schwimmrichtungein Feind in Richtung (x, y) wie ein Freund in Richtung (−x,−y) gezahlt wird. Wennalso beispielsweise ein Fisch einen Freund in der Richtung (0, 1) und einen Feind in derRichtung (1, 0) hat, schwimmt er nach (−1, 1).

Die Formel fur die durchschnittliche Schwimmrichtung erhalt man wie folgt. Diex-Komponente ∆x→ der neuen Schwimmrichtung ist das arithmetische Mittel der x-Komponenten der Abstande zu den anderen Fischen, wobei die x-Komponenten derFeinde mit −1 multipliziert werden. Also

∆x→ =(∆xA1 + ∆xA2 + · · ·+ ∆xA|A|) + (∆xB1 + ∆xB2 + · · ·+ ∆xB|B|) · (−1)

|A|+ |B|, (4)



wenn A Freunde und B Feinde sind und |a| bzw. |b| fur die Anzahl der Freunde bzw.Feinde steht. Selbiges gilt naturlich auch fur die y-Koordinate

∆y→ =(∆yA1 + ∆yA2 + · · ·+ ∆yA|A|) + (∆yB1 + ∆yB2 + · · ·+ ∆yB|B|) · (−1)

|A|+ |B|. (5)

Weil ein Fisch laut Abbildung 5 nur in benachbarte Felder schwimmen soll, wird dieendgultige Richtung (∆x∗→, ∆y∗→) durch den Quotienten ∆x→/∆y→ und die Vorzeichenvon ∆x→ und ∆y→ bestimmt. (Vgl. die Funktion welchesKaestchen im Quelltext.)

Hiermit wollen wir uns aber noch nicht zufrieden geben, denn es ist fur einen Fischsicherlich sinnvoll die Abstande der anderen Fische mit in seine Richtungsentscheidungeinfließen zu lassen. Diese Abhangigkeit vom Abstand d =

√∆x2 + ∆y2 zu den ande-

ren Fischen wird durch den Faktor 1d

vor jeder Richtungskomponente umgesetzt, d.h. jenaher ein fremder Fisch ist, desto großer ist dessen Einwirkung auf die Richtungsentschei-dung eines Fisches. Den einzelnen Richtungskomponenten werden also die Prioritaten1d

zugewiesen. Setzt man dies in die Gleichung (4) und (5) ein, so erhalt man fur diex-Koordinate

∆x→ =

(∆xA1

dA1+

∆xA2

dA2+ · · ·+

∆xA|A|dA|A|

)−

(∆xB1

dB1+

∆xB2

dB2+ · · ·+

∆xB|B|dB|B|

)(

1dA1

+ 1dA2

+ · · · 1dA|A|

)+

(1

dB1+ 1

dB2+ · · · 1

dB|B|

) (6)

und fur die y-Koordinate

∆y→ =

(∆yA1

dA1+

∆yA2

dA2+ · · ·+

∆yA|A|dA|A|

)−

(∆yB1

dB1+

∆yB2

dB2+ · · ·+

∆yB|B|dB|B|

)(

1dA1

+ 1dA2

+ · · · 1dA|A|

)+

(1

dB1+ 1

dB2+ · · · 1

dB|B|

) . (7)

Durch Zuschaltung der Option”Privatsphare“ kann ein Ubereinnanderschwimmen der

Fische verhindert werden. Jeder Fisch hat eine Art Box um sich, an die er keine anderenFische heranlasst.

Wenn sehr viele Fische die Privatsphaehren anderer Fische verletzen, schwimmen einpaar zufallig ausgewahlte Fische paranoid (

∧= vollig planlosem, vom Algorithmus befrei-

tem Umherschwimmen) durch die Gegend, so dass weiterhin Bewegung im Teich herrschtund das Wasser zirkuliert.

Zuletzt soll noch kurz auf die Randbedingung des Teiches eingegangen werden. Weilein Fisch seinen Teich nicht verlassen kann, wird er, wenn er versucht den Teich zu verlas-sen, wieder in den Teich

”zuruckgeschmissen“, d.h. seine ∆x- und ∆y-Schwimmkoordinaten

werden so korrigiert, dass die Koordinaten (x, y) eines Fisches die Rander nicht uber-schreiten.

4.2 Die drei Aufgaben

Bei Aufgabe Eins lasst sich bei geringer eingestellter Fischmenge oft sehr schon beob-achten, wie alle Fische in eine wilde Hetzjagd auf den

”traurigen Goldfisch“ verfallen,



der sich daraufhin am Rand entlang vor ihnen zu fluchten versucht. Es ist jedoch nichtgarantiert, dass dies geschieht, da die Fische untereinander trotz ihrer gemeinsamenZuneigung zu dem als Viereck dargestellten Einzelganger immer noch gewisse Zu- undAbneigungen hegen. Bei jedem Durchlauf aber ist der Wunsch des

”traurigen Goldfi-

sches“ zu sehen, sich abzusondern. Er befindet sich deshalb meist in Randregionen desTeiches.

Abbildung 3: Drei Fische rucken unaufhaltsam naher . . .

In Aufgabe zwei treffen sich alle Fische – bei ausgeschalteter Privatsphare – unweiger-lich irgendwann in einem Punkt. Da das Verhaltnis der Zuneigung das der Abneigungubertrifft, werden die Fische zu dem

”Treffpunkt“ auch dann scheinbar magisch angezo-

gen, wenn sich Goldfische darauf befinden, zu denen sie ein feindschaftliches Verhaltnishaben. Wird die Privatsphare aktiviert, herrscht ein aufgeregtes Treiben um den Mit-telpunkt: Die Tierchen positionieren sich, bedingt durch die Paranoiden standig neu.

Abbildung 4: Die Fisch treffen sich

Ein dazu gegenteiliger Effekt ist fur die letzte Aufgabe zu beobachten gewesen: Hierfinden sich kleiner Gruppe von Fischen am Rand zusammen, und das Zentrum wirdgenerell gemieden. Die Betrachtung ist besonders bei großer Fischmenge und aktivierterPrivatsphare empfehlenswert, da sich sonst die Fische zu Gruppen am Rand zusam-menschließen und moglicherweise nichts geschieht.



Abbildung 5: Positionierungsbewegungen zum Rand hin

4.3 Quellcode und Programmhinweis

Die Visualisierung der Fischbewegung wird mittels Java implementiert. Hierbei wird aufdas Applet JavaPsi2 zuruckgegriffen, das bereits einige nutzliche Voraussetzungen fur diegrafische Umsetzung enthalt. Die endgultige Implementierung der Visualisierung wirdim Folgenden aufgelistet.

Fisch.java1 public class Fisch {2

3 // Eigene Koordinaten x und y4 public int x ;5 public int y ;6

7 // Eigene Koordinaten x und y zur Zwischenspeicherung8 public int xAlt ;9 public int yAlt ;

10

11 // L i s t e a l l e r Freunde und Feinde12 public int [ ] f r eunde ;13 public int [ ] f e i nd e ;14

15 // Eigene Farbe16 public java . awt . Color f a rbe ;17

18 // Schwimme zum Punkt ( xZ ie l , yZ i e l )19 public void schwimme ( int xZie l , int yZ i e l ) {20 x = xZ i e l ;21 y = yZ i e l ;22 }23

24 }

2JavaPsi - Zur Quantenmechanik am Computer c© 2003 Marcel Schmittfull.http://javapsi.sf.net/


http://javapsi.sf.net/


Flitz.java1 /∗ ∗ F l i t z . java (C) 2003 by Marcel S c hm i t t f u l l and Moritz Be l l e r ∗ ∗/2

3 // Ben{\”o} t i g t e ex terne Klassen4 import java . app le t . Applet ;5 import java . awt . ∗ ;6 import java . awt . image . MemoryImageSource ;7 import java . awt . event . ∗ ;8 import java . lang . Math ;9 import java . u t i l .Random ;

10

11

12 /∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗ GRAFIK ∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/13

14 // Die g r a f i s c h e Ober f laeche wird {\”u} ber ein s e l b s t g e s t a l t e t e s Canvas Objekt15 // r e a l i s i e r t .16 class GCanvas extends Canvas {17 GFrame frame ;18 GCanvas (GFrame f ) {19 frame = f ;20 }21 public void update ( Graphics g ) {22 frame . updateF l i t z ( g ) ;23 }24 public void paint ( Graphics g ) {25 update ( g ) ;26 frame . updateF l i t z ( g ) ;27 }28 } ;29

30 // Entwurf der g ra f i s chen Ober f laeche31 class GLayout implements LayoutManager {32 public GLayout ( ) {}33 public void addLayoutComponent ( S t r ing name , Component comp) {}34 public void removeLayoutComponent ( Component c ) {}35 public Dimension pre f e r r edLayoutS i z e ( Container t a r g e t ) {36 return new Dimension (500 ,500) ;37 }38 public Dimension minimumLayoutSize ( Container t a r g e t ) {39 return new Dimension (400 ,400) ;40 }41 public void l ayoutConta iner ( Container t a r g e t ) {42 int barWidth = 0 ;43 int i ;44 for ( i = 1 ; i < t a r g e t . getComponentCount ( ) ; i++) {45 Component m = ta rg e t . getComponent ( i ) ;46 i f (m. i s V i s i b l e ( ) ) {47 Dimension d = m. g e tP r e f e r r e dS i z e ( ) ;48 i f ( d . width > barWidth )49 barWidth = d . width ;50 }51 }52 I n s e t s i n s e t s = ta rg e t . g e t I n s e t s ( ) ;53 int targetw = ta rg e t . g e tS i z e ( ) . width − i n s e t s . l e f t − i n s e t s . r i g h t ;54 int cw = targetw−barWidth ;55 int ta rge th = ta rg e t . g e tS i z e ( ) . he ight − ( i n s e t s . top+i n s e t s . bottom ) ;56 t a r g e t . getComponent (0 ) . s e tLoca t i on ( i n s e t s . l e f t , i n s e t s . top ) ;57 t a r g e t . getComponent (0 ) . s e t S i z e (cw , ta rge th ) ;58 cw += i n s e t s . l e f t ;59 int h = i n s e t s . top ;60 for ( i =1; i<t a r g e t . getComponentCount ( ) ; i++) {61 Component m = ta rg e t . getComponent ( i ) ;62 i f (m. i s V i s i b l e ( ) ) {63 Dimension d = m. g e tP r e f e r r e dS i z e ( ) ;64 i f (m instanceof S c r o l l b a r | | m instanceof DecentSc ro l lba r )65 d . width = barWidth ;66 i f (m instanceof Label ) {



67 h += d . he ight /5 ;68 d . width = barWidth ;69 }70 m. se tLoca t i on (cw , h) ;71 m. s e t S i z e (d . width , d . he ight ) ;72 h += d . he ight ;73 }74 }75 }76 } ;77

78 // Applet79 public class F l i t z extends Applet {80 GFrame frame ;81 void destroyFrame ( ) {82 i f ( frame != null )83 frame . d i spo s e ( ) ;84 frame = null ;85 }86 public void i n i t ( ) {87 System . out . p r i n t l n ( ”\” F l i t z \ ” : Aufgabe 3 , 2 2 . Bundeswettbewerb In format ik \n\

nCopyright (C) 2003 by\n\ tMarcel S chm i t t f u l l ( marcel−sl@gmx . de ) \n\ tMoritzB e l l e r (momo@4momo. de ) \n” ) ;

88 frame = new GFrame( this ) ;89 frame . i n i t ( ) ;90 }91 public void dest roy ( ) {92 i f ( frame != null )93 frame . d i spo s e ( ) ;94 frame = null ;95 }96 } ;97

98 class GFrame99 extends Frame

100 implements ComponentListener , Act ionLi s tener , MouseMotionListener , MouseListener, I temListener , Dec en tSc ro l l ba rL i s t en e r {

101

102 public GFrame ( F l i t z a ) {}103

104 public St r ing getApp le t In fo ( ) {105 return ” F l i t z (C) 2003 by Marcel S chm i t t f u l l −− http :// j avap s i . s ou r c e f o r g e . net

/” ;106 }107

108 /∗ Gra f i k va r i a b l en ∗/109 Thread engine = null ;110 Dimension winSize ;111 Image dbimage ;112 Image animImage ;113

114 Checkbox nextCheck ;115 Checkbox pr ivatsphaereCheck ;116 Choice t e i l au f gabeCho i c e ;117 Button neuButton ;118 DecentSc ro l lba r speedBar , anzahlFischeBar , f i schRadiusBar , ante i lFreundeBar ;119 Label speedLabel , anzahlFischeLabe l , f i s chRadiusLabe l , ante i lFreundeLabe l ;120 int p i x e l s [ ] ;121 MemoryImageSource source ;122 int pause ;123

124 GCanvas canvas ;125 F l i t z app le t ;126 Dimension d ;127 Graphics g2 ;128 int toth ;129

130 // Variabe ln f {\”u} r den Algorithmus



131 Random random ;132 int i , j , k , l , m, a , b , c , rand , ausnahmeFisch ;133 boolean nextFrame , zuNah , p r i va t sphae r e ;134 int summeAllerZuNahs ;135 int anzah lF i sche ;136 int f i s chRad iu s ;137 int xSchwimm , ySchwimm ;138 double xZaehler , yZaehler , nenner ;139 Fisch [ ] f i s c h e ;140 int [ ] r e s t l i c h e I n d i z e s ;141 double ante i lFreunde , ante i lFe inde , anzahlFreunde ;142 boolean i n i t e d ;143

144 stat ic f ina l double pi = 3.14159265358979323846;145

146 public void paint ( Graphics g ) {147 canvas . r epa in t ( ) ;148 }149

150 // Etwas Benu t ze r in t e rak t i on151 public void componentHidden ( ComponentEvent e ) {}152 public void componentMoved ( ComponentEvent e ) {}153 public void componentShown ( ComponentEvent e ) {}154 public void componentResized ( ComponentEvent e ) {}155 public void act ionPerformed ( ActionEvent e ) {156 i f ( e . getSource ( ) == neuButton ) {157 in i tWerte ( ) ;158 canvas . r epa in t ( ) ;159 }160

161 }162 public void itemStateChanged ( ItemEvent e ) {163 i f ( e . getSource ( ) == nextCheck )164 canvas . r epa in t ( ) ;165 i f ( e . getSource ( ) == privatsphaereCheck )166 canvas . r epa in t ( ) ;167 i f ( e . g e t I t emSe l e c t ab l e ( ) == te i l au f gabeCho i c e ) {168 in i tWerte ( ) ;169 canvas . r epa in t ( ) ;170 }171 }172 public void scro l lbarValueChanged ( DecentSc ro l lba r ds ) {173 i f ( ds == speedBar )174 canvas . r epa in t ( ) ;175 i f ( ds == anzahlFischeBar ) {176 in i tWerte ( ) ;177 canvas . r epa in t ( ) ;178 }179 i f ( ds == f i schRadiusBar ) {180 f i s chRad iu s = ( int ) ( f i s chRadiusBar . getValue ( ) /4) ;181 canvas . r epa in t ( ) ;182 }183 i f ( ds == ante i lFreundeBar ) {184 i f ( t e i l au f gabeCho i c e . g e tSe l e c t ed Index ( ) == 3) {185 in i tWerte ( ) ;186 canvas . r epa in t ( ) ;187 }188 }189 }190 public void s c r o l l b a rF i n i s h e d ( DecentScro l lba r ds ) {191 i f ( ds == speedBar )192 canvas . r epa in t ( ) ;193 }194 public boolean processEvent ( Event ev ) {195 i f ( ev . id == Event .WINDOWDESTROY) {196 app le t . destroyFrame ( ) ;197 return true ;198 }



199 // return super . processEvent ( ev ) ;200 return processEvent ( ev ) ;201 }202 MenuItem getMenuItem ( St r ing s ) {203 MenuItem mi = new MenuItem( s ) ;204 mi . addAct ionLis tener ( this ) ;205 return mi ;206 }207 CheckboxMenuItem getCheckItem ( St r ing s ) {208 CheckboxMenuItem mi = new CheckboxMenuItem ( s ) ;209 mi . addItemListener ( this ) ;210 return mi ;211 }212 public void mouseClicked ( MouseEvent e ) { }213 public void mouseEntered ( MouseEvent e ) { }214 public void mouseExited ( MouseEvent e ) { }215 public void mousePressed ( MouseEvent e ) { }216 public void mouseReleased ( MouseEvent e ) { }217 public void mouseDragged ( MouseEvent e ) { }218 public void mouseMoved ( MouseEvent e ) { }219

220 /∗ I n i t i a l i s i e r e Graf ik ∗/221 public void i n i t ( ) {222 setLayout (new GLayout ( ) ) ;223 canvas = new GCanvas ( this ) ;224 canvas . addComponentListener ( this ) ;225 canvas . addMouseMotionListener ( this ) ;226 canvas . addMouseListener ( this ) ;227 add ( canvas ) ;228

229 t e i l au f gabeCho i c e = new Choice ( ) ;230 t e i l au f gabeCho i c e . add ( ” Te i l au fgabe 1 ” ) ;231 t e i l au f gabeCho i c e . add ( ” Tai lau fgabe 2 ” ) ;232 t e i l au f gabeCho i c e . add ( ” Te i l au fgabe 3 ” ) ;233 t e i l au f gabeCho i c e . add ( ” Ante i l Freunde per S ch i e b e r e g l e r ” ) ;234 t e i l au f gabeCho i c e . addItemListener ( this ) ;235 add ( t e i l au f gabeCho i c e ) ;236

237 nextCheck = new Checkbox ( ”Animation an” ) ;238 nextCheck . addItemListener ( this ) ;239 nextCheck . s e t S t a t e ( true ) ;240 add ( nextCheck ) ;241 pr ivatsphaereCheck = new Checkbox ( ” Pr ivatsphaehre an” ) ;242 pr ivatsphaereCheck . addItemListener ( this ) ;243 pr ivatsphaereCheck . s e t S t a t e ( true ) ;244 add ( pr ivatsphaereCheck ) ;245

246 add ( neuButton = new Button ( ”Neu” ) ) ;247 neuButton . addAct ionLis tener ( this ) ;248

249 add ( speedLabel = new Label ( ” S imu la t i on sge s chw ind igke i t ” , Label .CENTER) ) ;250 add ( speedBar = new DecentSc ro l lba r ( this , 1 5 , 1 , 1 0 0 ) ) ;251 add ( anzah lF i scheLabe l = new Label ( ”Anzahl Fische ” , Label .CENTER) ) ;252 add ( anzahlFischeBar = new DecentSc ro l lba r ( this , 3 0 , 1 , 1 0 0 ) ) ;253 add ( f i s chRad iusLabe l = new Label ( ”Fisch Radius” , Label .CENTER) ) ;254 add ( f i schRadiusBar = new DecentSc ro l lba r ( this , 4 0 , 1 , 1 0 0 ) ) ;255 add ( ante i lFreundeLabe l = new Label ( ” Ante i l Freunde” , Label .CENTER) ) ;256 add ( ante i lFreundeBar = new DecentSc ro l lba r ( this , 4 0 , 1 , 1 0 0 ) ) ;257

258 s e t S i z e (600 , 400 ) ;259 canvas . setBackground ( Color . b lack ) ;260 canvas . setForeground ( Color . l i ghtGray ) ;261 s e tT i t l e ( ” F l i t z − 22 . Bundeswettbewerb In format ik ” ) ;262

263 show ( ) ;264

265 try {266 St r ing param = apple t . getParameter ( ”PAUSE” ) ;



267 i f ( param != null )268 pause = In t eg e r . pa r s e In t (param) ;269 } catch ( Exception e ) { }270

271 Color gray1 = new Color ( 76 , 76 , 76) ;272 Color gray2 = new Color ( 127 , 127 , 127 ) ;273

274 random = new Random( ) ;275 in i tWerte ( ) ;276 }277

278 /∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗ I n i t i a l i s i e r e Anfangswerte fuer Algorithmus ∗∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/279 public void in i tWerte ( ) {280

281 // Fischgr {\”o}{\ s s }e282 f i s chRad iu s = ( int ) ( f i s chRadiusBar . getValue ( ) /4) ;283

284 // Anzahl der Fische285 anzah lF i sche = ( int ) ( anzahlFischeBar . getValue ( ) /2) ;286

287 // Erzeuge F i s chob j e k t e288 f i s c h e = new Fisch [ anzah lF i sche ] ;289 for ( int i = 0 ; i < anzah lF i sche ; i++) {290 f i s c h e [ i ] = new Fisch ( ) ;291 }292 r e s t l i c h e I n d i z e s = new int [ anzah lF i sche ] ;293

294 // Freunde und Feinde295 i f ( t e i l au f gabeCho i c e . g e tSe l e c t ed Index ( ) == 0) {296 // Verhae l t i s Freunde zu Feinde297 ante i lFreunde = random . nextDouble ( ) ;298 an t e i lF e i nde = 1− ante i lFreunde ;299 }300

301 i f ( t e i l au f gabeCho i c e . g e tSe l e c t ed Index ( ) == 1) {302 // Verhae l t i s Freunde zu Feinde303 ante i lFreunde = 0 . 7 ;304 an t e i lF e i nde = 1− ante i lFreunde ;305 }306 i f ( t e i l au f gabeCho i c e . g e tSe l e c t ed Index ( ) == 2) {307 // Verhae l t i s Freunde zu Feinde308 ante i lFreunde = 0 . 3 ;309 an t e i lF e i nde = 1− ante i lFreunde ;310 }311

312 i f ( t e i l au f gabeCho i c e . g e tSe l e c t ed Index ( ) == 3) {313 ante i lFreunde = ( int ) ( ante i lFreundeBar . getValue ( ) /100) ;314 an t e i lF e i nde = 1− ante i lFreunde ;315 }316

317 // E r s t e l l e Freunde und Feinde Arrays318 for ( i =0; i<anzah lF i sche ; i++) {319 // Mit 50% i g e r Wahrsche in l i c ke i t wird abgerundet , sons t aufgerundet320 i f ( random . next Int (1 ) == 0)321 anzahlFreunde = Math . f l o o r ( ante i lFreunde ∗ anzah lF i sche ) ;322 else323 anzahlFreunde = Math . c e i l ( ante i lFreunde ∗ anzah lF i sche ) ;324 f i s c h e [ i ] . f r eunde = new int [ ( int ) ( anzahlFreunde ) ] ;325 f i s c h e [ i ] . f e i nd e = new int [ anzahlFische −( int ) ( anzahlFreunde ) ] ;326 }327 // Zu f a e l l i g e Re ihen fo l ge328 for ( i =0; i<anzah lF i sche ; i++) {329 // r e s t l i c h e Ind i z e s330 for ( j =0; j<anzah lF i sche ; j++)331 r e s t l i c h e I n d i z e s [ j ] = j ;332 for ( j =0; j<anzah lF i sche ; j++) {333 rand = random . next Int ( anzahlFische−j ) ;334 i f ( j<f i s c h e [ i ] . f r eunde . l ength )



335 f i s c h e [ i ] . f r eunde [ j ] = r e s t l i c h e I n d i z e s [ rand ] ;336 else337 f i s c h e [ i ] . f e i nd e [ j−f i s c h e [ i ] . f r eunde . l ength ] = r e s t l i c h e I n d i z e s [ rand ] ;338 // l oe s che Index j aus r e s t l i c h e I n d i z e s339 for ( k=rand ; k<r e s t l i c h e I n d i z e s . length −1; k++) {340 r e s t l i c h e I n d i z e s [ k ] = r e s t l i c h e I n d i z e s [ k+1] ;341 }342 }343 }344

345 i f ( t e i l au f gabeCho i c e . g e tSe l e c t ed Index ( ) == 0) {346 // Fisch 0 , der a l l e has s t und von a l l e n g e l i e b t wird347 // has s t a l l e348 f i s c h e [ 0 ] . f reunde = new int [ ] { } ;349 f i s c h e [ 0 ] . f e i nd e = new int [ anzah lF i sche ] ;350 for ( i =1; i<anzah lF i sche ; i++)351 f i s c h e [ 0 ] . f e i nd e [ i ] = i ;352 // wird von a l l e n g e l i e b t353 // Zu f a e l l i g e Re ihen fo l ge354 for ( i =1; i<anzah lF i sche ; i++) {355 // r e s t l i c h e Ind i z e s356 f i s c h e [ 0 ] . f e i nd e [ 0 ] = 0 ;357 for ( j =1; j<anzah lF i sche ; j++)358 r e s t l i c h e I n d i z e s [ j ] = j ;359 for ( j =1; j<anzah lF i sche ; j++) {360 rand = random . next Int ( anzahlFische−j +1) ;361 i f ( j<f i s c h e [ i ] . f r eunde . l ength )362 f i s c h e [ i ] . f r eunde [ j ] = r e s t l i c h e I n d i z e s [ rand ] ;363 else364 f i s c h e [ i ] . f e i nd e [ j−f i s c h e [ i ] . f r eunde . l ength ] = r e s t l i c h e I n d i z e s [ rand ] ;365 // l oe s che Index j aus r e s t l i c h e I n d i z e s366 for ( k=rand ; k<r e s t l i c h e I n d i z e s . length −1; k++) {367 r e s t l i c h e I n d i z e s [ k ] = r e s t l i c h e I n d i z e s [ k+1] ;368 }369 }370 }371 }372

373 // Fische schwimmen zu z u f a e l l i g e n Koordinaten374 for ( i =0; i<anzah lF i sche ; i++) {375 i f ( canvas . g e tS i z e ( ) . width>0 && canvas . g e tS i z e ( ) . he ight >0)376 f i s c h e [ i ] . schwimme( random . next Int ( canvas . g e tS i z e ( ) . width ) , random . next Int (

canvas . g e tS i z e ( ) . he ight ) ) ;377 else378 f i s c h e [ i ] . schwimme( random . next Int (100) , random . next Int (100) ) ;379 }380

381 // Farben fuer Fische ( per Zu f a l l zugewiesen )382 for ( i =0; i<anzah lF i sche ; i++) {383 f i s c h e [ i ] . f a rbe = new Color ( random . next Int (255) , random . next Int (255) , random

. next Int (255) ) ;384 }385 i n i t e d = true ;386 }387

388 /∗ ∗∗∗ Berechne naechsten Z e i t s c h r i t t , update ∗∗∗ ∗/389 public void updateF l i t z ( Graphics r e a l g ) {390

391 i f ( ! i n i t e d ) {392 Thread me1 = Thread . currentThread ( ) ;393 me1 . s e tP r i o r i t y ( Thread .MIN PRIORITY) ;394 try {395 me1 . s l e e p (500) ;396 }397 catch ( Inte r ruptedExcept ion e ) {398 return ;399 }400 }



401

402 pr iva t sphae r e = pr ivatsphaereCheck . ge tS ta t e ( ) ;403

404 /∗ Zunaechst etwas Graf ik . . . ∗/405 d = winSize = canvas . g e tS i z e ( ) ;406 i f ( winSize . width == 0) {407 System . out . p r i n t l n ( ”win width i s 0 ! ! ” ) ;408 return ;409 }410 toth = winSize . he ight ;411 dbimage = createImage (d . width , d . he ight ) ;412 g2 = dbimage . getGraphics ( ) ;413 i f ( winSize == null | | winSize . width == 0) {414 System . out . p r i n t l n ( ”win width i s 0 ! ! ” ) ;415 return ;416 }417 g2 . s e tCo lo r ( canvas . getBackground ( ) ) ;418 g2 . f i l l R e c t ( 0 , 0 , winSize . width , winSize . he ight ) ;419 g2 . s e tCo lo r ( canvas . getForeground ( ) ) ;420

421

422 /∗ ∗∗∗∗∗∗∗∗∗∗∗∗∗∗ Beginn Algorithmus ∗∗∗∗∗∗∗∗∗∗∗∗∗ ∗/423 // Speichere a l t e Pos i t ionen424 for ( i =0; i<anzah lF i sche ; i++) {425 f i s c h e [ i ] . xAlt = f i s c h e [ i ] . x ;426 f i s c h e [ i ] . yAlt = f i s c h e [ i ] . y ;427 }428 summeAllerZuNahs = 0 ;429

430 // Berechne naechsten Schwimmschritt f {\”u} r a l l e Fische nach Formel ( 3 )431 // und (4 ) in der Dokumentation432 for ( i =0; i<anzah lF i sche ; i++) {433 xSchwimm = ySchwimm = 0;434 xZaehler = yZaehler = nenner = 0 . ;435 for ( j =0; j<anzah lF i sche ; j++) {436 i f ( i != j && abstand ( f i s c h e [ i ] , f i s c h e [ j ] ) != 0 ) {437 for ( k=0; k<f i s c h e [ i ] . f r eunde . l ength ; k++) {438 i f ( f i s c h e [ i ] . f r eunde [ k ] == j ) {439 xZaehler −= abstandX ( f i s c h e [ i ] , f i s c h e [ j ] ) / abstand ( f i s c h e [ i ] ,

f i s c h e [ j ] ) ;440 yZaehler −= abstandY ( f i s c h e [ i ] , f i s c h e [ j ] ) / abstand ( f i s c h e [ i ] ,

f i s c h e [ j ] ) ;441 break ;442 }443 }444 for ( k=0; k<f i s c h e [ i ] . f e i nd e . l ength ; k++) {445 i f ( f i s c h e [ i ] . f e i nd e [ k ] == j ) {446 xZaehler += abstandX ( f i s c h e [ i ] , f i s c h e [ j ] ) / abstand ( f i s c h e [ i ] ,

f i s c h e [ j ] ) ;447 yZaehler += abstandY ( f i s c h e [ i ] , f i s c h e [ j ] ) / abstand ( f i s c h e [ i ] ,

f i s c h e [ j ] ) ;448 break ;449 }450 }451 nenner += 1./ abstand ( f i s c h e [ i ] , f i s c h e [ j ] ) ;452 }453 }454 xSchwimm = welchesKaestchen ( xZaehler /nenner , yZaehler /nenner , true ) ;455 ySchwimm = welchesKaestchen ( xZaehler /nenner , yZaehler /nenner , fa l se ) ;456 // schwimme zu neuer Pos i t ion457 f i s c h e [ i ] . schwimme( f i s c h e [ i ] . xAlt + xSchwimm , f i s c h e [ i ] . yAlt + ySchwimm) ;458

459 // Privatsphaehre der Fische460 i f ( p r i va t sphae r e ) {461 zuNah = fa l se ;462 for ( j =0; j<anzah lF i sche ; j++) {463 i f ( i != j && Math . sq r t ( ( f i s c h e [ i ] . x−f i s c h e [ j ] . xAlt ) ∗( f i s c h e [ i ] . x−f i s c h e [ j

] . xAlt )+( f i s c h e [ i ] . y−f i s c h e [ j ] . yAlt ) ∗( f i s c h e [ i ] . y−f i s c h e [ j ] . yAlt ) )



< f i s chRad iu s ) {464 zuNah = true ;465 break ;466 }467 }468 }469

470 // Fa l l s Pr iva tsphaehre v e r l e t z t471 i f ( p r i va t sphae r e && zuNah) {472 // schwimme wieder zurueck473 f i s c h e [ i ] . schwimme( f i s c h e [ i ] . x − xSchwimm , f i s c h e [ i ] . y − ySchwimm) ;474 // addiere 1 zur summeAllerZuNahs475 summeAllerZuNahs += 1;476 }477

478 // Raender479 i f ( random . next Int (1 ) == 0)480 rand = −1;481 else482 rand = 1 ;483 i f ( f i s c h e [ i ] . x < 0+ f i s chRad iu s )484 f i s c h e [ i ] . schwimme( f i s c h e [ i ] . x+2, f i s c h e [ i ] . y+rand ) ;485 i f ( f i s c h e [ i ] . y < 0+ f i s chRad iu s )486 f i s c h e [ i ] . schwimme( f i s c h e [ i ] . x+rand , f i s c h e [ i ] . y+2) ;487 i f ( f i s c h e [ i ] . x > winSize . width−f i s chRad iu s )488 f i s c h e [ i ] . schwimme( f i s c h e [ i ] . x−2, f i s c h e [ i ] . y+rand ) ;489 i f ( f i s c h e [ i ] . y > winSize . he ight−f i s chRad iu s )490 f i s c h e [ i ] . schwimme( f i s c h e [ i ] . x+rand , f i s c h e [ i ] . y−2) ;491 }492

493 // Wenn sehr v i e l e Fische d ie Privatsphaehren anderer Fische v e r l e t z en ,494 // schwimmen ein paar Fische paranoid durch d ie Gegend , sodass495 // we i t e rh in Bewegung im Teich he r r s ch t und das Wasser z i r k u l i e r t .496 i f ( summeAllerZuNahs > anzah lF i sche ∗0 . 9 ) {497 i f ( fa l se ) {498 // bestimme paranoiden Fisch499 a = random . next Int ( anzahlFische −1) ;500 // Plus oder Minus Bewegung501 b = ( int ) ( Math . pow(−1 ,random . next Int (100) ) ∗ f i s chRad iu s ) ;502 // c=1 −> x Bewegung c=2 −> y Bewegung503 c = random . next Int (1 ) +1;504 for ( i =0; i <10; i++) {505 i f ( ! p r ivat sphaereWirdVer l e t z t ( f i s c h e [ a ] , ( c%2)∗b , ( ( c%2)−1)∗(−b) ) ) {506 f i s c h e [ a ] . x += (c%2)∗b ;507 f i s c h e [ a ] . y += (( c%2)−1)∗(−b) ;508 }509 }510 }511 else {512 f i s c h e [ random . next Int ( anzahlFische −1) ] . x += Math . pow(−1 ,random . next Int (100) )

∗4 ;513 f i s c h e [ random . next Int ( anzahlFische −1) ] . y += Math . pow(−1 ,random . next Int (100) )

∗4 ;514 f i s c h e [ random . next Int ( anzahlFische −1) ] . x += Math . pow(−1 ,random . next Int (100) )

∗4 ;515 f i s c h e [ random . next Int ( anzahlFische −1) ] . y += Math . pow(−1 ,random . next Int (100) )

∗4 ;516 }517 }518

519 // Male Fische520 for ( i =0; i<anzah lF i sche ; i++) {521 g2 . s e tCo lo r ( f i s c h e [ i ] . f a rbe ) ;522 i f ( t e i l au f gabeCho i c e . g e tSe l e c t ed Index ( )==0 && i==0)523 g2 . f i l l R e c t ( f i s c h e [ i ] . x−f i s chRad iu s /2 , f i s c h e [ i ] . y−f i s chRad iu s /2 , f i s chRadius ,

f i s chRad iu s ) ;524 else



525 g2 . f i l l O v a l ( f i s c h e [ i ] . x−f i s chRad iu s /2 , f i s c h e [ i ] . y−f i s chRad iu s /2 , f i s chRadius ,f i s chRad iu s ) ;

526 }527

528 // Animation529 r e a l g . drawImage ( dbimage , 0 , 0 , this ) ;530 i f ( nextCheck . ge tS ta t e ( ) ) {531 Thread me = Thread . currentThread ( ) ;532 me. s e tP r i o r i t y ( Thread .MIN PRIORITY) ;533 try {534 i f ( true ) {535 i f ( speedBar . getValue ( ) < 4) {536 me. s l e e p (15000/(4∗4∗4) ) ;537 }538 else i f ( speedBar . getValue ( ) > 90) {539 me. s l e e p (0 ) ;540 }541 else {542 me. s l e e p (300000/( speedBar . getValue ( ) ∗ speedBar . getValue ( ) ∗ speedBar .

getValue ( ) ) ) ;543 // me. s l e e p (( i n t ) ( java . lang .Math . exp (20 ./ speedBar . getValue () ) ∗ ( .1/5) ) ) ;544 }545 }546 else547 me. s l e e p (0 ) ;548 } catch ( Inter ruptedExcept ion e ) {549 return ;550 }551 canvas . r epa in t ( ) ;552 }553

554 }555

556 private double abstand ( Fisch a , Fisch b) {557 return Math . sq r t ( ( a . xAlt−b . xAlt ) ∗( a . xAlt−b . xAlt )+(a . yAlt−b . yAlt ) ∗( a . yAlt−b . yAlt )

) ;558 }559

560 private int abstandX ( Fisch a , Fisch b) {561 return a . xAlt−b . xAlt ;562 }563

564 private int abstandY ( Fisch a , Fisch b) {565 return a . yAlt−b . yAlt ;566 }567

568 private int welchesKaestchen ( double xin , double yin , boolean returnX ) {569 // Achtung : In Java i s t Origo l i n k s oben , d . h . x nach rech t s p o s i t i v570 // und y nach unten p o s i t i v !571 int xout , yout ;572 i f ( Math . abs ( xin / yin ) >= Math . atan ( p i / 8 . ) && Math . abs ( xin / yin ) <= Math . atan ( 3 .∗

pi / 8 . ) ) {573 xout = signum ( xin ) ;574 yout = signum ( yin ) ;575 }576 else i f ( Math . abs ( xin ) >= Math . abs ( yin ) ) {577 xout = signum ( xin ) ;578 yout = 0 ;579 }580 else i f ( Math . abs ( xin ) <= Math . abs ( yin ) ) {581 xout = 0 ;582 yout = signum ( yin ) ;583 }584 else {585 System . out . p r i n t l n ( ”Kein K{\”a} stchen gefunden ! x”+xin+” y”+yin ) ;586 xout = 0 ;587 yout = 0 ;588 }



589 i f ( returnX )590 return xout ;591 else592 return yout ;593 }594

595 private int signum ( double a ) {596 i f ( a >= 0) return 1 ;597 else return −1;598 }599

600 private boolean pr ivat sphaereWirdVer l e t z t ( Fisch a , int xSchwimm , int ySchwimm){

601 for ( j =0; j<anzah lF i sche ; j++) {602 i f ( i != j && Math . sq r t ( ( a . xAlt+xSchwimm−f i s c h e [ j ] . xAlt ) ∗( a . xAlt−f i s c h e [ j ] .

xAlt )+(a . yAlt+ySchwimm−f i s c h e [ j ] . yAlt ) ∗( a . yAlt+ySchwimm−f i s c h e [ j ] . yAlt ) )< f i s chRad iu s ) {

603 return true ;604 }605 }606 return fa l se ;607 }608 } ;


5. BABBEL 22. BwInf, 1. Runde 37

5 Babbel

Diese Aufgabe setzt eine sehr gute Beherrschung der Muttersprache und vor allem desEnglischen voraus. Um sie wirklich angemessen beantworten zu konnen, ist de facto einSprachwissenschaftler zu Rate zu ziehen. (Bei ausreichend tiefer Betrachtung wurde derStoff sicher auch fur eine Doktorarbeit auf dem Gebiet reichen.) Obwohl der Autor dieseVoraussetzung (noch) nicht erfullt, hat er versucht, die Fragen, sofern ihm dies moglichwar, hintergrundig und detailiert zu beantworten.

Dazu musste der Autor auch einige Fachbegriffe verwenden. Die weniger gelaufigensind in Fußnoten am jeweiligen Seitenende mit kurzer Erklarung angegeben.

Wahrend der Arbeiten an der Aufgabe erkannte er das Potenzial, das halb-automatischeUbersetzungen bei weiterer Verbesserung des Computerteils in sich haben: Eine sehr gro-be Vorubersetzung kann dem menschlichen Ubersetzer aus Fleisch und Blut bereits eineVorstellung vom Text liefern, und der sich so gegebenenfalls bei entsprechender Fachlite-ratur mit weniger gebrauchlichem Vokabular auf ihm Unbekanntes einstellen. Menschen,die der Fremdsprache uberhaupt nicht machtig sind, erfahren durch die verfugbarenUbersetzungsmoglichkeiten wenigstens das Thema und Teile des Inhaltes. Fur mehrsind Computer-Ubersetzungen momentan noch nicht zu gebrauchen. Aber, wie schonder amerikanische Dramatiker Maxwell Anderson schrieb:

”Feldherren und Konige treten ab. Reichtumer zerrinnen, ohne eine Spur zu

hinterlassen.“

5.1 Teilaufgabe Eins

Einige Beispielsatze in Englisch3 und deren Ubersetzung nach der in der Aufgabe vorge-stellten Methode: (Die Ubersetzung wurde dadurch erschwert, dass in der Aufgabenstel-lung nicht definiert wird, welche Bedeutung bei mehreren Ubersetzungsmoglichkeitenpro Wort Vorrang hat.)

The cats eat the small mouse.4 Das/Die Katzen fressen das/die klein Maus.

The big cat runs after the small mice. Die groß Katze rennt nach die klein Mause.

Later, the big mice run into the small mouse’s hole. Spater, die groß Mause rennenin das schmal Maus’s Loch.

Aus diesen Beispielen wird ersichtlich, dass ein Ubersetzungswerkzeug dieser Art kei-ne Chance hat, logische Strukturen im Satz, wie Satzbau und Grammatik, zu erkennen.Schwachen treten deshalb bei Adjektiven und bei in verschiedenen Kasus5 stehenden

3Die Qualitat der Beispielsatze lasst freilich keine Ruckschlusse auf die Englischkenntnisse des Autorszu.

4Bei diesem und den weiteren Satzen geht nicht eindeutig aus der Fragestellung hervor, wie man ihnubersetzen musste.

5lat. casus = der Fall



Substantiven auf. Desweiteren werden die Worter einfach der Reihe nach stupide ab-gearbeitet, ohne je einen Sinn zu ergeben. Der Genitiv im letzten Beispiel findet keineBeachtung und verfalscht somit gar den Sinn des Satzes. Das Ubersetzungsergebnis istinsgesamt deshalb so schlecht, weil sich der Satz anhort, als sei er von einem der Sprachenicht machtigen Fremden gesprochen, der nicht im Stande ist, die Worte ihrer jeweili-gen Funktion im Satz anzupassen. Verben, die mit Prapoistion6 stehen, wie im zweitenBeispiel

”(to) run after“ hinterherlaufen heißt, und dann eine andere Bedeutung als in

der Infinitv-Form haben, konnen ebenfalls nicht adaquat ubersetzt werden.Ohne Original ist ein Textverstandnis erheblich gefahrdet oder gar – nicht moglich.

Einzige sinnvolle Verwendung kann diese Methode bei interaktiven Worterbuchern, wieLEO-Online7, oder Rechtschreibprufungen finden. Fur Ubersetzungen einzelner Satzeoder gar langerer Texte dagegen ist sie vollig ungeeignet.

5.2 Teilaufgabe Zwei

Wahrend des Testens der verschiedenen Ubersetzungswerkzeuge stellte der Autor fest,dass eine nahezu vollstandige Konvergenz zwischen den beliebtesten – und wohl auchbesten – Tools bestand. Trotzdem wurden die folgenden Ubersetzungen mit drei ver-schiedenen Programmen8, namlich den Google Language-Tools9, FreeTranslation.com10

und Systran11, durchgefuhrt.

Mr. Miller died: The late Mr. Miller was of course not alive anymore.Google:

”Herr Miller starb: Spate Herr Miller war selbstverstandlich mehr nicht leben-

dig.“FreeTranslation.com:

”Herr Miller ist gestorben: Der spate Herr Miller war selbstverstand-

lich nicht lebend mehr.“Systran:

”Herr Miller sterben: d spat Herr Miller sein selbstverstandlich nicht lebendig

mehr. “ (Die korrekte Ubersetzung musste”Herr Muller starb: Der verstorbene Herr

Muller war naturlich nicht mehr lebendig“ lauten.)Dieses erste Beispiel zeigt eine der großen Schwachen der Computerubersetzungen: Ihnenist eine Texterschließung unmoglich. Wahrend

”the late Mr. Miller“ in einem beliebi-

gen anderen Text sehr wohl”der spate Herr Muller“ heißen kann, ist dies aufgrund des

vorhergehenden Satzes im Beispiel nicht moglich. Hierbei handelt es sich um eine reineSinnfrage, die von einem Computer in absehbarer Zeit wohl nicht beherrscht werdenkann. Daraus wird bereits ersichtlich, dass zurzeit noch keine vollautomatische Uber-setzung eines (langeren) Textes denkbar ist. Abgesehen von dieser ersten Schwache derUbersetzung treten zwei weitere Fehler nach dem Doppelpunkt auf: Der Artikel wirdvon Google aus nicht naher nachvollziehbaren Grunden nicht mitubersetzt. Außerdem

6Prapositionen bezeichnen Verhaltnisse zwischen Personen und Sachen. Sie drucken kausale, lokale,modale und temporale Aspekte aus. Beispiele fur Prap. sind ”ab, unter, jenseits, von, auf“.

7LEO – Link Everything Online, http://www.dict.leo.org8Dies war wohl mit dem Begriff ”Funktion“ im Aufgabentext gemeint9http://google.de/language tools?hl=de

10http://freetranslation.com/11http://www.systranbox.com/systran/box


http://www.dict.leo.org

http://google.de/language_tools?hl=de

http://freetranslation.com/

http://www.systranbox.com/systran/box


ist die Syntax12 des Satzes falsch. (Es musste”nicht mehr“ an Stelle von

”mehr nicht“

heißen.) Wahrend FreeTranslation.com am besten abschnitt, ist Systrans Ubersetzungvollig unbrauchbar.

Because of the hot weather the children were not allowed to play in the garden.Google:

”Wegen des heißen Wetters wurden den Kindern nicht erlaubt, im Garten zu

spielen.“FreeTranslation.com:

”Wegen des heißen Wetters wurden die Kinder nicht erlaubt, im

Garten zu spielen.“Systran:

”wegen d heiß verwittern d Kind sein nicht lassen zu Spiel in d Garten. “

(Die korrekte Ubersetzung musste”wegen des heißen Wetters durften die Kinder nicht

im Garten spielen“ heißen.)Bis auf einen Numerusfehler13 (wurde) schafft Google es immerhin, mit einer gutenUbersetzung aufzuwarten. Systran scheint in einer anderen Liga zu spielen, was denFortschritt der computergestutzten Ubersetzung in den letzten Jahren deutlich zeigt.Unerklarlich bleibt weiterhin, warum Systran Zeilenumbruche (aus asthetischen Grundenentfernt) und Unterstriche in den Satz einfugt und den Artikel

”the“ als

”d“ deutet.

I enjoy relaxing in the sun.Google:

”Ich genieße, in der Sonne mich zu entspannen.“

FreeTranslation.com:”Ich genieße Entspannung in der Sonne.“

Systran:”

ich genießen relaxing in d Sonne. “ (Richtig ware”ich genieße das Entspan-

nen in der Sonne“ gewesen.)Googles Ubertragung ins Deutsche weist einen falschen Satzbau auf. Bei der Losungvon FreeTranslation.com ist zu monieren, dass

”Entspannung“ durch

”das Entspannen“

ersetzt werden sollte.

Did you get the same results as Paul?Google:

”Erhielten Sie die gleichen Resultate wie Paul?“

FreeTranslation.com:”Haben Sie die gleichen Ergebnisse als Paul erhalten?“

Systran:”

Sie erhalten d gleich Resultat wie Paul? “ (Richtig ist Googles Ubersetzung.)Anhand dieses Beispiels zeigt sich, dass computergestutzte Ubersetzungssysteme in derLage sind, auch einfache Fragen korrekt ins Deutsche zu ubertragen. Sie lesen zumindestnicht einfach uber das Fragezeichen (und andere Satzzeichen) hinweg, sondern beziehendies und die veranderte Wortstellung im Satz folgerichtig in Ihre Ubersetzung mit ein.FreeTranslation.com kann offensichtlich nicht zwischen

”als“ und

”wie“ unterscheiden.

Obwohl Google als einziger den Satz richtig ubersetzt, fragt sich, ob hier wirklich dieHoflichkeitsform im Singular verwendet werden sollte. Das englische

”you“ durfte eher

dem deutschen”du“ oder

”ihr“ entsprechen. In Anbetracht des Kunstwerkes von Systran,

wiederholt nicht einmal auch nur annahernd den Sinn zu treffen, mag es aber vielleichtals abwegig erscheinen, uber solche Feinheiten zu diskutieren.

12griech. syntaxis = Zusammenstellung, Anordnung, AneinanderreihungLehre von der Kombination von Wortern zu Satzen

13lat. numerus = Zahl, AnzahlHier: Verwechslung von Singular/Plural



5.3 Teilaufgabe Drei

• Viele Fehler entstehen durch eine falsche Sprachsyntax. (Vergleiche dazu Abschnitt5.2 auf Seite 38.)Sprachen sind komplizierte, aber nicht streng logische dynamische Gebilde. Com-puter sind komplizierte, aber streng logische Maschinen. Sie arbeiten immer wiedernach denselben (einfaltigen?) Strukturen und sind auch auf diesen Horizont der

”Denkweise“ beschrankt. Es ist also schon von Grund auf ein schwieriges Unter-

fangen, Ubersetzungen mit einem”Rechner“14 anfertigen zu lassen. (Man beachte

nur die Programmiersprachen: Verglichen mit echten Sprachen kann man sie imbesten Fall als einfach und abstrakt bezeichnen.)

• Dem Computer ist ein Textverstandnis unmoglich. Er kann deshalb bei Worternmit mehreren Bedeutungen, deren Ubersetzungen sich nur aus dem Zusammenhangdes Textes ergeben, nicht die in diesem Fall passende auswahlen und benutzen.(Siehe hierzu auch Abschnitt 5.2 auf Seite 38.)

• Eine weitere fundamentale Schwierigkeit ist das Ubersetzen von Phrasen und Rede-wendungen. Man denke nur an das in England oft gebrauchte

”home sweet home“

(moglicherweise etwas in der Richtung wie”trautes Heim, Gluck allein“), das die

Google Language-Tools fur ein”susses Haupthaus“ halten.

14engl. (to) compute = rechnen, berechnen


Dokumentation zur L¨osung der Aufgaben des 22...

Documents

Transcript of Dokumentation zur L¨osung der Aufgaben des 22...