Median-Berechnung von 2D-Teilarrays

[jono]

Hallo !

  public static double median(int[] m) {
    int middle = m.length / 2;
    if (m.length % 2 == 1) {
      return m[middle];
    } else {
      return (m[middle - 1] + m[middle]) / 2.0;
    }
  }
}

Das wäre die Berechnung des Medians in einem eindimensionalen Array. Ich komme aber einfach nicht darauf, wie ich das für ein 2d implementieren muss.. Also ich möchte ich die einzelnen Mediane von jedem Teilarray.

 

[MoxxiManagarm]

Ist denn bei dir sichergestellt, dass m sortiert ist?

Ich komme aber einfach nicht darauf, wie ich das für ein 2d implementieren muss.. Also ich möchte ich die einzelnen Mediane von jedem Teilarray.

Ein 2D-Array ist nichts anderes als ein Array von Array. Du kannst das äußere Array also wie ein einfaches Array betrachten und es iterieren. Das Iterationsobjekt ist ein inneres Array, welches du in deine Funktion schubsen kannst.

int[][] table = new int[m][n];

for (int[] row : mn) {
  double d = median(row);
}

 

[jono]

Ist denn bei dir sichergestellt, dass m sortiert ist?

Ja, habe die Sortierung jetzt nur nicht dazugeschrieben. Aber das gehört natürlich dazu

 

[MoxxiManagarm]

Hatte meine Antwort nochmal bearbeitet, schau nochmal bitte

 

[jono]

Hatte meine Antwort nochmal bearbeitet, schau nochmal bitte

Okay.

public static double medianInception(double[][] array) {

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length - 1; j++) {
                if (array[i][j] > array[i][j + 1]) {
                    double temp = array[i][j];
                    array[i][j] = array[i][j + 1];
                    array[i][j + 1] = temp;

                }
            }
        }

        for (int m = 0; m < array.length; m++) {
            for (int n = 0; n < array.length; n++) {
                int middle = array.length / 2;
                if (array.length % 2 == 1) {
                    return array[middle];
                } else {
                    return (array[middle - 1] + array[middle]) / 2.0;
                }
            }
        }

    }

}

Es wird ein 2D-Array sortiert. Dann wird ja hier die Median-Berechnung durchgeführt. (Die ja so noch nicht richtig ist)

int[][] table = new int[m][n]; for (int[] row : mn) { double d = median(row); }

Ich kann mir noch nicht erklären, wie ich das jetzt noch richtig in den obigen Code einbringen soll.,

 

[jono]

for (int m = 0; m < array.length; m++) {
            for (int n = 0; n < array.length; n++) {
                int middle = array.length / 2;
                if (array.length % 2 == 1) {
                    array[m][n];
                    for(double[] row:mn) {
                        double[] d = medianInception(row);
                    }
                } else {
                    return (array[middle - 1] + array[middle]) / 2.0;
                }
            }
        }

Wäre so ein kleiner Ansatz von mir..

 

[MoxxiManagarm]

Ich habe folgende Anmerkungen
1. Das ist keine Sortierung, zumindest nicht vollumfänglich. 2 3 1 würde z.B. nicht richtig sortiert werden, weil 3 und 1 zwar vertauscht werden würden, jedoch nicht dann auch 1 und 2
2. Bei der ersten inneren Schleife hast du korrekt die Größe von array[i] verwendet. Bei der zweiten inneren Schleife jedoch nicht. Das führt zu NPE, falls du weniger Spalten als Reihen hättest
3. Bist du dir sicher, dass die Methode einen einzelnen double Wert zurückgeben soll? Ich meine ja, dass das eher ein double Vektor (also ein double Array) sein sollte.

 

[jono]

1. Das ist keine Sortierung, zumindest nicht vollumfänglich. 2 3 1 würde z.B. nicht richtig sortiert werden, weil 3 und 1 zwar vertauscht werden würden, jedoch nicht dann auch 1 und 2

Was muss ich da denn noch ändern? Genau diesen Algorithmus haben wir vorgelegt bekommen, der auch nachdem ich mir über den Ablauf von dem Algorithmus Gedanken gemacht habe, Sinn gemacht hat.

for(int i = 0; i < array.length-1; i++){
             for(int j = i + 1; j > 0; j--){
               if(array[i][j] < array[i-1][j]){ 
                   double temp = array[i-1][j];
                   array[i-1][j] = array[i][j];
                   array[i][j] = temp;                  
               }
             }
        }

