Die Array Schnecke =)

[ocsme]

Guten Tag zusammen,

ich möchte sehr gerne eine Schleife Programmieren womit ich durch ein Array wie ein Schnecken Muster laufe.
Das ganze sieht dann so aus:

1 2 3
8 9 4
7 6 5

Es soll für Ungerade nxm Längen funktionieren. Bei 3x3 läuft es bei mir danach nicht mehr also 5x5 geht nicht mehr!

Also zuerst wandert man nach rechts, dann nach unten. Ist man unten angekommen geht man wieder zurück und dann nach oben so weit es geht. Dann wiederholt man das ganze.

Da ich oft die MACKE habe alles in einer Schleife zu versuchen dachte ich könnte man das hier auch hin bekommen doch leider klappt es nicht ganz

Hier mein Programm:

public class Schnecke {
    public static void main(String[] args) {
       
        int n=3;
        int m=3;
        int[][] quad=new int[n][m];
        int zeile=0;
        int spalte=0;
       
        for(int i=1;i<=n*m;i++) {
            quad[zeile][spalte]=i;
//            System.out.print("Zeile "+zeile+" Spalte "+spalte+" ");

            if(spalte<n-1 && quad[zeile][spalte+1]==0) {
                spalte++;
                quad[zeile][spalte]=i;
            }
           
            else if(zeile<m-1 && quad[zeile+1][spalte]==0) {
                zeile++;
                quad[zeile][spalte]=i;
            }
           
            else if(spalte>0 && quad[zeile][spalte-1]==0) {
                spalte--;
                quad[zeile][spalte]=i;
            }
           
            else if(zeile>0 && quad[zeile-1][spalte]==0) {
                zeile--;
                quad[zeile][spalte]=i;
            }
           
        }
       
        for(int i=0;i<quad.length;i++) {
            for(int j=0;j<quad[i].length;j++)
                System.out.print(quad[i][j]+" ");
            System.out.println("");
        }
       
    }

}

Natürlich würde es Funktionieren wenn ich aus jedem If ein while machen würde und dann mit 5 Schleifen arbeiten würde Doch das wollte ich eigentlich nicht.
Weiß da jemand eine Idee?

LG

 

[Meniskusschaden]

Weiß da jemand eine Idee?

Im Moment versucht dein Algorithmus, nach rechts zu gehen, wenn die Zelle dort frei ist. Du müsstest aber geradeaus gehen, bis es nicht mehr weiter geht und erst dann die Richtung ändern.

 

[DrZoidberg]

Man könnte das so machen:

public class Schnecke {
 
  static void print(int[][] a) {
    for(int i = 0; i < a.length; i++) {
      for(int j = 0; j < a[i].length; j++) {
        System.out.print(a[i][j]/10);
        System.out.print(a[i][j]%10);
        System.out.print(" ");
      }
      System.out.println();
    }
    System.out.println();
  } 
 
  static void fill(int[][] a, int startN, int startX, int startY, int dx, int dy, int sizeForward, int sizeSide) {
    while(sizeForward >= 1) {
      for(int n = startN, x = startX, y = startY; n < startN + sizeForward; n++, x += dx, y += dy) {
        a[y][x] = n;
      }
      startN += sizeForward;
      startX += dx * (sizeForward - 1) - dy;
      startY += dy * (sizeForward - 1) + dx;
      int t = dy; dy = dx; dx = -t;
      t = sizeForward; sizeForward = sizeSide - 1; sizeSide = t;
    }
  }
 
  public static void main(String[] args) {
    int[][] a = new int[5][5];
    fill(a, 1, 0, 0, 1, 0, a[0].length, a.length);
    print(a);
  }
}

 

[ocsme]

Danke für die Antwort doch ich verstehe nicht was du da machst sry! Ist mir zu Komplex!
Dann versuch ich es mit meiner Ausführung weiterhin oder nehme die 5 Schleifen

LG

 

[ocsme]

So läuft es ja zwar doch wie gesagt habe 5 Schleifen und es Funktionieren nur die Fälle 3x3, 5x5 also n=m nicht aber wie bei DrZoidberg 2x7 etc.

public class Schnecke {
    public static void main(String[] args) {
       
        int n=7;
        int m=7;
        int[][] quad=new int[n][m];
        int zeile=0;
        int spalte=0;
        int i=1;
        while(i<m*n) {
            quad[zeile][spalte]=i;
//            System.out.print("Zeile "+zeile+" Spalte "+spalte+" ");

            while(spalte<n-1 && quad[zeile][spalte+1]==0) {
                spalte++;
                i++;
                quad[zeile][spalte]=i;
            }
           
            while(zeile<m-1 && quad[zeile+1][spalte]==0) {
                zeile++;
                i++;
                quad[zeile][spalte]=i;
            }
           
            while(spalte>0 && quad[zeile][spalte-1]==0) {
                spalte--;
                i++;
                quad[zeile][spalte]=i;
            }
           
            while(zeile>0 && quad[zeile-1][spalte]==0) {
                zeile--;
                i++;
                quad[zeile][spalte]=i;
            }
       
        }
       
       
        for(int k=0;k<quad.length;k++) {
            for(int j=0;j<quad[k].length;j++) {
                System.out.print(quad[k][j]/10);
                System.out.print(quad[k][j]%10);
                System.out.print(" ");
            }
            System.out.println("");
        }
       
    }

}

 

[Xyz1]

Habe mich an der Quadratur des Kreises versucht und das Problem ist, das klappt nicht

public static void main(String[] args) {
    int b = 6;
    int c = b * b;
    int[][] a = new int[b][b];
    float d = 90;
    for (int i = 0; i < c; i++) {
        int r = (int) Math.ceil(Math.log(i + 5) / Math.log(2)) - 2;
        float e = (d - 11.25f * (r * r)) % 360;
        System.out.println("d e " + d + " " + e);
        int[] f = cp(r, e);
        a[f[0]][f[1]] = i;
        for (int[] is : a) {
            System.out.println(Arrays.toString(is));
        }
        d += (360f / (r * 4));
    }
}

static int[] cp(int r, float a) {
    return new int[]{ (int) (r * Math.cos(Math.toRadians(a)) + 3),
                      (int) (r * Math.sin(Math.toRadians(a)) + 3)  };
}

Das ist der letzte halbwegs brauchbare Versuch.
Und r müsste richtig sein.

Vielleicht weiß jemand, was falsch wäre.