Aufgabe Hilfe

[dieter000]

Die Aufgabe ist die Arrays von Zeilen jeweils mit 0ern aufzufüllen sodass sie die gleiche länge haben ein Beispiel:


[CODE lang="java" title="Das habe ich bis jetzt aber es funktioniert nicht wirklich:/"] private static int[][] extendArray(int[][] inputArray) {
int length = 0;
for (int[] item : inputArray) {
if (item.length > length) //sucht längstes Array
length = item.length;
}
for (int i = 0; i < inputArray.length; i++) {
int[] currentArr = inputArray;
if (currentArr.length < length) {
int result = length - currentArr.length; //Differenz der Länge des akt. Arrays und längsten Arrays

int[] arr = new int[length];
for (int j = 0; j < currentArr.length; j++) {
arr[length-1-j] = currentArr[currentArr.length-1-j];
if (j < result) {
arr[j] = 0; //mit Nullen auffüllen
}
else {
arr[j] = currentArr[j - result];
}
}
inputArray = arr;
}
}
return inputArray;
}[/CODE]

 

[krgewb]

Bisher hast du also:

public class Hauptprogramm {

	public static void main(String[] args) {

		int[][] a = extendArray(new int[][] { { 4 }, { 1, 2, 3 }, { 5, 6 }, { 7, 8, 9, 1 } });

		for (int y = 0; y < a.length; y++) {
			for (int x = 0; x < a[y].length; x++) {
				System.out.print(a[y][x] + " ");
			}
			System.out.println("");
		}
	}

	private static int[][] extendArray(int[][] inputArray) {
		int length = 0;
		for (int[] item : inputArray) {
			if (item.length > length) // sucht längstes Array
				length = item.length;
		}
		for (int i = 0; i < inputArray.length; i++) {
			int[] currentArr = inputArray[i];
			if (currentArr.length < length) {
				int result = length - currentArr.length; // Differenz der Länge des akt. Arrays und längsten Arrays

				int[] arr = new int[length];
				for (int j = 0; j < currentArr.length; j++) {
					arr[length - 1 - j] = currentArr[currentArr.length - 1 - j];
					if (j < result) {
						arr[j] = 0; // mit Nullen auffüllen
					} else {
						arr[j] = currentArr[j - result];
					}
				}
				inputArray[i] = arr;
			}
		}
		return inputArray;
	}
}

Ausgabe:

0 0 0 4 
0 1 2 3 
0 0 5 6 
7 8 9 1

In der Ausgabe ist die zweite Zeile falsch. Es muss 1230 lauten und nicht 0123. Ich weiß nicht, nach welcher Regel das entschieden werden soll.

 

[dieter000]

Bisher hast du also:

public class Hauptprogramm {

    public static void main(String[] args) {

        int[][] a = extendArray(new int[][] { { 4 }, { 1, 2, 3 }, { 5, 6 }, { 7, 8, 9, 1 } });

        for (int y = 0; y < a.length; y++) {
            for (int x = 0; x < a[y].length; x++) {
                System.out.print(a[y][x] + " ");
            }
            System.out.println("");
        }
    }

    private static int[][] extendArray(int[][] inputArray) {
        int length = 0;
        for (int[] item : inputArray) {
            if (item.length > length) // sucht längstes Array
                length = item.length;
        }
        for (int i = 0; i < inputArray.length; i++) {
            int[] currentArr = inputArray[i];
            if (currentArr.length < length) {
                int result = length - currentArr.length; // Differenz der Länge des akt. Arrays und längsten Arrays

                int[] arr = new int[length];
                for (int j = 0; j < currentArr.length; j++) {
                    arr[length - 1 - j] = currentArr[currentArr.length - 1 - j];
                    if (j < result) {
                        arr[j] = 0; // mit Nullen auffüllen
                    } else {
                        arr[j] = currentArr[j - result];
                    }
                }
                inputArray[i] = arr;
            }
        }
        return inputArray;
    }
}

Ausgabe:

0 0 0 4
0 1 2 3
0 0 5 6
7 8 9 1

In der Ausgabe ist die zweite Zeile falsch. Es muss 1230 sein und nicht 0123.

es soll immer abwechselnd die zeilen auffüllen

 

[dieter000]

 

[krgewb]

Achso. "Immer abwechselnd" lässt sich mit modulo realisieren.
zeilenindex % 2 == 0 --> Gerade
zeilenindex % 2 == 1 --> Ungerade

 

[dieter000]

Achso. "Immer abwechselnd" lässt sich mit modulo realisieren.
zeilenindex % 2 == 0 --> Gerade
zeilenindex % 2 == 1 --> Ungerade

