Zweidimensionales array kopieren und in eindimensionales überführen

[mihe7]

Gibts dann einen anderen Weg damit ich quasi keine leeren Stellen bekomme?

Klar, Du musst die Größe des Arrays richtig berechnen. Dazu kannst Du Dir anschauen, wie es in #159 und #166 gemacht wurde. Die Zielgröße erhältst Du logischerweise mit count2dPlusRemove(b, 1).

 

[jono]

Mihe wo würdest du denn dein Code bei mir einfügen ? SubArray wäre dann bei mir eindim oder ?

 

[mihe7]

Nein, eindim ist das Ausgabearray. Bei Dir ist array einfach zweidim und das mit dem subArray kannst Du so lassen.

 

[Snaer]

Klar, Du musst die Größe des Arrays richtig berechnen. Dazu kannst Du Dir anschauen, wie es in #159 und #166 gemacht wurde. Die Zielgröße erhältst Du logischerweise mit count2dPlusRemove(b, 1).

Was meinst du mit count2dPlusRemove ? Ist das eine Methode in Java? Ich kenne dazu nämlich leider noch nichts.

Hab mir die Beiträge jedenfalls angesehen es klappt schonmal das die Größe richtig berechnet wird danke, aber bei dem einfügen hakt es dennoch mit dem Code den ich zuvor schon hier gepostet habe.

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

Mit dem Code wird leider jede Stelle weiterhin hinzugefügt und wenn ich die -1 durch -2 ersetze werden einige Zahlen nur durch 0 ersetzt.

 

[mihe7]

Was meinst du mit count2dPlusRemove ? Ist das eine Methode in Java? Ich kenne dazu nämlich leider noch nichts.

Das ist die Methode aus #166

aber bei dem einfügen hakt es dennoch mit dem Code den ich zuvor schon hier gepostet habe.

Zeig mal, wie Du die Länge von a berechnest.

 

[Snaer]

Habe es in diesem Moment auch bemerkt mein Fehler ups ^^

int n =0;
        int ignoreCountPerArray=1;
        for (int i = 0; i < b.length; i++) {
              n += b[i].length -ignoreCountPerArray;
        }
        a = new int [n];

Dabei bekomme ich als Ausgabe [8, 7, 4, 3, 3, 2, 2, 1, 1, 0, -13]. An sich klappt damit zumindest das absteigende sortieren, aber das ignorieren der letzten Stelle will irgendwie nicht so ganz.

 

[Snaer]

Ich muss mich ergänzen tatsächlich wird die größte Zahl in jedem Array bis auf einem ignoriert.
int [][] b = { new int[] { 1, 2, 3, 4 }, new int[] { 4, 3, 2, 1 }, new int[] { 0, 7, 8, 4, 3 },
new int[] { -13, 4 } };
Aus jedem Array wird die 4 gelöscht, aber die 8 bzw das gesamte 3. Array bleibt vorhanden

 

[jono]

import java.util.Arrays;


public class Functionality {

	public static void main(String[] args) {
		
	System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(new int[][] {{1,2,3},{4,5,6},{7,8,9}})));
	
	}
	
	public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		
		if (array == null || array.length == 0)
        throw new IllegalArgumentException ("Array null oder leer!");
		
		   int[] eindim = new int[9]; 
	       int[][] zweidim = { 
	               new int[] {1,2,3},  
	               new int[] {4,5,6}, 
	               new int[] {7,8,9}}; 
	     
	  
	       int counter = 0; 
	       for (int i = 0; i < zweidim.length; i++) { 
	           for (int j = 0; j < zweidim[i].length; j++) {
	        	   
	        	   eindim[counter] = zweidim[i][j]; 
	               counter++; 
	           }
	       }
	               
	               for (int i = 0; i < zweidim.length; i++) {
	            	    int[] subArray = zweidim[i];
	            	    if (subArray.length > 0) {
	            	        
	            	        int ix = 0;
	            	        int max = subArray[ix];
	            	        for (int k = ix + 1 ; k < subArray.length; k++) {
	            	            if (subArray[k] > max) {
	            	                max = subArray[k];
	            	                ix = k;
	            	            }
	            	        }

	            	        
	            	        int last = subArray.length - 1;
	            	        int tmp = subArray[ix];
	            	        subArray[ix] = subArray[last];
	            	        subArray[last] = tmp;
	            	        
	            	    }
	            	}
	                      
	       
	       
	         boolean swapped;
	           do {
	           swapped = false;
	           for(int i = 1; i<eindim.length;i++) {
	           if(eindim[i]>eindim[i-1]) {
	           int swap = eindim[i-1];
	           eindim[i-1] = eindim[i];
	           eindim[i] = swap;
	           swapped = true;
	                          }
	           
	                 }
	           
	           
	             }while(swapped);
	           
	           
	           
	         
	           
	           return eindim;
    	 
	}    
           
         
}

