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.