ja genau, aber wie mache ivch das in meinem Fall?:/

 

[httpdigest]

Duplikat von: https://www.java-forum.org/thema/hilfe-bei-dem-beispiel-wie-gehe-ich-sowas-am-besten-an.190348/
Äh quatsch... Ich hab nicht richtig geguckt.

 

[DrPils]

ja genau, aber wie mache ivch das in meinem Fall?:/

Eigentlich hatt @krgewb ja alles gesagt, mit modulo 2 pruefst du ob gerade oder ungerade.
Auf eine gerade Zahl folgt immer eine Ungerade...
Wo in deinem Code muss die Pruefung auf gerade oder ungerade wohl hin?

 

[dieter000]

Eigentlich hatt @krgewb ja alles gesagt, mit modulo 2 pruefst du ob gerade oder ungerade.
Auf eine gerade Zahl folgt immer eine Ungerade...
Wo in deinem Code muss die Pruefung auf gerade oder ungerade wohl hin?

bei if j< result ?

 

[DrPils]

Also deine Zeilen sollen abwechselnd erst von links und rechts mit nullen aufgefuellt werden.
Du gehst doch dein Array Zeile fuer Zeile durch.
Die erste Zeile hat den index 0, die zweite 1, die dritte 2, ....
0 % 2 = 0
1 % 2 = 1
2 % 2 = 0
...

 

[dieter000]

Also deine Zeilen sollen abwechselnd erst von links und rechts mit nullen aufgefuellt werden.
Du gehst doch dein Array Zeile fuer Zeile durch.
Die erste Zeile hat den index 0, die zweite 1, die dritte 2, ....
0 % 2 = 0
1 % 2 = 1
2 % 2 = 0
...

ja genau si habe ich es mir auch gedacht aber wie setzte ich das mit dem index umhabe gedacht irgendwie currentArr[0] % 2 = 0 ?;/

 

[DrPils]

currentArr[0] % 2 = 0

da wuerdest du ja pruefen ob der int auf index 0 gerade ist.

In deinen for schleifen arbeitest du doch mit dem jeweiligen index

for(int i = 0; i < arr.length; i++){
            for(int j = 0; j < arr[i].length; j++){
                if (j % 2 == 0) {
                    System.out.println("Gerade Zeile");
                } else {
                    System.out.println("Ungerade Zeile");
                }
            }
        }

 

[krgewb]

Nein. Wenn du du das so schreibst (wegen den zwei Stellen mit length), dann repräsentiert i die Zeile und j die Spalte.

dieter000 macht es anders. Er schreibt nie "meinArray[y][x]", sondern zieht das eindimensionale Array heraus.
Das bin ich derzeit nicht gewohnt und kann bzw. will da nicht helfen.

 

[dieter000]

hallo, ich habe es leider noch nicht geschafft, habe sehr viele ansätze probiert, aber leider nicht geschafft, bin grundsätzlich beim gleichen wie am Anfang hier... würde mich über eine antwort freuen

 

[kneitzel]

Bei so Problemen wäre mein Ratschlag immer: Teile und Herrsche!

Also zerteile das Problem in Teilprobleme um dann nur noch die Teilprobleme lösen zu müssen.

Das macht den Code sofort übersichtlicher und einfacher. Und man findet leichter Lösungen für Probleme.
(Und dabei immer auf vernünftige Namen achten. bei Dir kommt man leicht durcheinander: i, j, inputArr, currentArr, ... Aber auch das wird einfacher, denn je kleiner die Methoden werden, desto weniger Variablen kommen in der Methode vor)

Und wenn Du ein Array von int anlegst, dann hast du ja die 0er schon direkt. Also die 0er zum Auffüllen musst Du nicht mehr schreiben.

Wenn du nun { 1, 2 } auf 5 Stellen erweiterst, was ist dann der Unterschied?
Mal fängst du bei 0 an, die Werte herein zu kopieren und mal bei 5 - 2 = 3.

Also ich würde Dir raten, das einmal zu zergliedern in mehrere Methoden um dann zu schauen, ob Du dann klar gekommen bist.
Dann gibt es auch keine Aussage wie in #13 mehr, denn auch wir können schneller und einfacher einen Überblick gewinnen....

 

[krgewb]

Ich erzeuge einfach ein neues Array. Da ist jedes Felder schon mit einer Null gefüllt.

public class Hauptprogramm {