Jetzt muss ich noch das Maximum aus dem auszugebenden Array eindim entfernen oder ? wie mache ich das

 

[mihe7]

Ich muss mich ergänzen tatsächlich wird die größte Zahl in jedem Array bis auf einem ignoriert.

Kannst Du mal den ganzen Code posten?

 

[Snaer]

public class beispiel {
    public static void main(String[] args) {
        int[][] b = { new int[] { 1, 2, 3, 4 }, new int[] { 4, 3, 2, 1 }, new int[] { 0, 7, 8, 4, 3 },
                new int[] { -13, 4 } };
        int n =0;
        int [] a ;
        int ignoreCountPerArray=1;
        for (int i = 0; i < b.length; i++) {
              n += b[i].length -ignoreCountPerArray;
        }
        a = new int [n];
        for (int i = 0; i< b.length;i++) {
            int[] subArray= b[i];
            if (subArray.length>0) {
                int ix=0;
                int max=subArray[ix];
                for (int k =ix+1;k<subArray.length;k++) {
                    if(subArray[k]>max) {
                        ix=k;
                    }
                }
                int last = subArray.length-1;
                int tmp=subArray[ix];
                subArray[ix]=subArray[last];
                subArray[last]=tmp;
            }
        }
        int count = 0;
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length - 1; j++) {
                a[count] = b[i][j];
                count++;
            }
        }
        boolean swapped;
        do {
            swapped = false;
            for (int i = 1; i < a.length; i++) {
                if (a[i] > a[i - 1]) {
                    int swap = a[i - 1];
                    a[i - 1] = a[i];
                    a[i] = swap;
                    swapped = true;
                }
            }
        } while (swapped);
        System.out.println(Arrays.toString(a));
        
    }

}

 

[mihe7]

Jetzt muss ich noch das Maximum aus dem auszugebenden Array eindim entfernen oder ? wie mache ich das

S. #204

 

[mihe7]

@Snaer Du hast hier:

                for (int k =ix+1;k<subArray.length;k++) {
                    if(subArray[k]>max) {
                        ix=k;
                    }
                }

vergessen, das max zu setzen. Vgl. #191:

for (int k = ix + 1 ; k < subArray.length; k++) {
    if (subArray[k] > max) {
        max = subArray[k];
        ix = k;
    }
}

 

[jono]

Ich glaube das Problem war gerade schonmal dran,
die Ausgabe ist jetzt korrekt jedoch gibt er jetzt drei mal die 0 am Ende aus ,anstatt einfach von den 9 Elementen
6 auszugeben.

 

[mihe7]

S. #206, das a von @Snaer ist das eindim bei Dir.

 

[Snaer]

An sich klappt es nun vielen Dank die Ausgaben sind aufjedenfall die richtigen, nur bei der Abgabe bekomme ich noch Fehlermeldungen. Da muss ich mich dann wohl ran setzen

 

[jono]

Snaer , bei mir dasselbe...

 

[Snaer]

Snaer , bei mir dasselbe...

Sind wohl im selben Kurs was ?

 

[jono]

Sehr wahrscheinlich

 

[jono]

