Alexandroppolus

А сколько всего студентов?
Если их N человек, то надо минимум C(N, 4) = N! / (4! * (N-4)!) интрегалов.

У нас имеется C(N, 4) различных четверок студентов. Для каждой четверки определим свой уникальный интеграл, в который они не смогли. Его решили все остальные.
Таким образом, любые 4 студента не справятся ровно с одним интегралом, и любой дополнительный пятый возьмет его (1 или 2 студента обязательно входят как минимум в 1 четверку и тоже не возьмут по крайней мере 1 интеграл).

Можно ли меньше?
Тогда либо найдется четверка, для которой нет "плохого" интеграла, то есть которая может взять их все, либо (по принципу Дирихле) найдутся 2 разные четверки, у которых общий "плохой" интеграл, но тогда из них можно собрать 5 студентов, которые с этим интегралом не справятся. Т.е. как ни крути, условия не выполняются.

в конец Expand нужно дописать & {}

ссылка, поправил Expand, из прочих типов выкинул лишнее

type NonNull<T> = {[K in keyof T]: Exclude<T[K], null>};


type X = NonNull<{email: string | null}>;

Я тоже не совсем понял, почему нужен именно класс, но если уж приспичило, то типизировать можно так: ссылка

и поскольку у тебя фиксированный набор полей, то лучше однократно навесить геттеры на прототип этого класса. То есть на User.prototype. Будет экономичнее при создании множества экземпляров. Только функцию для геттера сделать не стрелочной

За каждой фигуркой закреплена цифра. Для звёздочки подходит только 5. Слагаемые равны 555/3 = 185

Задача B

это которая про две пары индексов, с минимальной и максимальной дельтой?

там нужен просто один цикл по массиву. В нем надо поддерживать наилучшие найденные результаты, а так же максимальный и минимальный элементы слева от текущего. Набросок на js:

function findMM(arr) {
    let minDelta = Infinity, maxDelta = -Infinity;
    let i1 = 0, i2 = 0, j1 = 0; j2 = 0;
    let iMax = 0; // индекс максимального элемента
    let iMin = 0; // индекс минимального элемента
    for (let j = 1; j < arr.length; ++j) {
        //  минимальная дельта - разница между минимальным элементом
        // среди ранее найденных, и текущим
        if (arr[iMin] - arr[j] < minDelta) {
            i1 = iMin;
            j1 = j;
            minDelta = arr[iMin] - arr[j];
        }
        //  максимальная дельта - разница между максимальным элементом
        // среди ранее найденных, и текущим
        if (arr[iMax] - arr[j] > maxDelta) {
            i2 = iMax;
            j2 = j;
            maxDelta = arr[iMax] - arr[j];
        }
        if (arr[j] < arr[iMin]) {
            iMin = j;
        }
        if (arr[j] > arr[iMax]) {
            iMax = j;
        }
    }
    return [[i1, j1], [i2, j2]];
}

1) заменить any на unknown
2) отключить богомерзкий @typescript-eslint/no-empty-object-type в конфиге eslint
3) добавить displayName, видимо для PageWrapper

Playground

что поменялось: сделал RouteOptions как генерик, туда залетает тип B для body

метод get в классе Mini стал генериком по этому типу для body

далее вместо всего типа для RouteOptions, везде передается и доезжает до SpecifyContext этот самый B

Лишние фигурные скобки вокруг theme.id, зря ты это так

Как вариант:
ссылка

ProfileEntity теперь type, не interface

https://neerc.ifmo.ru/wiki/index.php
https://ru.algorithmica.org/
e-maxx.ru/algo (к нему есть ещё английский вариант, это типа как перевод, но там больше всего)

по математике считается неплохой книгой вот эта

Ну и для более вдумчивого неспешного изучения - классика: Кормен, Скиена, Кнут...

это ведь при n, стремящемся к бесконечности?

выражение сверху надо привести к общему знаменателю, а n^(q+1) перекинуть наверх, ну а (n+1)^q развернуть по биному Ньютона:

(1/n^q - 1/(n+1)^q) / (1/n^(q+1)) =

= ( ((n+1)^q - n^q) / (n^q * (n+1)^q) ) * n^(q+1) =

= ((n+1)^q - n^q) * n / (n+1)^q =

= (n^q + q * n^(q-1) + ... - n^q) * n / (n+1)^q =

= (q * n^(q-1) + ... ) * n / (n+1)^q =

= (q * n^q + ... ) / (n^q + ...)

на месте многоточий тут слагаемые, у которых n в меньшей степени, чем q, и если n стремится к бесконечности, то их можно считать незначительными по сравнению с n^q

вот и остается q * n^q / n^q , которое сокращается до q