Boucle en diagonale à travers un tableau à deux dimensions
J'ai écrit le code suivant pour parcourir la moitié des diagonales d'un tableau:
String[][] b = [a,b,c]
[d,e,f]
[g,h,i];
public void LoopDiag()
for (int i = b.length - 1; i > 0; i--) {
String temp = "";
for (int j = 0, x = i; x <= b.length - 1; j++, x++) {
temp = temp+b[x][j];
}
System.out.println(temp)
}
for (int i = 0; i <= b.length - 1; i++) {
String temp = "";
for (int j = 0, y = i; y <= b.length - 1; j++, y++) {
temp = temp+b[j][y];
}
System.out.println(temp);
}
}
À l’heure actuelle, les diagonales sont imprimées dans la sortie actuelle:
g dh aei bf c
Comment puis-je lui faire imprimer les autres demi-diagonales, c.-à-d. La sortie requise:
a db gec hf i
Initialiser le tableau uniquement à des fins de test:
int dim = 5;
char ch = 'A';
String[][] array = new String[dim][];
for( int i = 0 ; i < dim ; i++ ) {
array[i] = new String[dim];
for( int j = 0 ; j < dim ; j++, ch++ ) {
array[i][j] = "" + ch;
}
}
Sortie notre matrice:
for( int i = 0 ; i < dim ; i++ ) {
for( int j = 0 ; j < dim ; j++, ch++ ) {
System.out.print( array[i][j] + " " );
}
System.out.println();
}
System.out.println( "============================" );
Solution
Les index d'éléments de diagonales ont une règle - leur somme est constante sur une diagonale:
VARIANT 1
Utilisez deux boucles pour extraire toutes les diagonales.
La première boucle extrait la moitié supérieure des diagonales:
for( int k = 0 ; k < dim ; k++ ) {
for( int j = 0 ; j <= k ; j++ ) {
int i = k - j;
System.out.print( array[i][j] + " " );
}
System.out.println();
}
La deuxième boucle itère sur la moitié inférieure des diagonales:
for( int k = dim - 2 ; k >= 0 ; k-- ) {
for( int j = 0 ; j <= k ; j++ ) {
int i = k - j;
System.out.print( array[dim - j - 1][dim - i - 1] + " " );
}
System.out.println();
}
VARIANT 2
Utilisez une boucle pour extraire toutes les diagonales, mais il y a des itérations supplémentaires et une vérification supplémentaire :
for( int k = 0 ; k < dim * 2 ; k++ ) {
for( int j = 0 ; j <= k ; j++ ) {
int i = k - j;
if( i < dim && j < dim ) {
System.out.print( array[i][j] + " " );
}
}
System.out.println();
}
Le résultat:
A B C D E
F G H I J
K L M N O
P Q R S T
U V W X Y
============================
A
F B
K G C
P L H D
U Q M I E
V R N J
W S O
X T
Y
Mettre à jour
Il y a des questions sur la matrice rectangulaire (hauteur! = Largeur) dans les commentaires. Voici la solution pour la matrice rectangulaire:
La règle reste la même: La somme des index d'éléments de la même diagonale est constante
La somme minimale des index est 0 (pour le premier élément de la matrice avec index [0; 0])
La somme maximale des index est largeur + hauteur - 2 (pour le dernier élément de la matrice avec index [height-1; with-1])
Initialiser la matrice rectangulaire uniquement à des fins de test:
int WIDTH = 7;
int HEIGHT = 3;
char ch = 'A';
String[][] array = new String[HEIGHT][];
for( int i = 0 ; i < HEIGHT ; i++ ) {
array[i] = new String[WIDTH];
for( int j = 0 ; j < WIDTH ; j++, ch++ ) {
array[i][j] = "" + ch;
}
}
Imprimez notre matrice rectangulaire:
for( int i = 0 ; i < HEIGHT ; i++ ) {
for( int j = 0 ; j < WIDTH ; j++, ch++ ) {
System.out.print( array[i][j] + " " );
}
System.out.println();
}
System.out.println( "============================" );
Solution
for( int k = 0 ; k <= WIDTH + HEIGHT - 2; k++ ) {
for( int j = 0 ; j <= k ; j++ ) {
int i = k - j;
if( i < HEIGHT && j < WIDTH ) {
System.out.print( array[i][j] + " " );
}
}
System.out.println();
}
Sortie:
A B C D E F G
H I J K L M N
O P Q R S T U
============================
A
H B
O I C
P J D
Q K E
R L F
S M G
T N
U
Aidez-vous vous-même, regardez les indices que vous devez parcourir:
#1 (0,0) -> a
#2 (1,0) (0,1) -> bd
#3 (2,0) (1,1) (0,2) -> gec
#4 (2,1) (1,2) -> hf
#5 (2,2) -> i
Observez l'évolution des indices à chaque itération et créez votre algorithme. Pas si difficile, alors faites vos devoirs vous-même;)
Les solutions seraient beaucoup plus faciles si nous divisons cela en 2 sous-problèmes:
- Déterminez le début de chaque diagonale.
Étant donné les indices de départ d'une diagonale, imprimez la diagonale.
public void printMatrixDiagonals(int[][] matrix) { int c = 0; int count = matrix.length + matrix[0].length -1; int i = 0, j = 0; //There can be at most m + n -1 diagonals to be printed while (c < count) { //Start printing diagonals from i and j printDiagonal(i, j, matrix); if (i < matrix.length -1) { //We increment row index until we reach the max number of rows i++; } else if (j < matrix[0].length - 1) { //We are at maximum index of row; so its time to increment col index //We increment column index until we reach the max number of columns j++; } c++; } }
Imprimer la diagonale: Notez que chaque fois que nous commençons à imprimer chaque diagonale, l’index de la ligne doit être décrémenté et l’index de la colonne doit être incrémenté. Donc, étant donné les indices de départ de chaque diagonale, nous pouvons imprimer la diagonale comme suit:
private void printDiagonal(int i, int j, int[][] m) {
while (i >=0 && j< m[0].length ) {
System.out.print(m[i][j] + " ");
i--;
j++;
}
System.out.println("");
}
J'ai écrit le code suivant. L'essentiel est d'épuiser toutes les diagonales qui commencent par le haut, puis de passer aux diagonales commençant par les côtés. J'ai inclus une méthode qui combine les deux angles pour traverser les diagonales Nord-Ouest - Sud-Est et Nord-Est - Sud-Ouest et des méthodes autonomes pour franchir les angles respectifs.
public static void main(String[] args){
int[][] m = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
printDiagonals(m, DiagonalDirection.NEtoSW, new DiagonalVisitor() {
public void visit(int x, int y, int[][] m) {
System.out.println(m[x][y]);
}
});
}
public enum DiagonalDirection{
NWToSE,
NEtoSW
}
private static abstract class DiagonalVisitor{
public abstract void visit(int x, int y, int[][] m);
}
public static void printDiagonals(int[][] m, DiagonalDirection d, DiagonalVisitor visitor){
int xStart = d==DiagonalDirection.NEtoSW ? 0 : m.length-1;
int yStart = 1;
while(true){
int xLoop, yLoop;
if(xStart>=0 && xStart<m.length){
xLoop = xStart;
yLoop = 0;
xStart++;
}else if(yStart<m[0].length){
xLoop = d==DiagonalDirection.NEtoSW ? m.length-1 : 0;
yLoop = yStart;
yStart++;
}else
break;
for(;(xLoop<m.length && xLoop>=0)&&yLoop<m[0].length; xLoop=d==DiagonalDirection.NEtoSW ? xLoop-1 : xLoop+1, yLoop++){
visitor.visit(xLoop, yLoop, m);
}
}
}
public static void printDiagonalsNEtoSW(int[][] m, DiagonalVisitor visitor){
int xStart = 0;
int yStart = 1;
while(true){
int xLoop, yLoop;
if(xStart<m.length){
xLoop = xStart;
yLoop = 0;
xStart++;
}else if(yStart<m[0].length){
xLoop = m.length-1;
yLoop = yStart;
yStart++;
}else
break;
for(;xLoop>=0 && yLoop<m[0].length; xLoop--, yLoop++){
visitor.visit(xLoop, yLoop, m);
}
}
}
public static void printDiagonalsNWtoSE(int[][] m, DiagonalVisitor visitor){
int xStart = m.length-1;
int yStart = 1;
while(true){
int xLoop, yLoop;
if(xStart>=0){
xLoop = xStart;
yLoop = 0;
xStart--;
}else if(yStart<m[0].length){
xLoop = 0;
yLoop = yStart;
yStart++;
}else
break;
for(;xLoop<m.length && yLoop<m[0].length; xLoop++, yLoop++){
visitor.visit(xLoop, yLoop, m);
}
}
}
Cela fonctionne pour les tableaux non carrés. C'est simple à comprendre, mais appelle min () et max () une fois par diagonale.
int ndiags = width + height - 1;
System.out.println("---");
for (int diag = 0; diag < ndiags; diag++) {
int row_stop = Math.max(0, diag - width + 1);
int row_start = Math.min(diag, height - 1);
for (int row = row_start; row >= row_stop; row--) {
// on a given diagonal row + col = constant "diag"
// diag labels the diagonal number
int col = diag - row;
System.out.println(col + "," + row);
relax(col, row);
}
System.out.println("---");
}
Voici la sortie pour width = 3, height = 3
---
0,0
---
0,1
1,0
---
0,2
1,1
2,0
---
1,2
2,1
---
2,2
---
largeur = 3, hauteur = 2
---
0,0
---
0,1
1,0
---
1,1
2,0
---
2,1
---
largeur = 2, hauteur = 3
---
0,0
---
0,1
1,0
---
0,2
1,1
---
1,2
---
C'est une manière très intuitive d'imprimer une matrice diagonale dans la boucle while.
généralisez le problème en entier plutôt qu'en deux parties et optimisé en termes de complexité d'espace.
package algorithm;
public class printDiagonaly
{
public static void main(String[] args)
{
int[][] a = new int[][]{{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13, 14, 15},
{16, 17, 18, 19, 20}};
int lr = 0;
int lc = -1;
int fr = -1;
int fc = 0;
int row = a.length - 1;
int col = a[0].length - 1;
while (lc < col || fc < col || fr < row || lr < row)
{
if (fr < row)
{
fr++;
}
else
{
fc++;
}
if (lc < col)
{
lc++;
}
else
{
lr++;
}
int tfr = fr;
int tlr = lr;
int tlc = lc;
int tfc = fc;
while (tfr >= tlr && tfc <= tlc)
{
System.out.print(a[tfr][tfc] + " ");
tfr--;
tfc++;
}
System.out.println("\n");
}
}
}
C'est ainsi:
int [][]mat = { {1,2,3},
{4,5,6},
{7,8,9},
};
int N=3;
for (int s=0; s<N; s++) {
for (int i=s; i>-1; i--) {
System.out.print(mat[i][s-i] + " ");
}
System.out.println();
}
for (int s=1; s<N; s++) {
for (int i=N-1; i>=s; i--) {
System.out.print(mat[i][s+N-1-i] + " ");
}
System.out.println();
}
La première boucle imprime les diagonales en commençant par la première colonne, la deuxième boucle imprime les diagonales restantes (en commençant par la ligne du bas).
Sortie:
1
4 2
7 5 3
8 6
9
Comme Alex l'a mentionné ici, vous devez examiner les indices dans la boucle. Voici comment j'ai abordé ce problème.
Input:
a b c ----- (0,0) (0,1) (0,2)
d e f ----- (1,0) (1,1) (1,2)
g h i ----- (2,0) (2,1) (2,2)
Output:
a ----- (0,0)
b d ----- (0,1) (1,0)
c e g ----- (0,2) (1,1) (2,0)
f h ----- (1,2) (2,1)
i ----- (2,2)
public class PrintDiagonal{
public static void printDR(String[][] matrix, int rows, int cols){
for(int c=0; c < cols; c++){
for(int i=0, j=c; i< rows && j>=0;i++,j--){
System.out.print(matrix[i][j] +" ");
}
System.out.println();
}
for(int r =1; r < rows; r++){
for(int i =r, j= cols -1; i<rows && j>=0; i++,j--){
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
}
public static void main(String[] args){
String[][] matrix ={
{"a","b","c"},
{"d","e","f"},
{"g","h","i"}
};
int rows = matrix.length;
int columns = matrix[0].length;
printDR(matrix ,rows, columns);
}
}
String ar[][]={{"a","b","c"},{"d","e","f"},{"g","h","i"}};
int size1=ar.length-1, size2=ar.length;
for(int i=0; i<ar.length; i++)
{
String a="";
for(int j=0, x=ar.length-1-i; j<ar.length-i; j++, x--)
{
if((j+x)==size1)
a=a+ar[x][j];
}
size1--;
System.out.println(a);
a="";
for(int j=i+1, x=ar.length-1; j<ar.length; j++, x--)
{
if((j+x)==size2)
a=a+ar[x][j];
}
System.out.println(a);
size2++;
}
SORTIE
gec hf db i a
Voici le code:
public void loopDiag(String [][] b) {
boolean isPrinted = false;
for (int i = 0 ; i < b.length ; i++) {
String temp="";
int x=i;
for(int j = 0 ; j < b.length ; j++) {
int y = j;
while (x >= 0 && y < b.length) {
isPrinted = false;
temp+=b[x--][y++];
}
if(!isPrinted) {
System.out.println(temp);
isPrinted = true;
}
}
}
}