Zeilen eines 2d Arrays abwechselnd links und rechts mit Nullen auffüllen

[Reykja]

Guten Abend
bei dieser Aufgabe sollen die Zeilen des Arrays abwechselnd links und rechts mit Nullen aufgefüllt werden. Meine Methode tut das allerdings nur von links nach rechts weil ich nicht weiß wie man nach jeder Zeile wechselt. Hätte jemand eine Idee? LG
richtig wäre z.B. bei int[][] array = new int[][]{{1, 2, 3}, {4}, {5, 6}, {7, 8, 9, 1}}; kommt
0123
4000
0056
7891

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 < length; j++) {
                    if (j < result) {                       
                        arr[j] = 0;                           //mit Nullen auffüllen
                    }
                    else {
                        arr[j] = currentArr[j - result];
                    }
                }
                inputArray[i] = arr;
            }
        }
        return inputArray;
    }

 

[kneitzel]

Zwei Ansätze. Der erste wäre einfach, Deinen aktuellen Code weiter zu verwenden:

Die Frage ist doch nur, was du zuerst machst. Derzeit schreibst du zuerst die 0 um dann am Ende die zahlen zu kopieren.
Aber du kannst doch den Code bestimmt so umschreiben (Behalte aber den aktuellen Code noch), so dass in der inneren for schleife erst die Werte des Arrays kopiert werden um dann am Ende 0en rein zu stecken.

Dann kannst Du dir überlegen, wie du erkennen kannst, wie du das machen sollst ... schreib dir dazu einfach den index einmal auf... Bei welchen Werten ist das auffüllen rechts? bei welchen links? Fällt Dir da evtl. ein Kriterium auf?

Der andere Ansatz ist etwas anders:
Wenn Du ein neues in Array erzeugst: Was für Werte stehen denn dann da drin? Was für Werte musst Du also alle rein schreiben?
Was bleibt denn dann unter dem Strich?

 

[athkougr]

Du kannst auch folgendes versuchen. Als anfang initialisiere eine boolean Variable z.B left mit true; Du führst die zweite for-Schleife und prüfst ob left true oder false ist. Je nach Wert von left fügst du erst die Nullen und dann die Zahlen oder umgekehrt. Wenn die innere for-Schleife zu ende ist änderst du den Wert von left.

 

[Reykja]

@JustNobody @athkougr danke für die Antworten!

so dass in der inneren for schleife erst die Werte des Arrays kopiert werden um dann am Ende 0en rein zu stecken

hätte ich auf die Schnelle jetzt so gemacht:

for (int j = 0; j < length; j++) {
    if (j < currentArr.length)
    arr[j] = currentArr[j];

 

[Reykja]

Fällt Dir da evtl. ein Kriterium auf?

wäre Modulo eine Lösung? sprich bei allen ungeraden Zeilen hänge ich die 0en vorne an und bei allen geraden Zeilen hinten?

 

[kneitzel]

Also dem entnehme ich, dass du jetzt keine 0en mehr schreiben willst, sehr gut.

Mit dem Modulo hast du Recht. Genau so dachte ich es mir.

Aber kannst du die schleife aus #4 noch so anpassen, dass du kein if mehr brauchst?
Bis wohin läuft die Schleife und bis wohin brauchst du es nur? Wenn du das etwas 'optimiert' bekommen würdest, dann wäre es super.

Dann könntest du dies auch bei der anderen Variante anwenden - da wird der Code dann auch schön einfach.

Der generelle Ansatz ist halt: du gehst über die Werte eines Arrays um diese in einem anderen Array einzutragen.
Die zweite Überlegung ist dann der Ziel Index. Wie sieht der jeweils aus?

 

[Reykja]

also die Schleife läuft bis 4, brauchen tue ich sie allerdings nur bis currentArr.length, sprich:

for (int j = 0; j < currentArr.length; j++) {
    arr[j] = currentArr[j];

 

[kneitzel]

Ja genau. Und wie würde diese Schleife für den anderen Fall aussehen? Könntest du diesen Code so anpassen, dass die Werte am Ende des Arrays sind? Sozusagen mit zwei kleinen Änderungen...

 

[Reykja]

jetzt fällt es mir leider nicht mehr ein, werde es aber morgen Vormittag probieren

 

[kneitzel]

Kleiner Tipp für morgen: es geht in erster Linie nur um dass arr[j] in der Schleife, das angepasst werden muss.

 

[Reykja]

Guten Morgen
es gibt vermutlich eine schönere Art die Werte am Ende des Arrays einzufügen aber so hätte Ich es jetzt:

for (int j = 0; j < currentArr.length; j++) {
    arr[length-1-j] = currentArr[currentArr.length-1-j];

 

[kneitzel]

Ja, das ist natürlich auch eine Art, das zu machen. Das ist vollkommen richtig und ok.

Jetzt müsstest Du nur alles, was du erarbeitet hast, zusammen fügen. Ich meine du hast jetzt alles:
- Finden des längsten Arrays hattest Du schon und haben wir nicht weiter thematisiert.
- Die Schleife über die Zeilen hattest Du schon und die hatten wir nicht besprochen.
- Prüfung ob von rechts oder links (Gerade / Ungerade Check)
- Abhängig von der Prüfung dann eine der beiden Copy Schleifen.
- Neue Zeile in das zweidimensionale Array schreiben hattest Du auch schon.

 

[Reykja]

es hat geklappt! was für eine Erleichterung... vielen lieben Dank
LG

 

[kneitzel]

Super. Dann vielleicht noch eine alternative Möglichkeit, wie ich das evtl. gemacht hätte.

for (int index = 0; index < currentArr.length; index++) {
    arr[offset + index] = currentArr[index];

In der Prüfung selbst wird dann nur der Offset gesetzt. Das hattest Du in Deinem ersten Code eigentlich schon in der Variable result.
Offset ist also entweder 0 oder eben diese Differenz.

Aber Deine Lösung ist auch vollkommen ok und ebenfalls gut lesbar.

 

[Reykja]

Alles klar, verstehe.
LG