Zählwerk im Array

[DEvent]

Ich suche einen Algorithmus, der sich so beschreiben lässt:

Man startet mit Index=0 und erhöht die Zahl Nindex bis Max. Wenn die Zahl Nindex=Max ist, setzt man die Zahl Nindex=0 und erhöht die Zahl mit Nindex+1 um eins. Das wiederholt man solange, bis Nindex+1=Max erreicht hat. Wenn Nindex+1=Max erreicht hat, setzt man Nindex+1=0 und erhöht Nindex+2 um eins. Usw.

Ich habe bereits versucht mit einem Ansatz bei dem ich einen Zähler in eine andere Base konvertiere und dann den Integer in das Array einlese. Allerdings funktioniert es nur bis Max<11. Es würde mir schon helfen, wenn mir jemand den Namen des Algorithmus sagt. Ist es Kombinatorik? Vielleicht ist es ganz einfach und ich komme einfach nicht drauf. Ein Iterativer Ansatz würde mir besser passen. Danke vielmals.

Beispiel des Algorithmus:

Max = 3, Array Length = 2
[0, 0]
[1, 0]
[2, 0]
[0, 1]
[1, 1]
[2, 1]
[0, 2]
[1, 2]
[2, 2]

Max = 20, Array Length = 3
[0, 0, 0]
[1, 0, 0]
...
[19, 0, 0]
[0, 1, 0]
[1, 1, 0]
...
[19, 1, 0]
[0, 2, 0]
...
[19, 19, 0]
[0, 0, 1]
...
[19, 19, 19]

 

[ssoul26]

Überprüf auf Nindex mod max == 0 (beachte hier index 0 nicht ) bei true, springe einen index nach rechts und wiederhole es solange tiefe erreicht.

 

[All4Me]

Ich würde es mit ineinander geschahtelten for schleifen machen

int[][] array = new int[i*j*k][3];
int pos = 0;
for(i=0; i < max; i++){
   for(j=0; j < max; j++){
      for(k=0; k < max; k++){
         array[pos][0]=k;
         array[pos][1]=j;
         array[pos][2]=i;
         pos++;
      }
   }
}

 

[ssoul26]

Vielleicht klappts ja

      int xmax = 15;
      int ymax = 12;
      int x = 0;
      int y = 0;
      int[][] zahlen = new int[xmax][ymax];
      while (x < xmax) {
         while (y < ymax) {
            zahlen[x][y]++;
            y++;
         }
         x++;
         y = 0;
      }

 

[DEvent]

Ich meinte eigentlich, dass die Länge des Arrays frei wählbar ist. Für feste Längen kann man klar for-Schleifen verwenden. Ich will ja einen Algorithmus, der auch für Array Length = 20 funktioniert:

Max = 20, Array Length = 20
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
...
[19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
...
[19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19]

 

[ssoul26]

Ich meinte eigentlich, dass die Länge des Arrays frei wählbar ist. Für feste Längen kann man klar for-Schleifen verwenden. Ich will ja einen Algorithmus, der auch für Array Length = 20 funktioniert:

Max = 20, Array Length = 20
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
...
[19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
...
[19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19]

Guck mal meinen Post an, da ist es variabel!

 

[All4Me]

Dann probiers mal hiermit.

int max = 3;
int length = 2;
int[][] array = new int[max^length][length];
for(i=0;i<length;i++){
	int n=0;
	for(j=0; j<max^(lngth-i);j++){
		for(k=0;k<(max^length)/(max^(length-i));k++){
			array[n][i]=j%max;
			n++;
		}
	}
}