Alexandroppolus

type FuncSetNameParams = ['employers', {company: string}] | ['employees', {fio: string}] | ['products', {name: string}];

const setName = (...[key, item]: FuncSetNameParams): string => {
  switch (key) {
    case 'employers':
      return item.company
    case 'employees':
      return item.fio
    case 'products':
      return item.name
  }
}

https://www.typescriptlang.org/play?target=9&ssl=1...

это если все варианты возвращают строку.
а если тип возвращаемого значения зависит от key, то надо ещё слегонца дописать..

а возможно, всё гораздо проще, и item всегда один и тот же объект, независимо от key. Тогда просто описать его тип и использовать этот тип вместо unknown

Просто посмотри, как они строятся по таблице истинности, и всё станет очевидно

40000000 чисел Фибоначчи - это лютая вещь со всех сторон. Даже если ты врубишь мемоизацию, как посоветовал Максим Припадчев , то там дохрена вычислений, потому что числа будут длиной в миллионы цифр.

Мы суммируем только четные числа Фибоначчи.
Легко заметить, что F(n) четное, только если n делится на 3, т.е. n = 3m.
То есть тебе нужна сумма F(3*m) для всех m от 0 до floor((40000000-2) / 3) включительно, если правильно понимаю этот ваш range.

я тут пояндексил и промыслил формулы:
1) F(3*n) = F(n+1)^3 + F(n)^3 + F(n-1)^3 (из википедии)
2) sum[0...N] F(i)^3 = (1/2)*(F(n)*F(n+1)^2 + (-1)^(n-1)*F(n-1) + 1) отсюда

сумму F(3*n) можно выразить через сумму F(n)^3 и потом применить формулу (2)

в итоге получается

sum[0...N] F(3*i) = (1/2)*(F(n)*F(n+1)^2 + (-1)^(n-1)*F(n-1) + 1) - 1 + F(n)^3 + F(n+1)^3

для этого выражения нам нужны F(n), F(n+1) и F(n-1) = F(n+1) - F(n)

F(n) и F(n+1) вычисляем методом "fast doubling", который делает O(ln(n)) действий вместо O(n) стандартного способа. Ускорение знатное.

Итого:

const fib = (n, a = []) => {
    if (n < 1) {
        a[0] = 0n;
        a[1] = 1n;
    } else {
        const m = Math.floor(n/2);
        fib(m, a);
        const x = a[0] * (2n * a[1] - a[0]);
        const y = a[0] * a[0] + a[1] * a[1];
        if (n % 2) {
            a[0] = y;
            a[1] = x + y;
        } else {
            a[0] = x;
            a[1] = y;
        }
        
    }
    return a;
}

const sumFib3n = (n) => {
    if (n < 1) { return 0n; }

    const [fn, fnp1] = fib(n); // fn = fib(n), fnp1 = fib(n+1), 
    const fnm1 = fnp1 - fn;  // fnm1 = fib(n-1), 
    const sgn = n % 2 ? 1n : -1n;
    const sumPow3 = (fn * fnp1 * fnp1 + sgn * fnm1 + 1n) / 2n;
    
    return sumPow3 - 1n + fn * fn * fn + fnp1 * fnp1 * fnp1;
}

console.log(sumFib3n(Math.floor((40000000 - 2)/3)));

function getIntermediateItems(tree, result = []) {
  tree?.forEach((item) => {
    if (item.workControl?.includes('intermediate')) {
      result.push(item);
    }
    getIntermediateItems(item.content, result);
  });
  return result;
}

const arr = getIntermediateItems(myarr);
document.getElementById("dd").prepend(JSON.stringify(arr, '', 4))

Одно из двух: либо слишком часто обновляется стор, либо ты поймал бесконечный ререндер.
Хотя, кстати, возможен комбинированный вариант - вызов эффекта на каждом ререндере, обновление стора в эффекте.

В общем, без кода непонятно.

у тебя act.violation_type равен undefined.
такие дела.

Если "пустое" значение совсем валидно, то лучше его. Если совсем невалидно, то null.
Разумеется, есть и промежуточные варианты, когда это значание - объект, и некоторые поля можно использовать, а некоторые нет. Тут по ситуации, исходя из того, как удобнее делать проверки.

C null можно ещё немного переписать код так:

return value == null ? <EmptyComponent ../> : <RealComponent value={value} />

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

Рискнем предположить, что у тебя есть полный набор слов, в котором надо искать. Обходишь его циклом, для каждого слова считаешь число, собираешь хэш-таблицу (число -> массив_слов)

Теперь можно сразу взять все слова по числу

Если взять турнирную сетку на 2^N человек (или N раундов), то можно ещё составить рекуррентную формулу вероятности встречи P(N)

P(1) = 1
P(N) = 1/(2^N - 1) + (2^N - 2) /(2^N - 1) * 1/4 * P(N-1)

2^N - это 2 в степени N

здесь первое слагаемое для случая, когда второй игрок в самом ближайшем раунде встречается с первым
второе слагаемое - все остальные случаи, для которых с вероятностью 1/4 оба игрока выиграют раунд и далее встретятся с вероятностью P(N-1)

теперь по индукции можно доказать, что P(N) = 1/2^(N-1)

codewars, leetcode, и все остальные.

js

const func = (arr) => {
    if (!arr) {return [];}

    const counts = new Map();
    const r = [];

    arr.forEach((x) => {
        const count = counts.get(x) || 0;
        if (r.length === count) {
            r.push([]);
        }
        r[count].push(x);
        counts.set(x, count + 1);
    });

    return r;
}