0xD34F

$('.elem_block').on('click', '.dell', function() {
  $(this).closest('.block').addClass('fx_none');
  $('.no-res').toggleClass('fx_none', !!$('.block:not(.fx_none)').length);
});

или

document.addEventListener('click', e => {
  const btn = e.target.closest('.dell');
  if (btn) {
    btn.closest('.block').classList.add('fx_none');
    document.querySelector('.no-res').classList.toggle(
      'fx_none',
      !!document.querySelector('.block:not(.fx_none)')
    );
  }
});

UPD. Наконец-то дождались. Теперь можно сделать так:

• Класс fx_none вырезаем
  
• Элементам .no-res и .elem_block добавляем общую обёртку, какой-нибудь <div class="container">
  
• По кликам на .dell вместо добавления класса, скрывающего элементы, удаляем их по-настоящему:
  
  

  document.querySelectorAll('.dell').forEach(function(n) {
    n.addEventListener('click', this);
  }, e => e.target.closest('.block').remove());

• Прячем .no-res, если в .elem_block что-то есть:
  
  

  .container:has(.elem_block *) .no-res {
    display: none;
  }

  
  Если же удаление элементов не вариант, то прятать .no-res надо в том случае, если существует .block без класса, которые его скрывает:
  
  

  .container:has(.block:not(.fx_none)) .no-res {
    display: none;
  }

  
  
  

const controls = document.querySelectorAll('.segmented-control');
controls.forEach(n => n.addEventListener('change', updatePillPosition));
window.addEventListener('resize', () => controls.forEach(n => updatePillPosition.call(n)));

function updatePillPosition() {
  const inputs = [...this.querySelectorAll('.option input')];
  const x = this.offsetWidth / inputs.length * inputs.findIndex(n => n.checked);
  this.querySelector('.selection').style.transform = `translateX(${x}px)`;
}

const SHOW_ON_LOAD = 3;
const SHOW_MORE = 2;

const items = [...document.querySelectorAll('.box-list__item')];
const button = document.querySelector('.show-more');

showItems(SHOW_ON_LOAD);
button.addEventListener('click', () => showItems(SHOW_MORE));

function showItems(count) {
  items.splice(0, count).forEach(n => n.classList.add('ui-box-active'));
  button.classList.toggle('ui-button-hidden', !items.length);
}

const data = Array.prototype.reduce.call(
  document.querySelectorAll('input'),
  (acc, n) => {
    const keys = n.name.match(/\w+/g);
    const key = keys.pop();
    keys.reduce((p, c) => p[c] ??= {}, acc)[key] = n.value;
    return acc;
  },
  {}
);

Вместо назначения индивидуальных обработчиков клика элементам списка (которых в момент назначения ещё нет, openItems оказывается пуст, так что обработчики никому не назначаются) сделайте один делегированный, надо

openItems.forEach(function (formItem) {
  formItem.addEventListener('click', function () {
    openBtn.innerText = this.innerText;
    openList.classList.remove('open');
    hiddenInput.value = this.dataset.value;
  });
});

заменить на

openList.addEventListener('click', function(e) {
  const item = e.target.closest('li.form-item');
  if (item) {
    openBtn.innerText = item.innerText;
    openList.classList.remove('open');
    hiddenInput.value = item.dataset.value;
  }
});

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

const newData = data.map((n, i, a) => ({
  ...n,
  newSick: n.sick - (i < ~-a.length && a[-~i].sick),
}));

Добавить свойство элементам существующего массива:

data.forEach((n, i, a) => n.newSick = n.sick - (a[i + 1]?.sick ?? 0));
// или
data.reduceRight((prev, n) => (n.newSick = n.sick - prev, n.sick), 0);

const sorted = (arr, key) => arr
  .map(n => [ key(n), n ])
  .sort(([a], [b]) => a < b ? -1 : +(a > b))
  .map(n => n[1]);

Так как сортировка сбивается из-за наличия нечисловых символов в начале некоторых строк, просто вырежем их:

const sortedArr = sorted(arr, n => n[0].replace(/^\D+/, ''));

Если же значения могут быть не только двухзначными, то сравнивать их как строки уже нельзя. Делаем из них настоящие числа, считаем сумму; если второе слагаемое отсутствует, используем первое повторно:

const sortedArr = sorted(arr, n => {
  const d = n[0].match(/\d+/g);
  return +d[0] + +d.at(-1);
});