So muss es stimmen

Bei der ersten inneren Schleife hast du korrekt die Größe von array[i] verwendet. Bei der zweiten inneren Schleife jedoch nicht. Das führt zu NPE, falls du weniger Spalten als Reihen hättest

Worauf bezieht sich das genau?

Bist du dir sicher, dass die Methode einen einzelnen double Wert zurückgeben soll? Ich meine ja, dass das eher ein double Vektor (also ein double Array) sein sollte.

Nein. Es sollen die Mediane der 2D-Teilarrays berechnet werden. Diese widerrum sollen in ein Eindimensionales kopiert werden. Und aus dem Eindimensionalen widerrum soll der Median berechent werden, weshalb der Rückgabetyp so stimmt.

 

[MoxxiManagarm]

Was muss ich da denn noch ändern? Genau diesen Algorithmus haben wir vorgelegt bekommen, der auch nachdem ich mir über den Ablauf von dem Algorithmus Gedanken gemacht habe, Sinn gemacht hat

Das kommt ganz darauf an, welches Sortierverfahren du einsetzen willst, es gibt viele.

Worauf bezieht sich das genau?

Auf die innere Schleife mit n

for (int j = 0; j < array[i].length - 1; j++) { // hier ist korrekt array[i] in der Bedingung
for (int n = 0; n < array.length; n++) { // hier fehlt das, es müsste array[m] sein

Nein. Es sollen die Mediane der 2D-Teilarrays berechnet werden. Diese widerrum sollen in ein Eindimensionales kopiert werden. Und aus dem Eindimensionalen widerrum soll der Median berechent werden, weshalb der Rückgabetyp so stimmt.

Aha! Jetzt kommen wir langsam auf einen Nenner. Du hast die Methode doch schon für einen 1D-Median. Die kannst du wiederverwenden.

public double median1D(double[] array1D) {
  // deine Logik von oben, ich würde allerdings auch die Sortierung von dem Array hier machen
}

public double median2D(double[][] array2D) {
  double[] medianPerRow = new double[array2D.length];
  for (int i = 0; i < array2D.length; i++) {
    medianPerRow[i] = median1D(array2D[i]);
  }
  return median1D(medianPerRow);
}

So muss es stimmen

Da ist aber auch einiges anders als bei dir im Code oben

 

[jono]

for(int i = 0; i < array[i].length; i++){
             for(int j = 0; j < array[j].length; j++){
               if (array[i][j] > array[i][j + 1]) {
                   double temp = array[i][j];
                   array[i][j] = array[i][j + 1];
                   array[i][j + 1] = temp;

               }                 
               }
             }

Ist das jetzt so richtig ? Tue mich damit ziemlich schwer ^^...

 

[jono]

Das kommt ganz darauf an, welches Sortierverfahren du einsetzen willst, es gibt viele.

BubbleSort soll verwendet werden.

 

[MoxxiManagarm]

Ist das jetzt so richtig ? Tue mich damit ziemlich schwer ^^...

Nein du sollst nicht das 2D-Array sortieren, sondern nur das einzelne Array jeweils.

Deine Schleifen kommen Bubblesort sehr nahe, aber wie gesagt nur ein einzelnes Array, kein 2D-Array. Hier der Code von Wikipedia

bubbleSort(Array A)
  for (n=A.size; n>1; --n){
    for (i=0; i<n-1; ++i){
      if (A[i] > A[i+1]){
        A.swap(i, i+1)
      } // Ende if
    } // Ende innere for-Schleife
  } // Ende äußere for-Schleife

 

[jono]

Nein du sollst nicht das 2D-Array sortieren, sondern nur das einzelne Array jeweils.

Ich habe kein Plan, wie ich das machen soll.

 

[MoxxiManagarm]

Schau dir nochmal Antwort #9 an. Die 2D-Methode sollte so wie sie ist schon richtig sein. Du musst nur die Benennung noch anpassen. Du baust dir die Hilfsmethode für 1D zusammen und die Hilfsmethode sortiert das übergebene Array auch mit Bubblesort. Den Code für Bubblesort hast du ja auch schon, du darfst nur nicht den Fehler machen versuchen Bubblesort auf dein 2D-Array anzuwenden.

 

[MoxxiManagarm]

Beispiel

Der Median soll berechnet werden von
1 3 2
2 5 6
9 2 8
4 4 4

Dann gehst du zuerst Reihe für Reihe (jeweils ein Vektor, z.B. 1 3 2) durch und erhältst den Vektor
2
5
8
4

Diesen Vektor kannst du wie die Reihenvektoren berechnen und erhältst 4.5

 

[jono]

Den Code für Bubblesort hast du ja auch schon, du darfst nur nicht den Fehler machen versuchen Bubblesort auf dein 2D-Array anzuwenden.

Nur wie bekomme ich das hin ?

 

[jono]

Wie schaffe ich es nur die Reihen zu sortieren..

 

[fhoffmann]

Wie schaffe ich es nur die Reihen zu sortieren..

Du hast doch bereits eine Methode, um ein eindimensionales Array zu sortieren.

Ein zweidimensionales Array ist ein Array von eindimensionalen Arrays! (Diesen Satz solltest du verstehen!)
Du kannst das zweidimensionale Array also durchiterieren und für jeden Eintrag die Sortier-Methode für ein eindimensionales Array aufrufen.

 

[jono]

boolean swapped ;
         do {
         swapped = false ;
         for (int i = 1; i < array.length ; i ++)
         if ( array[i - 1] > array [i]) { 
         double swap = array [i];
         array[ i ] = array [ i - 1];
         array[ i - 1] = swap ;
           swapped = true ;
         }
         } while (swapped) ; // nicht richtig formatiert, Tastatur reagiert irgendwie nicht auf die Tastenkombination(Strg, Shift & F)

Das wäre ja dann die Sortiermethode für ein Eindimensionales.

Ein zweidimensionales Array ist ein Array von eindimensionalen Arrays! (Diesen Satz solltest du verstehen!)
Du kannst das zweidimensionale Array also durchiterieren und für jeden Eintrag die Sortier-Methode für ein eindimensionales Array aufrufen.

Ja, den Satz verstehe ich. Um das Zweidimensionale durchzuiterieren, müsste ich doch jetzt noch eine for-Schleife hinzufügen, oder nicht?
Was fehlt noch @fhoffmann

 

[mihe7]

müsste ich doch jetzt noch eine for-Schleife hinzufügen, oder nicht?

Äh:

Du hast die Methode doch schon für einen 1D-Median. Die kannst du wiederverwenden.

Schau dir nochmal Antwort #9 an. Die 2D-Methode sollte so wie sie ist schon richtig sein.

Das Zusammenkopieren der Lösungen bekommst Du selbst hin, oder sollen das @fhoffmann bzw. @MoxxiManagarm für Dich auch noch übernehmen?

 

[jono]

Das Zusammenkopieren der Lösungen bekommst Du selbst hin, oder sollen das @fhoffmann bzw. @MoxxiManagarm für Dich auch noch übernehmen?

Nein, darum geht es mir nicht. In #9 steht aber nicht, wie ich die Teilarrays jetzt sortiere. Mein Sortierverfahren sollte in Form von bubbleSort das 2D array sortieren. Mir ist gerade aufgefallen beim richtigen Hinschauen, dass ich etwas durcheinander geworfen hatte.
Wie könnte ich das von #9 jetzt aber in einer Methode, etwa in der median2D Methode alles in einem implementieren. Da in der Aufgabenstellung nichts von der Erlaubnis von Hilfsmethoden steht, denn normalerweise steht es dabei, wenn erlaubt.

 

[MoxxiManagarm]

Mein Sortierverfahren sollte in Form von bubbleSort das 2D array sortieren.

Du kannst ein 2D-Array aber nicht sortieren, du kannst nur einen Vektor sortieren, also eine Zeile oder eine Spalte. Du wirst trotzdem das 2D-Array iterieren und jede Zeile in sich sortieren müssen. Das iterieren ist eine Schleife, Bubblesort sind 2. Wenn du also wirklich darauf bestehst dann brauchst du 3 verschachtelte Schleifen.

 

[jono]

Du kannst ein 2D-Array aber nicht sortieren, du kannst nur einen Vektor sortieren, also eine Zeile oder eine Spalte.

Okay verstehe ich.

Das iterieren ist eine Schleife, Bubblesort sind 2. Wenn du also wirklich darauf bestehst dann brauchst du 3 verschachtelte Schleifen.

for(int i = 0; i < array[i].length; i++){
             for(int j = 0; j < array[j].length; j++){
                           for(int k = 0; k < array[j].length) {
               if (array[i][j] > array[i][j + 1]) {
                   double temp = array[i][j];
                   array[i][j] = array[i][j + 1];
                   array[i][j + 1] = temp;

               }                 
               }
             }

So?

 

[MoxxiManagarm]

Jetzt hast du ein k aber verwendest es nicht.

Ich denke du muss versuchen dir Bubblesort nochmal vor Augen zu halten.

Beispiel

5 2 3 1 4

Im Ersten Durchlauf wird das 1. Element mit allen anderen verglichen und ggf. vertauscht.
5 vs 2 --> swap ( 2 5 3 1 4 )
2 vs 3
2 vs 1 --> swap ( 1 5 3 2 4 )
1 vs 4

1 5 3 2 4

Im zweiten Durchlauf dann das 2. Element mit den nachfolgenden Elementen (an erster Stelle ist jetzt schon das niedrigste)
5 vs 3 --> swap ( 1 3 5 2 4 )
3 vs 2 --> swap ( 1 2 5 3 4 )
2 vs 4

1 2 5 3 4

Im dritten Durchlauf das 3. Element mit den Nachfolgeelementen
5 vs 3 --> swap (1 2 3 5 4)
3 vs 4

1 2 3 5 4

Und gleiches Prinzip
5 vs 4 --> swap ( 1 2 3 4 5)

 

[mihe7]

Nein, darum geht es mir nicht.

Du bist lustig, im überübernächsten Satz fragst Du bereits wieder, wie Du jetzt alles in eine Methode bekommst. Ich glaube Dir sogar, dass es Dir gar nicht ums Kopieren geht und das war von mir auch nicht böse gemeint, aber wenn Du Dir jede Lösung bis zum bitteren Ende vorkauen lässt, wirst Du nie selbständig eine finden. Man hat das Gefühl, Du stocherst irgendwie in der Gegend rum, weißt aber gar nicht, was Du da eigentlich tust.

 

[jono]

Jetzt hast du ein k aber verwendest es nicht

Also: mit i und j möchte ich Spalten und Zeilen sortieren. Mit dem k, hast du gesagt, soll iteriert werden.

for(int i = 0; i < array.length; i++){ for(int j = 0; j < array[j].length; j++){ for(int k = 0; k < array[j].length) { if (array[j] > array[j + 1]) { double temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } }

for(int i = 0; i < array[i].length; i++){
for(int j = 0; j < array[j].length; j++){
for(int k = 0; k < array[i].length) {
if (array[i][j] > array[i][j + 1]) {
double temp = array[i][j];
array[i][j] = array[i][j + 1];
array[i][j + 1] = temp;
}
}
}

Ich denke so ist es auch nicht richtig. Warum muss ich denn jetzt noch iterieren; Keine Ausrede: Aber ich finde die Aufgabe vom Verständnis bzw. Prinzip nicht schwer. Ich hab einfach keine Ahnung, wie ich jetzt noch richtig iterieren soll..

 

[jono]

Du bist lustig, im überübernächsten Satz fragst Du bereits wieder, wie Du jetzt alles in eine Methode bekommst. Ich glaube Dir sogar, dass es Dir gar nicht ums Kopieren geht und das war von mir auch nicht böse gemeint, aber wenn Du Dir jede Lösung bis zum bitteren Ende vorkauen lässt, wirst Du nie selbständig eine finden. Man hat das Gefühl, Du stocherst irgendwie in der Gegend rum, weißt aber gar nicht, was Du da eigentlich tust.

Ich weiß schon, was ich tue. Ich weiß auch, dass es nicht so wirkt. Aber das ist natürlich auch mir geschuldet, keine Frage.
Jedoch kamen wir erst eben darauf, dass es dann doch widerrum 3 Schleifen benötigt.

 

[MoxxiManagarm]

Also: mit i und j möchte ich Spalten und Zeilen sortieren. Mit dem k, hast du gesagt, soll iteriert werden.

Dann muss k aber an die äußerste Stelle

 

[mihe7]

Ich weiß schon, was ich tue. Ich weiß auch, dass es nicht so wirkt.

Du hast also die Gabe, es gut verstecken zu können Dann will ich nichts gesagt haben. Lasst Euch nicht stören.

 

[fhoffmann]

Warum machst du es dir denn so schwer???
Wenn du bereits eine Methode hast:

public static void sortiere(int[] arr) {
    //
}

kannst du doch einfach eine neue Methode schreiben:

public static void sortiereZeilen(int[][] arr2) {
    for (int zeile = 0; zeile < arr2.length; ++zeile) {
        sortiere(arr2[zeile]);
    }
}

Und genauso kannst du für jede Zeile den Median berechnen.

 

[MoxxiManagarm]

Da in der Aufgabenstellung nichts von der Erlaubnis von Hilfsmethoden steht, denn normalerweise steht es dabei, wenn erlaubt.

Ich möchte nochmal darauf plädieren, dass du dir Hilfsmethoden anlegst.
a) Der Prof wird das nicht ein Leben lang drunterschreiben. Irgendwann muss es selbstverständlich sein. Und für diese Aufgabe wäre es echt schrecklich, wenn sie nicht erlaubt sein würden.
b) Und selbst wenn du es nicht darfst, machs doch trotzdem erst. Es erleichtert die Struktur und damit deine Gedanken. Den Code kannst du doch anschließend auch aus den Hilfsmethoden an die entsprechenden Stellen kopieren

 

[mihe7]

a) Der Prof wird das nicht ein Leben lang drunterschreiben. Irgendwann muss es selbstverständlich sein. Und für diese Aufgabe wäre es echt schrecklich, wenn sie nicht erlaubt sein würden.

Ich würde sagen, dass es wegen fehlender Strukturierung auch Abzug geben kann.

 

[jono]

Als Ergebnis erhalte ich 5.0., was ja eigentlich korrekt ist. Die Aufgabenstellung für die Nachvollziehbarkeit:

Zunächst sollen die Mediane der Teilarrays berechnet werden. Beachten Sie, dass diese unsortiert sein können! Wie man den Median bestimmt können Sie beispielsweise auf Wikipedia nachlesen: https://de.wikipedia.org/wiki/Median. Zum Sortieren der einzelnen Arrays verwenden Sie BubbleSort, InsertionSort oder SelectionSort. Deren Mediane werden dann jeweils in ein neues (eindimensionales) Array eingetragen, von diesem wiederum erneut der Median berechnet und anschließend zurückgegeben wird. Falls eines der Arrays null oder leer ist, dann soll Double.NaN zurückgegeben werden.
Hinweis: Bei der Abfrage ob ein Array null oder leer ist, muss null immer zuerst abgefragt werden, sonst tritt eine NullPointerException auf!
Wie aber kommt es jetzt zu den Fehlermeldungen:

1) testSonderfallLeer(PublicTests)
java.lang.ArrayIndexOutOfBoundsException: Index -1 out of bounds for length 0
    at Functionality.bubbleSort(Functionality.java:33)
    at Functionality.medianInception(Functionality.java:40)
    at PublicTests.testSonderfallLeer(PublicTests.java:29)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)
2) testSonderfallNull(PublicTests)
java.lang.NullPointerException
    at Functionality.bubbleSort(Functionality.java:11)
    at Functionality.medianInception(Functionality.java:40)
    at PublicTests.testSonderfallNull(PublicTests.java:22)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)