    public static void main(String[] args) {

        int[][] a = extendArray(new int[][] { { 4 }, { 1, 2, 3 }, { 5, 6 }, { 7, 8, 9, 1 } });

        for (int y = 0; y < a.length; y++) {
            for (int x = 0; x < a[y].length; x++) {
                System.out.print(a[y][x] + " ");
            }
            System.out.println("");
        }
    }

    private static int[][] extendArray(int[][] inputArray) {

        int lengthOfLongestArray = 0;

        for (int y = 0; y < inputArray.length; y++) {
            if (inputArray[y].length > lengthOfLongestArray) {
                lengthOfLongestArray = inputArray[y].length;
            }
        }

        int[][] newArray = new int[inputArray.length][lengthOfLongestArray];

        for (int y = 0; y < inputArray.length; y++) {
            int diff = lengthOfLongestArray - inputArray[y].length;
            if (y % 2 == 0) {
                for (int i = 0; i < inputArray[y].length; i++) {
                    newArray[y][i + diff] = inputArray[y][i];
                }
            } else {
                for (int i = 0; i < inputArray[y].length; i++) {
                    newArray[y][i] = inputArray[y][i];
                }
            }
        }

        return newArray;
    }

}

Ausgabe:

0 0 0 4 
1 2 3 0 
0 0 5 6 
7 8 9 1

 

[Blender3D]

Teile und Herrsche!

Treffender kann man es nicht formulieren.
Die Teilprobleme:
1) Ermittle die maximale Zeilenlänge der Quelle

int getMaxArrayLenght(int[][] array)

2) Erzeuge ein passendes Ziel
3) Kopiere jede Zeile der Quelle nach dem Ziel mit der Bedingung

void copyToPos(int[] source, int[] destination, int start)

gerade Zeilen werden auf Position <maximaler Länge - Zeilen Länge>++
ungerade Zeilen auf Position <0>++ kopiert.
4) gib das Ergebnis aus

void printArray(int[][] array)

Nachdem man obige einfache Funktionen erstellt hat, ist es dann ein Leichtes das Hauptproblem zu lösen. 😉
Da @krgewb oben bereits eine Lösung gepostet hat folgt hier die Teile und Herrsche Variante.
[CODE lang="java" title="ExtendArrayTest" highlight="4-6,10-14,20-25,29-30"]public class ExtendArrayTest {

public static void main(String[] args) {
int[][] testArray = new int[][] { { 1, 3, 2 }, { 5, 1 }, { 6, 8, 5, 4 }, { 9, 4, 1, 9, 2 },
{ 1, 8, 7, 5, 3, 2, 5 }, { 3 } };
printArray(fillWithZeroSwapped(testArray));
}

private static int[][] fillWithZeroSwapped(int[][] source) {
int max = getMaxArrayLenght(source); // ermittle maximale Länge
int[][] destination = new int[source.length][max]; // erzeuge größes Array
for (int row = 0; row < source.length; row++) {
int start = row % 2 == 0 ? max - source[row].length : 0;
copyToPos(source[row], destination[row], start); // kopiere Zeile nach start Spalte
}
return destination;
}

private static int getMaxArrayLenght(int[][] array) {
int maxLength = 0;
for (int row = 0; row < array.length; row++) {
if (maxLength < array[row].length)
maxLength = array[row].length;
}
return maxLength;
}

private static void copyToPos(int[] source, int[] destination, int start) {
for (int i = 0; i < source.length; i++)
destination[start + i] = source;
}

private static void printArray(int[][] array) {
for (int row = 0; row < array.length; row++) {
for (int column = 0; column < array[row].length; column++)
System.out.print(array[row][column] + " ");
System.out.println("");
}
}
}[/CODE]

 

[krgewb]

@dieter000 Verstehst du mein Programm?

 

[BMW]

Hello folks!

I have a question. I have the same question, but instead of "zero = 0" I have to write "one = 1".

    int maxArray = 0;
    for (int i = 0; i <inputArray.length; i ++) {
        if (inputArray [i] .length> maxArray) // looks for longest array
            maxArray = inputArray [i] .length;
    }
    int[][] longArray = new int [inputArray.length] [maxArray];
    for (int j = 0; j <inputArray.length; j ++) {
        int diff = maxArray - inputArray [j] .length;
        if (j% 1 == 0) {
            for (int i = 0; i <inputArray [j] .length; i ++) {
                longArray [j] [i + diff] = inputArray [j] [i];
            }
        } else {
            for (int i = 1; i <inputArray [j] .length; i ++) {
                longArray [j] [i] = inputArray [j] [i];
            }
        }
    }

    return longArray;
}

But I have the result:

0 0 0 4    
0 1 2 3    
0 0 5 6    
7 8 9 1