Ingo A. Winter - Palindrome c 2 - gym1.at fileBegriffserklärung Java Java ist eine objektorientierte Programmiersprache, die in Anlehnung an die Programmiersprache C++ entwickelt
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
5.1. Das 196er Problem ................................................................................................ 20 5.2. Lösung in Excel ..................................................................................................... 21
6. Konzepte, die vermittelt werden sollen ........................................... 23
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
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