Zweidimensionales array kopieren und in eindimensionales überführen

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.
Code:
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.
 
Habe es in diesem Moment auch bemerkt mein Fehler ups ^^

Code:
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.
 
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
 
Java:
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
 
Code:
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));
        
    }

}
 
@Snaer Du hast hier:
Java:
                for (int k =ix+1;k<subArray.length;k++) {
                    if(subArray[k]>max) {
                        ix=k;
                    }
                }
vergessen, das max zu setzen. Vgl. #191:
Java:
for (int k = ix + 1 ; k < subArray.length; k++) {
    if (subArray[k] > max) {
        max = subArray[k];
        ix = k;
    }
}
 
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.
 
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 🙄
 
Java:
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 ?
 
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...
 
Java:
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.
 
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
 
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.
 
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 ?
 
Allmählich gehen mir die Ideen aus, wie ich das noch erklären soll.

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

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

Ergebnis ist die Anzeige von
Code:
5
auf der Konsole.

Noch ein Hinweis: es spielt dabei keine Rolle, ob der Parameter x, y, z, schlagMichTot oder sonstWie genannt wird:
Java:
public void zeige(int klimbim) {
    System.out.println(klimbim);
}
ist völlig analog zur oben definierten zeige-Methode.
 
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.
 
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. 😛
 
Java:
	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
 
Code:
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!
 
1) testNullElementArray(PublicTests)
java.lang.NullPointerException
at Functionality.flatternAndSortWithoutBiggest(Functionality.java:25)
at PublicTests.testNullElementArray(PublicTests.java:33)
 
Java:
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.
 
Das ist die gesamte Fehlermeldung
Java:
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
 

Zurück
Oben