Rsa97

Вариант 1: вешать обработчик циклом
Вариант 2: использовать всплытие событий

x = rand(1, 97);
y = rand(1, 98-x);
z = rand(1, 99-x-y);
result = sort([x, y, z, 100-x-y-z]);

dtw.find('.delivery-table-item[data-post="'+ deliveryVal +'"][data-status="'+ statusVal +'"]').show();

$(
  function() {
    function recalculateAll() {
      let res = parseInt($('#myselect_1').val()) 
              + parseInt($('#myselect_2').val());
      $('#outSumOption').text(res);
   
     if ($('#chk1').prop('checked')) {
        res *= 2;
      }
      $('#outSumChk1').text(res);

      if ($('#chk2').prop('checked')) {
        res += 100;
      }
      $('#outSumChk2').text(res);

      $('#outSum').text(res);
    }
  
    $('select, input[type="checkbox"]').change(
      function() {
        recalculateAll(); 
      }
    );
  
    recalculateAll();
  }
);

А сколько туда должно попасть? Параметр то указан только один - arguments.
Можете получить их массивом, function (...arguments) { }

>> 129.7*100
// 12969.999999999998

>> Math.round(100*129.7)
// 12970

Но, если есть возможность, то лучше работать в целых числах.

let result = users.reduce(
  (acc, val) => {
    acc[val.id] = {
      id: val.id,
      first_name: val.first_name,
      page_views: 0,
      clicks: 0
    };
    return acc;
  },
  []
);
result = views.reduce(
  (acc, val) => {
    acc[val.user_id].page_views += val.page_views;
    acc[val.user_id].clicks += val.clicks;
    return acc;
  },
  result
);
result = result.filter(x => x);

Возможность возвращения: sum(diff_X) % 2 == 0 && sum(diff_Y) % 2 == 0
Для комбинации перед единицами расставить соответственно sum(diff_X) / 2 и sum(diff_Y) / 2 плюсов и такое же количество минусов. В каком именно порядке - неважно.

function addLetters(...letters) {
  if (letters.length == 0) {
    return 'z';
  }
  let sum = letters.reduce(
    (acc, val) => {
      let newAcc = acc + val.charCodeAt(0) - 96;
      return newAcc > 26 ? newAcc - 26 : newAcc;
    },
    0
  );
  return String.fromCharCode(sum + 96);
}

function test(arr) {
  let len = arr.length;
  let sum = arr.reduce((acc, val) => acc + val, 0);
  while (sum / len <= 4.9) {
    arr.push(5);
    len++;
    sum += 5;
  }
  return arr;
}
console.log(test([2,5,3,5]));

// Array(51) [ 2, 5, 3, 5, 5, 5, 5, 5, 5, 5, … ]

function nameOfFunction

nameOfFanction();

Проблема не в области видимости, а в асинхронности. Анонимный каллбэк из Jimp.read вызывается уже после того, как основная функция завершила работу.

Оценка сложности алгоритма O() - это то, как меняется время вполнения алгоритма от изменения объёма обрабатываемых этим алгоритмом данных.
O(1) - время не зависит от объёма данных.
O(n) - время растёт пропорционально объёму данных.
O(n²) - время растёт пропорционально квадрату объёма данных.
и т.д.

Получение длины строки может иметь разную сложность в зависимости от языка программирования. Если используется хранение строк с префиксом длины, как в Паскале, то сложность будет O(1), так как достаточно только прочитать хранящееся значение. Если же строка хранится как в C/C++, с нулевым байтом в конце, то сложность будет O(n), так как надо в цикле перебрать все байты строки, пока не найдём ноль.

Потому что компьютер хранит числа в двоичном представлении.
Значит 598.68 запишется как 1.0001010110(10101110000101000111) * 2⁹
Поскольку дробь бесконечная, а разрядность вычислений нет, то число в памяти компьютера представляется с некоторой погрешностью. При вычислениях эта погрешность, как правило, нарастает.