dmitriyivvvv

#include <iostream>
#include <vector>

std::vector<int> arr = { 100, 50, 25, 10, 5, 1 };
int n = 100;
int matches = 0;

void calc( int val, unsigned int offs ) {
  if( val == n ) {
    matches++;
    return;
  } else if( val > n ) {
    return;
  }
  for( unsigned int i = offs; i < arr.size(); ++i ) {
    calc( val + arr[i], i );
  }
}

int main( int argc, char** argv ) {
  calc( 0, 0 );
  std::cout << matches << std::endl;
  return( EXIT_SUCCESS );
}

Если возникает необходимость посмотреть как интерпритируется тот или иной синтаксис - может быть полезно посмотреть на AST. Сделать это можно, например, тут https://astexplorer.net/

Слева вставляете код, справа смотрите как его понимает парсер (не реальный парсер движка, но в большинстве случаев это не критично)

Если вы вдруг забыли приоритеты операций (yield vs. ternary например) - это может быть полезно

Я так понимаю, что нужно не нахождение простых чисел, а эффективная проверка числа на простоту. Ваше решение представляет собой классическое решение "в лоб", которое, разумеется работает и даёт стопроцентно точный результат. Однако, помимо простого перебора всех чисел от 2 до sqrt(n) есть и более эффективные алгоритмы. На ум быстро приходит два метода оптимизации:

1. Если не нужна прям гарантия простоты, то можно воспользоваться тестом Рабина-Миллера. Есть ряд чисел, которые не являются простыми, но проходят этот тест. Про них можно почитать и добавить в дополнительное условие.

2. Можно использовать свойство составных чисел, что они не только не делятся на числа из диапазона 2 .. sqrt(n), но так же не делятся ни на одно из простых чисел меньше sqrt(n). Если после отработки функции isPrime сохранять переданное число в массив, если оно оказалось простым, то можно организовывать цикл не по диапазону 2 .. sqrt(n), а по массиву уже известных простых чисел.

Смотрите

var obj = {
  test() {
    console.log(this);
  }
}(obj.test)()

На что это похоже?
А вот так?

var obj = {
  test() {
    console.log(this);
  }
}();

На попытку вызвать функцию с выражения, и передать в нее obj.test, хотя obj еще не существует.
Вот так еще нагляднее

var obj = ({
  test() {
    console.log(this);
  }
}(obj.test)());

т.е. присваивание всего этого в obj идет в последнюю очередь, а до этого, мы пытаемся использовать obj, но он еще не существует. Хотя даже если вы вместо obj.test поставите другую переменную, или например число, то будет ошибка
Uncaught TypeError: {(intermediate value)} is not a function
т.е. вы пытаетесь выполнить конструкцию вида
({a: 10}())
И все из-за того, что вы забыли точку с запятой

var obj = {
  test() {
    console.log(this);
  }
};

(obj.test)()

var arr = [1,2,3,4,5,6,7,8]
var i = 3
var j = 4

console.log(arr); // [1,2,3,4,5,6,7,8]
[arr[i], arr[j]] = [arr[j++], arr[i--]];
console.log(arr); // [1,2,5,4,5,4,7,8]

// #1
// arr[j++]
// j++  вернет 4
// arr[4] вернет 5
// [arr[i], arr[j]] = [5, arr[i--]]

// #2
// arr[i--]
// i--  вернет 3
// arr[3] вернет 4
// [arr[i], arr[j]] = [5, 4]

// #3
// arr[i]
// i вернет 2
// [arr[2], arr[j]] = [5, 4]

// #4
// arr[j]
// j вернет 5
// [arr[2], arr[5]] = [5, 4]

// #5
// выполняем деструктуризацию

// #5.1
// console.log(arr[2]); // 3
// arr[2] = 5
// console.log(arr[2]); // 5

// #5.2
// console.log(arr[5]); // 6
// arr[5] = 4
// console.log(arr[5]); // 4

// #6
// в результате деструктуризации изменили исходный массив:
// [ 1, 2, 5, 4, 5, 4, 7, 8 ]

При известных размерах поля можно вычислить координаты элемента на основе его индекса:

строка = floor(индекс / количество столбцов)
столбец = индекс % количество столбцов

Ну а при клике надо взять все элементы, чьи координаты отличаются от координат кликнутого элемента не более чем на какое-то определённое значение (в данном случае 2 - т.к. сторона квадрата 5, floor(5 / 2)).

Заценить живьём.

Но если на функцию ссылается объект...

Ну так это совсем другая ссылка, не та, что вы используете при переопределении.

Указывайте контекст при переопределении, т.е., замените

foo = function () {

на

this.foo = function () {

Нет, у тебя в примере в переменную d записывается 2 и все.
Там нет замыкания.
И понимаешь ты все не верно.
Твой пример похож на задачу по замыканиям, которую надо решить.

Вот если переписать так:

function a() {
    var c = 2;

    function b() { 
      return c++;
    };

    return b;
}

var d = a();

alert(d()); // 2
alert(d()); // 3

то d будет присвоенна функция:

function b() { 
  return c++;
};

а значение с будет браться из скоупа в котором функция была создана и перезаписывается с каждым вызовом d.
Скоуп будет существовать пока есть ссылка на функцию, то есть пока мы не присвоим d другое значение.
Это и есть замыкание.

Значение c было определенно в функции a в момент вызова. Следом мы возвращаем из функции a функцию b. Функция b использует переменную c из скоупа созданного в момент вызова функции a и, как я писал выше, пока будет существовать ссылка на функцию b скоуп будет существовать, потому что функция b использует a и может быть вызвана.
А с каждым вызовом a мы создаем новый скоуп, и если возвращать каждый результат вызова a в переменную, каждый раз мы будем получать новое замыкание:

function a() {
    var c = 2;

    function b() { 
      return c++;
    };

    return b;
}

var d = a();
var e = a();

alert(d()); // 2
alert(d()); // 3

alert(e()); // 2

alert(d()); // 4
alert(d()); // 5

alert(e()); // 3

Надеюсь так понятней.

А зачем двигаться "пошагово"? Известны же координаты кнопок - можно вычитать одни из других, и сразу получать количество шагов:

const keyboard = [
  'abcde123',
  'fghij456',
  'klmno789',
  'pqrst.@0',
  'uvwxyz_/',
].reduce((acc, [...row], iRow) => {
  row.forEach((key, iCol) => acc[key] = [ iRow, iCol ]);
  return acc;
}, {});

function tvRemote(word) {
  let steps = word.length;
  let prev = [ 0, 0 ];

  for (const n of word) {
    const curr = keyboard[n];
    steps += Math.abs(prev[0] - curr[0]) + Math.abs(prev[1] - curr[1]);
    prev = curr;
  }

  return steps;
}

function foo(data) {
	return data.reduce((acc, x) => {
    if (acc[acc.length-1]+x !== 0) acc.push(x)
    else acc.pop()
    return acc
  }, [])
}

jsfiddle.net/ztfu2a9v

var arr = [1, -1, -1, -2, 2, 1, 2];
var r = [];
for(var i=0;i<arr.length;i++){
   if(i== arr.length-1 || arr[i]+arr[i+1]!==0)
      r.push(arr[i]);
   else
      i++;
}

const result = arr.slice(index).reduce((acc, el) => acc + el);

Массивы индексируются с нуля. В вашем случае, надо прибавлять к позиции 1.

arr.slice(ind+1).reduce((val, sum) => sum + val)