2D-Array mit Zahlenmuster füllen

[sashady]

Hallo Leute, ich habe bei einer Aufgabe folgendes Problem:

Ich soll ein 2D-Array mit einem Zahlenmuster füllen, bei dem die Zahl n (die Zahl, die die Größe des 2D-Arrays bestimmt und gleichzeitig die größte Ziffer ist) diagonal von rechts oben nach links unten laufen soll. Alle Einträge, die links und rechts von der Zahl n sind, werden von n absteigend initialisiert, also zB:

n = 5

1 2 3 4 5
2 3 4 5 4
3 4 5 4 3
4 5 4 3 2
5 4 3 2 1

Mein Problem ist nun, dass ich nicht weiß, wie ich die einzelnen Einträge links und rechts von n implementieren soll, dass sie eben dieses Muster ergeben.

Ich habe zuerst die Diagonale implementiert:

int column = 0;
        for (int row = n - 1; row >= 0; row--) {        //diagonale
            numberArray[row][column] = n;
            column++;
        }

/*
Ausgabe:

0  0  0  0  5
0  0  0  5  0
0  0  5  0  0
0  5  0  0  0
5  0  0  0  0

*/

Ich dachte mir, dass ich das Array in 3 Teile teile, also:

1. links von der Diagonale
2. Diagonale
3. rechts von der Diagonale

aber ich komme so auf keine ordentliche Lösung..
Kann mir jemand einen Denkanstoß geben, wie ich genau vorgehen soll?

 

[Meniskusschaden]

Ich dachte mir, dass ich das Array in 3 Teile teile, also:

1. links von der Diagonale
2. Diagonale
3. rechts von der Diagonale

aber ich komme so auf keine ordentliche Lösung..

Das kommt mir zu kompliziert vor. Eigentlich sind ja alle Zeilen nach demselben Schema strukturiert: Jede Zeile beginnt mit einem Startwert und dann wird spaltenweise ein Delta addiert, dessen Vorzeichen beim Erreichen des Maximums gewechselt wird. Das wäre eine relativ einfache Alternative.

 

[sashady]

Der Ansatz hört sich viel logischer an, danke!

 

[sashady]

Ich habe jetzt folgenden Code implementiert. Habt ihr noch "Verschönerungsvorschläge" oder passt der so?
Bin halt noch blutiger Anfänger

    //a
    private static int[][] genFilledArray(int n) {
        int[][] numberArray = new int[n][n];
        for (int row = 0; row < n; row++) {
            int num = 1;
            for (int column = 0; column < n; column++) {
                if (row + column + num > n) {
                    numberArray[row][column] = n - num;
                    num++;
                } else {
                    numberArray[row][column] = row + column + num;
                }
            }
        }
        return numberArray;
    }

 

[berndoa]

Hallo Leute, ich habe bei einer Aufgabe folgendes Problem:

Ich soll ein 2D-Array mit einem Zahlenmuster füllen, bei dem die Zahl n (die Zahl, die die Größe des 2D-Arrays bestimmt und gleichzeitig die größte Ziffer ist) diagonal von rechts oben nach links unten laufen soll. Alle Einträge, die links und rechts von der Zahl n sind, werden von n absteigend initialisiert, also zB:

n = 5

1 2 3 4 5
2 3 4 5 4
3 4 5 4 3
4 5 4 3 2
5 4 3 2 1

Mein Problem ist nun, dass ich nicht weiß, wie ich die einzelnen Einträge links und rechts von n implementieren soll, dass sie eben dieses Muster ergeben.

Ich habe zuerst die Diagonale implementiert:

int column = 0;
        for (int row = n - 1; row >= 0; row--) {        //diagonale
            numberArray[row][column] = n;
            column++;
        }

/*
Ausgabe:

0  0  0  0  5
0  0  0  5  0
0  0  5  0  0
0  5  0  0  0
5  0  0  0  0

*/

Ich dachte mir, dass ich das Array in 3 Teile teile, also:

1. links von der Diagonale
2. Diagonale
3. rechts von der Diagonale

aber ich komme so auf keine ordentliche Lösung..
Kann mir jemand einen Denkanstoß geben, wie ich genau vorgehen soll?

Du solltest dir mal ganz shclicht überlegen:
Gegeben der Zeilenindex i, der ja von 0 bis n-1 gehen kann.
An welcher Spaltenstelle j ist dann (in dieser zeile) die zahl n untegerbacht, also wo befindet sich bspw. die 5, wenn due die zeile mit i=1 betrachtest (was im bild der 2. zeile entspricht)?

wenn du diesen index j* des größten elements in jener zeile hast,
wenn du bspw. 1 nach links oder rechts gehst, also sich der index um 1 vergrößert oder verkleinert, welches element hast du dann an jener stelle, in bezug auf n gesehen?

an deiner stelle würde ich da an dreisatz denken a la
j* n
j*-1 n-1
j*-2 n-2

und natürlich nicht die andere seite zu vergessen
j*+1 n-1
j*+2 n-2


einen indexoutofbounds error zu vermeiden dürfte da wohl der schwierigste part dran sein



Edit: Auch noch ne dumme Idee:
wenn bspw. die zahl n=5 gegeben ist, baut man sich erst die "vollständige" reihe
1 2 3 4 5 4 3 2 1, idealerweise als array,
und betrachtet dann gewissermassen nur teilarrays davon.
also anfangs von j=0 bis 4
nächste zeile die werte von j=1 bis 5
usw
mit jeder weiteren zeile im ergebnis array geht man bzgl linker und rechter grenze einfach eins nach rechts
Nur so ein gedanke.

Man hat also das "volle bild" und liest je nach zeilenindex nur einen bestimmten bereich davon ab
muss man dann nicht ganz so arg mit indexumrechnungen arbeiten sondern hat schön sowas wie untere grenze von 0 bis n-1
obere grenze von n-1 bis 2n-2

oder so