3) testNormal(PublicTests)
java.lang.AssertionError: expected:<-3.5> but was:<NaN>
    at org.junit.Assert.fail(Assert.java:88)
    at org.junit.Assert.failNotEquals(Assert.java:834)
    at org.junit.Assert.assertEquals(Assert.java:553)
    at org.junit.Assert.assertEquals(Assert.java:683)
    at PublicTests.testNormal(PublicTests.java:17)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)

?

public class calculateMedian {

    public static void main(String[] args) {
        double[][] arr = { { 2, 5, 3, 8, 6 }, { 2, 5, 3, 8, 6 } };
        System.out.println(medianInception(arr));
    }

    public static double bubbleSort(double[] arr) {
        for(int i = 0; i < arr.length; i++) {
            if(arr == null || arr[i] == 0) {
            return Double.NaN;
            }
        }
        
        boolean swapped;
        do {
            swapped = false;
            for (int i = 1; i < arr.length; i++)
                if (arr[i - 1] > arr[i]) {
                    double swap = arr[i];
                    arr[i] = arr[i - 1];
                    arr[i - 1] = swap;
                    swapped = true;
                }
        } while (swapped);

        int middle = arr.length / 2;
        if (arr.length % 2 == 1) {
            return arr[middle];
        } else {
            return (arr[middle - 1] + arr[middle]) / 2.0;
        }
    }

