Habe ich tatsächlich gerade. Jedoch nach wie vor irgendwo einen Rechenfehler. Und doch ich mache mir sogar sehr viele Gedanken über die Hinweise. 🙂
Habe ich tatsächlich auch, klappt nur nicht so ganz..
for (int i = 0; i < array.length; i++) {
if (array == null || array.length == 0) {
return new int[] {}; // leeres Array der Länge 0 ausgeben
}
}
Leider. Ich verstehe es ehrlich auch nicht. Aber da es gleich drei Leute sind, die hier ein Problem haben, zweifle ich langsam an mir selbst. *Heul-Smiley*
Ich glaube es liegt weniger an euch, ich für meinen Teil verzweifle selber fast, obwohl man ja scheinbar nah dran ist und vermutlich denkt man was ähnliches, drückt es nur anders aus oder denkt zu komplex.
Ja, das dürfte es aus meiner Sicht sein. Daher wäre meine Tendenz, wirklich mehr in Methoden zu unterteilen.
public static int getElementCountOfArrayWithIgnoredElements(int array[], int ignoreCount)
Puh, gerade noch rechtzeitig gesehen - ich war gerade dabei seinen Code umstrukturiert zu posten 🙂
public static int shortMethod(int array[], int ignoreCount) {
if (ignoreCount > array.length) return 0;
int count = 0;
for (int i = 0; i < array.length; i++) {
count = array[i];
}
int result = count - ignoreCount;
return result;
}Du weißt doch, wie viele es sind: b.length
public static int getElementCountOfArrayWithIgnoredElements(int array[], int ignoreCount) {
if (array.length <= ignoreCount) return 0;
return array.length - ignoreCount;
}public static int getElementCountOfArraysWithIgnoredElements(int array[][], int ignoreCountPerArray) {
}Ja, bei mir kam ja auch dasselbe raus nur war deutlich länger, deswegen wundert mich das gerade
Nein, bei Dir kam der Wert des letzten Elements im Array abzgl. ignoreCount raus - oder 0, falls ignoreCount die Array-Länge übersteigt. D. h. bei {1,2,3} kommt für ignoreCount==1 tatsächlich 2 raus, bei {1,2,4} dagegen 3.
Tatsache, sorry.
Wichtig ist, dass Du (Deinen) Code verstehst, also nachvollziehen kannst. Das ist mit ein Grund, warum man das in kleinere Methoden aufteilt. Nachvollziehen kannst Du das gedanklich oder wirklich auf Papier. Mit Übung wird es leichter. Bei Schleifen wirklich jede Iteration einzeln durchgehen.
public static int count2dPlusRemove(int array[][], int ignoreCountPerArray) {
int result = 0;
for (int i = 0; i < array.length; i++) {
result += getElementCountOfArrayWithIgnoredElements(array[i].length, ignoreCountPerArray);
}
return result;
}War zu blöd das so richtig zu schreiben, daran gedacht hatte ich, nur bisschen an der Sache vorbei gedacht. 🙄
int counter = 0;
for (int[] r : array) {
Arrays.sort(r);
for (int i = 0; i < array.length - 1; i++) {
result[counter] = r[i];
counter++;
}
}Dafür nochmal wirklich herzlichsten Dank an euch, dass ihr Anfängern helft! 🙂
for (int i = 0; i < array.length; i++) {
if (array == null || array.length == 0) {
return new int[] {};
}
}
/* Ausgabe: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
/at Functionality.flatternAndSortWithoutBiggest(Functionality.java:29) Zeile 29 = result[counter] = r[i];
/ at Functionality.main(Functionality.java:54)
*/ int counter2 = 0;
for (int i = 0; i < array.length; i++) {
counter2 += array[i].length;
}
int[] result = new int [counter2 - array.length];
int counter = 0;
for (int[] r : array) {
Arrays.sort(r);
for (int i = 0; i < array.length - 1; i++) {
result[counter] = r[i];
counter++;
}
}public class Test {
public static int[] doit() {
int[] eindim = new int[9];
int[][] zweidim = {
new int[] {1,2,3},
new int[] {4,5,6},
new int[] {7,8,9} };
// Kopiere alle Teilarrays aus zweidim nach eindim
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++;
}
}
// Sortiere eindim
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);
// Fertig
return eindim;
}
public static void main(String[] args) {
System.out.println(Arrays.toString(doit()));
}
}Also bisher war die Kernidee, dass die Maxima nicht erst mit kopiert wurden. Dazu diente die Idee, das Maximum ans Ende zu setzen um dann das letzte Element in jedem Teil-Array von Anfang an nicht mit zu kopieren.
int max = Integer.MIN_VALUE;
for(int i: zweidim) if(max<i) max=i;import java.util.Arrays;
import java.util.logging.Logger;
public class ArrayMerge {
private final static Logger log = Logger.getLogger(ArrayMerge.class.getName());
public static int[] quicksort(final int[] source) {
return sort(source, 0, source.length-1);
}
public static int[] sort(final int[] source, final int start, final int end) {
log.info("sort: " + start + " - " + end);
int[] result;
if (end - start > 0) {
int[] first = sort(source, start, start + (end-start)/2);
int[] second = sort(source, start + (end-start)/2 + 1, end);
result = merge(first, second);
} else {
result = new int[] { source[start] } ;
}
log.info("sort(" + Arrays.toString(source) + ", " + start + ", " + end + ") = " + Arrays.toString(result));
return result;
}
public static int[] merge(final int[] first, final int[] second) {
return merge(first, first.length, second, second.length);
}
public static int[] merge(final int[] first, final int lengthFirst, final int[] second, final int lengthSecond) {
// Normalen QuickSort Algorithmus könnte man durch ersetzen von lengthFirst und lengthSecond durch
// first.length und second.length bekommen.
int[] result = new int[lengthFirst + lengthSecond];
int firstIndex = 0;
int secondIndex = 0;
int resultIndex = 0;
while (resultIndex < result.length) {
if (firstIndex < lengthFirst && secondIndex < lengthSecond) {
// We take minimum from first and second
if (first[firstIndex] < second[secondIndex]) {
result[resultIndex] = first[firstIndex];
firstIndex++;
} else {
result[resultIndex] = second[secondIndex];
secondIndex++;
}
} else if (firstIndex < lengthFirst) {
// We take element from first
result[resultIndex] = first[firstIndex];
firstIndex++;
} else {
// We take element from second
result[resultIndex] = second[secondIndex];
secondIndex++;
}
resultIndex++;
}
log.info("Merged: " + Arrays.toString(first) + " + " + Arrays.toString(second) + " = " + Arrays.toString(result));
return result;
}
public static void main (String[] args) {
// testing the QuickSort
int[] array = { 17, 32, 3, 45, 1, 7 };
System.out.println(Arrays.toString(array));
System.out.println(Arrays.toString(ArrayMerge.quicksort(array)));
// Now merging the Arrays with ignoring of the highest Element.
int[][] twodimarray = { { 21, 14, 7 },
{ 8, 32, 24, 16 },
{ 9, 18, 27} };
int[] result = new int[0];
for(int[] subArray: twodimarray) {
if (subArray.length > 1)
result = merge(result, result.length, quicksort(subArray), subArray.length - 1);
}
System.out.println(Arrays.toString(result));
}
}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++;
}
}
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);
int max = Integer.MIN_VALUE;
for(int[] i : ) if(max<i) max=i;
return eindim;
}
}Klingt vielleicht dumm, aber ich muss mich anschließen. Leider fällt es mir schwer einen schnellen Überblick zu finden.
3 2 1
5 6 4
8 7 93 2 1 -> Maximum an Index 01 2 35 6 4 -> Maximum an Index 15 4 68 7 9 -> Maximum an Index 28 7 91 2 3
5 4 6
8 7 91 2 3 --> 1 2
5 4 6 --> 1 2 5 4
8 7 9 --> 1 2 5 4 8 7Das Grund Prinzip ist schlüssig, aber ich tue mich schwer damit es in einem mehrdimensionalen Array umsetzen. Mein Ansatz bislang sieht so aus allerdings funktioniert es damit leider noch nicht.
int tmp = 0;
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < b[i].length; j++) {
tmp = b[i][0];
if (b[i][j] > tmp) {
tmp = b[i][j];
b[i][j] = b[i][b[i].length - 1];
b[i][b[i].length - 1] = tmp;
}
}
}Das ist das, was ich ziemlich am Anfang des Threads schon einmal zu erklären versucht habe (auch im Zusammenhang mit dem Maximum). Ihr müsst anfangen, die Dinge besser voneinander zu isolieren. Das funktioniert genauso wie mit einem 1D-Array, nur dass nochmal eine Schleife außenrum ist:
for (int i = 0; i < array.length; i++) {
int[] subArray = array[i];
if (subArray.length > 0) {
// ermittle Index ix des größten Elements in subArray
// und danach: vertausche ix und subArray.length-1 in subArray.
}
}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;for (int i = 0; i < array.length; i++) {
int[] subArray = array[i];
if (subArray.length > 0) {
// ermittle Index ix des größten Elements in subArray
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;
}
}
// und danach: vertausche ix und subArray.length-1 in subArray.
int last = subArray.length - 1;
int tmp = subArray[ix];
subArray[ix] = subArray[last];
subArray[last] = tmp;
}
}for (int i = 0; i < array.length; i++) {
int[] subArray = array[i];
if (subArray.length > 0) {
int ix = indexOfMax(subArray);
swap(ix, subArray.length-1);
}
}array.length gibt an, wie viele Elemente array aufnehmen kann (sprich: die Größe von array).
Nein, damit hole ich mir einfach das i-te Element aus array - bei dem es sich ja wieder um ein Array handelt. Das subArray durchlaufen wird erst in der zweiten Schleife.
Also, Du hast ein "äußeres Array", das mehrere "innere Arrays" enthält. Ähnlich einer Tabelle: die kann man als Array von Zeilen auffassen und jede Zeile als Array von Spalten.
Das kann man machen, weil b[0] ein Array liefert 🙂
int[] subArray = b[0];
int wert = subArray[4];
// ist analog zu
int wert = (b[0])[4];
// also
int wert = b[0][4];Nein, weil es in Java keine echten mehrdimensionalen Arrays gibt: es sind Arrays von Arrays.
Nein. Der Code verschiebt lediglich das Maximum eines jeden Subarrays ans Ende.
Das macht ja nichts, Du kannst ja über array auf die einzelnen Arrays zugreifen.
Sind die Werte dadurch denn dann in array sortiert ? Weil du hattest in den Code doch nur Werte zu subArray zugewiesen und array nur für die For Schleife benutzt.
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));Nein, das ist auch unnötig, da das Ausgabearray sowieso sortiert werden muss.
Ja, der passt.
Du hast die Größe für a noch nicht richtig berechnet. Wenn Du ein Array der Größe 15 erzeugst, sind erstmal alle Werte im Array 0. Wenn Du jetzt 10 Werte in das Array kopierst, stehen am Ende 5 Nullen. Wenn Du jetzt noch absteigend sortierst, stehen die negativen Werte rechts von den 0en.
Gibts dann einen anderen Weg damit ich quasi keine leeren Stellen bekomme?
int n =0;
int []a;
for (int i = 0; i < b.length; i++){
n+=b[i].length;
}
a= new int [n];
