Rsa97

Задача о кратчайшем пути

Как найти условие такого соединения?

Легко. f2 = int((f1-1)/3)*2+1

И что почитать чтобы уметь такие условия составлять?

Школьный курс математики.

Для произвольных (x₁, y₁) и (x₂, y₂), IMHO, только брать все целые значения между x₁ и x₂ и проверять значение y в полученных точках.
Для целочисленных (x₁, y₁) и (x₂, y₂) можно так:
n = НОД(|x₂ − x₁|, |y₂ − y₁|)
dx = (x₂ − x₁) / n
dy = (y₂ − y₁) / n
И взять все пары (x₁ + dx × i, y₁ + dy × i) для i = 1 .. n − 1

Тут отсылка к банальной логике и методике доказательства/опровержения утверждений.
Любое число, в том числе и чётное можно представить как его сумму с нулём
n = n + 0
Поскольку 0 - число чётное, то для n ≠ 0 утверждение выполняется. Для нуля мы можем взять пару ненулевых чётных чисел с разным знаком
0 = n + (-n), n ≠ 0
Таким образом, для нуля утверждение также выполняется, следовательно оно истинно.

Навык нахождения оптимального алгоритма можно натренировать решением любых задач в условиях ограничения каких-либо ресурсов. Скажем, для оптимизации по времени вашу задачу можно решить составлением ещё одного массива, где индексом будет количество очков, а содержимым элемента - позиция в таблице. Тогда задача будет решаться за линейное время O(n) за счёт увеличения расхода памяти.
Приведу пример на псевдокоде.

positions := array[0..max_scores] of 0
foreach of scores as score
  positions[score] := 1
position := 1
for i := max_scores to 0
  temp := position + positions[i]
  positions[i] := position
  position := temp
result := array[]
foreach of alice as score
  result[] := positions[score]

function generate(string, rest) {
  if (rest.length == 0) {
    console.log(string);
    return
  }
  rest[0].forEach(element => {
    generate(string+element, rest.slice(1));
  });
}
generate('', modifiers);

machine dependent constants - это количество тактов на один цикл алгоритма и тактовая частота процессора.
Предположим, что линейный алгоритм O(n) работает на быстром компьютере и каждый цикл выполняется за 1 наносекунду, то есть общее время будет 1×n. Логарифмический алгоритм O(log n) работает на медленном компьютере и каждый его цикл занимает 100 наносекунд, общее время 100×log(n) Посмотрим, как будет меняться время алгоритма при изменении n.

n    | O(n) | O(log n)
1    |    1 |   100
10   |   10 |   200
100  |  100 |   300
1000 | 1000 |   400

То есть, в интервале от 100 до 1000 есть значение n, после которого логарифмический алгоритм работает быстрее даже на более медленном компьютере.
В общем случае значение n можно получить из равенства a×n = b×log(n)

Берём номер первого элемента (0..31)
Умножаем на 31, прибавляем номер второго элемента в последовательности с удалённым первым элементом (0..30).
Умножаем на 30, прибавляем номер третьего элемента в последовательности с удалёнными первым и вторым элементами (0..29).
...
Умножаем на 2, прибавляем номер тридцать первого элемента в последовательности с удалёнными первым - тридцатым элементами (0..1).
Максимум получим 8.68331761881189e+36, что меньше 2¹²⁸ = 3.4028237e+38.

var t = {
  list: {
    "action_buttons[0]": "View",
    "action_buttons[1]": "Share",
    "action_buttons[2]": "Download",
    "columns[0]": "Date of Study",
    "columns[1]": "Patient",
    "columns[2]": "File name",
    "columns[3]": "Reporting <br>Physician",
    "columns[4]": "Institution"
  }
};

var list = {};
var re = /^(.*?)\[(\d+)\]$/;
var match;
for (var prop in t.list) {
  match = prop.match(re);
  if (typeof list[match[1]] == "undefined") {
    list[match[1]] = [];
  }
  list[match[1]][match[2]] = t.list[prop];
}
t.list = list;
console.log(t);

{…}
​   list: {…}
​​      action_buttons: […]
​​​         0: "View"
​​​         1: "Share"
​​​         2: "Download"
​​​      columns: […]
​​​         0: "Date of Study"
​​​         1: "Patient"
​​​         2: "File name"
​​​         3: "Reporting <br>Physician"
​​​         4: "Institution"
​

В принципе, ваш алгоритм рабочий, только перебирать надо не все отрезки в каждом цикле, а только те, что лежат ниже. То есть

for (i = 0; i < pairs.length-2; i++) {
  ... 
  for (i = i+1; j < pairs.length-1; j++) {
    ...
    for (k = j+1; k < pairs.length; k++) {
      ...
    }
  }
}