    public static double medianInception(double[][] array) {
        double[] a = new double[array.length];
        for (int i = 0; i < array.length; ++i) {
            a[i] = bubbleSort(array[i]);
        }
        int median = a.length / 2;
        if (a.length % 2 == 1) {
            return a[median];
        }
        return (a[median - 1] + a[median]) / 2;

    }
}

 

[mihe7]

Wie aber kommt es jetzt zu den Fehlermeldungen:

Lies doch mal die Aufgabenstellung, inbesondere den Hinweis. Der steht da nicht zum Spaß.

 

[jono]

Lies doch mal die Aufgabenstellung, inbesondere den Hinweis. Der steht da nicht zum Spaß.

Ich habe doch null zuerst abgefragt..

 

[fhoffmann]

public static double bubbleSort(double[] arr)

Schon die Methodendeklaration sieht komisch aus.
Warum sollte eine Methode bubbleSort einen double zurückgeben.
Und was hat die Berechnung eines Medians in einer solchen Merhode zu tun.

Bitte benenne deine Methoden vernünftig. Und benutze bereits fertige Methoden!

 

[mihe7]

Ich habe doch null zuerst abgefragt..

So, und was kann das nun zu bedeuten haben? Tipp: schau Dir den Stacktrace an.

 

[MoxxiManagarm]

