0xD34F

Не "что", а "в каком случае".

return getValue(objectValus[prop], property);

Надо не тупо возвращать результат рекурсивного вызова, а сначала проверять, что там не undefined, например.

А вообще, можно и попроще сделать:

const getValue = (obj, key) => Object
  .values(obj ?? {})
  .reduce((found, n) => found ?? getValue(n, key), obj?.[key]);

Массив выбранных значений у вас есть - вот на его основе и создавайте input'ы:

<div className={css.inputList}>
  {checkedList.map(n => (
    <div className={css.field} key={n}>
      <p>{n}:</p>
      <Input />
    </div>
  ))}
</div>

потому что это не jquery

Можно сбросить в 0 продолжительность выполнения анимации: transition-duration: 0ms;.
Или вообще убрать её: transition: none;.

Как это будет выглядеть на практике: определяете в стилях класс, который убирает анимацию, в компоненте определяете свойство, в зависимости от значения которого класс будет назначаться элементу. Надо, чтобы анимация воспроизводилась - устанавливаете свойству значение true, не нужна анимация - false. Как-то так.

const total = results.reduce((acc, n) => acc + n.counts, 0);
const resultsObj = Object.fromEntries(results.map(n => [ n.id, n.counts ]));
const usersWithResults = users.map(n => ({
  ...n,
  result: (resultsObj[n.id] ?? 0) / total * 100,
}));

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

const result = Object.values(arr.reduce((acc, { id }) => (
  (acc[id] ??= { id, count: 0 }).count++,
  acc
), {}));

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

function uniqueWithCount(data, key, countKey) {
  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) ?? { ...n, [countKey]: 0 })
      .get(k)[countKey]++;
  }

  return unique;
}

const result = Array.from(
  uniqueWithCount(arr, 'id', 'count').values(),
  ({ id, count }) => ({ id, count })
);

Да без понятия, в чём там у вас проблема. Что за ошибка - об этом вы почему-то предпочли умолчать. Так что, какой вопрос - такой ответ. Вот вам решения рабочие, сравнивайте со своим, думайте:

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

function solve(arr) {
  const last = arr.reduce((acc, n, i) => (acc[n] = i, acc), {});
  return arr.filter((n, i) => last[n] === i);
}

Или удалять элементы из существующего:

function solve(arr) {
  const last = new Map(arr.map((n, i) => [ n, i ]));

  arr.length -= arr.reduce((acc, n, i, a) => (
    a[i - acc] = n,
    acc + (i !== last.get(n))
  ), 0);

  return arr;
}

Или и то и другое сразу:

const solve = arr => (
  arr.splice(0, arr.length, ...[...new Set(arr.reverse())].reverse()),
  arr
);

values.map{|n| Hash[keys.map(&:to_sym).zip(n)]}

Возможны варианты:

const merge = (arr1, arr2, step) => Array
  .from(
    { length: Math.min(arr1.length, 1 + arr2.length / step | 0) },
    (_, i) => [ ...arr2.slice(~-i * step, i * step), arr1[i] ]
  )
  .flat();

или

const merge = (arr1, arr2, step) =>
  [].concat(...Array.from(
    { length: Math.min(arr1.length, 1 + arr2.length / step | 0) },
    (_, i) => [ arr1[i], ...arr2.slice(i * step, -~i * step) ]
  ));

или

const merge = (arr1, arr2, step) =>
  Array.prototype.flatMap.call(arr1, (n, i) => [
    ...Object.assign(
      i ? Array(step).fill(null) : [],
      arr2.slice((i - 1) * step, i * step)
    ),
    n,
  ]);

или

function merge(arr1, arr2, step) {
  const len = arr2.length;
  return Array.from(
    { length: len - (len % step) + 1 + len / step | 0 },
    (_, i) => {
      const j = i / (step + 1) | 0;
      return i % (step + 1)
        ? arr2[i - j - 1]
        : arr1[j] ?? null
    });
}

Для вашего случая - const c = merge(b, a, 5); - можете воспользоваться любой из этих функций, результаты выдадут одинаковые. Чего может и не быть с другими аргументами. Например:

Во втором массиве недостаточно элементов:

merge('ABCD', [ 1, 2, 3, 4, 5, 6, 7 ], 4)

// первая и четвёртая функции останавливаются на элементе первого массива,
// если во втором массиве не хватает элементов, на заполнение
// очередного промежутка между элементами первого массива
['A', 1, 2, 3, 4, 'B']

