0xD34F

const createArr = length =>
  Array.from({ length }, (_, i) =>
    Array.from({ length }, (_, j) =>
      (i === j || i === length - j - 1) +
      ((i <= j && i <= length - j - 1) || (i >= j && i >= length - j - 1))
    )
  );

Собрать новый массив:

const newArr = arr.reduce((acc, n) => (
  acc.push({ ...n, fractionTotal: n.fraction + (acc.at(-1)?.fractionTotal ?? 0) }),
  acc
), []);

// или

const newArr = arr.map(function({ ...n }) {
  n.fractionTotal = this[0] += n.fraction;
  return n;
}, [ 0 ]);

Изменить существующий:

arr.forEach((n, i, a) => n.fractionTotal = n.fraction + (i && a[i - 1].fractionTotal));

// или

arr.reduce((acc, n) => n.fractionTotal = acc + n.fraction, 0);

const rows = 8;
const cols = 8;

document.body.innerHTML = Array
  .from({ length: rows }, (_, i) => Array
    .from({ length: cols }, (_, j) => (i ^ j) & 1)
    .join(''))
  .join('<br>');

Как сортировать по нескольким параметрам:

const sorted = (data, keys) => Array
  .from(data, n => [ n ].concat(keys(n)))
  .sort((a, b) => {
    let diff = 0;
    for (let i = 0; ++i < a.length && !(diff = ((a[i] < b[i]) ? -1 : +(a[i] > b[i])));) ;
    return diff;
  })
  .map(n => n[0]);

Как сортировать дочерние элементы:

const sortChildren = (el, keys) =>
  el.append(...sorted(el.children, keys));

Сортируем:

const ul = document.querySelector('ul');

ul.addEventListener('change', e => sortChildren(
  e.currentTarget,
  el => [
    -el.querySelector('input').checked,
    el.innerText.trim().toLowerCase(),
  ]
));

ul.dispatchEvent(new Event('change'));

arr.filter(RegExp.prototype.test.bind(/^[рим]+$/i))

// или

arr.filter(n => !n.match(/[^рим]/i))

// или

arr.filter(n => !n.replace(/р|и|м/gi, ''))

// или

arr.filter(n => [...n.toLowerCase()].every(m => 'рим'.includes(m)))

Делаем ровно то, что спрошено:

const result = Object.values(data.reduce((acc, n) => (
  (acc[n.brand] ??= { ...n, price: 0 }).price += n.price,
  acc
), {}));

Или, решаем задачу в более общем виде:

function uniqueWithSum(data, key, sumKey) {
  const getKey = key instanceof Function ? key : n => n[key];
  const unique = new Map;

  for (const n of data) {
    const k = getKey(n);
    unique
      .set(k, unique.get(k) ?? Object.assign(new n.constructor, n, { [sumKey]: 0 }))
      .get(k)[sumKey] += n[sumKey];
  }

  return unique;
}

// ваш случай
const result = [...uniqueWithSum(data, 'brand', 'price').values()];

// элементам исходного массива не обязательно быть объектами
Array.from(uniqueWithSum([
  [ 'aaa',   1 ],
  [ 'aaa',  10 ],
  [ 'aaa', 100 ],
  [ 'bbb', 666 ],
], 0, 1).values()) // [ [ 'aaa', 111 ], [ 'bbb', 666 ] ]

const itemSelector = '.radio';
const activeClass = 'active';


// конечно, вы можете и дальше продолжать ковырять jquery
const $items = $(itemSelector).on('change', function() {
  $items.next().removeClass(activeClass);
  $(this).next().addClass(activeClass);
});

// но ведь есть и другой путь
const items = document.querySelectorAll(itemSelector);
const onChange = ({ currentTarget: t }) =>
  items.forEach(n => n.nextElementSibling.classList.toggle(activeClass, n === t));

items.forEach(n => n.addEventListener('change', onChange));

UPD. Наконец-то дождались, теперь использовать js тут необязательно:

.radio:has(:checked) + .order__form-input {
  /* сюда переносим стили, делающие input видимым */
}

arr.reduce((acc, n) => (
  Object.entries(n.json_build_object).forEach(([ k, v ]) => {
    (acc[k] ??= []).find(m => m.id === v.id) || acc[k].push(v);
  }),
  acc
), {})

links.reduce((acc, n) => {
  const path = n.url.split('/');
  const [ lastFolder ] = path.splice(-2);
  (path.reduce((p, c) => p[c] ??= {}, acc)[lastFolder] ??= []).push(n);
  return acc;
}, {})

Перестаньте заниматься ерундой и замените div'ы на ol + li.

data.filter(n => n.rounds[round - 1]?.position)

После кого надо удалить элементы: const selector = '#point';.

Удаляем:

const elem = document.querySelector(selector);
const parent = elem?.parentNode;
const elems = [...parent?.children ?? []];
const index = elems.indexOf(elem);
elems.slice(-~index || elems.length).forEach(n => parent.removeChild(n));

