0xD34F

const teamNamesObj = Object.fromEntries(teamNames.map(n => [ n.id, n.name ]));
const eplWithNames = epl.map(n => ({ ...n, team_name: teamNamesObj[n.team_id] }));

epl.forEach(function(n) {
  n.team_name = this[n.team_id];
}, teamNames.reduce((acc, n) => (acc[n.id] = n.name, acc), {}));

arr.reduce((acc, n) => acc + (n ** 2) * !(n & 1), 0)

const countWithKey = (arr, key) => arr.filter(n => key in n).length;

console.log(countWithKey(arr, 'ключ'));

const sum = (data, val = n => n) =>
  Array.prototype.reduce.call(
    data,
    (acc, n) => acc + val(n),
    0
  );

console.log(sum(arr, obj => obj.hasOwnProperty('ключ')));

const cart = [
  { price: 100, count: 5 },
  { price:  10, count: 6 },
  { price:   1, count: 7 },
];

const total = sum(cart, item => item.price * item.count); // 567

const likes = sum(document.querySelectorAll('.btn_like .btn__counter'), n => +n.innerText);

function Counter(data, key = n => n) {
  const counted = new Map;

  for (const n of data) {
    const k = key(n);
    counted.set(k, (counted.get(k) ?? 0) + 1);
  }

  return k => counted.get(k) ?? 0;
}

const keyExists = Counter(arr, obj => Object.hasOwn(obj, 'ключ'));
console.log(keyExists(true)); // смотрим, у скольких элементов массива ключ есть
console.log(keyExists(false)); // и у скольких нет

const str = 'hello, world!!';

const chars = Counter(str);
console.log(chars('h')); // 1
console.log(chars('!')); // 2
console.log(chars('x')); // 0

const persons = [
  { name: 'Вася', birthday: new Date('1999-05-22') },
  { name: 'Маша', birthday: new Date('2004-03-06') },
  { name: 'Катя', birthday: new Date('1976-05-15') },
  { name: 'Петя', birthday: new Date('1987-04-18') },
  { name: 'Коля', birthday: new Date('2000-01-01') },
  { name: 'Дима', birthday: new Date('2003-05-09') },
  { name: 'Миша', birthday: new Date('1996-02-29') },
  { name: 'Таня', birthday: new Date('1981-03-12') },
  { name: 'Олег', birthday: new Date('1992-08-24') },
];

const birthMonths = Counter(
  persons,
  ({ birthday }) => birthday.toLocaleString('ru-RU', { month: 'long' })
);
console.log(birthMonths('май')); // в мае родилось три человека
console.log(birthMonths('март')); // в марте два
console.log(birthMonths('октябрь')); // а в октябре никто

function* naturalNumbers(n) {
  for (let i = 1; i <= n; i++) {
    yield i;
  }
}

const numLengths = Counter(naturalNumbers(100), num => `${num}`.length);
console.log(numLengths(2)); // среди первых ста натуральных чисел - девяносто двухзначных
console.log(numLengths(3)); // и одно трёхзначное
console.log(numLengths(0)); // число из нуля знаков? - конечно же нет таких

function objToString(val, tabSize = 2, depth = 0, noIndent = false) {
  const indent = ' '.repeat(tabSize * depth);

  return (noIndent ? '' : indent) + (
    val instanceof Array
      ? `[\n${val.map(n => objToString(n, tabSize, depth + 1)).join(',\n')}\n${indent}]`
      : val instanceof Object
        ? `{\n${Object
            .entries(val)
            .map(n => n.map((m, i) => objToString(m, tabSize, depth + 1, i)).join(': '))
            .join(',\n')}\n${indent}}`
        : typeof val === 'string'
          ? `"${val}"`
          : val
  );
}

console.log(objToString({
  numbers: [ 69, 187, 666 ],
  strings: [ 'hello, world!!', 'fuck the world', 'fuck everything' ],
  falsy_values: [ 0, '', NaN, false, null, undefined ],
  object: { xxx: true, yyy: Infinity, zzz: { '!&$': [ [ [ -1 ] ] ] } }
}));

