2d Tableau dans l'ordre en spirale

Question

J'essaye de remplir un tableau dans l'ordre en spirale. Jusqu'à présent, je peux imprimer le tableau dans l'ordre de la spirale, mais y a-t-il un moyen de modifier le tableau pour que je puisse le remplir dans l'ordre de la spirale, puis imprimer le tableau? J'aimerais que ça se passe dans l'ordre décroissant comme un compte à rebours. S'il vous plaît aider!

public class Spiral { 
    public static void main(int m, int n) { 

    // create m by n array of integers 1 through m*n 
    int[][] values = new int[m][n]; 
    for (int i = 0; i < m; i++) 
     for (int j = 0; j < n; j++) 
      values[i][j] = 1 + (m*n)*i + j; 

    // spiral 
    for (int i = (m*n)-1, j = 0; i > 0; i--, j++) { 
      for (int k = j; k < i; k++) System.out.println(values[j][k]); 
      for (int k = j; k < i; k++) System.out.println(values[k][i]); 
      for (int k = i; k > j; k--) System.out.println(values[i][k]); 
      for (int k = i; k > j; k--) System.out.println(values[k][j]); 
    } 
    } 
} 

Answer 1

Si vous avez trouvé le code pour faire le lit (pour l'impression), alors sûrement vous pouvez simplement modifier que pour faire à la place des écritures, en utilisant la même logique?

Si vous voulez que chaque cellule de la matrice pour contenir son « numéro séquentiel », compte à rebours, quelque chose comme ça devrait fonctionner, en supposant que votre logique d'accès est correct:

for (int i = (m*n)-1, j = 0, index = m * n; i > 0; i--, j++) { 
     for (int k = j; k < i; k++) values[j][j] = index--; 
     for (int k = j; k < i; k++) values[k][i] = index--; 
     for (int k = i; k > j; k--) values[i][k] = index--; 
     for (int k = i; k > j; k--) values[k][j] = index--; 
} 

Answer 2

Pas le plus efficace, mais ça devrait marcher: g est le tableau. J'utilise aussi des exceptions pour contrôler la logique.

public static void spiralFill() 
{ 
    x = (g.length-1)/2; 
    y = (g[0].length-1)/2; 

    try 
    { 
     while(true) 
     { 
      east(); 
      south(); 
      step++; 
      west(); 
      north(); 
      step++;   
     } 
    } 
    catch(ArrayIndexOutOfBoundsException e) 
    { 

    } 
} 

public static void east() 
{ 
for(int i = 0; i < step; i++) 
{ 
     g[x][y] = count; 
     count++; 
    x++; 
    } 
} 
public static void south() 
{ 
    for(int i = 0; i < step; i++) 
    { 
     g[x][y] = count; 
     count++; 
     y--; 
    } 
} 
public static void west() 
{ 
    for(int i = 0; i < step; i++) 
    { 
     g[x][y] = count; 
     count++; 
     x--; 
    } 
} 
public static void north() 
{ 
    for(int i = 0; i < step; i++) 
    { 
     g[x][y] = count; 
     count++; 
     y++; 
    } 
} 

Answer 3

Voici quelques-unes des variations:

public class SpiralMatrix { 

    private static int[][] createSpiralMatrix(int size) { 
     int[][] matrix = new int[size][size]; 

     int row = 0, col = -1; 
     int value = 1; 

     boolean horizontal = true; 
     boolean increasing = true; 
     boolean finish = false; 

     while(!finish) { 

      finish = true; 
      if (horizontal && increasing) { 
       while(tryAndSet(matrix, row, col + 1, value)) { 
        finish = false; 
        col++; 
        value++; 
       } 
      } else if (horizontal && !increasing) { 
       while(tryAndSet(matrix, row, col - 1, value)) { 
        finish = false; 
        col--; 
        value++; 
       } 
      } else if (!horizontal && increasing) { 
       while(tryAndSet(matrix, row + 1, col, value)) { 
        finish = false; 
        row++; 
        value++; 
       } 
      } else { 
       while(tryAndSet(matrix, row - 1, col, value)) { 
        finish = false; 
        row--; 
        value++; 
       } 
      } 

      if (!horizontal) { 
       increasing = !increasing; 
      } 
      horizontal = !horizontal; 
     } 

     return matrix; 
    } 


    private static boolean tryAndSet(int[][] matrix, int row, int col, int value) { 
     if (row < 0 || col < 0 || row >= matrix.length || col >= matrix[row].length || matrix[row][col] != 0) { 
      return false; 
     } 
     matrix[row][col] = value; 
     return true; 
    } 

    private static void printMatrix(int[][] matrix) { 
     for (int i = 0; i < matrix.length; i++) { 
      for(int j = 0; j < matrix[i].length; j++) { 
       System.out.print("\t" + matrix[i][j]); 
      } 
      System.out.println(); 
     } 
    } 


    public static void main(String[] args) { 
     try { 
      int[][] spiralMatrix = createSpiralMatrix(40); 
      printMatrix(spiralMatrix); 
     } catch (Throwable th) { 
      th.printStackTrace(); 
     } 
    } 

Answer 4

int maxValue = target.length * target[0].length; 

private int[][] generateMatrix(int[][] target, int level, int currentVal) { 
    // always start from lower left corner in each layer 
    int w = level; 
    int h = target.length - level - 1; 

    // fill the bottom line 
    int i = 0; 
    for (i = w; i < target[0].length - level && currentVal <= maxValue; i++) { 
     target[h][i] = currentVal++; 
    } 

    w = target[0].length - level - 1; 

    int j = 0; 
    // fill the right line 
    for (j = h - 1; j >= level && currentVal <= maxValue; j--) { 
     target[j][w] = currentVal++; 
    } 

    h = level; 

    // fill the above line 
    for (i = w - 1; i >= level && currentVal <= maxValue; i--) { 
     target[h][i] = currentVal++; 
    } 
    w = level; 

    // fill the left line 
    for (j = h + 1; j < target.length - level - 1 && currentVal <= maxValue; j++) { 
     target[j][w] = currentVal++; 
    } 

    if (currentVal > maxValue) 
     return target; 
    return generateMatrix(target, ++level, currentVal); 

} 

Answer 5

public ArrayList<Integer> spiralOrder(final List<ArrayList<Integer>> a) { 
    ArrayList<Integer> result = new ArrayList<Integer>(); 
     int m = a.get(0).size(); 
     int n = a.size(); 
     if(m>1 && n>1){ 
     int loopCounter = (n > m) ? m*2 : n *2 -1 ; 
     int opr=1; 
     int i=0,j=0; 
     int opA=m,opB=n,opC=0,opD=1; 
     for(int k=0;k < loopCounter ;k++){ 
       if(opr == 1){ 
       int counter =0; 
       while(counter < opA){ 
        System.out.print(a.get(i).get(j)+ ";"); 
        result.add(a.get(i).get(j)); 
        counter++; 

        if(j != opA-1){ 
         j++; 
        } 
        else{ 
         break; 
        } 
       } 
       opr =2; 
       continue; 
      } 
      if(opr == 2){ 
       i++; 
       int counter =1; 
       while(counter < opB){ 
        System.out.print(a.get(i).get(j)+ ";"); 
        result.add(a.get(i).get(j)); 
        counter++; 

        if(i != opB-1){ 
        i++; 
        } 
        else{ 
         break; 
        } 
       } 
       opr =3; 
       continue; 
      } 
      if(opr == 3){ 
       j--; 
       int counter =j; 
       while(counter >= opC){ 
        System.out.print(a.get(i).get(j)+ ";"); 
        result.add(a.get(i).get(j)); 
        counter --; 
        if(j != opC){ 
        j--; 
        } 
        else{ 
         break; 
        } 
        } 
       opr =4; 
       continue; 
      } 
      if(opr == 4){ 
       i--; 
       int counter = i; 
       while(counter >= opD){ 
        System.out.print(a.get(i).get(j)+ ";"); 
        result.add(a.get(i).get(j)); 
        counter --; 
        if(i != opD){ 
        i--; 
        }else{ 
         break; 
        } 
       } 
       opr =1; 
       j++; 
       opA = opA -1; 
       opB = opB -1; 
       opC= opC +1; 
       opD = opD+1; 
       continue; 
      } 
     } 

    } 

     else if(n ==1){ 
       for(int k=0;k < a.get(0).size();k++){ 
        result.add(a.get(0).get(k)); 
       } 
     } 

     else if(m==1 && n==1){ 
      result.add(a.get(0).get(0)); 
     } 

    // Populate result; 
    return result; 

}