Falls eines der Arrays null oder leer ist

Falls ein Array null oder leer ist, nicht falls ein Array Element null oder leer ist. Ein double Array Element kann auch nicht null oder leer sein, das ist ein primitiver Datentyp und kein Objekt.

 

[jono]

if (arr == null || arr.length == 0) {
            return Double.NaN;
        }

Ich habe die Anweisung dann jetzt so formuliert.
Warum erscheint diese Meldung noch..?

1) testSonderfallNull(PublicTests)
java.lang.AssertionError: expected:<NaN> but was:<5.5>
    at org.junit.Assert.fail(Assert.java:88)
    at org.junit.Assert.failNotEquals(Assert.java:834)
    at org.junit.Assert.assertEquals(Assert.java:553)
    at org.junit.Assert.assertEquals(Assert.java:683)
    at PublicTests.testSonderfallNull(PublicTests.java:23)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)

 

[MoxxiManagarm]

Wie sieht den PublicTests aus? Wenn du die Abfrage immernoch in der bubblesort Methode machst wird dir das nichts bringen

 

[jono]

Stimmt ja ich denke Mal auch dass die Meldung nur etwas damit zu tun hat

 

[MoxxiManagarm]

Übrigens, ich habe gerade festgestellt, dass du in diese Bedingung nie reinlaufen wirst, warum weiß ich nicht genau, aber das könnte auch bei dir passieren oder passiert sein.

