Клиппи и Мерлин

const n = 50;
const k = 32;
const rand = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
// ячейки с деньгами
let cells = Array.from(new Array(n), (_, i) => [rand(1, 109), i])
    .sort((a, b) => b[0] === a[0] ? a[1] - b[1] : b[0] - a[0]);
let result = [];
end:
    for (let v1, i = 0; i < n; i++) {
        v1 = cells[i];
        for (let v2, j = i + 1; j < n; j++) {
            v2 = cells[j];
            if (Math.abs(v1[1] - v2[1]) >= k) {
                result = [v1, v2];
                break end;
            }
        }
    }
 
console.log(result);
console.log(cells);

let n = 20;
let k = 10;
 
let arr = [128, 662, 237, 27, 101, 957, 871, 812, 647, 597, 4, 295, 797, 325, 556, 150, 70, 805, 272, 803]
function rob(arr, k) {
    if (k < arr.length / 2) return;
 
    let si1 = 0, sv1 = -1, si2 = -1, sv2 = 0;
    for (let i1 = 0, i2 = k + 1; i2 < arr.length; i1++, i2++) {
        if (sv1 < arr[i1]) {
            sv1 = arr[i1];
            si1 = i1;
        }
        if (sv2 < arr[i2]) {
            sv2 = arr[i2];
            si2 = i2;
        }
    }
    console.log(si1 + 1, si2 + 1); // Для нумерации с единицы
}
 
rob(arr, k);

// set operation object or class - irrelevant for js
let opCellThief = {
 
  // generate array of bank cells with random values
  // 2  <= N <=  105
  cellsBank: Array.from(
    // generate random N - length iterable object
    // use a fixed value like to form a step
    { length: 20 },
 
    // generate in callback random cost of each cell
    function () {
      return Math.floor( Math.random() * 1000 ) + 1;
    }
  ),
 
  // set 10 - we can't using this.cellsBank in TDZ
  // 0 <= K < N− 1
  stepCells: 10,
 
  // get result ~O(2n)
  // arguments:
  // cells - bank of cells
  // _step - step between thieves
  getCellsThief : function (_cells, _step) {
 
    // use Map structure like a couple container "cost -> index"
    let mapCells = new Map();
 
    // set temp array for max values meet conditions of task
    let max = [ 0, 0 ];
 
    // fisrt O(n)
    // here we're filtering array cells by conditions task
    // forming Map structure and find first max value in range 0 + K... length - 1 + K
    for ( let i = 0; i < _cells.length; i++ ) {
 
      if (
        _cells[i + _step + 1] ||
        _cells[_cells.length - i + _step]
      ) {
 
        if (max[0] !== _cells[i]) {
          mapCells.set(_cells[i], i);
        }
 
        if (max[0] < _cells[i]) {
          max[0] = _cells[i];
        }
 
      }
    }
 
    // second O(n)
    // find second max value by conditions task
    for (let i = 0; i < _cells.length; i++) {
 
      if (
        max[1] < _cells[i] &&
        Math.abs(
          mapCells.get( max[0] ) - ( mapCells.get( _cells[i] ) )
        ) > _step) {
 
        max[1] = _cells[i];
 
      }
 
      // check the double max
      // upon coincidence extends max[]
      if (
        max[0] === _cells[i] &&
        Math.abs( i - mapCells.get(_cells[i]) ) > _step
      ) {
 
        let tmp = new Map();
        max.push(tmp.set(_cells[i], i));
        tmp = null;
      }
 
    }
 
    //console.log(mapCells);
 
    // returning indexes's
    // the template literals & ternary operation makes this line longer - no sense use  if...else
    return `\[${ _cells }\]\; step = ${ _step }\; costly -  ${ mapCells.get(max[0]) } and ${ max.length > 2 ? max[2].get(max[0]) : mapCells.get(max[1]) }`;
  },
 
};
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
// Tested
 
console.clear();
 
console.log(opCellThief.getCellsThief(opCellThief.cellsBank, opCellThief.stepCells));
console.log(opCellThief.getCellsThief([128, 662, 237, 27, 101, 957, 871, 812, 647, 597, 4, 295, 797, 325, 556, 150, 70, 805, 272, 803], 2)); // 5 and 17
console.log(opCellThief.getCellsThief([128, 662, 237, 27, 70, 957, 871, 812, 647, 1597, 4, 295, 797, 325, 556, 150, 170, 805, 11272, 803], 17)); // 0 and 18
console.log(opCellThief.getCellsThief([128, 662, 237, 27, 70, 957, 871, 812, 647, 20000, 4, 295, 797, 325, 556, 150, 170, 805, 11272, 803], 2)); // 9 and 18
console.log(opCellThief.getCellsThief([128, 662, 237, 27, 70, 957, 871, 812, 647, 11272, 4, 295, 797, 325, 556, 150, 170, 805, 11272, 803], 2)); // 9 and 18
 
 
for (let z = 10; z < 95; z++) {
  console.log(
    opCellThief.getCellsThief(
      // generate array
      // length 20+
      Array.from(
        { length: 20 + parseInt(z / 5) },
        function () {
          return Math.floor( Math.random() * 1000 ) + 1;
        }
        // iterate step 2...18
      ), parseInt(z / 5)
    )
  );
};

const n = 20;
const k = 7;
const c = n - k;
const t = k - 1;
const maxIdx = n - 1;
const left = new Array(n);
const right = new Array(n);
const result = {sum: 0, left: 0, right: 0};
const rand = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
const arr = Array.from(new Array(n), _ => rand(1, 100));
 
left[0] = [arr[0], 0];
right[maxIdx] = [arr[maxIdx], maxIdx];
 
for (let i1 = 1, i2 = n - 2; i1 < n; i1++, i2--) {
    left[i1] = arr[i1] > left[i1 - 1][0] ? [arr[i1], i1] : left[i1 - 1];
    right[i2] = arr[i2] >= right[i2 + 1][0] ? [arr[i2], i2] : right[i2 + 1];
}
 
for (let sum, dist, i = 0; i < c; i++) {
    sum = left[i][0] + right[i + t][0];
    dist = left[i][1] + right[i + k][1];
    if (sum > result.sum && dist > t) {
        result.sum = sum;
        result.left = left[i][1];
        result.right = right[i + k][1];
    }
}
console.log(arr);
console.log(result);
console.log(arr[result.left], arr[result.right]);

const n = 12;
const k = 8;
const c = n - k;
const t = k - 1;
const maxIdx = n - 1;
const left = new Array(n);
const right = new Array(n);
const rand = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
const arr = Array.from(new Array(n), _ => rand(1, 100));
let result = {sum: 0, left: 0, right: 0};
left[0] = [arr[0], 0];
right[maxIdx] = [arr[maxIdx], maxIdx];
 
for (let i1 = 1, i2 = n - 2; i1 < c; i1++, i2--) {
    left[i1] = arr[i1] > left[i1 - 1][0] ? [arr[i1], i1] : left[i1 - 1];
    right[i2] = arr[i2] >= right[i2 + 1][0] ? [arr[i2], i2] : right[i2 + 1];
}
 
for (let sum, z = k, i = 0; i < c; i++, z++) {
    sum = left[i][0] + right[z][0];
    if (sum > result.sum && left[i][1] + right[z][1] > t) {
        result = {sum, left: left[i][1], right: right[z][1]};
    }
}
console.log(arr);
console.log(result);
console.log(arr[result.left], arr[result.right]);
console.log(`distance: ${result.right - result.left}`);}