# Palindrom im array



## canyakan95 (28. Jan 2015)

```
public static boolean checkArray2( int[]arr)
    {
        for(int i=0;i<arr.length;i++)
        {
            for(int j=arr.length-1;j>=0;j--)
            {
                if(arr[i]!=arr[j])
                {
                    return false;
                }
            }
        }
        return true;
    }
```

Hallo
meine aufgabe war es zu überprüfen ob die im Array abgelegten werte ein palindrom bilden.
ich habe es versucht mit einer doppelten schleife zu versuchen.
ich wollte einmal den Array von vorne und einmal von hinten durchlaufen und ich bekomme für die werte {12,34,78,34,12} immer false raus , obwohl das ein palindrom ist.
wisst ihr vllt wo mein Fehler liegen könnte.

mfg


----------



## flopalko (28. Jan 2015)

Dein Fehler liegt darin, dass du in der inneren Schleife alle Indizes durchgehst und dann erst der nächste Durchlauf der äußeren Schleife passiert. Daher kommt natürlich false raus.
Lösung: pack alles in eine Schleife (am besten while(i<arr.length/2)) und arbeite mit zwei Variablen die du am Ende der Schleife immer inkrementierst/dekrementierst 

Aja und noch ein Tipp: du wärst leicht selbst draufgekommen wenn du zb vor dem if die Werte printen lässt 

EDIT:
hier noch ein Code den ich schnell geschrieben hab 

```
public static boolean palindrom_int(int[] pal){
        int i = 0, j = pal.length-1;
        while(i<pal.length/2){
        	if(pal[i] != pal[j])
        		return false;
        	i++;
        	j--;
        }
        return true;
    }
```


----------



## Flown (29. Jan 2015)

@flopalko: Bitte keine fertigen Lösungen posten. Des Weiteren kann man sich die Berechnung der Hälfte des Arrays sparen:


```
public static boolean isPalindrom(int[] arr) {
  for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
    if (arr[i] != arr[j]) {
      return false;
    }
  }
  return true;
}
```

Eine weiter Variante ist es nur einen Index zu halten und den Anderen zu berechnen:


```
public static boolean isPalindrom(int[] arr) {
  for (int i = 0; i < arr.length >> 1; i++) {
    if (arr[i] != arr[arr.length - 1 - i]) {
      return false;
    }
  }
  return true;
}
```


----------



## flopalko (29. Jan 2015)

Flown hat gesagt.:


> @flopalko: [...] Des Weiteren kann man sich die Berechnung der Hälfte des Arrays sparen:
> 
> 
> ```
> ...



Ja das mach ich mit meinem Code auch...wir beide haben exakt gleich viele Schleifendurchläufe, und zwar immer n/2. Wenn du Code kritisierst lies ihn vorher auch


----------



## Flown (29. Jan 2015)

Bitte les dir auch meine Aussage durch: du kannst dir die Berechnung:


```
while(i<pal.length/2 /* Die hier sparen*/){
```

Da du nur zu prüfen brauchst:


```
while(i<j){
```


----------



## flopalko (29. Jan 2015)

Aso sorry falsch verstanden, ich dachte, du meinst ich könnte die Berechnung ob es übereinstimmt nach der Hälfte abbrechen...und das tu ich ja auch^^
Du hast natürlich recht, perfomancemäßig ist es vernünftiger i<j zu prüfen, ich habe aber bewusst i<pal.length/2 gewählt, um dem TE genau das zu zeigen und ich bei Anfängern nie sicher bin, ob sie es so dann verstehen.

LG


----------

