0xD34F

/(?=.*1)(?=.*2)(?=.*3)/.test(str)

или

[ 1, 2, 3 ].every(n => str.includes(n))

или

new Set(str.match(/[123]/g)).size === 3

Как можно дополнить мой код, чтобы он проверял то, что требуется?

Дополнить - никак. Надо переписать. К единице надо плюсовать не все результаты рекурсивных вызовов, а только один, наибольший.

И можно как-нибудь без объявления переменной n внутри функции?

Можно:

const getMaxDepth = arr =>
  Array.isArray(arr)
    ? 1 + Math.max(0, ...arr.map(getMaxDepth))
    : 0;


console.log(getMaxDepth([ 1, [ 2 ], [ [ 3 ] ], [ [ [ 4 ] ] ] ])); // 4
console.log(getMaxDepth([])); // 1
console.log(getMaxDepth(666)); // 0

const createArr = (source, maxLength) =>
  [...Array(1 + Math.random() * maxLength | 0)].map(() => source[Math.random() * source.length | 0]);


const [ arr1, arr2, arr3 ] = [...Array(3)].map(() => createArr(arr, 5));

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

const createArr = ([...source], maxLength) => Array.from(
  { length: Math.min(source.length, 1 + Math.random() * maxLength | 0) },
  () => source.splice(Math.random() * source.length | 0, 1)[0]
);

или, копируем исходный массив, перемешиваем копию, берём случайное количество элементов из начала:

function createArr(source, maxLength) {
  const arr = source.slice();

  for (let i = arr.length; --i > 0;) {
    const j = Math.random() * (i + 1) | 0;
    [ arr[j], arr[i] ] = [ arr[i], arr[j] ];
  }

  return arr.slice(0, 1 + Math.random() * maxLength | 0);
}

function createTable(rows, cols) {
  const maxLen = `${rows * cols}`.length;

  return [...Array(rows)]
    .map((n, i) => [...Array(cols)]
      .map((m, j) => `${cols * i + j + 1}`.padStart(maxLen, 0))
      .join(' '))
    .join('\n');
}

или

function createTable(rows, cols) {
  const zeroStr = Array(1 + Math.ceil(Math.log10(rows * cols + 1))).join(0);
  let result = '';

  for (let i = 0; i < rows; i++) {
    result += i ? '\n' : '';

    for (let j = 0; j < cols; j++) {
      result += (j ? ' ' : '') + (zeroStr + (cols * i + j + 1)).slice(-zeroStr.length);
    }
  }

  return result;
}

https://datatables.net/reference/option/language.search

series: {
  0: {
    color: 'red',
  },
},

const grouped = arr.reduce((acc, n) => {
  const [ , month, year ] = n.x.split('.');
  (acc[year] ??= Array(12).fill(0))[month - 1] += n.y;
  return acc;
}, {});

const SHOW_INITIAL = 3;
const SHOW_MORE = 5;
const listSelector = '.myList';
const itemSelector = 'li';
const showSelector = '.loadMore';
const hideSelector = '.showLess';

$(listSelector)
  .on('click', showSelector, function({ delegateTarget: t }) {
    $(`${itemSelector}:hidden`, t).slice(0, SHOW_MORE).show();
  })
  .on('click', hideSelector, function({ delegateTarget: t }) {
    $(`${itemSelector}:visible`, t).slice(SHOW_INITIAL).slice(-SHOW_MORE).hide();
  })
  .each(function() {
    $(itemSelector, this).slice(0, SHOW_INITIAL).show();
  });

Режем второй параметр на куски, перебираем полученный массив ключей для извлечения значения вложенного свойства - следующее значение будет свойством предыдущего с именем, равным текущему элементу массива:

const sorted = (arr, path) => arr
  .map(function(n) {
    return [ n, this.reduce((p, c) => p?.[c], n) ];
  }, path.split('.'))
  .sort((a, b) => a[1] - b[1])
  .map(n => n[0]);

А вообще, предлагаю изменить тип второго параметра со строки на функцию:

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


const sortedByCommentsCount = sorted(arr, n => n.comments.count);
const sortedByLengthDesc = sorted(arr, n => -n.length);

FormData:

document.querySelector('form').addEventListener('submit', function(e) {
  e.preventDefault();
  const data = Object.fromEntries(new FormData(this));
  console.log(JSON.stringify(data, null, 2));
});

https://jsfiddle.net/c9t3vLje/

Сложить в массив экземпляры picker'ов; в общем обработчике выбора даты устанавливать выбранную дату всем экземплярам и обновлять их. Как-то так:

