Palindrom eines int-Arrays berechnen

[Rauschkugel]

Hi, ich möchte von einem int-Array dessen Palindrom ausgeben lassen und hab dazu folgendes programmiert. Kann mir jmd helfen, wieso ich [7,7,7,7,7] ausgegeben bekomme? Wo liegt der Fehler in meinem Programm?

public class Test {
	
	//Methode zur Berechnung des Palindroms
	public static int[] palindrom(int[] a){
		int[] hilfsarray = new int[a.length];
		for (int i=0; i<a.length; i++){
			for (int j=a.length-1; j>=0; j--){
			hilfsarray[i] = a[j];
			}
		}
		return hilfsarray;
}
	
	//Methode für die Ausgabe des Arrays
	public static void printArray(int[] a) {
        if (a.length == 0) {
            return;
        }
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]);
            if (i != a.length - 1) {
                System.out.print(",");
            }
        }
        System.out.println("]");
    }

	
	//main-Methode
	public static void main(String[] args) {
		System.out.print("palindrom(7,4,8,42,13) = ");
		printArray(palindrom(new int[]{7, 4, 8, 42, 13})); 
    }
}

 

[minzee]

Das liegt an deiner Schleife in der Schleife. Mit j bewegst du dich immer zum ersten Element, der 7. Die schreibst du in das Element i. Und das i läuft von links nach rechts durch. Darum bekommst du das erste Element genau so oft, wie lange das Array ist.

Was willst du hier eigentlich berechnen? Ist eine UNI-Aufgabe, richtig? Könnten wir die Aufgabe lesen?

 

[minzee]

class Main
{
   static private int[] createPalindrom(int[] a)
   {
      int aLength = a.length;
      if(aLength < 2)
      {
         return a;
      }
      int bLength = 2 * aLength - 1;
      int[] b = new int[bLength];
      for(int i = 0; i < aLength; ++i)
      {
         b[bLength - i - 1] = b[i] = a[i];
      }
      return b;
   }
   public static void main(String[] args)
   {
      int[] a = {7, 4, 8, 42, 13};
      int[] b = createPalindrom(a); 
      for(int i = 0; i < b.length; ++i)
      {
         System.out.println(b[i]); // 7 4 8 42 13 42 8 4 7
      }
   }
}

Suchst du das hier?

 

[njans]

Kleiner Tipp: Du brauchst nur eine Schleife.
Um die Reihenfolge deines Arrays umzudrehen, musst du nur den index neu berechnen.
Dazu machst du folgendes:
index_0 ---> index_length-1
index_1 ---> index_length-2
index_2 ---> index_length-3
usw.

Das geht einfach zu lösen und ist eine Zeile.

@minzee
Nicht immer Lösungen herausgeben!
Und ich glaube er will nur die Reihenfolge seines Arrays umdrehen

 

[minzee]

Nicht immer Lösungen herausgeben!

Ich weiß doch eigentlich gar nicht, worum es hier geht. Ist doch nur geraten 😉

 

[Rauschkugel]

Also die Aufgabe lautet: Berechnen Sie für ein int-Array dessen Palindrom, das heißt das Array in umgekehrter Reihenfolge.
palindrom([7, 4, 8, 42,13]) = [13, 42, 8, 4, 7]

 

[Rauschkugel]

Okay, ihr habt mir schon ein bisschen weitergeholfen 🙂 Nur ganz funktioniert es noch nicht 🙁
Also ich hab jetzt nur noch eine for-Schleife gemacht und versucht den Index da neu zu bestimmen:

for (int i=0; i<a.length; i++){
a=a[a.length-i-1];

--> leider kommt dann das raus: [13,42,8,42,13]
Ich denk mal, weil nach jedem Schleifendurchgang das Array schon so abgespeichert wird und wenn man dann bei den letzten Durchgängen den Wert am Anfang des Arrays haben möchte, dann kommt nicht der alte Wert, sondern einer der schon bereits ausgewechselt wurde, deswegen die Spiegelung oder?
Wie kann ich das verhindern?

 

[Rauschkugel]

Hab`s 😉 Mit meinem Hilfsarray hats jetzt geklappt^^
Trotzdem vielen Dank! =)

 

[fLooojava]

offtopic:
Da besucht wohl jemand die EiP-Vorlesung in München! 😉

 

[minzee]

Dann sollte irgendwer dem Herrn Kröger mitteilen, dass das nur ein einfacher reverse ist. Das hat nichts mit einem Palindrom zu tun 🙂

http://www.dbs.ifi.lmu.de/Lehre/EIP/WS1415/uebungen/u09/u09.pdf

 

[minzee]

Wie würdet ihr 9.1 a) programmieren?

class Main
{
   private static long sum(int[] a) throws Exception
   {
      long s = 0; 
      for(int i = 0; i < a.length; ++i)
      {
         if(a[i] > Long.MAX_VALUE - a[i])
         {
            throw new Exception("overflow");
         }
         s += a[i];
      }
      return s;
   }
   public static void main(String[] args)
   {
      try
      {
         int[] a = {7, 4, 8, 42, 13};
         long s = sum(a);
         System.out.println(s);
      }
      catch(Exception e)
      {
         System.out.println("error");
      }
   }
}

So?

 

[minzee]

Und b)?

class Main
{
   private static int min(int[] a) throws Exception
   {
      if(a.length == 0)
      {
         throw new Exception("length");
      }
      int min = a[0];
      for(int i = 1; i < a.length; ++i)
      {
         if(a[i] < min)
         {
            min = a[i];
         }
      }
      return min;
   }
   public static void main(String[] args)
   {
      try
      {
         int[] a = {7, 4, 8, 42, 13};
         int m = min(a);
         System.out.println(m);
      }
      catch(Exception e)
      {
         System.out.println("error");
      }
   }
}

 

[fLooojava]

abgesehen mal von den Aufgaben - weshalb arbeitest du bereits mit Exceptions?

Sollte aber passen, habs auch so 😉.

 

[njans]

if(a[i] > Long.MAX_VALUE - a[i])

Also die Abfrage würde ich mir an deiner Stelle nochmal überlegen 😉
Long ist 64 bit, int nur 32. Wenn die Bedingung jemals wahr wird dann prost Mahlzeit.

 

[Flown]

Also Überlauf kann man mit Java 8 einfach überprüfen:

Math.addExact(int x, int y);