Imprimer un tableau à deux dimensions en ordre spiralé

Comment imprimer un tableau bidimensionnel 5 × 5 en ordre spiralé?

Existe-t-il une formule permettant d’imprimer un tableau de taille quelconque en ordre spiralé?

L’idée est de traiter la masortingce comme une série de couches, de couches en haut à droite et de couches en bas à gauche. Pour imprimer la masortingce en spirale, nous pouvons décoller les couches de ces masortingces, imprimer la partie décollée et appeler récursivement l’impression sur la partie restante. La récursivité se termine lorsque nous n’avons plus de couches à imprimer.

Masortingce d’entrée:

1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 1 

Après avoir épluché la couche supérieure droite:

  1 2 3 4 8 5 6 7 2 9 0 1 6 3 4 5 1 7 8 9 

Après avoir décollé la couche inférieure gauche de la sous-masortingce:

  6 7 5 0 1 9 4 5 3 7 8 9 

Après avoir décollé la couche supérieure droite de la sous-masortingce:

  6 7 1 0 5 4 

Après avoir décollé la couche inférieure gauche de la sous-masortingce:

  0 4 

La récursivité se termine.


Fonctions C:

 // function to print the top-right peel of the masortingx and // recursively call the print bottom-left on the submasortingx. void printTopRight(int a[][COL], int x1, int y1, int x2, int y2) { int i = 0, j = 0; // print values in the row. for(i = x1; i<=x2; i++) { printf("%d ", a[y1][i]); } // print values in the column. for(j = y1 + 1; j <= y2; j++) { printf("%d ", a[j][x2]); } // see if more layers need to be printed. if(x2-x1 > 0) { // if yes recursively call the function to // print the bottom left of the sub masortingx. printBottomLeft(a, x1, y1 + 1, x2-1, y2); } } // function to print the bottom-left peel of the masortingx and // recursively call the print top-right on the submasortingx. void printBottomLeft(int a[][COL], int x1, int y1, int x2, int y2) { int i = 0, j = 0; // print the values in the row in reverse order. for(i = x2; i>=x1; i--) { printf("%d ", a[y2][i]); } // print the values in the col in reverse order. for(j = y2 - 1; j >= y1; j--) { printf("%d ", a[j][x1]); } // see if more layers need to be printed. if(x2-x1 > 0) { // if yes recursively call the function to // print the top right of the sub masortingx. printTopRight(a, x1+1, y1, x2, y2-1); } } void printSpiral(int arr[][COL]) { printTopRight(arr,0,0,COL-1,ROW-1); printf("\n"); } 

Lien Ideone

  1. Pop top row
  2. Transposer et retourner à l’envers (même rotation de 90 degrés dans le sens inverse des aiguilles d’une montre)
  3. Aller à 1

Code Python:

 import itertools arr = [[1,2,3,4], [12,13,14,5], [11,16,15,6], [10,9,8,7]] def transpose_and_yield_top(arr): while arr: yield arr[0] arr = list(reversed(zip(*arr[1:]))) print list(itertools.chain(*transpose_and_yield_top(arr))) 

Je vois que personne n’a utilisé qu’un seul for loop et sans récursivité dans le code, et je veux donc consortingbuer.

L’idée est comme ceci:

Imaginez une tortue se trouvant au point (0,0), c’est-à-dire le coin supérieur gauche, face à l’est (vers la droite)

Il continuera d’avancer et chaque fois qu’il verra un signe, la tortue tournera à droite

Donc, si nous plaçons la tortue au point (0,0) face à la droite, et si nous plaçons les signes aux endroits appropriés, la tortue traversera le tableau en spirale.

Maintenant, le problème est: “Où placer les signes?”

