Inhaltsverzeichnis
<1>
Inhaltsverzeichnis
1. Einleitung........................................................................................... 2
2. Begriffsklärungen.............................................................................. 3
3. Algorithmen ...................................................................................... 5
3.1. Wortverdreher, Zeichenverdreher ...................................................................... 5 3.2. Entscheider ............................................................................................................ 6 3.3. Leerraum-, Sonderzeichenentfernung............................................................... 6 3.4. Sucher .................................................................................................................... 7 3.5. Palindromsammlung ......................................................................... 8
4. Realisierung ...................................................................................... 9
4.1. Realisierung in VB................................................................................................. 9 4.2. Realisierung in Javascript ................................................................................... 13 4.3. Realisierung in Java ............................................................................................. 14 4.4. Realisierung in PHP ............................................................................................. 15
5. Zahlenpalindrome ............................................................................ 20
5.1. Das 196er Problem ................................................................................................ 20 5.2. Lösung in Excel ..................................................................................................... 21
6. Konzepte, die vermittelt werden sollen ........................................... 23
6.1. Rekursion................................................................................................................ 23 6.2. Modultechnik ........................................................................................................ 24 6.3. Sprachform ............................................................................................................ 25 6.4. Programmoberflächen ........................................................................................ 26 6.5. Compiler ................................................................................................................. 26 6.6. Klassen und Objekte, Objektorientierung ........................................................ 27 6.7. Client-Server Beziehungen .................................................................................. 28
7. Quellenverzeichnis............................................................................ 30
Einleitung
<2>
1. Einleitung
Während meiner Ferialtätigkeit als Barkeeper wuchs mein Interesse an diversen
Mixgetränken und ich machte mich daher auch auf die Suche nach Rezepten im
Internet. Dabei stieß ich auf eine Homepage über Cocktails, auf der auch ein Foto
einer Würstelbude mit dem Namen „Der FREIBIER Fred“ zu sehen war. Da fiel mir
ein, dass wir im Rahmen des Informatikunterrichtes in der 7. Klasse ein Programm
geschrieben haben, das ein Wort verdrehen kann. Prof. Micheuz fragte schon
damals, ob einer der Schüler vielleicht bereit wäre, in der 8. Klasse eine
Fachbereichsarbeit über Palindrome zu schreiben, was mich aber zu der Zeit noch
nicht so sehr interessierte.
Eines Tages, als ich mir Bilder von Sportautos im Internet ansah, fiel mir auf, dass
das englische Wort für Rennwagen, „RACECAR“, auch ein Palindrom ist. Sofort
kam mir wieder das Palindrom „Der FREIBIER Fred“ in den Sinn, und irgendwie
gingen mir diese Worte danach nicht mehr aus dem Kopf.
Da erinnerte ich mich auch wieder daran, dass Prof. Micheuz einmal gefragt hat, ob
einer von uns eine Fachbereichsarbeit über Palindrome schreiben will. Ich
beschäftigte mich immer mehr mit Palindromen, stieß auch auf Zahlenpalindrome
und beschloss, das Angebot von Prof. Micheuz anzunehmen, und als
Fachbereichsthema „Palindrome aus informatischer Sicht“ zu wählen.
Begriffserklärung
<3>
2. Begriffsklärungen
Palindrom1
Palindrom das; -s, -e (Wort[folge] od. Satz, die vorwärts wie rückwärts gelesen
[den gleichen] Sinn ergeben, z. B. Reittier; Leben - Nebel; Rentner; Reliefpfeiler)
Es folgen nun Kurzbeschreibungen der Programmiersprachen, die ich im
Zusammenhang mit den Palindrom-Aufgaben verwendet habe.
Visual Basic (for Applications) – VB(A)
Visual Basic ist eine komplett eigene Programmiersprache die, anders als
JavaScript, PHP oder Java, nicht von der C Syntax abstammt. Visual Basic
zeichnet sich besonders durch eine bedienungsfreundliche Benutzeroberfläche aus,
und besticht außerdem durch die Möglichkeit, in Visual Basic geschriebene Module
in die Standardsoftware MS-Office einzubinden (Visual Basic for Applications).
JavaScript:
JavaScript ist kein direkter Bestandteil von HTML, sondern eine eigene
Programmiersprache. Diese Sprache wurde jedoch eigens zu dem Zweck
geschaffen, HTML-Autoren ein Werkzeug in die Hand zu geben, Web-Seiten zu
optimieren. JavaScripts werden wahlweise direkt in der HTML-Datei oder in
separaten Dateien notiert. Sie werden zur Laufzeit vom Web-Browser interpretiert.
Dazu besitzen moderne Web-Browser entsprechende Interpreter-Software.2
Hinzuzufügen wäre, dass JavaScript eine von der C Syntax abstammende
Programmiersprache ist.
1 Defintion aus dem Duden 2 aus SELFHTML 8.0 von Stefan Münz
Begriffserklärung
<4>
Java
Java ist eine objektorientierte Programmiersprache, die in Anlehnung an die
Programmiersprache C++ entwickelt wurde. Java ist jedoch leichter anwendbar als
diese. Mit Java lassen sich komplette Anwendungen erstellen, die sowohl auf einem
einzigen Computer laufen als auch auf Netzwerk-Servern und - Clients verteilt sein
können. Java eignet sich auch zur Programmierung kleinerer Anwendungsmodule
(Applets) als Elemente einzelner Web-Seiten. Java-Applets ermöglichen es dem
Web-Nutzer, z.B. über Schaltflächen mit einer Seite zu interagieren.
PHP
PHP ist eine serverseitige, in HTML-Seiten einbaubare Programmiersprache für
Web-Anwendungen. Sie war ursprünglich ein einfacher, in Perl geschriebener CGI-
Wrapper, die später - zur Verbesserung der Performance - in C neu implementiert
wurde.
Algorithmen
<5>
3. Algorithmen
Nachdem in einer Spezifikation ein Problem genau beschrieben worden ist, geht es
darum, einen Lösungsweg zu entwerfen. Da die Lösung von einem Rechner
durchgeführt wird, muss jeder Schritt genau und eindeutig vorgeschrieben werden.
Daher kann ein Algorithmus von einem Menschen oder von einer Maschine
durchgeführt werden. Ein Algorithmus ist eine eindeutige Anleitung, um ein
bestimmtes, endliches Problem zu lösen. In einem Algorithmus muss jederzeit
eindeutig bestimmt sein, was als nächstes gemacht werden muss. Ist der jeweils
nächste Schritt eindeutig bestimmt, so spricht man von einem
deterministischen Algorithmus, ansonsten von einem nicht-
deterministischen Algorithmus.
3.1. Wortverdreher - Zeichenverdreher
Der Wortverdreher-Algorithmus ist der einfachste und grundlegendste
Algorithmus. Er wird benötigt, um die Grundlage zur Überprüfung von
Palindromen zu schaffen, denn ein eingegebenes Wort wird später mit dem
verdrehten verglichen. Der Wortverdreher-Algorithmus hat einen Eingabewert mit
dem Datentyp String (eine Variable, die immer nur Zeichenfolgen und niemals
numerische Werte enthält) und einen Ausgabewert, ebenfalls mit dem Datentyp
String.
Struktogramm: Wortverdreher
Funktion Wortverdrehen
temp = ""
Zählvariable i = 1 bis 'Länge des Strings'
temp = (1+i)ter Buchstabe & temp
verkerht = temp
Ende der Funktion
Algorithmen
<6>
3.2. Entscheider
Der Palindrom-Entscheider ist ein Algorithmus, der entscheidet, ob ein
eingegebener Text ein Palindrom ist oder nicht. Er hat einen Eingabewert mit dem
Datentyp String, den er an den oben erklärten Wortverdreher weiterleitet, und
anhand des Ausgabestrings des Verdrehers vergleicht, ob der Eingabestring gleich
dem verdrehten ist. Als Ausgabewert hat dieser Algorithmus den Datentyp boolean.
Dieser Datentyp kann genau zwei mögliche Werte annehmen, entweder true oder
false (wahr oder falsch).
Struktogramm: Palindrom-Überprüfer
Funktion Palindrom
Länge L des Strings ermitteln
Zählvariable i = 0
Wenn String = verkehrt(String)ja nein
Ja 'String' ist ein Palindrom Nein 'String' ist kein Palindrom
aa
Algorithmen
<7>
3.3. Leerzeichen-, Sonderzeichenentfernung
Dieser Algorithmus ist sehr wichtig, da man bei einem längeren Text Leerräume
entfernen muss, um zu überprüfen, ob ein Palindrom enthalten ist oder nicht.
Weiters wandelt dieser Algorithmus alle großgeschriebenen Zeichen in
Kleinbuchstaben um, da zum Beispiel ein großes A ein anderes Zeichen ist, als ein
kleines a und daher das Programm nicht überprüfen kann ob ein groß
geschriebenes Wort ein Palindrom ist oder nicht (z.B.: Kajak würde der Computer
nicht als Palindrom erkennen sondern nur kajak).
Struktogramm: Leerzeichen, Sonderzeichenentfernung
Funktion entfernen
Länge L des Strings ermitteln
String in Kleinbuchstaben umwandeln
Zählvariable = i bis L
Wenn Zeichen 'i' = Buchstabe ausKleinbuchstabenalphabet oder
Kleingeschriebener Umlautja nein
fortfahren Zeichen Löschen und fortfahren
3.4. Sucher
Der Palindrom Sucher durchsucht einen eingegebenen String nach Palindromen.
Er nimmt daher jede mögliche Zeichenfolge mit mindestens drei Zeichen und leitet
jede dieser Zeichenfolgen dann weiter an den Entscheider-Algortihmus. Der Such-
Algorithmus selber hat keinen Ausgabewert, sondern verarbeitet nur die
Ausgabewerte der anderen beiden Algorithmen weiter.
Algorithmen
<8>
3.5. Palindromsammlung
Bei der Palindromsammlung, geht es darum, dass man mittels der
Programmiersprache PHP Zeichenketten (Strings), die bestimmte Bedingungen
erfüllen, also Palindrome sind, zu einer Datenbank hinzufügt. Der Algorithmus ist
eigentlich nichts anderes als eine spezielle Form des Entscheide-Algorithmus. Es
geht darum, dass ein eingegebenes Wort zu einer Datenbank hinzugefügt wird,
sofern es ein Palindrom ist.
Stuktogramm: Palindrom-Sammler
String in Kleinbuchstaben umwandeln
Leerräume und Sonderzeichen entfernen
Wenn String = umdrehen(String)ja nein
Ausgabe:Ja 'String' ist ein Palindrom
String zur Datenbank hinzufügen
Ausgabe:
'String' ist kein Palindrom
Realisierung
<9>
4. Realisierungen
4.1. Realisierung in Visual Basic
Der Wortverdreher
Function verkehrt(ByVal wort As String) As String temp = "" For i = 1 To Len(wort) temp = Mid(wort, i, 1) & temp Next verkehrt = temp End Function
Bei diesem Algorithmus handelt es sich um eine Function-Prozedur aus Visual
Basic. Diese Function wird in einigen Programmen verwendet. Sie heißt „verkehrt“
und verdreht einen eingegebenen Wert mit dem Datentyp String (eine Variable,
die immer nur Zeichenfolgen und niemals numerische Werte enthält) und gibt
diesen Wert dann in einer Variable aus. Sie verwendet zwei Variablen, wort und
temp, wobei wort für den anzugebenden Wert steht und temp eine Hilfsvariable
ist. Als erstes wird eine for-Schleife erzeugt (for i = 1 to...), die so oft
durchfahren wird, wie lange wort ist (... len(wort)). Die Zeile „temp =
Mid(wort, i, 1) & temp“ setzt zuerst das erste Zeichen von wort vor das letzte
Zeichen von temp, danach das zweite Zeichen von wort vor das letzte Zeichen von
temp usw. so lange, bis die Schleife oft genug durchlaufen ist (Länge von wort).
Der Ausgabewert der Prozedur ist das umgedrehte Wort.
Realisierung
<10>
Leerraum und Sonderzeichenentfernung
Text1.Text = LCase(Text1.Text) x = Text1.Text Text1.Text = Trim(x)
In diesem Teil des Algorithmus werden alle Großbuchstaben in Kleinbuchstaben
umgewandelt. Die Lcase() -Funktion ist eine in Visual Basic bereitgestellte
Funktion, die einen String zurückgibt, in dem alle Buchstaben in Kleinbuchstaben
umgewandelt werden.
Dim hilf_text For i = 1 To Len(x) asc_wert = Asc(Mid$(x, i, 1)) If (asc_wert >= 97) And (asc_wert <= 122) Or (asc_wert = 228) Or (asc_wert = 246) Or (asc_wert = 252) Then hilf_text = hilf_text & Mid(x, i, 1) End If Next Text1.Text = Trim(hilf_text) In diesem Teil werden in Visual Basic alle Leerräume und Sonderzeichen entfernt.
Da jedes Zeichen einen eigenen ASCII-Wert hat, funktioniert dies so, dass einfach
alle Zeichen, die nicht mit dem ASCII-Werten der Kleinbuchstaben und den ASCII-
Werten der Umlaute übereinstimmen, aus dem String entfernt werden. Zuvor
muss der gesamte Text in Kleinbuchstaben umgeschrieben werden, da
Großbuchstaben andere ASCII-Werte haben als Kleinbuchstaben.
Hier wird eine for-Schleife benötigt, die so lange ist, wie der gesamte String
(For i = 1 To Len(x)).
Der ASCII-Wert jedes Zeichens wird überprüft und verglichen, ob das Zeichen den
ASCII-Wert von 97 bis 122 [die kleinbuchstaben] ((asc_wert >= 97) And
(asc_wert <= 122)), und mit den Werten 228, 246 und 252 (den umlauten). Wenn
der ASCII-Wert nicht mit den verglichenen Werten übereinstimmt, wird das
Zeichen aus dem String einfach herausgelöscht.
Realisierung
<11>
Entscheider
Function palindrom(ByVal wort As String) As Boolean If wort = verkehrt(wort) Then palindrom = True Else palindrom = False End If End Function Dieser zweite Algorithmus mit dem Namen „Palindrom” überprüft, ob der
eingegebene String gleich dem Verdrehten ist. Dazu verweist die Funktion auf die
„Verkehrt“-Funktion (If wort = verkehrt(wort)) und vergleicht das
Eingabewert wort mit dem Ausgabewert der „Verkehrt“-Funktion.
Es gibt bei der „Palindrom“-Funktion zwei mögliche Ausgabewerte: entweder
true oder false (ja oder nein), da als Datentyp boolean gewählt wurde (erste
Zeile). Die „Palindrom“-Function funktioniert nur in Verbindung mit der
„Verkehrt“-function (es sei denn, man ändert sie ein wenig ab).
Realisierung
<12>
Sucher
Private Sub Command1_Click() List1.Clear x = Text1.Text For i = 3 To Len(x) z = 1 Do If palindrom(Mid$(x, z, i)) = True Then List1.AddItem Mid$(x, z, i) End If z = z + 1 Loop Until z + i - 1 > Len(x) Next End Sub
Dieser Algorithmus in Visual Basic ist eine Sub-Prozedur, die beim Klick auf den
„Command1“-Button anfängt, den gesamten String (den eingegebenen Text)
nach Palindromen durchzusuchen. Den Ablauf muss man sich so vorstellen, dass
zuerst die Zeichen eins bis drei überprüft werden, dann eins bis vier (bis zum
letzten), danach vom zweiten Zeichen weg wieder der beschriebene Ablauf. So
werden alle Möglichkeiten von mindestens drei aufeinanderfolgenden Zeichen
abgesucht und immer durch die Palindrom-Funktion geschickt.
Realisierung
<13>
4.2. Realisierung in Javascript
Wortverdreher, Zeichenverdreher <html> <head> <title>Wort-Umdreher</title> <script language="JavaScript"> function umdrehen(temp) { var t=""; for(i=temp.length; i>=0; i--) { t = t + temp.substr(i,1); } return t; } function palind() { document.form1.wort.value = umdrehen(document.form1.wort.value) } </script> </head> <body topmargin=50> <form name=form1 method=post> <table border=1 align=center cellpadding=0 cellspacing=0> <tr> <td heigth=50 colspan=2 bgcolor="&HFFF&"><p align=center><font size=6>Wort-Umdreher</font></p></td> </tr> <tr> <td><b>Wort</b>:</td> <td><input type=text size=50 name=wort></td> </tr> <tr><td colspan=2><p align=center> <input type=button value=umdrehen onclick=palind()> </p></td></tr> </table> </form> </body> </html> Dieser Code beschreibt die Vorgehensweise des Wortumdrehers in JavaScript.
Hier wird der Code direkt in eine HTML-Datei geschrieben, was bedeutet, dass das
Programm später in eine Homepage eingebaut werden kann. Zuerst wird wieder
der Name, „umdrehen“ der Funktion festgelegt (function umdrehen(temp)).
Im Formularteil (untere Hälfte) wird die Javascript-Funktion aufgerufen, in der
der im Textfeld eingegebene String "ungedreht" wird und im gleichen Textfeld
mit der Bezeichnung "wort" ausgegeben wird.
Realisierung
<14>
4.3. Realisierung in JAVA
Entscheider
public class Palindrom { static boolean palTest(String wort) { int laenge = wort.length(); String wort_klein = wort.toLowerCase(); boolean pal_ok = true; for (int i = 0; i < laenge / 2; i++) if (wort_klein.charAt(i) != wort_klein.charAt(laenge - i - 1)) pal_ok = false; return pal_ok; } public static void main(String argv[]) { String wort; if (argv.length == 1) { wort = argv[0]; boolean pal_ok = palTest(wort); if (pal_ok) System.out.println("" + wort + " ist ein Palindrom"); else System.out.println("" + wort + " ist kein Palindrom"); } else System.out.println("Es muss genau ein Wort angegeben werden!"); } }
Hier wird in Java keine Function erstellt, sondern eine Klasse mit dem Namen
Palindrom, als Ausgabewert WAHR oder FALSCH (daher wieder der Datentyp
Boolean). Zuerst wird die Variable „wort“ mit dem Datentyp String festgelegt.
Weiters wird eine Variable „laenge“ festgelegt, die die Anzahl der Zeichen des
Eingabewortes ist (Datentyp Integer). Weiters wird der Text wieder in
Kleinbuchstaben umgewandelt (String wort_klein = wort.toLowerCase();) um die
Groß-Kleinschreibung wieder zu ignorieren.
Realisierung
<15>
4.4. Realisierung in PHP
Wortverdreher – Zeichenverdreher - Algorithmus
<form name=form action="?a=umdrehen" method=post> <table border=1 align=center cellpadding=0 cellspacing=0> <tr> <td height=50 colspan=2 bgcolor=#cccccc><p align=center><font size=6>Wort-Umdreher</font></p></td> </tr> <tr> <td><b>Wort</b>:</td> <td><input type=text size=50 name=wort></td> </tr> <tr><td colspan=2><p align=center> <input type=submit value=umdrehen></p></td></tr> </table> </form>
In der ersten Zeile wird zuerst ein Formular erzeugt (mit dem <form>-Tag), später
mit dem </form>-Tag wird es wieder geschlossen. Die Attribute des Formulares
sind name, action und method. Name legt den Namen des Formulares fest,
während action dem Formular befiehlt, was zu tun ist, wenn die vom Benutzer
eingegebenen Daten abgeschickt werden. Das method-Attribut bestimmt die
http-Übertragungsmethode, post. In diesem Formular wird eine Tabelle
erzeugt (trägt zur optischen Gestaltung der Seite bei). In der Tabelle werden zwei
Eingabefelder <input> erzeugt. Auch die „inputs“ haben verschiedene Attribute:
hier type, name und size(<input type=text size=50 name=wort>). Type legt die
Art der Eingabe fest, in diesem Fall ein Textfeld, size gibt die Größe an, hier 50 (50
Pixel breit), und das name-Attribut legt den Namen des Textfeldes fest, mit dem
das Textfeld aufgerufen wird (hier „wort“). Das zweite Eingabefeld ist vom typ
„submit“ (Button), der „value“ (die Beschriftung) lautet: umdrehen.
Das Umdrehen funktioniert in PHP erst hier:
Realisierung
<16>
<? if($a == "umdrehen") { ?> <table border=1 align=center cellpadding=0 cellspacing=0 width=400> <tr> <td height=50 bgcolor=#CCCCCC><p align=center><font size=6>Wort- Umdreher</font></p></td> </tr> <tr> <td><p align=center>Das Wort <b><?echo $wort;?></b> ergibt umgedreht <b><?echo strrev($wort);?></b>! </p></td> </tr> </table> <? } ?>
Das Wort-Umdreher-Programm in PHP hat eine vordefinierte strrev-funktion.
Das bedeutet, dass der Umdreh-Algorithmus schon vorhanden ist und man nur
noch darauf zugreifen muss. In PHP wird also das Wort in eine variable ($wort)
mit dem Datentyp String gespeichert und umgedreht.
Realisierung
<17>
Entscheider
<form name=form action="?a=palindrom" method=post> <table border=1 align=center cellpadding=0 cellspacing=0> <tr> <td height=50 colspan=2 bgcolor=#cccccc><p align=center><font size=6>Palindrom-Entscheider</font></p></td> </tr><tr> <td><b>Palindrom</b>:</td> <td><input type=text size=50 name=wort></td> </tr> <tr><td colspan=2><p align=center><input type=submit value=überprüfen></p></td></tr> </table> </form> if($a == "palindrom") { $wort=str_replace(" ", "", $wort); ; If($wort == strrev($wort)) { $palindrom = "True"; } Else { $palindrom = "False"; } ?> <table border=1 align=center cellpadding=0 cellspacing=0 width=400> <tr> <td height=50 bgcolor=#cccccc><p align=center><font size=6>Palindrom-Entscheider</font></p></td> </tr><tr> <td><p align=center> <? $wort == strrev($wort); if($palindrom == "True") {echo "Das Wort <b>$wort</b> ist ein Palindrom!";} if($palindrom == "False") {echo "Das Wort <b>$wort</b> ist kein Palindrom!";} ?> </p></td> </tr> </table>
Auch hier wird wieder zuerst ein Formular mit dem Namen „form“ erstellt. Dann
wieder die zwei Eingabefelder (Submit und Text).
Der eigentliche Palindromvergleich erfolgt in diesem Teil:
If($wort == strrev($wort)) { $palindrom = "True"; } Else { $palindrom = "False"; }
Realisierung
<18>
Hier bedient sich das Programm wieder der vorgefertigten „strrev“- Funktion und
vergleicht die Variable „wort“ mit der umgedrehten (strrev($wort)).
Ausgabewert ist hier wieder True oder False. Abgerufen wird dieser Palindrom-
Algorithmus erst später, (if($palindrom == “True“)...; if($palindrom ==
“False“)...).
Der Palindromsammler <? if (isset($eingabe)) { $wort = $eingabe; if (strlen($wort)>2 ){ if ($wort == strrev($wort))$wort wird mit strrev($wort) { echo "Ja, $wort ist ein Palindrom"; $fp = fopen ( "palindrom.txt", "a"); fputs( $fp, "$wort \n"); fclose($fp); } else { echo "Nein, $wort ist kein Palindrom"; } } } else { echo "Kein Wort"; } ?> Dieser Algorithmus überprüft einen eingegebenen String auf zwei Kriterien:
1. Die Mindestlänge des strings muss mindestens mehr als drei Zeichen betragen
(if (strlen($wort)>2 ){), ansonsten soll das Programm anzeigen: „Nein, (wort)
ist kein Palindrom (echo "Nein, $wort ist kein Palindrom";).
Realisierung
<19>
2. Es wird überprüft ob es ein Palindrom ist oder nicht (if ($wort ==
strrev($wort))). Wenn beide Bedingungen erfüllt sind, so passieren folgende
Dinge:
1. echo "Ja, $wort ist ein Palindrom"; 2. $fp = fopen ( "palindrom.txt", "a"); 3. fputs( $fp, "$wort \n"); 4. fclose($fp); 1. Es wird der Text, „Ja, (wort) ist ein Palindrom“ angezeigt.
2. Eine Textdatei mit dem Namen „palindrom.txt“ geöffnet.
3. Das Palindrom wird in diese geöffnete Textdatei eingefügt, und
die Textdatei wieder geschlossen.
Der fertige Palindromsammler könnte dann auf dem Bildschirm so aussehen:
Zahlenpalindrome
<20>
5. Zahlenpalindrome
Ein weiterer interessanter Aspekt von Palindromen sind Zahlenpalindrome.
Nimmt man zum Beispiel eine beliebige positive Zahl (z.B. 83) und addiert dazu
die Ziffern in umgekehrter Reihenfolge, so ergibt sich entweder ein
Zahlenpalindrom oder nicht. Wenn nicht, so wiederholt man dies so lange, bis es
irgendwann einmal ein Palindrom ist. Allerdings stellt sich hier die Frage:
„Funktioniert das immer?“
Bei der Zahl 196 gibt es da noch immer ein kleines Problem (Das 196-Problem)
5.1. Das 196er Problem
Das 196er-Problem wird so genannt, weil 196 die kleinste Zahl ist, mit der es noch
nicht gelungen ist, ein Palindrom zu erzeugen. Jedoch gibt es auch keinen Beweis
dafür, dass nie ein Palindrom mit dieser Zahl entstehen wird. Der Rekord lag im
Februar 2002 bei dieser Zahl bei 67 Millionen Inversionen mit einer 28 Millionen
ziffrigen Zahl, im Jänner 2003 schon bei einer Zahl mit 100 Millionen! Ziffern.
Vieles spricht dafür, dass die Suche vergeblich sein wird, obwohl viele
Wissenschaftler an diesem Problem arbeiten. Schließlich wird die
Wahrscheinlichkeit für das Auftreten eines Palindroms mit den länger werdenden
Zahlen immer geringer. Andererseits hat man aber “unendlich viele Versuche” zur
Verfügung (und der strenge mathematische Beweis dafür, dass sich die 196
tatsächlich der Regel widersetzt, existiert nicht und wird auch schwierig zu
erbringen sein).
Interessant ist auch, dass bei der Untersuchung der Zahlen bis 10000 festgestellt,
dass es 246 Zahlen gibt, die sich widersetzen, Bei allen anderen Zahlen (97,5%)
braucht man weniger als 24 Schritte bis zum Erfolg. Daher kann man behaupten,
„entweder funktioniert es schnell oder gar nicht“. Jenseits der 10000 gibt es
schließlich auch noch Zahlen, die sehr hartnäckig sind (z.B.: 10911 nach 55
Inversionen 4668731596684224866951378664.
Zahlenpalindrome
<21>
5.2. Lösung in Excel
Um die Zahlenpalindrome zu veranschaulichen habe ich auch noch ein kleines
Programm in Excel geschrieben um dies zu veranschaulichen:
Der Quelltext hierzu sieht wie folgt aus: Private Sub CommandButton1_Click() Range(Cells(i + 1, 4), Cells(i + 25, 4)) = "" For i = 1 To 25 Cells(i, 2) = verkehrt(Cells(i, 1)) Cells(i + 1, 1) = Cells(i, 3) If Cells(i, 3) = verkehrt(Cells(i, 3)) Then Cells(i, 4) = "<--" Text.BackColor = &HFFFF& Text.Text = Int(Cells(1, 1)) & " wird nach " & Int(i) & " Inversion(en) ein Palindrom" Range(Cells(i + 1, 1), Cells(i + 25, 2)) = "" Range(Cells(i + 1, 4), Cells(i + 25, 4)) = "" Exit Sub Else Text.BackColor = &HFF& Text.Text = Cells(1, 1) & " wird auch nach 25 Inversionen kein Palindrom" End If Cells(26, 1) = "" Next End Sub
Zahlenpalindrome
<22>
Bei diesem Algorithmus wird zuerst eine Zahl aus dem Eingabefeld umgedreht,
und dann in die Zelle daneben übertragen (Cells(i, 2) = verkehrt(Cells(i, 1)).
Diese beiden Werte werden dann mittels der Summenfunktion von Excel (nicht
VBA!) in der dritten Spalte zusammengezählt. Dann wird überprüft, ob diese
Summe ein Palindrom ist (If Cells(i, 3) = verkehrt(Cells(i, 3))).
Wenn dies der Fall ist, dann wird der Algorithmus beendet (Exit Sub –
Anweisung). Wenn nicht wird der Wert der dritten Spalte in die erste Spalte der
nächsten Zeile übertragen, und das ganze beginnt von vorne, so lange bis entweder
der Fall eintritt, dass die Summe der 1 + der umgedrehten Zahl ein Palindrom ist,
oder die Schleife 25 mal durchfahren ist.
Die Begrenzung liegt bei 25, da es in Excel - ohne "Kunstgriffe" und großem
Aufwand an Stringprogrammierung - nicht leicht möglich, ist mit sehr großen
hohen Zahlen zu rechen. Man muss sich vorstellen, dass man wie oben beim 196-
Problem schon mit 100 millionenstelligen Zahlen rechnet(!) Und dies übersteigt
eindeutig die Kapazität für den Normalbenutzer.
Konzepte, die vermittelt werden sollen
<23>
6. Konzepte, die vermittelt werden sollen
6.1. Rekursion In der Mathematik werden Funktionen durch Gleichungen dargestellt, weil es
einfacher ist als die Beschreibung durch Algorithmen. Als Beispiel dient die
Fakultätsfunktion fact(n) = n!, deren algorithmische Darstellung 1*2*3*4...*n
lautet, aber in der Gleichungsdarstellung
I) fact(0) = 1 II) fact(n) = n*fact(n-1), u > 0.
Da fact als Unbekannte auftritt ergibt sich die eindeutige Lösung der Gleichung II),
(I) darf aber nicht fehlen, da es sonst mehrere Lösungen gibt)
In Visual Basic würde dies so aussehen: Function fact (n as Integer) As Integer If n = 0 Then fact = 1 Else Fact = n*fact(n-1) End Function
Man erkennt hier bereits, dass ein Aufruf von fact verwendet wird, deshalb nennt
man solche Definitionen auch rekursiv! Rekursive Definitionen sind in den
Programmiersprachen sehr häufig:
Beispiel: fact(4)
Der Compiler erledigt solche Berechnungen aufgrund des Textes aus der rekursiven
Definition selbsständig. Man muss nur darauf achten, dass die rekursiven Aufrufe
immer einfacher werden und schließlich mit einem nichtrekursiven Fall enden.
Aber auch rekursive Prozeduren sind mit Hilfe von Visual Basic leicht ausführbar.
Definition: Eine rekursive Prozedur P liegt dann vor, wenn in ihrer Definition ein
Aufruf von P vorkommt. Auch die Palindrom-Funktion kann rekursiv
programmiert werden. Hier eine Lösung in VBA:
Function palindrom(ByVal wort As String) As String
If Len(wort) = 0 Then
palindrom = ""
Else
Palindrom = palindrom(Right(wort, Len(wort) – 1)) & Left(wort,1)
End If
End Function
Konzepte, die vermittelt werden sollen
<24>
Hier sieht man, dass die palindrom-Funktion erst aufgerufen wird, wenn
Len(wort) nicht O ist.
6.2. Strukturen und Modultechnik
Das Prinzip der Modultechnik liegt darin, dass man ein Programm in mehrere
Teilprogramme (Unterprogramme) strukturiert, um bestimmte Elemente in
anderen Programmen wieder verwenden zu können. So kann man zum Beispiel
einen Algorithmus für ein bestimmtes Problem in anderen Anwendungen
wiederverwenden. Dadurch erspart man sich eine Menge Zeit, da man nicht
jedesmal einen Algorithmus neu schreiben muss, um ein Problem zu lösen. Daher
wird ein Programm strukturiert, damit man immer ein Modul einfügen kann, und
immer wenn man das Modul benötigt, darauf verweisen kann (wenn man dies
nicht könnte, müsste man jedesmal anstelle des Verweises den Algorithmus wieder
anschreiben).
Speziell In Visual Basic kann man viele Module wieder verwenden:
Es ist möglich, in Word, PowerPoint, Excel und Access Makros einzubauen, was
soviel bedeutet, dass man in Visual Basic programmierte Dinge in den Microsoft
Office Anwendungen ausführen kann.
Die „umdrehen“-Funktion sieht in Excel zum Beispiel so aus:
Konzepte, die vermittelt werden sollen
<25>
Hier sieht man die „verkehrt“-Funktion und die „palindrom“-Funktion in Modul1
(roter Kreis) im VB-Editor in Excel eingebaut.
Im roten Kreis:
Der Verweis auf die „verkehrt“-Funktion, die als Modul in Excel eingebaut wurde.
in der Spalte C ist auch schön zu erkennen, dass die Palindrom Funktion als
Ausgabewert den Datentyp Boolean verwendet (WAHR, FALSCH). Abgerufen wird
die Funktion in Excel einfach mit =NamederFunktion(Ausdruck).
6.3. Sprachform und Syntax
An den oberen Quelltexten kann mann sehr leicht erkennen, dass Visual Basic auf
den ersten Blick eine viel einfachere Syntax hat, als die anderen Sprachen, die auf
die C-Syntax aufbauen. Dies heißt allerdings nicht, dass VB leichter ist. Zwar mag
es oft störend sein, wenn man aufpassen muss, dass man keine der vielen
Klammern vergisst, aber man hat in den Sprachen der C-Syntax viel mehr
Möglichkeiten, da diese Sprachen meist mehr vorgefertigte Funktionen hat.
Nebenbei sind größere Projekte in Sprachen mit C-Syntax auch viel übersichtlicher
als in Visual Basic, da man bei längeren Schleifen besser erkennen kann, wo eine
Prozedur anfängt und wo sie aufhört. In PHP zum Beispiel muss bei der Eröffnung
einer Prozedur immer eine geschwungene Klammer stehen. Auch wenn die
Prozedur geschlossen wird.
Konzepte, die vermittelt werden sollen
<26>
6.4. Programmoberflächen
Eigentlich gibt es zwei Programmoberflächen für PHP, JavaScript, JAVA und
Visual Basic. Während sich Visual Basic der benutzerfreundlichen eigenen
Bedienungsoberfläche bedient, sind die anderen Programmiersprachen in dieser
Hinsicht nicht so praktisch. PHP, JavaScript und JAVA können oder müssen im
einfachen Texteditor geschrieben werden. In
Visual Basic ist es so, dass man zur Erstellung
eines Eingabefeldes „einfach auf den Knopf
drückt“ und schon ist alles fertig da (Name,
Beschriftung,...). In den anderen Sprachen
dagegen muss man jedes Eingabefeld
niederschreiben, damit es später auf dem
Bildschirm erscheint. Will man zum Beispiel
einen Button mit dem Namen „knopf“, mit der
Beschriftung „drücken sie hier“ und der Größe
100 erzeugen, so sieht das etwa so aus: <input type=submit name="knopf" value="drücken sie
hier" size=100> In Visual Basic sieht das
dagegen so aus (bild rechts):
6.5. Compiler
Ein Compiler ist ein Programm, dass aus einem Quelltext ein lauffähiges
Programm macht. Da jede Programmiersprache verschieden ist, braucht auch jede
einen eigenen Compiler. Wenn eine Programmiersprache keinen Compiler hätte,
so könnte man einen Quelltext aus dieser Sprache nicht verwenden, er wäre
unbrauchbar. Die Voraussetzungen, dass ein Compiler aus einem Quelltext ein
lauffähiges Programm macht, sind erstens, dass der Quelltext von der Syntax her
fehlerfrei ist und zweitens, dass der Quelltext bereits fertig ist. Er übersetzt quasi
Konzepte, die vermittelt werden sollen
<27>
den Quelltext für das System, um diesen auf die Oberfläche zu projezieren. Daher
geht ein Compiler in mehreren Schritten vor:
1. Analysephase
lexikalische Analyse:
In der lexikalischen Analyse wird festgestellt, ob Bezeichner, Zahlen,
Schlüsselworte, usw. richtig geschrieben sind.
syntaktische Analyse:
Hier wird die syntaktische Struktur der gerade untersuchten Eingabe ermittelt.
2. Synthesephase
Zwischencode-Erzeugung:
Hier wird der Code vorerst übersetzt, um dann später
Zwischencode-Optimierung:
In diesem Teil wird der Zwischencode optimiert, um ihn effizienter und
schneller zu machen.
Maschinencode-Erzeugung:
In dieser Phase des Übersetzungsvorganges der Code-Generierung, wird aus
dem optimierten Zwischencode der endgültige Code erzeugt, mit dem der
Computer arbeitet.
6.6. Klassen und Objekte, Objektorientierung
Objektorientierte Programmierung bedeutet, dass eine Programmiersprache mit
Objekten arbeitet. Ein Objekt ist eine Kombination von Code und Daten, die als
eine Einheit aufgefaßt werden kann. Ein Objekt kann ein Teil einer Anwendung
sein, z.B. ein Steuerelement oder ein Formular. Eine ganze Anwendung kann
ebenfalls ein Objekt darstellen. Diese Objekte sind eigentlich dazu da, um die
Programmierung zu erleichtern. Beispiele für Objekte wären zum Beispiel Buttons,
Textfelder, List-Boxen, eigentlich die gesamte Bedieneroberfläche. In JavaScript,
PHP und Java hat man Klassen an Stelle von Objekten. Oft werden Klassen und
Objekte verwechselt, allerdings gibt es einen großen Unterschied: Eine Klasse ist
Konzepte, die vermittelt werden sollen
<28>
sozusagen eine Vorlage für ein Objekt, das heißt, bei einer Klasse muss ein Objekt
erst definiert werden. Objektorientierng ist daher dazu da, um dem Benutzer das
Arbeiten mit dem Computer zu erleichtern und schneller zu machen. Einer der
wichtigsten Begründer der objektorientierten Programmierung ist Dr. Alan Key.
Seine Definition zur Objektorientierung lautet: „Bei der objektorientierten
Programmierung beschreiben Programme, wie Nachrichten zwischen Objekten
ausgetauscht werden. Ein Objekt ist ein Baustein, der Zustände und Prozesse
enthält, die er schützt und versteckt und auf den von außen, nur durch Austausch
von Nachrichten zugegriffen werden kann. Dabei entscheidet ein Objekt selber, wie
es auf eine bestimmte Nachricht reagiert. Welches Objekt eine bestimmte
Nachricht erhält, kann erst äußerst spät, während des Programmablaufs festgelegt
werden.“
6.7. Client-Server Beziehungen
Bei dem Palindromsammlerprogramm spielen die Client-Server Prinzipien auch
eine sehr große Rolle. An diesem Programm kann man nämlich schön erkennen,
was es mit diesen Prinzipien auf sich hat:
1. Client/Server bezeichnet vor allem eine Beziehung zwischen Prozessen, die auf
verschiedenen Rechnern laufen.
2. Der Rechner, der einen Dienst anbietet, ist der Serverprozess (z.B.: die
Palindromeingabeseite)
3. Der Client ist der Rechner, der diese, vom Server zur Verfügung gestellten
Dienste in Anspruch nimmt.
Weiters wäre zu beachten, dass Client-Server Verarbeitung eine saubere
Trennung von Funktionen ist. Am Beispiel des Palindromammel-Programmes
kann man diese Funktionen so trennen:
- der Server stellt das Eingabeformular zur Verfügung und überprüft die
vom Client eingegebenen Daten.
- Der Client ruft hingegen dieses Eingabeformular ab und sendet eine
Abfrage an den Server.
Weiters wäre zu erwähnen, dass der Server gleichzeitig mehrere Clients bedienen
kann und er den Zugriff der Clients auf gemeinsam benutzte Ressourcen regelt.
Konzepte, die vermittelt werden sollen
<29>
Zwischen Server und Client besteht eine 1:n Beziehung, was so viel heißt wie, dass
auf einem Server mehrere passende Clients zugeordnet sein können. Der Server
wartet immer passiv auf die Anfragen des Clients, d.h.: er tut nichts bis ein Client
etwas will. Ideale Bedingungen für eine einwandfreie Client-Server beziehung wäre
eine Plattformunabhängikkeit, was bedeutet, dass es optimal wäre, wenn Server
und Client unabhängig von deren Konfiguration sind, z.B.: Unabhängigkeit der
vom Client und vom Server benutzten Betriebssysteme.
Quellenverzeichnis
<30>
7. Quellenverzeichnis
Visual Basic 6.0, 8. Aufl.
1998, Addison Wesley, Michael Kofler
Jetzt lerne ich VBA mit Excel
2001, Markt und Technik, Said Baloui
Einführung in die Informatik
2002, Oldenburg, H.-P. Gumm / M. Sommer
Selfhtml 8.0 von Stefan Münz
http://www.teamone.de/selfhtml
SelfPHP von Damir Enseleit, Co-Autor: Matthias Hupp
http://www.selfphp.de
Zahlenpalindrome
http://www.haw-hamburg.de/rzbt/dankert/Palindrom/Zahlen-
Palindrome/zahlen-palindrome.html
Struktogramm-Editor Homepage
http://www.structed.de
Ich bestätige hiermit, dass ich diese Fachbereichsarbeit selbstständig verfasst und
außer den genannten Quellen keine weiteren verwendet habe.