const insert = (str, substr, ...indices) => [ 0 ]
  .concat(indices)
  .filter(n => 0 <= n && n <= str.length)
  .sort((a, b) => a - b)
  .map((n, i, a) => str.slice(n, a[i + 1]))
  .join(substr);

// или

const insert = (str, substr, ...indices) => indices
  .sort((a, b) => b - a)
  .reduce((acc, n) => (
    0 <= n && n <= str.length && acc.splice(n, 0, substr),
    acc
  ), [...str])
  .join('');

// или

const insert = (str, substr, ...indices) =>
  ''.concat(...Array.from(
    { length: -~str.length },
    function(_, i) {
      return substr.repeat(this[i] ?? 0) + str.charAt(i);
    },
    indices.reduce((acc, n) => (acc[n] = -~acc[n], acc), {})
  ));

const insert = (str, substr, ...indices) => indices
  .filter(n => 0 <= n && n <= str.length)
  .sort((a, b) => a - b)
  .reduceRight((acc, n, i) =>
    acc.replace(RegExp(`(?<=^.{${n}})`), substr)
  , str);

// ваш случай
const str = insert(`${number}`, '-', 3, 5, 8, 10);

// вставлять можно больше одного символа
insert('abc', ' --> ', 1, 2) // 'a --> b --> c'

// можно по одному индексу несколько раз делать вставку
insert('abc', '~', 0, 0, 0) // '~~~abc'

// за границы строки вставка не выполняется,
// за исключением позиции сразу же после конца строки
insert('abc', '!', -1, 3, 4) // 'abc!'

вторая не работает

const container = document.querySelector('.nav-student-new-lesson');
const blockSelector = '.grade-item-block';
const itemSelector = `${blockSelector} .grade-item`;
const colors = {
  grades: [
    [ 5, 'rgba(150, 255, 0, 0.3)' ],
    [ 3, 'rgba(255, 150, 0, 0.3)' ],
    [ 1, 'rgba(255,   0, 0, 0.3)' ],
  ],
  default: 'white',
};

function updateGrade(item) {
  const items = item.closest(blockSelector).querySelectorAll(itemSelector);
  const grade = 1 + Array.prototype.indexOf.call(items, item);
  const color = colors.grades.find(n => n[0] <= grade)[1];
  items.forEach((n, i) => n.style.background = i < grade ? color : colors.default);
}

container.addEventListener('click', ({ target: t }) =>
  (t = t.closest(itemSelector)) && updateGrade(t)
);

container.querySelectorAll(itemSelector).forEach(function(n) {
  n.addEventListener('click', this);
}, e => updateGrade(e.currentTarget));

const container = document.querySelector('#list');
const activeClass = 'active';

container.firstElementChild.classList.add(activeClass);

document.addEventListener('keydown', e => {
  const nextElKey = ({
    ArrowDown: 0,
    ArrowUp: 1,
  })[e.key];

  const currEl = container.querySelector(`:scope > .${activeClass}`);
  const nextEl =
    currEl[[ 'nextElementSibling', 'previousElementSibling' ][nextElKey]]/* ??
    container[[ 'firstElementChild', 'lastElementChild' ][nextElKey]]*/;

  // если надо, чтобы при переходе от последнего к следующему элементу
  // активным становился первый, а при переходе от первого к предыдущему
  // активным становился последний, достаточно удалить многострочное 
  // комментирование выше

  if (nextEl) {
    currEl.classList.remove(activeClass);
    nextEl.classList.add(activeClass);
  }
});

const next = function(step) {
  this[1][this[0]].classList.remove(activeClass);

  this[0] = Math.max(0, Math.min(this[1].length - 1, this[0] + step));
  // или, если надо, чтобы выделение по кругу бегало
  // this[0] = (this[0] + step + this[1].length) % this[1].length;

  this[1][this[0]].classList.add(activeClass);
}.bind([ 0, container.children ]);