Voyons où placer les signes (marqués par # et les nombres par O):

 Pour une grid qui ressemble à ceci:
 OOOO
 OOOO
 OOOO
 OOOO

 Nous mettons les signes comme ceci:
 OOO #
 # O # O
 O # # O
 # OO #

 Pour une grid qui ressemble à ceci:
 OOO
 OOO
 OOO
 OOO

 Nous mettons les signes comme ceci:
 OO #
 # # O
 O # O
 # O #

 Et pour une grid qui ressemble à ceci:
 OOOOOOO
 OOOOOOO
 OOOOOOO
 OOOOOOO
 OOOOOOO

 Nous mettons les signes comme ceci:
 OOOOOO #
 # OOOO # O
 O # OO # OO
 O # OOO # O
 # OOOOO #

Nous pouvons voir que, sauf si le point est en haut à gauche, les signes sont des endroits situés à des endroits où les distances par rapport à la bordure horizontale la plus proche et à la bordure verticale la plus proche sont les mêmes . la bordure supérieure est une de plus que la distance par rapport à la bordure gauche , la priorité étant donnée à la partie supérieure droite si le point est centré horizontalement et à la partie supérieure gauche si le point est centré verticalement.

Cela peut être réalisé facilement dans une fonction simple, en prenant le minimum de ( curRow et height-1-curRow ), puis le minimum de ( curCol et width-1-curCol ) et comparez si elles sont identiques. Mais nous devons tenir compte de la casse supérieure gauche, c’est-à-dire lorsque le minimum est curRow et curCol eux-mêmes. Dans ce cas nous réduisons la distance verticale en conséquence.

Voici le code C:

 #include  int shouldTurn(int row, int col, int height, int width){ int same = 1; if(row > height-1-row) row = height-1-row, same = 0; // Give precedence to top-left over bottom-left if(col >= width-1-col) col = width-1-col, same = 0; // Give precedence to top-right over top-left row -= same; // When the row and col doesn't change, this will reduce row by 1 if(row==col) return 1; return 0; } int directions[4][2] = {{0,1},{1,0},{0,-1},{-1,0}}; void printSpiral(int arr[4][4], int height, int width){ int directionIdx=0, i=0; int curRow=0, curCol=0; for(i=0; i 

Quelles sorties:

 1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10
 1 2 3 4 8 12 11 10 9 5 6 7

Voici les trois façons intéressantes

  1. La lecture en spirale peut être traitée comme un serpent se déplaçant vers la limite et allumant la limite ou elle-même (je la trouve élégante et la plus efficace étant une boucle unique de N itérations)

     ar = [ [ 0, 1, 2, 3, 4], [15, 16, 17, 18, 5], [14, 23, 24, 19, 6], [13, 22, 21, 20, 7], [12, 11, 10, 9, 8]] def print_spiral(ar): """ assuming a rect array """ rows, cols = len(ar), len(ar[0]) r, c = 0, -1 # start here nextturn = stepsx = cols # move so many steps stepsy = rows-1 inc_c, inc_r = 1, 0 # at each step move this much turns = 0 # how many times our snake had turned for i in range(rows*cols): c += inc_c r += inc_r print ar[r][c], if i == nextturn-1: turns += 1 # at each turn reduce how many steps we go next if turns%2==0: nextturn += stepsx stepsy -= 1 else: nextturn += stepsy stepsx -= 1 # change directions inc_c, inc_r = -inc_r, inc_c print_spiral(ar) 

sortie:

 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 
  1. Une approche récursive consisterait à imprimer la couche externe et à appeler la même fonction pour le rectangle interne, par exemple

     def print_spiral(ar, sr=0, sc=0, er=None, ec=None): er = er or len(ar)-1 ec = ec or len(ar[0])-1 if sr > er or sc > ec: print return # print the outer layer top, bottom, left, right = [], [], [], [] for c in range(sc,ec+1): top.append(ar[sr][c]) if sr != er: bottom.append(ar[er][ec-(c-sc)]) for r in range(sr+1,er): right.append(ar[r][ec]) if ec != sc: left.append(ar[er-(r-sr)][sc]) print " ".join([str(a) for a in top + right + bottom + left]), # peel next layer of onion print_spiral(ar, sr+1, sc+1, er-1, ec-1) 

Enfin, voici un petit extrait pour le faire, pas efficace mais amusant :), fondamentalement, il imprime la première ligne et fait pivoter le rectangle entier dans le sens inverse des aiguilles d’une montre et se répète

 def print_spiral(ar): if not ar: return print " ".join(str(a) for a in ar[0]), ar = zip(*[ reversed(row) for row in ar[1:]]) print_spiral(ar) 