// вторая функция остановится после того,
// как отдаст все элементы второго массива
['A', 1, 2, 3, 4, 'B', 5, 6, 7]

// третья функция подставит дефолтные значения
// вместо недостающих элементов второго массива
['A', 1, 2, 3, 4, 'B', 5, 6, 7, null, 'C', null, null, null, null, 'D']

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

merge('ABC', [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ], 2)

// 1, 3
['A', 1, 2, 'B', 3, 4, 'C']

// 2
['A', 1, 2, 'B', 3, 4, 'C', 5, 6]

// 4
['A', 1, 2, 'B', 3, 4, 'C', 5, 6, null, 7, 8, null]

const grouped = props.mainPage.room.reduce((acc, n) => (
  (acc[n.storey] ??= []).push(n),
  acc
), {});

{Object.entries(grouped).map(([ groupName, group ]) => (
  <div className="group" key={groupName}>
    <h3>{groupName}</h3>
    {group.map(n => <NumberRoom key={n.id} {...n} />)}
  </div>
))}

Ничего не лучше - показанные куски кода делают разное. Откройте консоль, выполните

(function() {
  function func(arg) {
    console.log(arg, this);
  }

  let arg = 1;

  const f1 = () => func(arg);
  const f2 = func.bind(this, arg);

  arg = 2;

  f1();
  f2();
}).call('hello, world!!');

, подумайте над полученными результатами.

Сами решайте, чего вам надо.

this.setState(({ todos }) => ({
  todos: todos.map((n, i) => i === index
    ? { ...n, isSuccess: true }
    : n
  ),
}));

Второе значение - подставляйте противоположное по знаку:

sorted(result, key=lambda n: (n[0], -n[1]))

Array.from(str, n => n < 5 ? 0 : 1).join('')

// или

[...str].reduce((acc, n) => acc + +(n >= 5), '')

// или

''.concat(...str.split('').map(n => Math.floor(n / 5)))

// или

[].map.call(str, n => -~-~-~n >> 3).join``

// или

str.replace(/./g, m => Number('56789'.includes(m)))

// или

str.replace(/[1-4]/g, 0).replace(/[5-9]/g, 1)

const newArr = Array.from(
  { length: arr.length / 2 },
  (n, i) => ({ ...arr[i], ...arr[i + arr.length / 2] })
);

Но всегда ли количество ключей будет равно двум? - лучше посчитаем самостоятельно, сколько их там:

const numKeys = new Set(arr.flatMap(Object.keys)).size;
const newArr = arr.reduce((acc, n, i, a) => (
  Object.assign(acc[i % (a.length / numKeys)] ??= {}, n),
  acc
), []);

// или

const numKeys = Object.keys(Object.assign({}, ...arr)).length;
const numObjs = arr.length / numKeys;
const newArr = Array.from(
  { length: numObjs },
  (n, i) => Object.assign({}, ...Array.from(
    { length: numKeys },
    (m, j) => arr[j * numObjs + i]
  ))
);

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

const newArr = arr.reduce((acc, n) => {
  const [ [ k, v ] ] = Object.entries(n);
  const i = acc[0][k] = (acc[0][k] ?? -1) + 1;
  (acc[1][i] ??= {})[k] = v;
  return acc;
}, [ {}, [] ])[1];

Меняем на месте:

for (let i = 1; i < arr.length; i += 2) {
  [ arr[i], arr[i - 1] ] = [ arr[i - 1], arr[i] ];
}

Создаём новый массив:

const newArr = arr.map((n, i, a) => a[i - (i & 1 || -1)] ?? n);

document.querySelector('селектор контейнера с кнопками').addEventListener('click', e => {
  const coord = e.target.dataset.addressItem?.split(' ').map(Number);
  if (coord) {
    map.setCenter(coord);
    marker.geometry.setCoordinates(coord);
  }
});

Потому что целевым элементом будет уже не <a>. Соответственно, не будет и атрибута href. А у null не будет метода substr. О чём вы должны были узнать сами, из сообщения об ошибке - если бы открыли консоль.

Вместо target следует использовать currentTarget.

url.match(/.+\//)[0]

// или

url.replace(/[^\/]+$/, '')

// или

url.slice(0, url.lastIndexOf('/') + 1)

// или

url.split(/(?<=\/)/).slice(0, -1).join('')

// или

[...url].reduceRight((acc, n) => (acc || n === '/') ? n + acc : acc, '')