Array mid three

[Masumania]

Hallo , ich habe gerade folgende Aufgabe zu lösen und hänge irgendwie zu so später Stunde.

Aufga
Schreiben Sie eine Klasse "MidThree" mit einer Methode "midThree", die als Parameter ein int-Array erhält. Die Methode soll für ein ungerades Array der Länge >= 3 die mittleren drei Elemente in einem Array zurückgeben. Im Fehlerfall soll ein leeres Array zurückgegeben werden.

Bisher habe ich folgenden Code geschrieben.

public static void main(String[] args) {
        int a = 4;
        int b = 1;
        int c = 5;

        int[] array = {a,b,c};

        Arrays.sort(array);
        System.out.println("das Mittlere = "+array[array.length/2]);
    }

kann mir hier jmd helfen? Vielen Dank schon einmal

 

[Robat]

Hallo Masumania,

lt. Aufgabenstellung ist der Ansatz noch nicht ganz richtig.

Hier mal die Aufgabe in "Unterprogramme" gesplittet.

1. Grundform der Klasse mit Methode erstellen
- eigene Klasse namens MidThree
- Methode mit dem Namen midThree
- Die Methode liefert ein int Array zurück.
- Die Methode erwartet ein int Array.

2. Logik der Methode
- ein leeres int Array erstellen
- Wenn die Länge des Ausgangsarrays kleiner als 3 ist soll das leere Array zurückgegeben werden (if-Abfrage)
- Wenn die Länge des Ausgangsarrays gleich 3 ist soll das übergebene Array zurückgegeben werden (if-Abfrage)
- Ansonsten sollen die mittleren 3 Elemente in dem (im Punkt 1) erstellen Array gespeichert werden
- Array zurückgeben

3. Finden der mittleren 3 Elemente
- Das mittlere Element eines Arrays, ist die Länge durch 2. (bei einer Länge von 9 wäre das 4. Im Array die Stelle 4 ist das 5. Element da man bei 0 anfängt zu zählen)
- Um die 3 mittleren Elemente zu finden, geht man einfach x+1 und x-1 (wobei x die das mittlere Element aus Punkt 1 ist)
- Um die 3 Elemente zu finden muss man also 3 Dinge machen:
> die Stelle von Punkt 2 (1 drunter) -1 rechnen und an die 0. Stelle des neuen Arrays speichern
> die halbe Länge des Array ermitteln und den Wert aus dem Array an dieser Stelle speichern (im neuen Array an Stelle 1)
> die Stelle von Punkt 2 (1 drüber) +1 rechnen und an die 2. Stelle des neuen Arrays speichern

Als Spoiler ist hier mal der Lösungsanstaz für Punkt 1 zu sehen.

Spoiler: 1. Grundform der Klasse mit Methode

public class MidThree
{
      public static void main(String[] args)
      {
               // Das Array wessen 3 Elemente gefunden werden sollen
               int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
              
              int[] mid = midThree(array);
      }

      private static int[] midThree(int[] array)
      {
            // neues leeres Array deklarieren

            // die 2 Sonderfälle abfragen
 
            // Die 3 mittleren Elemente finden

            // neues Array zurückgeben
      }
}

Gruß´
Robert

 

[Masumania]

Hallo Robert, vielen Dank schon einmal für deine Antwort. Ich habe jetzt mal folgendes geschrieben

public class NoTriples {



    public boolean noTriples (int[] inArray){



        for( int i =0; i< inArray.length; i++){



            int num = inArray [i];

                for (int c = i+1; c < inArray.length ;){

           

                if(num == inArray[c]){

                    int num2 = inArray [c];

        for (int c2 = c +1; c2 < inArray.length ; c2 ++);{

   

        if (num2== inArray [c]){ 

            return false;

                    }

                else{ break;

                    }

                    }

            }else {break;

}

}

}

return true ;

}

}

Wenn ich es aber so einreiche wird der JUnit Test nicht bestanden. Was mache ich falsch?

 

[Masumania]

Oh falscher code für diese Aufgabe . Ich hänge dort aber trotzdem.

Die Aufgabe dazu ist folgende:
Ein "Triple" ist eine Folge von 3 gleichen Zahlen hintereinander in einem Array. Schreiben Sie eine Klasse "NoTriples" mit einer Methode "noTriples", welche ein int-Array als Eingabe erhält und true ausgibt, wenn kein Triple vorkommt.

 

[Robat]

Habe mir deinen Code jetzt nicht weiter angeguckt weil allein die Formatierung nicht sehr schön ist aber 2 for-Schleifen gehen schon mal in die falsche Richtung. (bzw 2 for-Schleifen machen es komplizierter)

Der Klassenaufbau scheint ja schon mal richtig zu sein.

Die Logik dahinter ist folgende:

private boolean noTripples(int[] array)
{
      WENN länge des arrays größer oder gleich 3 
      {
          durchlaufe das arrray von der 2. Zahl bis zur vorletzten Zahl

              WENN array[i-1] gleich array[i] UND array[i] gleich array[i+1]
                  
                  return false;
      
      }
      SONST  
            return true;  
}

Zur Erklärung:
Ein Trippel ensteht immer dann, wenn eine Zahl gleich mit seinem Vorgänger und seinem Nachfolger ist.
Da die 1. Zahl (index 0) und die letzte Zahl (Index Länge-1) keinen Vorgänger bzw Nachfolger haben muss man diese nicht durchlaufen.
Daher Fängt man bei der 2. Zahl an und geht bis zur vorletzten.
Wenn dann der Vorgänger von der Zahl ( [i-1] ) und der Nachfolger ( [i+1] ) gleich der Zahl an der Stelle [i] sind hast du ein Tripple gefunden.