# Palindrome überprüfen



## JoeB (11. Mrz 2011)

Hallo,

ich habe ein Problem...muss überprüfen, ob ein Wort ein Palindrom ist. Weiß allerdings gar nicht, wie ich anfangen soll. Soll Worte buchstabenweise von Anfang und Ende vergleichen. Erst ohne Groß und Keinschreibung und dann mit. Anschließend soll ich das Wort umdrehen und mit dem ursprünglichen Wort vergleichen.
Ich denke, der buchtsabenweise Vergleich wird mit startsWith() und endsWith() durchgeführt, oder? Und das vergleichen mit equals()?
Kann mir da vielleicht jemand helfen? 

Vielen Dank schon mal!


----------



## bone2 (11. Mrz 2011)

ich würde einfach mit einer schleife den ersten und letzten buchstaben vergleichen, dann den zweiten und vorletzten usw
aufpassen wegen gerade/ungerade buchstaben zahl

charAt() gibt nen einzelnen char zurück
mit toLowerCase() kann man ganzen string in kleinbuchstaben umwandeln


----------



## SlaterB (11. Mrz 2011)

wenn du fertige Lösungen suchst, kannst du Palindrom in die Foren-Suche eintippen, das kommt öfters dran,
manchmal mit besseren Antworten als diese hier (  )

bei 'buchstabenweise' würde ich eher an charAt() denken und chars vergleicht man mit ==, nicht mit equals,
startsWith() usw. ist natürlich auch interessant wenn du Zeichen neu zusammenbaust,

aber du musst schon einiges coden, ausprobieren, bevor man das bewerten kann


----------



## JoeB (11. Mrz 2011)

Ok..Danke. Und das ganze schreib ich in eine Methode, dass überprüft, ob er erste und letzte Buchstabe gleich ist? Wie bring ich die Methode dann in "main" rein, sodass ich in main dann ein Wort eingeben kann?


----------



## SlaterB (11. Mrz 2011)

auf korrekte Weise, das hat doch nichts mit Palindrom zu tun, 

hast du je eine Methode aus einer main aufgerufen? mit Parameter?
wenn nein dann wirklich erstmal Beispiele von anderen anschauen, gar ein Lehrbuch


----------



## dehlen (11. Mrz 2011)

ich würde es so machen:

```
public static void main(String[] args)  throws IOException {
String palindrom;

BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

System.out.println("Wort eingeben: ");
palindrom = input.readLine();
palindrom= palindrom.toLowerCase();

if(palindrom.equals(new StringBuilder(palindrom).reverse().toString())) {
System.out.println("Palindrom gefunden! : "+palindrom);
}
else
System.out.println("Kein Palindrom gefunden!");



  
}
```

Sprich das Herzstück diesen Programmes ist diese Zeile hier:

```
if(palindrom.equals(new StringBuilder(palindrom).reverse().toString())) {
```
Die Methode reverse ist genau das was du suchst weil sie unschwer zu erkennen das wort spiegelt

EDIT: Sry nur die Frage überflogen hatte nicht gesehen das du es Buchstabenweise machen sollst


----------



## kirax (11. Mrz 2011)

Ich möchte ja nicht querverweisen auf die Diskussion zum Thema Rekursion, aber dieses Problem lässt sich doch wunderbar mit einer Rekursion lösen:


```
private boolean palindrom(StringBuilder wort) {
  if (wort.charAt(0) == wort.charAt(wort.length-1) {
    return wort.length() > 1 ? palindrom(wort.deleteCharAt(wort.length-1).deleteCharAt(0)) : true;
  }
  return false;
}
```

Nicht getestet aber müsste so ungefähr klappen.


----------



## Andi_CH (14. Mrz 2011)