next(0);

document.addEventListener('keydown', ({ key }) => {
  const step = +(key === 'ArrowDown') || -(key === 'ArrowUp');
  if (step) {
    next(step);
  }
});

Object.values(Object.fromEntries(arr.map(n => [ n.user.id, n ])))

// или, если в результирующий массив должны попадать те из "одинаковых" элементов,
// что расположены в исходном массиве первыми

Object.values(arr.reduce((acc, n) => (acc[n.user.id] ??= n, acc), {}))

// или, если также надо сохранять взаимное расположение элементов

arr.filter(function({ user: { id: n } }) {
  return !(this[n] = this.hasOwnProperty(n));
}, {})

function* unique(data, key = n => n) {
  const getKey = key instanceof Function ? key : n => n[key];
  const keys = new Set;

  for (const n of data) {
    const k = getKey(n);
    if (!keys.has(k)) {
      keys.add(k);
      yield n;
    }
  }
}

Array.from(unique([{id: 1}, {id: 2}, {id: 1}, {id: 1} ], 'id')) // [{id: 1}, {id: 2}]

for (const n of unique(Array(20).keys(), n => Math.sqrt(n) | 0)) {
  console.log(n); // 0 1 4 9 16
}

const radios = document.querySelectorAll('[name="radios"]');
const selects = Array.from(radios, n => n.nextElementSibling);
const onChange = e => selects.forEach(n => n.disabled = n !== e.target.nextElementSibling);
radios.forEach(n => n.addEventListener('change', onChange));

const arithmeticProgression = ({ length, a1 = 0, d = 1 }) =>
  Array.from(
    { length },
    (n, i) => a1 + i * d
  );

const arr = arithmeticProgression({
  length: 10,
  a1: 6,
  d: 3,
});

function* arithmeticProgression(a1, d, length) {
  for (let i = 0; i < length; i++) {
    yield a1 + i * d;
  }
}

for (const n of arithmeticProgression(100, 10, 5)) {
  console.log(n);
}

console.log(Array.from(arithmeticProgression(10, -7, 10)));

const voidTags = [ 'input', 'img', 'br', 'hr', ещё какой-то тэг, и ещё, ... ];

function createHTML(data) {
  const attrs = Object
    .entries(data.attrs ?? {})
    .map(n => `${n[0]}="${n[1]}"`)
    .join(' ');

  const startTag = `<${data.tagName}${attrs && (' ' + attrs)}>`;

  if (voidTags.includes(data.tagName)) {
    return startTag;
  }

  const children = (data.subTags ?? [])
    .map(createHTML)
    .join('');

  return `${startTag}${data.text ?? ''}${children}</${data.tagName}>`;
}

const search = ` ${str}.`;
const item = arr.find(n => n.includes(search));

const test = RegExp.prototype.test.bind(RegExp(`\\b${str}\\b`));
const items = arr.filter(test);

arr.map((n, i, a) => a.slice(0, i + 1).join(''))
// или
arr.reduce((acc, n) => (acc.push((acc.at(-1) ?? '') + n), acc), [])

(function xxx(str) {
  if (str.length === arr.length) {
    return [];
  }

  const newStr = str.concat(arr[str.length]);
  return [ newStr, ...xxx(newStr) ];
})('')

overlay.click(e => {
  if (e.target === e.delegateTarget) {
    overlay.fadeOut();
  }
});

// или

overlay.click(function(e) {
  $(this).filter(e.target).fadeOut();
});

overlay
  .click(() => overlay.fadeOut())
  .children()
  .click(e => e.stopPropagation());

$.each($.parseJSON(response), (k, v) => $(`.${k}`).text(v));

for (const [ k, v ] of Object.entries(JSON.parse(response))) {
  document.querySelector(`.${k}`).innerText = v;
}

