Как найти точки, которые являются частью одной и той же диагонали в ортонормированной системе координат

#javascript #math

#javascript #математика

Вопрос:

У меня есть массив объектов, который представляет ортонормированную систему координат, где каждый объект представляет точку с буквой и координатами (x amp; y).

 const array = [
  { x: 0, y: 0, value: 'A' },
  { x: 1, y: 0, value: 'B' },
  { x: 2, y: 0, value: 'C' },
  { x: 3, y: 0, value: 'D' },
  { x: 0, y: 1, value: 'E' },
  { x: 1, y: 1, value: 'F' },
  { x: 2, y: 1, value: 'G' },
  { x: 3, y: 1, value: 'H' },
  { x: 0, y: 2, value: 'I' },
  { x: 1, y: 2, value: 'J' },
  { x: 2, y: 2, value: 'K' },
  { x: 3, y: 2, value: 'L' },
  { x: 0, y: 3, value: 'M' },
  { x: 1, y: 3, value: 'N' },
  { x: 2, y: 3, value: 'O' },
  { x: 3, y: 3, value: 'P' },
]
  

Существует схематическое представление:
схематическое представление массива

Мне нужно найти точки, которые являются частью одной и той же диагонали. Например, возьмем точку G. Я должен найти объекты со значениями: B, L, D, J amp; M.

Я не могу решить эту проблему из-за математики, я понятия не имею, как мне поступить. Какой самый простой / умный способ?

ПРИМЕЧАНИЕ: мои координаты меняются местами, y идет снизу, а не сверху (точка M.y должна быть -3 вместо 3 обычным способом), имеет ли это значение?

Комментарии:

1. Подсказка: есть 2 диагонали. Одна диагональ имеет общее значение x y , а другая диагональ имеет общее значение x-y .

2. Являются ли диагонали исключительно диагоналями квадрата? т.е. Они всегда будут кратны (1,1) и (1, -1)?

3. @Makogan x = 0, x < 1000, y = 0, y < 1000 и для каждой координаты есть точка

4. Это не то, о чем я спрашиваю. Я спрашиваю, каковы будут направления диагоналей. С точки зрения математики существует бесконечно много диагоналей, я хочу знать, заботитесь ли вы только о 2 таких, что x = y и x = -y

5. @Makogan да, только тезисы 2 диагонали

Ответ №1:

Я нашел этот шаблон, может быть, это поможет:

Для вашего примера G:

     array[6] //G
    array[6 3] // J
    array[6 2*3] // M
    array[6-3] // D

    array[6-5] // B
    array[6 5] L
  

насколько я вижу, этот шаблон работает для каждой буквы, вам нужно только проверить ошибку array out of bounds


редактировать: для каждого размера матрицы:

x — это размер матрицы, тогда вам нужны два числа: x 1 и x — 1

итак, для размера 4 у вас есть 3 и 5

Комментарии:

1. Это пример, он должен работать с массивом длиной 1000 ^^

2. @TintinSansYeux Я добавил это в свой ответ

Ответ №2:

Ну, как объяснено в моем комментарии, ваши диагонали подчиняются правилу, что либо x = y, либо x =-y.

Итак, если x = y (например, (0,0); (1,1))… Это в одной диагонали. Если (x =-y) (например (1,-1), (10,-10)) тогда это в другом. Во всех остальных случаях точка не находится на диагонали.

Ваши комментарии немного сбивают с толку, это ваши точки, как описано в таблице.

введите описание изображения здесь

Комментарии:

1. Я не понимаю. Пример с точкой G => L точка находится по диагонали, но ни x =-y / x = y

2. Они не находятся на этой диагонали. Направление от одной точки к другой коллинеарно диагонали, но сами точки в ней не находятся. Итак, вы хотите, чтобы точки были по диагонали, или вы хотите, чтобы направления между точками были?

Ответ №3:

Если вы посмотрите на простой пример, диагональ A, F, K, P имеет x == y , так что это отправная точка. Затем мы смотрим на B, G, L и замечаем это x == y 1 . И C, H имеет x == y 2 , так что это начало шаблона само по себе. Таким образом, алгоритм может быть x == y Alpha.x , но это работает, только если вы начинаете с первой строки. Если мы немного перевернем его, мы получим x - y = t , или t = x - y где t равно для всего в той же диагонали. Теперь вы можете сравнить t A.x - A.y и B.x - B.y увидеть, что они находятся не на одной диагонали, а E.x - E.y равны J.x - J.y , поэтому они находятся на одной диагонали.

Для другой диагонали мы можем видеть, что M, J, G, D находятся в той же диагонали другого направления. Мы также можем видеть это x y = 4 для всех этих случаев. И I, F, C имеет x y = 2 , опять же, для всех этих случаев, так что теперь мы можем начать видеть, что u = x y , где u будет одинаково и для всего в этой диагонали.

Итак, теперь у нас есть 2 простых случая:

  • t = x — y
  • u = x y

Если t или u равно t или u другой буквы, она находится в одной из тех же диагоналей. Пример: I.t == N.t и N.u == K.u . Это должно работать независимо от размера или формы вашей матрицы, например, если это широкий или высокий прямоугольник. Если в итоге получается отверстие посередине, как в пончике, вам решать, хотите ли вы «перепрыгнуть» отверстие или игнорировать что-либо на другой стороне отверстия. Я показал вам, как это работает с чем-то другим, кроме ситуации «из угла в угол», так что это встроено в сравнения.

Вам даже не нужно знать размер матрицы, чтобы это работало.

Кроме того, это должно работать независимо от вашей системы координат. Единственное, что может измениться, это то, какая диагональ t и u представляет.

Просто помните, что сравнение между t и u бессмысленно.

PS — Обычно я не использую t or u в качестве переменных, но я подумал, что буду использовать буквы, которых нет в приведенной выше матрице, чтобы попытаться избежать путаницы.

Ответ №4:

 const array = [{ x: 0, y: 0, value: 'A' }, { x: 1, y: 0, value: 'B' }, { x: 2, y: 0, value: 'C' }, { x: 3, y: 0, value: 'D' }, { x: 0, y: 1, value: 'E' }, { x: 1, y: 1, value: 'F' }, { x: 2, y: 1, value: 'G' }, { x: 3, y: 1, value: 'H' }, { x: 0, y: 2, value: 'I' }, { x: 1, y: 2, value: 'J' }, { x: 2, y: 2, value: 'K' }, { x: 3, y: 2, value: 'L' }, { x: 0, y: 3, value: 'M' }, { x: 1, y: 3, value: 'N' }, { x: 2, y: 3, value: 'O' }, { x: 3, y: 3, value: 'P' },]
// given a point P with coordinates (xp, yp) the equations of the two diagonal lines 
// passing from P are y1 = x - xp   yp and y2 = -x   xp   yp
// maxx, maxy are the max x and y values
const diagonalPoints = (xp, yp, maxx, maxy) => { 
    const ra = [];
    for (let x = 0; x <= maxx; x  ) {
        const y1 = x - xp   yp;
        if (y1 >=0 amp;amp; y1 <= maxy amp;amp; !(x === xp amp;amp; y1 === yp)) ra.push([x, y1]);
        const y2 = - x   xp   yp;
        if (y2 >=0 amp;amp; y2 <= maxy amp;amp; !(x === xp amp;amp; y2 === yp)) ra.push([x, y2]);
    }
    return ra.flatMap(v => array.filter(point => point.x === v[0] amp;amp; point.y === v[1]).map(z => z.value));
}
console.log(...diagonalPoints(2, 1, 3, 3));