Ich lass mich ungerne immer wieder über die Lesbarkeit von x?y:z Konstrukten aus, aber es sieht einfach potthässlich aus :-( .. und ausserdem versagt die Routine bei Strings mit gerader Anzahl Buchstaben (z.B. ABBA) -> String index out of range: 0

Hier die korrigierte und lesbarere Variante:

```
private static boolean checkPalindrom(StringBuilder wort) {
		if (wort.length()>=2) {
			if (wort.charAt(0) == wort.charAt(wort.length()-1)) {
				return checkPalindrom(wort.deleteCharAt(wort.length()-1).deleteCharAt(0));
			} else {
				return false;
			}
		}
		return true;
	}
```

Eine andere Variante:

```
private static boolean checkPalindrom(String pWort){
		int j = pWort.length();
		for (int i=0; i<j; i++) {
			--j;
			if (pWort.charAt(i) != pWort.charAt(j)) {
				return false;
			}
		}
		return true;
	}
```


----------



## kirax (14. Mrz 2011)

Sieht vielleicht potthässlich aus, aber ich persönlich finde es deswegen nicht weniger lesbar - im Gegenteil, x?y:z find ich wirklich lesbarer. Aber das wird Geschmackssache sein.

Stimmt mit dem Fehler. Aber das liegt weniger an der Tatsache von gerader Anzahl Buchstaben, sondern dass einfach nicht geprüft wird, ob [c]length()-1[/c] überhaupt noch ein gültiger Index ist. Asche auf mein Haupt 

Oh - nochmehr Asche... [c]length()[/c] nicht [c]length[/c] ^^


----------



## Andi_CH (15. Mrz 2011)

So outen sich C Programmierer  - zum Glück haben die Java Entwickler wenigstens auf Pointerarithmetik verzichtet.


----------



## kirax (15. Mrz 2011)

ssst... 
Pointerarithmetik :bloed: selten was dämlicheres gesehen...
Bei sowas muss ich immer an die (doch ironische) Entstehungsgeschichte von C denken.

Operatoren überladen wäre aber IMHO ne Bereicherung für Java geworden


----------



## Andi_CH (16. Mrz 2011)

Sorry für OT ist mein letzte OT Posting hier 



kirax hat gesagt.:


> ssst...
> Pointerarithmetik :bloed: selten was dämlicheres gesehen...
> Bei sowas muss ich immer an die (doch ironische) Entstehungsgeschichte von C denken.
> 
> Operatoren überladen wäre aber IMHO ne Bereicherung für Java geworden



Das nennt man Eigentor  x?y:z - selten etwas dämlicheres gesehen :bloed: 
Meinst du das Programm wird schneller wenn man es so schreibt?

Ich habe erfahren, dass es besser ist "sprechend" als kompakt zu programmieren.
Wer sagt schon 
	
	
	
	





```
Hunger Fragezeichen essen Doppelpunkt Kino
```


```
Wenn Hunger dann essen sonst Kino
```
 ist doch besser verständlich, auch wenn es imer noch nicht der Umgangssprache entspricht.

Pointerarithmetik macht dann Sinn, wenn man das Letzte an Optimierungspotential ausnutzen will, aber sie ist extrem gefährlich (Ohne Pointerarithmektik hätte der Nokia Communicator das Sprechen nie gekonnt - ein Text to speech system auf einem so schlappen Prozessor geht nicht ohne - ja, da hab ich mitprogrammiert  )

x?y:z macht genau dann Sinn, wenn man in C++ Konstruktoren Konstanten nicht konstante Werte zuweisen will. (Java läst ja netterweise in dem Zusammenhang if - else zu)

operatoroverloading - oh ja gerne! Aber ich kann die Gründe verstehen warum es das in Java nicht gibt.


----------



## kirax (16. Mrz 2011)

Wird nicht schneller... aber ich les das so (in gewisser Weise auch "sprechend" ):
[c]Hunger ? [<- Frage] (dann) ess was : [<- sonst] geh ins Kino[/c] 
Wie gesagt Geschmackssache.
Was der in C++ noch für weitere Funktionen hat weiß ich nicht. So tief war ich da dann nicht drin 
Und Pointerarithmetik macht eben deswegen so wenig Spaß, weils so gefährlich IST  Man kann zwar schöne Dinge mit tun, aber man muss schon extrem aufpassen.


----------