double d = Double.NaN;
if (d == Double.NaN) {
  // wird nicht erreicht
}

Du musst für d en Vergleich die Double::isNaN Methode aufrufen.

 

[jono]

Du musst für d en Vergleich die Double::isNaN Methode aufrufen.

Das habe ich jetzt nicht verstanden. Den Code, den du da notiert hast, verstehe ich jetzt bezogen auf mein Programm nicht wirklich.
Die isNaN Methode hast du da ja auch nicht verwendet...

 

[MoxxiManagarm]

Die isNaN Methode hast du da ja auch nicht verwendet...

Ich habe ja auch das negativ-Beispiel aufgeführt. In dem Inline Kommentar steht dass das innere der if-Bedingung nicht erreicht wird. Richtig wäre es mit isNaN. Du wirst es nicht unbedingt brauchen, kommt ganz darauf an wie du den Code aufziehst. Ich wollte es dir nur schon mitgeben, falls du es brauchen wirst.

 

[jono]

Wenn du die Abfrage immernoch in der bubblesort Methode machst wird dir das nichts bringen

Also, ich habe die Abfrage jetzt in die medianInception-Methode geschrieben:

public static double medianInception(double[][] array) {
        
        double[] a = new double[array.length];
        
        
        for (int i = 0; i < array.length; ++i) {
            a[i] = bubbleSort(array[i]);
        }
        
        if (a == null || a.length == 0) {
            return Double.NaN;
        }
        
        int median = a.length / 2;
        if (a.length % 2 == 1) {
            return a[median];
        }
        return (a[median - 1] + a[median]) / 2.0;

    }