let count = 0;
const countEl = document.querySelector('.text');
const buttons = [...document.querySelectorAll('.click')];
const onClick = e => updateCount(e.target.classList.toggle('clicked') ? 1 : -1);
const updateCount = change => countEl.innerText = count += change;
buttons.forEach(n => n.addEventListener('click', onClick));
updateCount(buttons.reduce((acc, n) => acc + n.classList.contains('clicked'), 0));

const result = arr.map((n, i) => n * matrix.reduce((acc, row) => acc + row[i], 0));

или

const result = Array(arr.length).fill(0);

for (const row of matrix) {
  for (const [ i, n ] of row.entries()) {
    result[i] += n * arr[i];
  }
}

Вместо click'а у кнопки обрабатывайте input у формы:

- document.querySelector('.calculate').addEventListener('click', function () {
+ document.querySelector('form').addEventListener('input', function () {

UPD. Сам обработчик - как-то не круто всё выглядит:

let select = document.querySelector('select').selectedIndex;
let selectValue = select + 1; // selectedIndex считается с 0, поэтому +1

Зачем индекс? У option'ов указаны value, так что можно смотреть значение select'а.

let dateStart = document.querySelector('.start_date').value;
let dateEnd = document.querySelector('.end_date').value;

Ради получения значений нет необходимости искать элементы - ссылки на них есть в свойстве elements формы, в качестве ключа выступают значения атрибутов id и name. Также можно создать FormData, и доставать нужное уже оттуда.

let out_3 = document.querySelector('.out_3');

Аналогично - искать элемент не надо, ссылка на output внутри него есть в elements формы.

for (let i = dateStart; i <= dateEnd; i = i + 24 * 60 * 60 * 1000) {

Цикл не нужен. Вычитаем одну дату из другой, делим на количество миллисекунд в дне, получаем таким образом количество дней.

Исправляем:

document.querySelector('form').addEventListener('input', function() {
  const { elements } = this;
  const data = new FormData(this);
  const keys = [ 'enterDate', 'outDate', 'countRooms', 'prepayment' ];

  const basePayment = 2000;
  const [ enter, out, rooms, prepayment ] = keys.map(k => data.get(k) /* или elements[k].value */);
  const days = enter && out && enter < out
    ? (new Date(out) - new Date(enter)) / (24 * 60 * 60 * 1000)
    : 0;

  elements.payment.textContent = `${basePayment * days * rooms - prepayment} р`;
});

const result = Array.prototype.reduce.call(letter, (acc, n) => (
  (n = soundParts[Number.isNaN(+n) ? 'letter' : 'number'][n]) && acc.push(n),
  acc
), []);

или

const result = Object
  .entries(Object.assign({}, ...Object.values(soundParts)))
  .reduce((acc, n) => (letter.includes(n[0]) && acc.push(n[1]), acc), []);

str.match(/\]\s*(.+?)\s*#/)?.[1] ?? '< unknown >'

Делаем просто:

const result = arr.reduce((acc, n, i, a) => (
  (i && n.name === a[~-i].name) || acc.push([]),
  acc.at(-1).push(n),
  acc
), []);

Делаем сложно:

function groupAdjacent(
  data,
  {
    key = n => n,
    newGroup = (c, p) => c !== p,
  } = {}
) {
  const getVal = key instanceof Function ? key : n => n[key];

  return Array.prototype.reduce.call(
    data,
    (acc, n, i) => {
      const v = getVal(n, i);
      const iGroup = acc[0].length - (i && !newGroup(v, acc[1]));
      (acc[0][iGroup] ??= []).push(n);
      acc[1] = v;
      return acc;
    },
    [ [], null ]
  )[0];
}

const result = groupAdjacent(arr, { newGroup: (c, p) => c.name !== p.name });
// или
const result = groupAdjacent(arr, { key: 'name' });

for (let i in goods) {
  if (discounts.length === 0) {
    count = goods[i].value * goods[i].amount;
  }
  for (let j in discounts) {
    if (goods[i].name === discounts[j].name) {
      count =
        (goods[i].value - goods[i].value * discounts[j].discount) *
        goods[i].amount;
    } else {
      count = goods[i].value * goods[i].amount;
    }
  }
  sum += count;
  console.log(count, goods[i].name);
}

Зачем на каждой итерации цикла, ищущего скидку, пересчитывать цену? Предположим, нашли скидку для текущего товара, что дальше? Дальше, на следующей итерации, цена будет рассчитана заново, но уже без скидки - ведь объект скидки будет другим, будет соответствовать другому товару. Исключение - если скидка найдена на последней итерации.

Правильно будет вычислять до цикла сумму без скидки, искать в цикле скидку, если нашли - пересчитывать со скидкой, прерывать цикл:

for (const n of goods) {
  let s = n.value * n.amount;
  for (const m of discounts) {
    if (n.name === m.name) {
      s *= 1 - m.discount;
      break;
    }
  }
  sum += s;
}

Возможно есть лучший способ для решения такой задачи.

function totalCost(goods, discounts) {
  discounts = Object.fromEntries(discounts.map(n => [ n.name, 1 - parseFloat(n.discount) / 100 ]));
  return goods.reduce((acc, n) => acc + n.value * n.amount * (discounts[n.name] ?? 1), 0);
}

let letters = 'АаЕеIiOoUuYy'  //Создал переменную со строкой с гласными

Почему символы из разных алфавитов? - первые четыре кириллические.

if (arg1[i] == letters[j]) {  //Если элемент слова равен элементу строки с согласными
  newArr.push(arg1[i].indexOf())  //То пушу в массив индексы гласных этого слова
}

Зачем тут indexOf (кстати, вы не знаете, что он делает, откройте документацию и разберитесь)? Что является индексом проверяемого символа? Строчкой выше ещё помнили, а когда до push'а дело дошло, уже забыли? Просто .push(i).

Не ошибка, но упомянуть косячок стоит - после найденного совпадения продолжать крутить внутренний цикл смысла нет. Гуглите, как прервать цикл.

Ну и это, как ещё можно сделать:

const getVowelsIndexes = str =>
  Array.from(str.matchAll(/[aeiouy]/gi), n => n.index);

или

const getVowelsIndexes = ((vowels, str) =>
  Array.prototype.reduce.call(
    str.toLowerCase(),
    (acc, n, i) => (vowels.has(n) && acc.push(i), acc),
    []
  )
).bind(null, new Set('aeiouy'));

или

const getVowelsIndexes = str => Object
  .entries(str)
  .filter(n => 'AaEeIiOoUuYy'.includes(n[1]))
  .map(n => +n[0]);

или

const getVowelsIndexes = str =>
  eval(`[${[...str]
    .map((n, i) => /a|e|i|o|u|y/i.test(n) ? `${i},` : '')
    .join('')
  }]`);

Кого будем перекрашивать, и в какие цвета:

const className = 'some-link';
const colors = {
  En:   'red',
  Ru: 'green',
  De:  'blue',
};

Перекрашиваем текст в случае точного совпадения:

for (const n of document.getElementsByClassName(className)) {
  n.style.setProperty('color', colors[n.textContent]);
}

Или, смотрим наличие подстроки, регистр не важен:

document.querySelectorAll(`.${className}`).forEach(function(n) {
  n.style.color = this.find(m => m[0].test(n.innerText))?.[1];
}, Object.entries(colors).map(n => [ RegExp(n[0], 'i'), n[1] ]));

Можно и без регулярных выражений:

- RegExp(n[0], 'i')
+ n[0].toLowerCase()

- m[0].test(n.innerText)
+ n.innerText.toLowerCase().includes(m[0])

const newData = data.reduce((acc, n) => {
  const k = Object.keys(n)[0];
  (acc.result[acc.keys[k] = (acc.keys[k] ?? -1) + 1] ??= []).push(n);
  return acc;
}, { result: [], keys: {} }).result.flat();

или

const numKeys = new Set(data.flatMap(Object.keys)).size;
const numObjs = data.length / numKeys;
const newData = data.map((n, i, a) => a[(i % numKeys) * numObjs + (i / numKeys | 0)]);

document.querySelectorAll('селектор элементов').forEach(n => {
  n.classList.toggle('класс', n.children.length >= минимум_необходимого);
});

(function toArrays(obj) {
  const arr = Object.values(obj ?? {});
  arr.forEach(n => n.children = toArrays(n.children));
  return arr;
})(arr.reduce((acc, n) => {
  const keys = n.path.replace(/^\/|\/$/g, '').split('/');
  const obj = keys.reduce((p, c) => (p.children ??= {})[c] ??= {}, acc);
  Object.assign(obj, n);
  return acc;
}, {}).children)