Was denkst du denn woran es jetzt liegt ?

 

[jono]

import java.util.Arrays;

public class Functionality {
 public static void main(String[] args) {
 
 System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(new int[][] {{1,2,3},{4,5,6},{7,8,9}})));
 
 }
 
 public static int[] flatternAndSortWithoutBiggest(int[][] array) {
 
  if (array == null || array.length == 0)
        throw new IllegalArgumentException ("Array null oder leer!");
 
     int[] eindim = new int[9];
        int[][] zweidim = {
                new int[] {1,2,322},  
                new int[] {4,567,6},
                new int[] {7,87,9}};
     
        int n =0;
                int ignoreCountPerArray=1;
                for (int i = 0; i < zweidim.length; i++) {
                      n += zweidim
                [i].length -ignoreCountPerArray;
                }
                eindim = new int [n];
   
        int count = 0;
         for (int i = 0; i < zweidim.length; i++) {
             for (int j = 0; j < zweidim[i].length - 1; j++) {
                 eindim[count] = zweidim[i][j];
                 count++;
             }
         }
         
         
                 
                 
                for (int i = 0; i < zweidim.length; i++) {
                  int[] subArray = zweidim[i];
                  if (subArray.length > 0) {
                     
                      int ix = 0;
                      int max = subArray[ix];
                      for (int k = ix + 1 ; k < subArray.length; k++) {
                          if (subArray[k] > max) {
                              max = subArray[k];
                              ix = k;
                          }
                      }
                     
                      int last = subArray.length - 1;
                      int tmp = subArray[ix];
                      subArray[ix] = subArray[last];
                      subArray[last] = tmp;
                   
                     
                     
                  }
                }
        boolean swapped;
               
            do {
            swapped = false;
            for(int i = 1; i<eindim.length;i++) {
            if(eindim[i]>eindim[i-1]) {
            int swap = eindim[i-1];
            eindim[i-1] = eindim[i];
            eindim[i] = swap;
            swapped = true;
                           }
           
                  }
           
           
              }while(swapped);
   
           
           
            return eindim;
     
 }    
           
         
}

Warum funktioniert es bei der Zahlenkombination im zweidim nicht ?

 

[mihe7]

Warum funktioniert es bei der Zahlenkombination im zweidim nicht ?

Bei der Formatierung würde ich auch nicht funktionieren...

 

[jono]

Meinst du weil keine einzelnen Methoden vorhanden sind ?

 

[mihe7]

Nein, ich meine, weil das keine Sau lesen kann

Schau Dir mal an, was Du der Reihe nach machst (in groben Blöcken) und überleg Dir, ob das so stimmen kann...

 

[jono]

Okay, ich schaue mal , aber du hast den Fehler entdeckt ?

 

[mihe7]

Natürlich, sonst würde ich nicht ohne Einschränkungen schreiben, dass Du Dir den Ablauf anschauen sollst

 

[jono]

import java.util.Arrays;


public class Functionality {