isNaN verwenden zu sollen kann ich immer noch nicht ganz nachvollziehen, denn es heißt ja in der Aufgabenstellung, dass einfach nur abgefragt werden soll, ob das array null || array.length == 0 ist. Wenn ja, dann soll Double.NaN zurückgeliefert werden...

 

[MoxxiManagarm]

Du hast ja immernoch einen Rückgabewert im bubblesort. Tu mir den Gefallen und lies nochmal alle Kommentare, versuche sie zu verstehen. Aktuell machst du nur Müll, man hat wirklich das Gefühl du stocherst nur so herum. Und das ist nicht mal böse gemeint.

isNaN verwenden zu sollen kann ich immer noch nicht ganz nachvollziehen, denn es heißt ja in der Aufgabenstellung, dass einfach nur abgefragt werden soll, ob das array null || array.length == 0 ist. Wenn ja, dann soll Double.NaN zurückgeliefert werden...

Das liegt daran, dass du vermutlich einen Fall vergisst. Es kann sowohl das 2D-Array null oder leer sein, als auch jedes Teilarray. Die Teilarrays kannst du an verschiedenen Stellen prüfen. Die meisten Varianten würden Double::isNaN brauchen, jedoch nicht alle.

Beispiel

double[][] arr = {null,{2, 5, 6},{9, 2, 8},{4, 4, 4}}; // Teilarray ist null
double[][] arr = {}; // 2D-Array ist leer

 

[jono]

Und was hat die Berechnung eines Medians in einer solchen Merhode zu tun.

@fhoffmann Ich habe die Berechnung dort hingeschrieben, weil ich dachte, dass es wie mit der Sortierung ist. Wenn ich dementsprechend sozusagen auch in der bubbleSort-Methode auch den Median des sortierten Arrays berechne, dass sich das dann auch auf die Teilarrays des zweidimensionalen Arrays der medianInception-Methode auswirkt. Sozusagen, dass dann die Mediane der Teilarrays direkt in

for (int i = 0; i < array.length; ++i) { a= bubbleSort(array); }

a geladen werden...

 

[mihe7]

Aktuell machst du nur Müll, man hat wirklich das Gefühl du stocherst nur so herum.

Sag nicht sowas, er weiß genau, was er tut...

@jono eine Frage bzgl. der Methode aus #45 (Zeile 10): in welchem Fall wird a == null sein?

 

[jono]

eine Frage bzgl. der Methode aus 45 (Zeile 10): in welchem Fall wird a == null sein?

In keinem Fall, weil a schon initialisiert worden ist...?

 

[MoxxiManagarm]

Ich habe keine Lust mehr und gebe auf. Ich habe die Hoffnung, dass du es vielleicht mit dem fertigen Beispiel besser verstehst was wir alle bisher geschrieben haben. Bitte öffne das nur, wenn du mir versprichst alles noch einmal nachzuvollziehen.

Spoiler

private static void bubbleSort(double[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                // swap
                double temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

private static double medianInception(double[] arr) {
    // sort the array (byReference)
    bubbleSort(arr);

    // return the median
    int middle = arr.length / 2;
    if (arr.length % 2 == 1) {
        return arr[middle];
    } else {
        return (arr[middle - 1] + arr[middle]) / 2.0;
    }
}

public static double medianInception(double[][] arr) {
    // return NaN if 2D-Array is null or empty
    if (arr == null || arr.length == 0) {
        return Double.NaN;
    }

    // return NaN if Sub-Array is null or empty
    for (double[] subArr : arr) {
        if (subArr == null || subArr.length == 0) {
            return Double.NaN;
        }
    }

    // calculate the median of each sub-array and store it in a new array
    double[] mediane = new double[arr.length];
    for (int i = 0; i < arr.length; i++) {
        mediane[i] = medianInception(arr[i]);
    }

    // return the median of the new array
    return medianInception(mediane);
}