C++ Matrix spiralfoermig fuellen

[Kaj G. (Firma: RUB) (bloody)]

Nabend Leute :)

In der Vorlesung Informatik 1 gabs folgende Hausaufgabe:

Ergänzen Sie das folgende C++-Programmfragment so, dass bei
Ausführung die Zahlen 1, 2, 3 ... n*n in das zweidimensionale
Array matrix[n][n] als Spirale im Uhrzeigersinn geschrieben
werden. Z.B. wollen wir für n=4 die folgende Ausgabe haben:
 1  2  3  4
12 13 14  5
11 16 15  6
10  9  8  7

Das Codefragemnt dazu:

#include <iostream>
using namespace std;

int main () {
    const unsigned int n = 5;
    unsigned int matrix[n][n];

    //*************************************
    // Hier beliebig viele Zeilen ergaenzen
    //*************************************

    for (unsigned int r = 0; r < n; ++r){
        for (unsigned int c = 0; c < n; ++c){
            if (matrix [r][c] < 10){
                cout << ' ';
            }
            cout << matrix[r][c] << ' ';
        }
        cout << endl;
    }

    return 0;
}

An dem bestehenden Codefragment (also den beiden for-Schleifen) soll 
natuerlich nichts geaendert werden.

Meine Loesung fuer diese Aufgabe sieht so aus:

#include <iostream>
using namespace std;

int main () {
    const unsigned int n = 5;
    unsigned int matrix[n][n];

    //*************************************
    // Hier beliebig viele Zeilen ergaenzen

    int counter = 1, x = 0, y = n - 1;

    while (counter <= (n * n)) {
        //  von links nach rechts
        for (int i = x; i <= y; i++) {
            matrix[x][i] = counter++;
        }

        //  von oben nach unten
        for (int i = x + 1; i <= y; i++) {
            matrix[i][y] = counter++;
        }

        //  von rechts wieder nach links
        for (int i = y - 1; i >= x; i--) {
            matrix[y][i] = counter++;
        }
        y--;

        //  von unten wieder nach oben
        for (int i = y; i > x; i--) {
            matrix[i][x] = counter++;
        }
        x++;
    }

    //*************************************

    for (unsigned int r = 0; r < n; ++r){
        for (unsigned int c = 0; c < n; ++c){
            if (matrix [r][c] < 10){
                cout << ' ';
            }
            cout << matrix[r][c] << ' ';
        }
        cout << endl;
    }

    return 0;
}

Meine Loesung (scheint) fuer beliebige n-Werte (solange n >= 1) zu 
funktionieren.

Meine Frage:
Wie haettet Ihr das gemacht? Kann man das so stehen lassen, oder habt 
Ihr noch ein paar Tipps wie man das haette besser machen koennen?

Freue mich ueber euren Input :)

Gruesse

[Flitzenpiep (Gast)]

Kaj G. schrieb:
> wie man das haette besser machen koennen?

Na ja, "besser", keine Ahnung. Ich habe es mal mit zwei Schleifen 
versucht; es geht sicher auch eleganter. Sollte aber funktionieren, 
denke ich.

int a = n;
int dir = 1;
int idx = 0;
int x = 0;
int y = -1;
do
{
  int *v = &y;
  for (int i = 0; i < 2 * a - 1; i++)
  {
    if (i == a) v = &x;
    *v += dir;
    matrix[x][y] = idx;
    idx++;
  };

  a--;
  dir *= -1;

} while (a > 0);

oder einfach

for (int i = 0; i < 2 * a - 1; i++)
{
  if (i < a)
    y += direction;
  else
    x += direction;
  ...

oder mit zwei separaten inneren Schleifen ("horizontal/vertikal").

> Wie haettet Ihr das gemacht?

Bei Prüfungen, Hausaufgaben & Co. so einfach wie noch gerade nicht 
peinlich und auch mit einem Kater problemlos erklärbar.

[Thomas (Gast)]

Mein Lesbarkeitsfavorit wäre es, die Grenzen des leeren Bereichs 
explizit mitzuführen:

  // aktuell zu fuellender zeilenbereich. inklusive
  int min_r = 0;
  int max_r = n-1;

  // aktuell zu fuellender spaltenbereich. inklusive
  int min_c = 0;
  int max_c = n-1;

  int cnt = 0;
  while (min_r <= max_r && min_c <= max_c)
  {
    //oberste reihe r = min_r
    for (int c = min_c; c <= max_c; ++c)
      matrix[min_r][c] = cnt++;
    ++min_r; // obere reihe fertig, ausschliessen
    
    //rechte spalte c = max_c
    for (int r = min_r; r <= max_r; ++r )
      matrix[r][max_c] = cnt++;
    --max_c; // rechte spalte fertig, ausschliessen

    //unterste reihe r = max_r
    for (int c = max_c; c >= min_c; --c)
      matrix[max_r][c] = cnt++;
    --max_r; // obere reihe fertig, ausschliessen

    //linke spalte c = min_c
    for (int r = max_r; r >= min_r; --r )
      matrix[r][min_c] = cnt++;
    ++min_c; // linke spalte fertig, ausschliessen
  }

Das hat die nette Nebenwirkung, dass es auch mit rechteckigen Matrizen 
funktioniert.