const pickers = $('селектор элементов, на которых инициализируются экземпляры календаря')
  .datepicker({
    onSelect(formattedDate, date, picker) {
      pickers.forEach(n => n !== picker && (
        n.currentDate = picker.currentDate,
        n.selectedDates = [ date ],
        n.update()
      ));
    },
  })
  .get()
  .map(n => $(n).data('datepicker'));

То же, но для третьей версии:

const options = {
  onSelect({ date, datepicker }) {
    pickers.forEach(n => n !== datepicker && n.update({
      viewDate: datepicker.viewDate,
      selectedDates: [ date ],
    }, {
      silent: true,
    }));
  },
};

const pickers = Array.from(
  document.querySelectorAll('селектор элементов с календарями'),
  n => new AirDatepicker(n, options)
);

<select id="country"></select>
<select id="city"></select>

const setOptions = (el, data) =>
  el.innerHTML = data
    .map(n => `<option>${n}</option>`)
    .join('');


const countries = [
  { name: 'Германия', cities: [ 'Берлин', 'Бонн', 'Мюнхен' ] },
  { name: 'Франция', cities: [ 'Париж', 'Лион', 'Марсель' ] },
  { name: 'Италия', cities: [ 'Рим', 'Неаполь', 'Милан' ] },
];


const country = document.querySelector('#country');
const city = document.querySelector('#city');


setOptions(country, countries.map(n => n.name));

country.addEventListener('change', function() {
  setOptions(city, countries.find(n => n.name === this.value).cities);
});

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

https://jsfiddle.net/ky4qbt8a/

const sortedInventory = Object
  .values(inventory)
  .sort((a, b) => a.price - b.price)
  .map(n => `${n.title} - ${n.amount}`)
  .join('\n');

Вместо элементов работайте с разметкой:

const html = '<p class="table__text"></p>'.repeat(data.length);
column.forEach(n => n.insertAdjacentHTML('beforeend', html));

const add = (str, val) =>
  str.replace(/\d+$/, m => `${+m + val}`.padStart(m.length, 0));


add('string0001',    1) // 'string0002'
add('string1010',   99) // 'string1109'
add('string2345', 6789) // 'string9134'

Если при переполнении не должно происходить увеличения количества разрядов (т.е., string99 + 1 должно быть равно string00, а не string100), то после вызова padStart добавьте .slice(-m.length).

<p class="typeit">hello, world!!</p>
<p class="typeit">fuck the world</p>
<p class="typeit">fuck everything</p>

const typeit = Array.from(
  document.querySelectorAll('.typeit'),
  (n, i) => new TypeIt(n, {
    cursor: false,
    afterComplete: () => typeit[i + 1]?.go(),
  })
);

typeit[0].go();

Регистр учитываем? Да:

const firstNonRepeatingLetter = str =>
  [...str].find((n, i, a) => a.indexOf(n) === a.lastIndexOf(n)) || '';

Нет:

const firstNonRepeatingLetter = str =>
  str.charAt(Array
    .from(str.toLowerCase())
    .findIndex((n, i, a) => a.indexOf(n) === a.lastIndexOf(n))
  );

function calc(val = 0) {
  const self = {
    add: v => (val += v, self),
    sub: v => (val -= v, self),
    mul: v => (val *= v, self),
    div: v => (val /= v, self),
    pow: v => (val **= v, self),
    toString: () => val,
  };

  return self;
}


calc().add(5).mul(5) + 1 // 26
+calc(100).div(10).sub(2) // 8
`${calc(2).pow(10)}` // "1024"

Функция должна возвращать результат обработки переданного ей значения + сумму результатов обработки вложенных значений (если таковые есть):

const sum = (data, getVal) => Object
  .values(data instanceof Object ? data : {})
  .reduce((acc, n) => acc + sum(n, getVal), getVal(data));


sum([ 1, 2, 3, '1', [ '2', 4, [ '3' ] ], '4' ], x => +(typeof x === 'string')) // 4
sum({ a: { b: [ NaN, Infinity ], c: 123456 } }, x => +(typeof x === 'number')) // 3

Никак. Возвращается же всегда функция, а вызовов возможно произвольное количество. Так что, чтобы получить значение, надо выполнить какое-то дополнительное действие. Правда, в некоторых обстоятельствах, его можно выполнять неявно:

function sum(a) {
  const f = b => sum(a + b);
  f.valueOf = () => a;
  return f;
}


sum(1)(2)(3) + 4 // 10
sum(5) * sum(6) // 30
700 / sum(7) // 100
Math.pow(sum(8), 2) // 64

// но если попутно не выполняется никаких числовых операций, придётся немного поработать руками:
+sum(9)(10) // 19
Number(sum(11)(12)) // 23