// или

for (
  const el = document.querySelector(selector);
  el?.nextElementSibling;
  el.nextElementSibling.remove()
) ;

// или

document.querySelectorAll(`${selector} ~ *`).forEach(n => n.outerHTML = '');

По событию mouseover перезаписывайте css-переменную, отвечающую за цвет:

document.querySelector('.shopWrapper').addEventListener('mouseover', function() {
  const color = `#${Math.random().toString(16).slice(2, 8).padEnd(6, 0)}`;
  this.style.setProperty('--random-color', color);
});

arr.map(n => {
  const ids = Object
    .values(n.childrenHash.reduce((acc, m) => ((acc[m.hash] ??= []).push(m.id), acc), {}))
    .filter(m => m.length > 1);

  return {
    ...n,
    childrenHash: ids.length ? ids : null,
  };
})

Где и какой класс будем добавлять:

const table = document.querySelector('здесь селектор вашей таблицы');
const className = 'active';

Добавляем:

table.querySelectorAll('tbody td').forEach(td => {
  td.classList.toggle(className, !td.textContent.trim());
});

или

for (const { rows } of table.tBodies) {
  for (const { cells } of rows) {
    for (const td of cells) {
      if (/^\s*$/.test(td.innerText)) {
        td.classList.add(className);
      }
    }
  }
}

function isEqual(a, b) {
  if (a instanceof Object && a.constructor === b?.constructor) {
    const keys = Object.keys(a);
    return (
      keys.length === Object.keys(b).length &&
      keys.every(k => Object.hasOwn(b, k) && isEqual(a[k], b[k]))
    );
  } else {
    return Object.is(a, b);
  }
}

Куда и что надо перенести:

const where = '.container';
const what = '.wrapper-item h3';

Переносим:

$(where).prepend(function() {
  return $(what, this);
});

или

document.querySelectorAll(where).forEach(n => {
  n.prepend(n.querySelector(what));
});

Кому и какой надо добавить класс:

const index = 1;
const className = 'active';

Можно при создании элементов проверять, чему равен текущий индекс:

navigation.innerHTML = objectNavigation
  .map((n, i) => `
    <div class="${i === index ? className : ''}">
      <img src="${n.image}">
    </div>`)
  .join('');

или

navigation.append(...objectNavigation.map((n, i) => {
  const div = document.createElement('div');
  const img = document.createElement('img');
  img.src = n.image;
  div.append(img);
  div.classList.toggle(className, i === index);
  return div;
}));

или

for (const [ i, n ] of objectNavigation.entries()) {
  navigation.appendChild(document.createElement('div'));
  navigation.lastChild.appendChild(new Image);
  navigation.lastChild.lastChild.src = n.image;
  navigation.lastChild.className = i === index ? className : '';
}

Другой вариант - добавлять класс после того, как все элементы будут созданы:

navigation.children[index]?.classList.add(className);

const newArray = numbers.filter(i => i !== firstMin);

Что, если минимальный элемент представлен в нескольких экземплярах? Вы их все выкинете.

Можно найти индекс минимального элемента и фильтровать по индексу:

function sumTwoSmallestNumbers(nums) {  
  const iMin = nums.indexOf(Math.min(...nums));
  return nums[iMin] + Math.min(...nums.filter((_, i) => i !== iMin));
}

Это если идти вашим путём. Но есть и иные способы решить задачу. Например, можно отсортировать массив и взять два крайних элемента:

const sumTwoSmallestNumbers = ([...nums]) => nums
  .sort((a, b) => b - a)
  .slice(-2)
  .reduce((acc, n) => acc + n, 0);

Или, сосчитать, кто сколько раз повторяется и выбирать второе слагаемое в зависимости от количества повторений первого:

function sumTwoSmallestNumbers(nums) {
  const count = Object.entries(nums.reduce((acc, n) => (acc[n] = -~acc[n], acc), {}));
  return +count[0][0] + +count[+(count[0][1] === 1)][0];
}

Или, пройти по массиву один раз, запоминая встреченные элементы, если они меньше тех, что вам уже попадались (т.е., сделать то, чего от вас тут и ожидается - решить задачу с линейной сложностью по времени и константной по памяти):

function sumTwoSmallestNumbers(nums) {
  let min1 = Infinity;
  let min2 = Infinity;

  for (const n of nums) {
    if (n < min1) {
      [ min1, min2 ] = [ n, min1 ];
    } else if (n < min2) {
      min2 = n;
    }
  }

  return min1 + min2;
}

// или

const sumTwoSmallestNumbers = nums =>
  eval(nums.reduce(([ min1, min2 ], n) => 
    n < min1 ? [    n, min1 ] :
    n < min2 ? [ min1,    n ] :
               [ min1, min2 ]
  , [ Infinity, Infinity ]).join('+'));