How to get the element which are diagonal to a certain index in an array which represents a rectangle

Some math (ie, modulus, integer division, and minimums) can find the beginning row and column for both the diagonal that runs left-to-right (LTR) and right-to-left (RTL), saving complexity of iterating backwards to find the starting points. Then, using those beginning rows and columns, simply iterate until outside the height and width bounds of the array.

let arr = Array(20).fill().map((x, i) => i);

function diagonals(arr, h, w, n) {
  var nRow = Math.floor(n / w);
  var nCol = n % w;

  let LTR = [];
  for (let r = nRow - Math.min(nRow, nCol), c = nCol - Math.min(nRow, nCol); r < h && c < w; r++, c++) LTR.push(arr[r * w + c]);

  let RTL = [];
  for (let r = nRow - Math.min(nRow, w - nCol - 1), c = nCol + Math.min(nRow, w - nCol - 1); r < h && 0 <= c; r++, c--) RTL.push(arr[r * w + c]);

  return [LTR, RTL];
}

Sample runs...

diagonals(arr, 4, 5, 7);  // returns ==> [[1, 7, 13, 19], [3, 7, 11, 15]]
diagonals(arr, 4, 5, 15); // returns ==> [[15], [3, 7, 11, 15]]

Edit: Note on arr value vs index.

Also, just a point of clarification. The question indicates "There is also a given index. I want to get the two arrays containing elements which lie on the diagonal line which passes through that particular index." If the index of the rectangular array is being sought rather than the actual value of arr, then there is no need to build arr, and subsequently the function and push statements can be changed to...

• function diagonals(h, w, n)
• LTR.push(r * w + c)
• RTL.push(r * w + c)

Try the following code

let arr = Array(20).fill().map((x,i) => i);

function getDias(arr, l, w, ind){
  let arr1 = [];
  let arr2 = [];
  n = l*w;
  lVal = Math.floor(ind/w);
  rVal = ind%w;
  temp1  = lVal;
  temp2  = rVal;
  while(temp1>=0 && temp2>=0){
    val = ((w*temp1) + temp2);
    arr1.unshift(arr[val]);  
    temp1--;
    temp2--;
  }
  temp1  = lVal;
  temp2  = rVal;
  temp1++;
  temp2++;
  while(temp1<l && temp2<w){
    val = ((w*temp1) + temp2);
    arr1.push(arr[val]);  
    temp1++;
    temp2++;
  }

   
  console.log(arr1);
  temp1  = lVal;
  temp2  = rVal;
  while(temp1>=0 && temp2<w){
    val = ((w*temp1) + temp2);
    arr2.unshift(arr[val]);  
    temp1--;
    temp2++;
  }
  
  temp1  = lVal;
  temp2  = rVal;
  temp1++;
  temp2--;
  while(temp1<l && temp2>=0){
    val = ((w*temp1) + temp2);
    arr2.push(arr[val]);  
    temp1++;
    temp2--;
  }

  console.log(arr2);

}
getDias(arr, 4, 5, 7);
getDias(arr, 4, 5, 16);
getDias(arr, 4, 5, 0);

The idea is to compute l_val and r_val.

l_val = index/w
r_val = index%w

Now arr[l_val][r_val] marks the position in the matrix found by l_val* w+ r_val

This is now followed by 4 steps:

1) Start iteration from arr[l_val][r_val]. Subtract 1 from both till we reach the end. Unshift this to array_1 (to maintain order)

2) Start iteration from [l_val][r_val].Add 1 to both till we reach the end. Push this to array_1.

3) Start iteration from arr[l_val][r_val]. Subtract 1 from l_val and add 1 t r_val till we reach the end. Unshift this to array_2 (to maintain order)

4) Start iteration from [l_val][r_val].Add 1 to l_val and subtract 1 from r_val till we reach the end. Push this to array_2.

let arr = Array(20).fill().map((x, i) => i);

function getDias(arr, l, w, ind) {
  let arr1 = [];
  let arr2 = [];
  let row = parseInt(ind / w);
  let col = ind - row * w;
  diagIteration(arr, row, col, l, w, -1, arr1);
  diagIteration(arr, row, col, l, w, 1, arr2);
  return [arr1, arr2];
}

function diagIteration(arr, row, col, l, w, strategy, result) {
  // find the starting row and col to begin with
  while (row - 1 >= 0 && col + strategy >= 0 && col + strategy < w) {
    row--;
    col += strategy;
  }
  // iterate the diagonal elements and add it in result
  strategy *= -1; // since we need to diagonally the reverse way after getting the base indexes to begin with
  for (; row >= 0 && row < l && col >= 0 && col < w; row++, col += strategy) result.push(arr[row * w + col]);
}

// tests
for (var i = 0; i < arr.length; ++i) {
  console.log(arr[i] + ' =>', getDias(arr, 4, 5, i));
}

• We compute the row and column for a particular given index. For any given index, the row would be index / width and column would be index - row * width.
• Now, we find the base indexes to begin with and iterate over the diagonal as if were a 2D array. The index lying on any diagonal can be computed as row * width + column. We do an additional check to see if we are still in range of the simulated 2D array.

/* you need to start your loop with respect of R and C; if you find the element then you need to break the loop and follow same process.*/

function Diagonals(R, C, matrix, K)
{
for(let i=0; i<R;i++)
{
for(let j=0; j<C; j++)
{
if(matrix[i][j]==K)
{
r=i;
c=j;
break;

}
}
}
let sum = r+c;
let diff= r-c;
let left= "";
let right="";
for(let i=0; i<R; i++){
for(let j=0; j<C; j++){
if(i-j==diff){
left=left+matrix[i][j]+" ";
}
if(i+j==sum)
{
right=right+matrix[i][j]+" ";
}
}
}
console.log(left);
console.log(right);

}