	public static void main(String[] args) {
		
	System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(new int[][] {{1,2,3},{4,5,6},{7,8,9}})));
	
	}
	
	public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		
		if (array == null|| array.length == 0) {
	        throw new IllegalArgumentException ("Array null oder leer!");}
		        
		
		   int[] eindim = new int[9]; 
	       int[][] zweidim = { 
	               new int[] {1,11,3,2},  
	               new int[] {5,-4,6,2,4,2}, 
	               new int[] {8,9,7}}; 
	     
	       
	       int n =0;
 	        int ignoreCountPerArray=1;
 	        for (int i = 0; i < zweidim.length; i++) {
 	              n += zweidim
 	       	[i].length -ignoreCountPerArray;
 	        }
 	        eindim = new int [n];
       	
 	       
            for (int i = 0; i < zweidim.length; i++) {
         	    int[] subArray = zweidim[i];
         	    if (subArray.length > 0) {
         	        
         	        int ix = 0;
         	        int max = subArray[ix];
         	        for (int k = ix + 1 ; k < subArray.length; k++) {
         	            if (subArray[k] > max) {
         	                max = subArray[k];
         	                ix = k;
         	            }
         	        }

         	        
         	        int last = subArray.length - 1;
         	        int tmp = subArray[ix];
         	        subArray[ix] = subArray[last];
         	        subArray[last] = tmp;
         	      
         	    
         	        
         	    }
            }
          
	       int count = 0;
	        for (int i = 0; i < zweidim.length; i++) {
	            for (int j = 0; j < zweidim[i].length -1; j++) {
	                eindim[count] = zweidim[i][j];
	                count++;
	            }
	        }
	   
	        
	        	        
	   
	                
	       boolean swapped;
	               
	           do {
	           swapped = false;
	           for(int i = 1; i<eindim.length;i++) {
	           if(eindim[i]>eindim[i-1]) {
	           int swap = eindim[i-1];
	           eindim[i-1] = eindim[i];
	           eindim[i] = swap;
	           swapped = true;
	                          }
	           
	                 }
	           
	           
	             }while(swapped);
	  
	           return eindim;
    	 
	}   
           
         
}

Das Problem habe ich behoben, jedoch werden bei der Abgabe noch 2 Fehlermeldungen angezeigt , warum ? Der Nulltest schlägt fehl und der testMultipleElementsArray.

 

[jono]

Hier ein screen

 

[mihe7]

jedoch werden bei der Abgabe noch 2 Fehlermeldungen angezeigt , warum ?

Naja, Du verwendest in flatternAndSortWithoutBiggest nicht das übergebene, sondern ein fixes Array.

 

[jono]

Welches meinst du übergeben ?

 

[jono]

Was muss ich denn jetzt genau ändern? also weiß schon was du meinst mit dem fixen Array aber nicht wie ich das jetzt so wie gewünscht ändern kann

 

[mihe7]

Welches meinst du übergeben ?

Ernsthaft?

int[] flatternAndSortWithoutBiggest(int[][] array) deklariert eine "Funktion" (Methode) flatternAndSortWithoutBiggest, die als Parameter ein zweidimensionales int-Array erhält, auf das innerhalb der Methode über den Namen array zugegriffen werden kann.

In main übergibst Du ein Array an die Methode, das nimmst Du in der Methode aber nicht her, sondern definierst dort fix ein neues, zweidimensionales Array mit dem Namen zweidim.

 

[jono]

Ja ich weiß war etwas zu eilig geantwortet ich weiß schon was du damit meinst, die frage hätte lauten können wie ich das übergebene in der flatternAndSortWithoutBiggest-Methode jetzt auch anwende ?

 

[jono]

Habe das noch nie gemacht deshalb frage ich mal

 

[jono]

Also wie nehme ich das jetzt in der Methode her , klingt lächerlich, aber weiß es nun mal nicht

 

[mihe7]

Allmählich gehen mir die Ideen aus, wie ich das noch erklären soll.

public void zeige(int x) { // Parameter x
    System.out.println(x); // wird hier verwendet
}

Aufruf:

zeige(5); // ruft Methode mit dem Argument 5 für Parameter x auf

Ergebnis ist die Anzeige von

5

auf der Konsole.

Noch ein Hinweis: es spielt dabei keine Rolle, ob der Parameter x, y, z, schlagMichTot oder sonstWie genannt wird:

public void zeige(int klimbim) {
    System.out.println(klimbim);
}

ist völlig analog zur oben definierten zeige-Methode.

 

[jono]

Echt nicht falsch verstehen, regt dich bestimmt auf, aber warum abstrahierst du das so? Ich weiß nicht wie ich das zweidim umbennen soll. Wäre echt dankbar wenn du mir das einfach gerade mal so sagen kannst , dann weiß ich es auch für die Zukunft.
Es ist ja alles gut, ich hatte in den vorherigen Seiten nur nichts dazu gefunden.
Bitte wende das mal auf mein Fall an bzw gebe genau an was zu machen ist.

 

[jono]