const first = document.querySelector('.listing');
const tag = 'p';
const arr = [...'ABCDEF'];

first.after(...arr.map(n => {
  const el = document.createElement(tag);
  el.innerHTML = n;
  return el;
}));

// или

first.replaceWith(first, ...arr.reduce((acc, n, i) => (
  (acc[i] = document.createElement(tag)).innerHTML = n,
  acc
), []));

// или

arr.reduce((prev, n) => (
  prev.insertAdjacentElement('afterend', document.createElement(tag)),
  prev.nextSibling.innerHTML = n,
  prev.nextSibling
), first);

// или

const parent = first.parentNode;
const nodes = parent.childNodes;

arr.forEach(function(n) {
  const el = document.createElement(tag);
  el.innerHTML = n;
  parent.insertBefore(el, nodes[++this[0]]);
}, [ Array.prototype.indexOf.call(nodes, first) ]);

// или

first.insertAdjacentHTML(
  'afterend',
  arr.map(n => `<${tag}>${n}</${tag}>`).join('')
);

$('table').on('change', 'select', ({ target: t }) => {

  $(t).replaceWith(t.value);

  // или

  $(t).prop('outerText', t.value);

  // или

  $(t).after(t.value).remove();
});

const isSelect = el => el.tagName === 'SELECT';
// или
const isSelect = el => el.nodeName === 'SELECT';
// или
const isSelect = el => el.matches('select');
// или
const isSelect = el => el instanceof HTMLSelectElement;

document.querySelector('table').addEventListener('change', ({ target: t }) => {
  if (isSelect(t)) {

    t.replaceWith(t.value);

    // или

    t.parentNode.replaceChild(new Text(t.value), t);

    // или

    t.outerText = t.value;

    // или

    t.after(t.value);
    t.remove();

    // или

    t.parentNode.replaceChildren(...Array.from(
      t.parentNode.childNodes,
      n => n === t ? t.value : n
    ));
  }
});

progress.css('background-color', [
  { min: 100, color: '#47C965' },
  { min:  40, color: '#f5dd30' },
  { min:   0, color: '#bf4542' },
].find(n => n.min <= strength).color);

const tests = [ здесь перечисляете регулярные выражения ].map((n, i) => ({
  regex: n,
  message: error_wrap.attr(`data-error_${i + 1}`),
}));

const newArr = Object
  .values(arr.reduce((acc, n, i) => ((acc[n] ??= []).push(i), acc), {}))
  .reduce((acc, n) => (n.forEach(i => acc[i] = n.length > 1), acc), []);

// или

const newArr = arr.map(function(n) {
  return this[n];
}, arr.reduce((acc, n) => (acc[n] = acc.hasOwnProperty(n), acc), {}));

// или

const count = arr.reduce((acc, n) => (acc[n] = (acc[n] ?? 0) + 1, acc), {});
const newArr = arr.map(n => count[n] > 1);

// или

const newArr = arr.map((n, i, a) => a.indexOf(n) !== a.lastIndexOf(n));

arr.forEach(function(n, i, a) {
  a[i] = this.get(n) > 1;
}, arr.reduce((acc, n) => acc.set(n, -~acc.get(n)), new Map));

// или

const duplicates = arr.reduce((acc, n) => acc.set(n, acc.has(n)), new Map);
arr.splice(0, arr.length, ...arr.map(n => duplicates.get(n)));

$('select').change(function() {
  const text = $(':checked', this).text();
  console.log(text);
});

document.querySelector('select').addEventListener('change', function(e) {
  const select = this;
  // или
  // const select = e.target;
  // const select = e.currentTarget;

  const [ option ] = select.selectedOptions;
  // или
  // const option = select[select.selectedIndex];
  // const option = select.querySelector(':checked');
  // const option = [...select.options].find(n => n.selected);

  const text = option.text;
  // или
  // const text = option.textContent;
  // const text = option.innerText;

  console.log(text);
});