Ce programme fonctionne pour n’importe quelle masortingce n * n.

 public class circ { public void get_circ_arr (int n,int [][] a) { int z=n; { for (int i=0;i=i;l--) { int k=i; System.out.printf("%d",a[k][l]); } for (int j=i+1;j<=z-1-i;j++) { int k=i; { System.out.printf("%d",a[j][k]); } } for (int j=i+1;j<=zi-1;j++) { int k=z-1-i; { System.out.printf("%d",a[k][j]); } } for (int j=z-2-i;j>=i+1;j--) { int k=zi-1; { System.out.printf("%d",a[j][k]); } } } } } } 

J’espère que cela aide

J’étais obsédé par ce problème quand j’apprenais Ruby. C’était le meilleur que je pouvais faire:

 def spiral(masortingx) masortingx.empty? ? [] : masortingx.shift + spiral(masortingx.transpose.reverse) end 

Vous pouvez vérifier certaines de mes autres solutions en passant en revue les révisions de cet aperçu . De plus, si vous suivez le lien vers lequel je vous ai parlé, vous trouverez d’autres solutions intelligentes. Problème vraiment intéressant qui peut être résolu de plusieurs manières élégantes – en particulier dans Ruby.

Solution JavaScript:

 var printSpiral = function (masortingx) { var i; var top = 0; var left = 0; var bottom = masortingx.length; var right = masortingx[0].length; while (top < bottom && left < right) { //print top for (i = left; i < right; i += 1) { console.log(matrix[top][i]); } top++; //print right column for (i = top; i < bottom; i += 1) { console.log(matrix[i][right - 1]); } right--; if (top < bottom) { //print bottom for (i = right - 1; i >= left; i -= 1) { console.log(masortingx[bottom - 1][i]); } bottom--; } if (left < right) { //print left column for (i = bottom - 1; i >= top; i -= 1) { console.log(masortingx[i][left]); } left++; } } }; 

Une solution implique des directions à droite, à gauche, en haut, en bas et leurs limites correspondantes (indices). Une fois que la première ligne est imprimée et que la direction change (de droite) vers le bas, la ligne est supprimée en incrémentant la limite supérieure. Une fois que la dernière colonne est imprimée et que la direction change à gauche, la colonne est supprimée en décrémentant la limite de droite … Les détails peuvent être vus dans le code C explicite.

 #include  #define N_ROWS 5 #define N_COLS 3 void print_spiral(int a[N_ROWS][N_COLS]) { enum {up, down, left, right} direction = right; int up_limit = 0, down_limit = N_ROWS - 1, left_limit = 0, right_limit = N_COLS - 1, downcount = N_ROWS * N_COLS, row = 0, col = 0; while(printf("%d ", a[row][col]) && --downcount) if(direction == right) { if(++col > right_limit) { --col; direction = down; ++up_limit; ++row; } } else if(direction == down) { if(++row > down_limit) { --row; direction = left; --right_limit; --col; } } else if(direction == left) { if(--col < left_limit) { ++col; direction = up; --down_limit; --row; } } else /* direction == up */ if(--row < up_limit) { ++row; direction = right; ++left_limit; ++col; } } void main() { int a[N_ROWS][N_COLS] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; print_spiral(a); } 

Lien pour le test et le téléchargement

.

Étant donné une masortingce de caractères, implémentez une méthode qui imprime tous les caractères dans l’ordre suivant: d’abord le cercle extérieur, puis le suivant, etc.

 public static void printMasortingxInSpiral(int[][] mat){ if(mat.length == 0|| mat[0].length == 0){ /* empty masortingx */ return; } SsortingngBuffer str = new SsortingngBuffer(); int counter = mat.length * mat[0].length; int startRow = 0; int endRow = mat.length-1; int startCol = 0; int endCol = mat[0].length-1; boolean moveCol = true; boolean leftToRight = true; boolean upDown = true; while(counter>0){ if(moveCol){ if(leftToRight){ /* printing entire row left to right */ for(int i = startCol; i <= endCol ; i++){ str.append(mat[startRow][i]); counter--; } leftToRight = false; moveCol = false; startRow++; } else{ /* printing entire row right to left */ for(int i = endCol ; i >= startCol ; i--){ str.append(mat[endRow][i]); counter--; } leftToRight = true; moveCol = false; endRow--; } } else { if(upDown){ /* printing column up down */ for(int i = startRow ; i <= endRow ; i++){ str.append(mat[i][endCol]); counter--; } upDown = false; moveCol = true; endCol--; } else { /* printing entire col down up */ for(int i = endRow ; i >= startRow ; i--){ str.append(mat[i][startCol]); counter--; } upDown = true; moveCol = true; startCol++; } } } System.out.println(str.toSsortingng()); } 

La masortingce N * N à deux dimensions est une masortingce carrée

Idée:

Nous devons parcourir quatre directions différentes pour traverser comme une spirale. Nous devons traverser la masortingce une fois qu’une couche de spirale est terminée. Donc, au total, nous avons besoin de 5 boucles, 4 boucles à parcourir en spirale et 1 boucle à traverser les couches.

 public void printSpiralForm(int[][] a, int length) { for( int i = 0 , j = length-1 ; i < j ; i++ , j-- ) { for( int k = i ; k < j ; k++ ) { System.out.print( a[i][k] + " " ) ; } for( int k = i ; k < j ; k++ ) { System.out.print(a[k][j] + " "); } for( int k = j ; k > i ; k-- ) { System.out.print(a[j][k] + " ") ; } for( int k = j ; k > i ; k-- ) { System.out.print( a[k][i] + " " ) ; } } if ( length % 2 == 1 ) { System.out.println( a[ length/2 ][ length/2 ] ) ; } } 

Ceci est ma mise en œuvre:

 public static void printMasortingx(int masortingx[][], int M, int N){ int level = 0; int min = (M < N) ? M:N; System.out.println(); while(level <= min/2){ for(int j = level; j < N - level - 1; j++){ System.out.print(matrix[level][j] + "\t"); } for(int i = level; i < M - level - 1; i++) { System.out.print(matrix[i][N - level - 1] + "\t"); } for(int j = N - level - 1; j > level; j--){ System.out.print(masortingx[M - level - 1][j] + "\t"); } for(int i = M - level - 1; i > level; i-- ){ System.out.print(masortingx[i][level] + "\t"); } level++; } } 

int N = Integer.parseInt (args [0]);

  // create N-by-N array of integers 1 through N int[][] a = new int[N][N]; for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) a[i][j] = 1 + N*i + j; // spiral for (int i = N-1, j = 0; i > 0; i--, j++) { for (int k = j; k < i; k++) System.out.println(a[j][k]); for (int k = j; k < i; k++) System.out.println(a[k][i]); for (int k = i; k > j; k--) System.out.println(a[i][k]); for (int k = i; k > j; k--) System.out.println(a[k][j]); } // special case for middle element if N is odd if (N % 2 == 1) System.out.println(a[(N-1)/2][(N-1)/2]); } 

}

Restez simple ->

 public class spiralMasortingx { public static void printMasortingx(int[][] masortingx, int rows, int col) { int rowStart=0; int rowEnd=rows-1; int colStart=0; int colEnd=col-1; while(colStart<=colEnd && rowStart<=rowEnd) { for(int i=colStart;icolStart;i--) System.out.println(masortingx[rowEnd][i]); for(int i=rowEnd;i>rowStart;i--) System.out.println(masortingx[i][colStart]); rowStart++; colEnd--; rowEnd--; colStart++; } } public static void main(Ssortingng[] args){ int[][] array={{1,2,3,4},{5,6,7,8}}; printMasortingx(array,2,4); } 

}

Slash Top Row -> Transposer -> Retourner -> Répéter.

 void slashTransposeFlip(int[][] m){ if( m.length * m[0].length == 1){ //only one element left System.out.print(m[0][0]); }else{ //print the top row for(int a:m[0]){System.out.print(a+" ");} //slash the top row from the masortingx. int[][] n = Arrays.copyOfRange(m,1,m.length); int[][] temp = n; int rows = temp.length; int columns = temp[0].length; //invert rows and columns and create new array n = new int[columns][rows]; //transpose for(int x=0;x 

Complexité: traversée unique O(n)

S’il vous plaît laissez-moi append ma réponse en boucle unique avec la complexité O(n) . J’ai observé que lors de la traversée gauche-droite et droite-gauche de la masortingce, il y a respectivement une augmentation et une diminution d’un indice dans l’index de rangée. De même, pour le déplacement en haut et en bas, il y a augmentation et diminution par n_cols . J’ai donc fait un algorithme pour cela. Par exemple, pour une masortingce (3×5) avec des entrées, l’index des lignes majeures 1,2,3,4,5,10,15,14,13,12,11,6,7,8,9 : 1,2,3,4,5,10,15,14,13,12,11,6,7,8,9 .

  ------->(+1) ^ 1 2 3 4 5 | (+n_cols) | 6 7 8 9 10 | (-n_cols) | 11 12 13 14 15 (-1)<------- 

Solution de code:

 #include  using namespace std; int main() { // your code goes here bool leftToRight=true, topToBottom=false, rightToLeft=false, bottomToTop=false; int idx=0; int n_rows = 3; int n_cols = 5; int cnt_h = n_cols, cnt_v = n_rows, cnt=0; int iter=1; for (int i=0; i <= n_rows*n_cols + (n_rows - 1)*(n_cols - 1)/2; i++){ iter++; if(leftToRight){ if(cnt >= cnt_h){ cnt_h--; cnt=0; leftToRight = false; topToBottom = true; //cout << "Iter: "<< iter << " break_leftToRight"<= cnt_v-1){ cnt_v--; cnt=0; leftToRight = false; topToBottom = false; rightToLeft=true; //cout << "Iter: "<< iter << " break_topToBottom"<= cnt_h){ cnt_h--; cnt=0; leftToRight = false; topToBottom = false; rightToLeft=false; bottomToTop=true; //cout << "Iter: "<< iter << " break_rightToLeft"<= cnt_v-1){ cnt_v--; cnt=0; leftToRight = true; topToBottom = false; rightToLeft=false; bottomToTop=false; //cout << "Iter: "<< iter << " break_bottomToTop"< 

Pour imprimer une masortingce 2D, considérez la masortingce comme une composition de rectangles et / ou de lignes où un rectangle plus petit est inséré dans un plus grand, prenez la limite de la masortingce qui forme un rectangle à imprimer, en commençant par l’élément ; Une fois cela fait, passez à la prochaine couche de plus petit rectangle, au cas où je n’aurais pas de rectangle, il devrait être imprimé, horizontal ou vertical. J’ai collé le code avec un exemple de masortingce, HTH.

 #include  int a[2][4] = { 1, 2 ,3, 44, 8, 9 ,4, 55 }; void print(int, int, int, int); int main() { int row1, col1, row2, col2; row1=0; col1=0; row2=1; col2=3; while(row2>=row1 && col2>=col1) { print(row1, col1, row2, col2); row1++; col1++; row2--; col2--; } return 0; } void print(int row1, int col1, int row2, int col2) { int i=row1; int j=col1; /* This is when single horizontal line needs to be printed */ if( row1==row2 && col1!=col2) { for(j=col1; j<=col2; j++) printf("%d ", a[i][j]); return; } /* This is when single vertical line needs to be printed */ if( col1==col2 && row1!=row2) { for(i=row1; j<=row2; i++) printf("%d ", a[i][j]); return; } /* This is reached when there is a rectangle to be printed */ for(j=col1; j<=col2; j++) printf("%d ", a[i][j]); for(j=col2,i=row1+1; i<=row2; i++) printf("%d ", a[i][j]); for(i=row2,j=col2-1; j>=col1; j--) printf("%d ", a[i][j]); for(j=col1,i=row2-1; i>row1; i--) printf("%d ", a[i][j]); } 

Voici mon implémentation en Java:

 public class SpiralPrint { static void spiral(int a[][],int x,int y){ //If the x and y co-ordinate collide, break off from the function if(x==y) return; int i; //Top-left to top-right for(i=x;i=x;i--) System.out.println(a[y-1][i]); //Bottom left to top-left for(i=y-2;i>x;i--) System.out.println(a[i][x]); //Recursively call spiral spiral(a,x+1,y-1); } public static void main(Ssortingng[] args) { int a[][]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}; spiral(a,0,4); /*Might be implemented without the 0 on an afterthought, all arrays will start at 0 anyways. The second parameter will be the dimension of the array*/ } } 
 //shivi..coding is adictive!! #include #define R 3 #define C 6 using namespace std; void PrintSpiral(int er,int ec,int arr[R][C]) { int sr=0,sc=0,i=0; while(sr<=er && sc<=ec) { for(int i=sc;i<=ec;++i) cout<=sc;--i) cout<=sr;--i) cout< 

Code Java si quelqu’un est intéressé.
Entrée :
4
1 2 3 4
5 6 7 8
9 1 2 3
4 5 6 7

Sortie : 1 2 3 4 8 3 7 6 5 4 9 5 6 7 2 1

 public class ArraySpiralPrinter { public static void main(Ssortingng[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); //marrix size //read array int[][] ar = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { ar[i][j] = sc.nextInt(); } } printTopRight(0, 0, n - 1, n - 1, ar); } //prints top and right layers. //(x1,y1) to (x1, y2) - top layer & (x1,y2) to (x2, y2) private static void printTopRight(int x1, int y1, int x2, int y2, int[][] ar) { //print row values - top for (int y = y1; y <= y2; y++) { System.out.printf("%d ", ar[x1][y]); } //print column value - right for (int x = x1 + 1; x <= x2; x++) { System.out.printf("%d ", ar[x][y2]); } //are there any remaining layers if (x2 - x1 > 0) { //call printBottemLeft printBottomLeft(x1 + 1, y1, x2, y2 - 1, ar); } } //prints bottom and left layers in reverse order //(x2,y2) to (x2, y1) - bottom layer & (x2,y1) to (x1, y1) private static void printBottomLeft(int x1, int y1, int x2, int y2, int[][] ar) { //print row values in reverse order - bottom for (int y = y2; y >= y1; y--) { System.out.printf("%d ", ar[x2][y]); } //print column value in reverse order - left for (int x = x2-1; x >= x1; x--) { System.out.printf("%d ", ar[x][y1]); } //are there any remaining layers if (x2 - x1 > 0) { printTopRight(x1, y1 + 1, x2 - 1, y2, ar); } } } 

Ceci est une version récursive en C à laquelle je pourrais penser: –

 void printspiral (int[][100],int, int, int, int); int main() { int r,c, i, j; printf ("Enter the dimensions of the masortingx"); scanf("%d %d", &r, &c); int arr[r][100]; int min = (ri-1;a--) printf("%d\n", arr[j-1][a]); for (a=j-2; a>i; a--) printf("%d\n", arr[a][i]); if (i < min) printspiral(arr,i+1, j-1,k-1, min); } 

http://www.technicalinterviewquestions.net/2009/03/print-2d-array-masortingx-spiral-order.html

Voici la meilleure explication pour la réponse ci-dessus 🙂 avec diagramme 🙂

 public static void printSpiral1(int array[][],int row,int col){ int rowStart=0,colStart=0,rowEnd=row-1,colEnd=col-1; int i; while(rowStart<=rowEnd && colStart<= colEnd){ for(i=colStart;i<=colEnd;i++) System.out.print(" "+array[rowStart][i]); for(i=rowStart+1;i<=rowEnd;i++) System.out.print(" "+array[i][colEnd]); for(i=colEnd-1;i>=colStart;i--) System.out.print(" "+array[rowEnd][i]); for(i=rowEnd-1;i>=rowStart+1;i--) System.out.print(" "+array[i][colStart]); rowStart++; colStart++; rowEnd--; colEnd--; } } 
 public class SpiralPrint{ //print the elements of masortingx in the spiral order. //my idea is to use recursive, for each outer loop public static void printSpiral(int[][] mat, int layer){ int up = layer; int buttom = mat.length - layer - 1; int left = layer; int right = mat[0].length - layer - 1; if(up > buttom+1 || left > right + 1) return; // termination condition //traverse the other frame, //print up for(int i = left; i <= right; i ++){ System.out.print( mat[up][i]+ " " ); } //print right for(int i = up + 1; i <=buttom; i ++){ System.out.print(mat[i][right] + " "); } //print buttom for(int i = right - 1; i >= left; i --){ System.out.print(mat[buttom][i] + " "); } //print left for(int i = buttom - 1; i > up; i --){ System.out.print(mat[i][left] + " "); } //recursive call for the next level printSpiral(mat, layer + 1); } public static void main(Ssortingng[] args){ int[][] mat = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {13,14,15,16}}; int[][] mat2 = {{1,2,3}, {4,5,6}, {7,8,9}, {10,11,12}}; SpiralPrint.printSpiral(mat2,0); return; } } 

Voici ma solution en C #:

 public static void PrintSpiral(int[][] masortingx, int n) { if (masortingx == null) { return; } for (int layer = 0; layer < Math.Ceiling(n / 2.0); layer++) { var start = layer; var end = n - layer - 1; var offset = end - 1; Console.Write("Layer " + layer + ": "); // Center case if (start == end) { Console.Write(matrix[start][start]); } // Top for (int i = start; i <= offset; i++) { Console.Write(matrix[start][i] + " "); } // Right for (int i = start; i <= offset; i++) { Console.Write(matrix[i][end] + " "); } // Bottom for (int i = end; i > start; i--) { Console.Write(masortingx[end][i] + " "); } // Left for (int i = end; i > start; i--) { Console.Write(masortingx[i][start] + " "); } Console.WriteLine(); } } 

Voici mon approche en utilisant un iterator. Notez que cela résout presque le même problème. Code complet ici: https://github.com/rdsr/algorithms/blob/master/src/jvm/misc/FillMasortingx.java

 import java.util.Iterator; class Pair { final int i; final int j; Pair(int i, int j) { this.i = i; this.j = j; } @Override public Ssortingng toSsortingng() { return "Pair [i=" + i + ", j=" + j + "]"; } } enum Direction { N, E, S, W; } class SpiralIterator implements Iterator { private final int r, c; int ri, ci; int cnt; Direction d; // current direction int level; // spiral level; public SpiralIterator(int r, int c) { this.r = r; this.c = c; d = Direction.E; level = 1; } @Override public boolean hasNext() { return cnt < r * c; } @Override public Pair next() { final Pair p = new Pair(ri, ci); switch (d) { case E: if (ci == c - level) { ri += 1; d = changeDirection(d); } else { ci += 1; } break; case S: if (ri == r - level) { ci -= 1; d = changeDirection(d); } else { ri += 1; } break; case W: if (ci == level - 1) { ri -= 1; d = changeDirection(d); } else { ci -= 1; } break; case N: if (ri == level) { ci += 1; level += 1; d = changeDirection(d); } else { ri -= 1; } break; } cnt += 1; return p; } private static Direction changeDirection(Direction d) { switch (d) { case E: return Direction.S; case S: return Direction.W; case W: return Direction.N; case N: return Direction.E; default: throw new IllegalStateException(); } } @Override public void remove() { throw new UnsupportedOperationException(); } } public class FillMatrix { static int[][] fill(int r, int c) { final int[][] m = new int[r][c]; int i = 1; final Iterator iter = new SpiralIterator(r, c); while (iter.hasNext()) { final Pair p = iter.next(); m[pi][pj] = i; i += 1; } return m; } public static void main(Ssortingng[] args) { final int r = 19, c = 19; final int[][] m = FillMasortingx.fill(r, c); for (int i = 0; i < r; i++) { for (int j = 0; j < c; j++) { System.out.print(m[i][j] + " "); } System.out.println(); } } } 

Complétez le programme C pur pour toute masortingce de tableau 2D avec une rangée donnée de colonne .

 #include  void printspiral(int *p,int r, int c) { int i=0,j=0,m=1,n=0; static int firstrun=1,gCol; if (!p||r<=0||c<=0) return ; if(firstrun) { gCol=c; firstrun=0; } for(i=0,j=0;(0<=i && i 

Cette question est liée à celle-ci: Problèmes d’arrangement masortingciel dans PHP

Les réponses présentées semblent fonctionner mais sont compliquées à comprendre. Un moyen très simple de résoudre ce problème est de diviser et conquérir, c.-à-d. Après avoir lu le bord, supprimez-le et la lecture suivante sera beaucoup plus simple. Découvrez ci-dessous une solution complète en PHP:

 #The source number masortingx $source[0] = array(1, 2, 3, 4); $source[1] = array(5, 6, 7, 8); $source[2] = array(9, 10, 11, 12); $source[3] = array(13, 14, 15, 16); $source[4] = array(17, 18, 19, 20); #Get the spiralled numbers $final_spiral_list = get_spiral_form($source); print_r($final_spiral_list); function get_spiral_form($masortingx) { #Array to hold the final number list $spiralList = array(); $result = $masortingx; while(count($result) > 0) { $resultsFromRead = get_next_number_circle($result, $spiralList); $result = $resultsFromRead['new_source']; $spiralList = $resultsFromRead['read_list']; } return $spiralList; } function get_next_number_circle($masortingx, $read) { $unreadMasortingx = $masortingx; $rowNumber = count($masortingx); $colNumber = count($masortingx[0]); #Check if the array has one row or column if($rowNumber == 1) $read = array_merge($read, $masortingx[0]); if($colNumber == 1) for($i=0; $i<$rowNumber; $i++) array_push($read, $matrix[$i][0]); #Check if array has 2 rows or columns if($rowNumber == 2 || ($rowNumber == 2 && $colNumber == 2)) { $read = array_merge($read, $matrix[0], array_reverse($matrix[1])); } if($colNumber == 2 && $rowNumber != 2) { #First read left to right for the first row $read = array_merge($read, $matrix[0]); #Then read down on right column for($i=1; $i<$rowNumber; $i++) array_push($read, $matrix[$i][1]); #..and up on left column for($i=($rowNumber-1); $i>0; $i--) array_push($read, $masortingx[$i][0]); } #If more than 2 rows or columns, pick up all the edge values by spiraling around the masortingx if($rowNumber > 2 && $colNumber > 2) { #Move left to right for($i=0; $i<$colNumber; $i++) array_push($read, $matrix[0][$i]); #Move top to bottom for($i=1; $i<$rowNumber; $i++) array_push($read, $matrix[$i][$colNumber-1]); #Move right to left for($i=($colNumber-2); $i>-1; $i--) array_push($read, $masortingx[$rowNumber-1][$i]); #Move bottom to top for($i=($rowNumber-2); $i>0; $i--) array_push($read, $masortingx[$i][0]); } #Now remove these edge read values to create a new reduced masortingx for the next read $unreadMasortingx = remove_top_row($unreadMasortingx); $unreadMasortingx = remove_right_column($unreadMasortingx); $unreadMasortingx = remove_bottom_row($unreadMasortingx); $unreadMasortingx = remove_left_column($unreadMasortingx); return array('new_source'=>$unreadMasortingx, 'read_list'=>$read); } function remove_top_row($masortingx) { $removedRow = array_shift($masortingx); return $masortingx; } function remove_right_column($masortingx) { $neededCols = count($masortingx[0]) - 1; $finalMasortingx = array(); for($i=0; $i 
 // Program to print a masortingx in spiral order #include  int main(void) { // your code goes here int m,n,i,j,k=1,c1,c2,r1,r2;; scanf("%d %d",&m,&n); int a[m][n]; for(i=0;i=c1;i--) { k++; printf("%d ",a[r2][i]); } for(j=r2-1;j>=r1+1;j--) { k++; printf("%d ",a[j][c1]); } c1++; c2--; r1++; r2--; } return 0; } 

This is java implementation for any mxn masortingx. Where rows = No. of rows and Column = No. of Columns

 public static void printSpiral(int rows, int columns, int a[][]) { int i, k = 0, l = 0; /* k - starting row index l - starting column index */ while (k < rows && l < columns) { /* Print the first row from the remaining rows */ for (i = l; i < columns; ++i) { System.out.println(a[k][i]); } k++; /* Print the last column from the remaining columns */ for (i = k; i < rows; ++i) { System.out.println(a[i][columns-1]); } columns--; /* Print the last row from the remaining rows */ if ( k < rows) { for (i = columns-1; i >= l; --i) { System.out.println(a[rows-1][i]); } rows--; } /* Print the first column from the remaining columns */ if (l < columns) { for (i = rows-1; i >= k; --i) { System.out.println(a[i][l]); } l++; } } } 

Voici ma solution Veuillez corriger si je me trompe.

 class Spiral: def spiralOrder(self, A): result = [] c = [] c.append(A[0]) b = A[1:] while len(b) > 0: b = self.rotate(b) c.append(b[0]) b = b[1:] for item in c: for fitem in item: print fitem, result.append(fitem) return result def rotate(self,a): b = [] l = zip(*a) for i in xrange(len(l)-1,-1,-1): b.append(list(l[i])) return b if __name__ == '__main__': a = [[1, 2, 3,3], [4, 5, 6,6], [7, 8, 9,10]] s = Spiral() s.spiralOrder(a)