Wäre einfach viel hilfreicher wenn du das auf mein Beispiel anwendest mit int x und syso(x) bringt mich nicht weiter ist einfach nicht transparent genug meiner Auffassung nach, um das bei mir anzuwenden.

 

[jono]

In dem Fall müsstest du es mir glaube ich wirklich mal ausnahmsweise vorsagen

 

[jono]

	public static void main(String[] args) {
		
	System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(array)));
	
	}
	
	public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		
		if (array == null|| array.length == 0) {
			throw new IllegalArgumentException ("Array null oder leer!");}
		        
		
		   int[] eindim = new int[9]; 
	            array = { 
	               new int[] {1,2,3},  
	               new int[] {4,5,6}, 
	               new int[] {7,8,9}};

So verstehe ich das, aber so ist es nicht ausführbar

 

[jono]

Eigentlich ne banale Sache ist mir auch bewusst

 

[kneitzel]

public static int[] flatternAndSortWithoutBiggest(int[][] array) {
==> Hier hast Du array - damit sollst Du arbeiten!
           int[][] zweidim = {
==> Hier hast Du ein neues Array erstellt mit dem Du aber arbeitest.

Also Du willst für mich einkaufen gehen. Du bekommst eine Einkaufsliste ("array") und prüfst diese: Ist diese auch nicht leer?

Dann ignorierst diese, erstellst Dir einfach eine eigene Einkaufsliste und gehst die dann einkaufen und wunderst Dich, dass ich unzufrieden bin, weil du mir nicht gekauft hast, was ich auf meine Einkaufsliste geschrieben habe ...

Mit der letzten Änderung:
Jetzt machst Du keine neue eigene Einkaufliste mehr - sondern du überschreibst meine Einkaufsliste.

Tipp: Mach gar keine neue Einkaufliste! Die Methode bekommt das zweidimensionale Array, also hast Du da kein eigenes mehr zu erstellen!

 

[jono]

Okay, vielen Dank, habe jetzt die 2. Fehlermeldung vom vorherigen Screen behoben. Jetzt besteht noch die 1.

 

[jono]

1) testNullElementArray(PublicTests)
java.lang.NullPointerException
at Functionality.flatternAndSortWithoutBiggest(Functionality.java:25)
at PublicTests.testNullElementArray(PublicTests.java:33)

 

[jono]

War echt ein gutes Beispiel

 

[jono]

if (array == null|| array.length == 0) {
			throw new IllegalArgumentException ("Array null oder leer!");}

Das habe ich ja in meinem Code.
Und das soll erfüllt sein laut Aufgabenstellung: Sollte irgendein Array "null" sein oder leer sein, dann soll ein leeres Array der Länge 0 ( {} ) zurückgegeben werden.

 

[mihe7]

1) testNullElementArray(PublicTests)
java.lang.NullPointerException
at Functionality.flatternAndSortWithoutBiggest(Functionality.java:25)

Was steht denn in Functionality.java, Zeile 25?

 

[mihe7]

Und das soll erfüllt sein laut Aufgabenstellung: Sollte irgendein Array "null" sein oder leer sein, dann soll ein leeres Array der Länge 0 ( {} ) zurückgegeben werden.

Dann solltest Du das auch tun und keine Exception werfen

 

[jono]

Das ist die gesamte Fehlermeldung

PublicTests.java: Test failed ✘ 
JUnit version 4.12
.E.
Time: 0.006
There was 1 failure:
1) testNullElementArray(PublicTests)
java.lang.NullPointerException
	at Functionality.flatternAndSortWithoutBiggest(Functionality.java:25)
	at PublicTests.testNullElementArray(PublicTests.java:33)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(java.base@9-internal/Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(java.base@9-internal/NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(java.base@9-internal/DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(java.base@9-internal/Method.java:531)
	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)

FAILURES!!!
Tests run: 2,  Failures: 1

 

[jono]

In der Zeile 25 ist nur ein "}"

 

[jono]

Was kommt dann anstatt der "throw new IllegalArgumentException ("Array null oder leer!");" dahin?