Перемещение массива по диагонали

Question

У меня есть большой массив произвольного размера. Это квадратный массив. Я пытаюсь понять, как пройти по диагонали, как /, а не \ (что я уже знаю, как это сделать). У меня есть следующий код до сих пор:

char[][] array = new char[500][500]; 
//array full of random letters 
String arrayLine = ""; 
for (int y = 0; y < array.length; y++) { 
    for (int x = 0; x < array.length; x++) { 
     for (???) { 
      arrayLine = arrayLine + array[???][???]; 
     } 
    } 
    System.out.println(arrayLine); 
} 

У меня есть три петли, потому что это, как я сделал другую диагональ:

for (int y = 0; y < array.length; y++) { 
    for (int x = 0; x < array.length; x++) { 
     for (int z = 0; z < array.length-y-x; z++) { 
      arrayLine = arrayLine + array[y+z][x+z]; 
     } 
    } 
    System.out.println(arrayLine); 
} 

В своих попытках, я продолжаю идти за границами и получить Исключение ElementOutOfBounds. Скажем, массив, как показано ниже (3х3 вместо 500x500):

A B C 
D E F 
G H I 

Я хочу напечатать следующие как строки:

A 
BD 
CEG 
FH 
I 

Предыдущий SO вопрос была аналогичная проблема с целыми массивами, и решение основано на сумме элементов массива. Но я работаю с символами, поэтому я не могу придумать методологию, чтобы получить ее.

Answer 1

Подумайте о координатах ячеек:

. 0 1 2 
0 A B C 
1 D E F 
2 G H I 

Для любой диагонали, все элементы имеют нечто общее: сумма координат Элементом является постоянным. Вот константы:

0 = 0+0 (A) 
1 = 1+0 (B) = 0+1 (D) 
2 = 2+0 (C) = 1+1 (E) = 0+2 (G) 
3 = 2+1 (F) = 1+2 (H) 
4 = 2+2 (I) 

Минимальная константа является наименьшей координатой сумму, 0. Максимальная константа является самой крупной суммой координат. Поскольку каждый компонент координат может достигать array.length - 1, максимальная постоянная равна 2 * (array.length - 1).

Так что нужно делать, это перебирать константы. Для каждой константы перебираем элементы, координаты которых суммируются с константой. Это, вероятно, самый простой подход:

for (int k = 0; k <= 2 * (array.length - 1); ++k) { 
    for (int y = 0; y < array.length; ++y) { 
     int x = k - y; 
     if (x < 0 || x >= array.length) { 
      // Coordinates are out of bounds; skip. 
     } else { 
      System.out.print(array[y][x]); 
     } 
    } 
    System.out.println(); 
} 

Однако, что будет в конечном итоге итерации много недоступного координат, потому что она всегда перебирает все возможные y координат, даже если только одна диагональ содержит все возможную y координаты. Давайте изменим цикл y, поэтому он посещает только y координаты, необходимые для текущего k.

Одним из условий для внеочередных координат является x < 0. Подставьте определение из x и решить:

x < 0 
k - y < 0 
k < y 
y > k 

Так что, когда y > k, x будет отрицательным. Таким образом, мы хотим только петли, пока y <= k.

Другое условие для внеочередных координат - x >= array.length. Решить:

x >= array.length 
k - y >= array.length 
k - array.length >= y 
y <= k - array.length 

Так что, когда y <= k - array.length, x будет слишком большим. Таким образом, мы хотим начать y по адресу 0 или k - array.length + 1, в зависимости от того, что больше.

for (int k = 0; k <= 2 * (array.length - 1); ++k) { 
    int yMin = Math.max(0, k - array.length + 1); 
    int yMax = Math.min(array.length - 1, k); 
    for (int y = yMin; y <= yMax; ++y) { 
     int x = k - y; 
     System.out.print(array[y][x]); 
    } 
    System.out.println(); 
} 

Примечание: Я проверял этот код правильно. Я его не тестировал.

Answer 2

Более простой способ - проверить сумму, если индексы равны array.length = 1; для diagonalRight и diagonalLeft просто проверить, если я это равняется ямайский

Примера:

digonalLeft суммирует \ матрицы, так как (0,0) (1,1) (2,2) делает диагональ. diagonalRight суммирует/матрицы, так как (0 + 2) = (1 + 1) = (2 + 0) = 2 и 2 является array.length - 1.

long diagonalLeft = 0; 
long diagonalRight = 0; 

for (int i = 0; i < array.lenth - 1; i++) { 
    for (int j = 0; j < array.length -1; j++) { 
     if (i == j) digonalLeft += array[i][j]; 
     if (i + j == array.length - 1) diagonalRight += array[i][j]; 
    }  
}