Kodlo-chan
1843 lines
66 KiB
JSON
1843 lines
66 KiB
JSON
{
|
||
"version": 3,
|
||
"note": "Уровни: base — база (начинать отсюда), core — то, что спросят, deep — нишевое. Поле ref — куда смотреть, why — пояснение.",
|
||
"facts": [
|
||
{
|
||
"domain": "algo",
|
||
"q": "Средняя сложность поиска в хеш-таблице при разумной загрузке?",
|
||
"a": "амортизированное O(1)",
|
||
"accept": [
|
||
"o(1)",
|
||
"амортизированное o(1)",
|
||
"o(1) амортизированное",
|
||
"амортизированно o(1)"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_algo §1",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Худшая сложность поиска в хеш-таблице (все ключи в одну корзину)?",
|
||
"a": "O(n)",
|
||
"accept": [
|
||
"o(n)"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_algo §1",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сколько сравнений в худшем случае у бинарного поиска в массиве из 1 000 000 элементов?",
|
||
"a": "20",
|
||
"accept": [
|
||
"20",
|
||
"log2 1e6 = 20",
|
||
"около 20"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_algo §1 (log2 1e6 ≈ 20)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "При каком условии применим алгоритм Дейкстры?",
|
||
"a": "веса рёбер неотрицательны",
|
||
"accept": [
|
||
"неотрицательные веса",
|
||
"все веса >= 0",
|
||
"веса неотрицательны",
|
||
"нет отрицательных рёбер"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (графы)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Чем заменить Дейкстру при отрицательных рёбрах?",
|
||
"a": "Беллман–Форд",
|
||
"accept": [
|
||
"беллман-форд",
|
||
"беллман форд",
|
||
"bellman-ford"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (графы)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность построения кучи (heapify) из произвольного массива?",
|
||
"a": "O(n)",
|
||
"accept": [
|
||
"o(n)",
|
||
"о(n)"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_algo §2 (heapify снизу вверх)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность вставки одного элемента в кучу?",
|
||
"a": "O(log n)",
|
||
"accept": [
|
||
"o(log n)"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_algo §2",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Какая сортировка устойчивая: merge, quick, heap или selection?",
|
||
"a": "merge sort",
|
||
"accept": [
|
||
"merge",
|
||
"merge sort",
|
||
"слиянием",
|
||
"сортировка слиянием"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_algo §2",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Худшая сложность quicksort?",
|
||
"a": "O(n²)",
|
||
"accept": [
|
||
"o(n^2)",
|
||
"o(n²)",
|
||
"o(n2)"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_algo §2",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Средняя сложность quicksort и mergesort?",
|
||
"a": "O(n log n)",
|
||
"accept": [
|
||
"o(n log n)",
|
||
"o(n*logn)",
|
||
"o(nlogn)"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_algo §2",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Для какого графа возможна топологическая сортировка?",
|
||
"a": "для ациклического (DAG)",
|
||
"accept": [
|
||
"dag",
|
||
"ациклический",
|
||
"без циклов",
|
||
"dag (ациклический)"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (графы, только DAG)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Как найти цикл в связном списке за O(1) дополнительной памяти?",
|
||
"a": "алгоритм Флойда: черепаха и заяц",
|
||
"accept": [
|
||
"флойд",
|
||
"черепаха и заяц",
|
||
"алгоритм флойда"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D3 (списки)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "BFS или DFS даёт кратчайший путь в невзвешенном графе?",
|
||
"a": "BFS",
|
||
"accept": [
|
||
"bfs",
|
||
"обход в ширину"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (графы)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность Дейкстры на priority_queue (двоичная куча)?",
|
||
"a": "O((V+E) log V)",
|
||
"accept": [
|
||
"o((v+e) log v)",
|
||
"o((v+e)logv)",
|
||
"o(e log v)"
|
||
],
|
||
"level": "deep",
|
||
"ref": "урок D4 (графы)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "За какую сложность ищется НВП (LIS) в оптимальном решении?",
|
||
"a": "O(n log n)",
|
||
"accept": [
|
||
"o(n log n)",
|
||
"o(nlogn)",
|
||
"o(n*log n)"
|
||
],
|
||
"level": "deep",
|
||
"ref": "урок D5 (ДП и НВП)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность задачи о рюкзаке 0/1 через ДП по вместимости?",
|
||
"a": "O(n * W)",
|
||
"accept": [
|
||
"o(n*w)",
|
||
"o(nw)",
|
||
"o(n*w)"
|
||
],
|
||
"level": "deep",
|
||
"ref": "урок D5 (ДП)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Насколько быстро работают операции union-find с эвристиками?",
|
||
"a": "почти O(1), O(α(n))",
|
||
"accept": [
|
||
"почти o(1)",
|
||
"o(alpha(n))",
|
||
"o(α(n))",
|
||
"обратная функция аккермана"
|
||
],
|
||
"level": "deep",
|
||
"ref": "урок D4 (union-find)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Какова сложность по памяти рекурсивного DFS в графе в худшем случае?",
|
||
"a": "O(V) — глубина стека рекурсии",
|
||
"accept": [
|
||
"o(v)",
|
||
"o(h)",
|
||
"o(v) в худшем случае"
|
||
],
|
||
"level": "deep",
|
||
"ref": "урок D4 (графы)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Какова нижняя оценка сложности сортировки сравнениями?",
|
||
"a": "O(n log n)",
|
||
"accept": [
|
||
"o(n log n)",
|
||
"o(nlogn)"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_algo §2",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Структура для поиска слов по префиксу за O(len)?",
|
||
"a": "trie (префиксное дерево)",
|
||
"accept": [
|
||
"trie",
|
||
"префиксное дерево",
|
||
"бор"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D3 (структуры)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что делает fork()?",
|
||
"a": "создаёт новый процесс (свой PID, COW-копия памяти)",
|
||
"accept": [
|
||
"создаёт новый процесс",
|
||
"создает новый процесс",
|
||
"новый процесс"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_linux §1",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что происходит со страницами памяти при fork()?",
|
||
"a": "copy-on-write: копируются при первой записи",
|
||
"accept": [
|
||
"cow",
|
||
"copy-on-write",
|
||
"копирование при записи"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_linux §1 (COW)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Какой механизм держит десятки тысяч соединений в одном потоке?",
|
||
"a": "epoll",
|
||
"accept": [
|
||
"epoll",
|
||
"эполл"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (epoll)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Сложность select против epoll на большом числе дескрипторов?",
|
||
"a": "select — O(n) по всем, epoll — O(1) на готовое событие",
|
||
"accept": [
|
||
"select o(n), epoll o(1)",
|
||
"epoll o(1)",
|
||
"o(1) на готовое"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (epoll)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что даёт mmap() на файл?",
|
||
"a": "отображает файл в память; страницы подгружаются по обращению",
|
||
"accept": [
|
||
"отображает файл в память",
|
||
"mmap файла в память",
|
||
"отображение файла в память"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (mmap)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Зачем родителю waitpid()?",
|
||
"a": "чтобы забрать код возврата и не оставлять зомби",
|
||
"accept": [
|
||
"забрать код возврата",
|
||
"убрать зомби",
|
||
"чтобы не остались зомби"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_linux §3",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое процесс-зомби?",
|
||
"a": "завершившийся процесс, чья запись ждёт wait/waitpid",
|
||
"accept": [
|
||
"завершившийся процесс без wait",
|
||
"ждёт wait",
|
||
"запись ждёт wait"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_linux §3",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Код возврата 137 — что это?",
|
||
"a": "SIGKILL (128+9) — убит",
|
||
"accept": [
|
||
"sigkill",
|
||
"128+9",
|
||
"убит sigkill"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_linux §3",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Код возврата 139 — что это?",
|
||
"a": "SIGSEGV (128+11) — падение по памяти",
|
||
"accept": [
|
||
"sigsegv",
|
||
"128+11",
|
||
"сегфолт"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_linux §3",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что означает errno EAGAIN на неблокирующем сокете?",
|
||
"a": "данных сейчас нет, повторить позже",
|
||
"accept": [
|
||
"повторить позже",
|
||
"нет данных, попробовать снова",
|
||
"данных нет"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_linux §5 (errno)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое TID (Thread ID) в /proc?",
|
||
"a": "номер задачи в /proc/<pid>/task/",
|
||
"accept": [
|
||
"номер задачи",
|
||
"task",
|
||
"в /proc/<pid>/task"
|
||
],
|
||
"level": "deep",
|
||
"ref": "man 5 proc",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что делает ulimit -n?",
|
||
"a": "показывает/меняет лимит открытых файловых дескрипторов",
|
||
"accept": [
|
||
"лимит дескрипторов",
|
||
"лимит открытых файлов",
|
||
"число открытых файлов"
|
||
],
|
||
"level": "deep",
|
||
"ref": "man 2 getrlimit",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Сигнал с номером 15?",
|
||
"a": "SIGTERM — запрос на завершение",
|
||
"accept": [
|
||
"sigterm",
|
||
"sigterm (мягкое завершение)",
|
||
"запрос на завершение"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D1_linux §4 (сигналы)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Сколько байт в заголовке TCP без опций?",
|
||
"a": "20",
|
||
"accept": [
|
||
"20",
|
||
"20 байт"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D5 (TCP)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Сколько байт в Ethernet-заголовке без VLAN?",
|
||
"a": "14",
|
||
"accept": [
|
||
"14",
|
||
"14 байт"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (L2)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Сколько байт добавляет VLAN-тег 802.1Q?",
|
||
"a": "4",
|
||
"accept": [
|
||
"4",
|
||
"4 байта"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (802.1Q)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Сколько адресов узлов в подсети /26?",
|
||
"a": "62",
|
||
"accept": [
|
||
"62",
|
||
"62 узла"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (подсети: /26 = 62)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Сколько адресов узлов в подсети /24?",
|
||
"a": "254",
|
||
"accept": [
|
||
"254"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (подсети)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Какое поле IPv4-заголовка уменьшается на 1 на каждом маршрутизаторе?",
|
||
"a": "TTL",
|
||
"accept": [
|
||
"ttl"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (IPv4)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Правильная последовательность установки TCP-соединения?",
|
||
"a": "SYN -> SYN-ACK -> ACK",
|
||
"accept": [
|
||
"syn, syn-ack, ack",
|
||
"syn syn-ack ack",
|
||
"syn -> syn-ack -> ack"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (TCP)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что делает ARP?",
|
||
"a": "находит MAC по IP в локальном сегменте",
|
||
"accept": [
|
||
"mac по ip",
|
||
"ip -> mac",
|
||
"находит mac по ip"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (ARP)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Размер MTU Ethernet по умолчанию?",
|
||
"a": "1500 байт",
|
||
"accept": [
|
||
"1500"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (L2)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "На каком уровне OSI работает обычный коммутатор?",
|
||
"a": "L2 (канальный)",
|
||
"accept": [
|
||
"l2",
|
||
"канальный",
|
||
"2"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (OSI)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "На каком уровне OSI работает маршрутизатор?",
|
||
"a": "L3 (сетевой)",
|
||
"accept": [
|
||
"l3",
|
||
"сетевой",
|
||
"3"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (OSI)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Сколько байт в минимальном IPv4-заголовке?",
|
||
"a": "20",
|
||
"accept": [
|
||
"20"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (IPv4)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "По какому протоколу и порту работает DNS?",
|
||
"a": "UDP/53 (при больших ответах TCP/53)",
|
||
"accept": [
|
||
"udp 53",
|
||
"53",
|
||
"udp/53"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D5 (DNS)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что означает маска /30 в адресах?",
|
||
"a": "4 адреса: сеть, 2 узла, broadcast",
|
||
"accept": [
|
||
"4 адреса, 2 узла",
|
||
"2 узла",
|
||
"сеть+2 узла+broadcast"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D4 (подсети)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что делает ICMP Time Exceeded?",
|
||
"a": "сообщает, что TTL истёк (используется в traceroute)",
|
||
"accept": [
|
||
"ttl истёк",
|
||
"истёк ttl",
|
||
"сообщает об истечении ttl"
|
||
],
|
||
"level": "deep",
|
||
"ref": "RFC 792 (ICMP)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Чему равен sizeof(struct S { char a; int b; char c; }) на x86-64 без pack?",
|
||
"a": "12 (паддинг до выравнивания)",
|
||
"accept": [
|
||
"12",
|
||
"12 байт"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (выравнивание)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое UB?",
|
||
"a": "undefined behavior: стандарт не накладывает требований",
|
||
"accept": [
|
||
"undefined behavior",
|
||
"неопределённое поведение",
|
||
"неопределенное поведение"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (C++, UB)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что делает std::move сам по себе?",
|
||
"a": "static_cast к rvalue-ссылке; перемещение делает конструктор/присваивание",
|
||
"accept": [
|
||
"static_cast к rvalue",
|
||
"ничего, это каст",
|
||
"это каст к rvalue"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (move)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Чем new отличается от malloc?",
|
||
"a": "new вызывает конструктор и возвращает типизированный указатель",
|
||
"accept": [
|
||
"вызывает конструктор",
|
||
"конструктор",
|
||
"конструктор + типизированный указатель"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (new/malloc)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Класс владеет ресурсом и имеет деструктор, копирование не объявлено. Что будет?",
|
||
"a": "сгенерируется поверхностное копирование — двойное освобождение",
|
||
"accept": [
|
||
"двойное освобождение",
|
||
"двойное free",
|
||
"поверхностное копирование"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (правило 0/3/5)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Зачем нужен виртуальный деструктор у базового класса?",
|
||
"a": "иначе delete через Base* — UB, деструктор наследника не вызовется",
|
||
"accept": [
|
||
"деструктор наследника не вызовется",
|
||
"иначе ub",
|
||
"чтобы вызвался деструктор наследника"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (virtual-деструктор)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что делает const после сигнатуры метода?",
|
||
"a": "делает this const, запрещает менять поля",
|
||
"accept": [
|
||
"this const",
|
||
"запрещает менять поля",
|
||
"метод не меняет объект"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (const-метод)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Определён ли стандартом порядок вычисления аргументов f(a(), b())?",
|
||
"a": "нет, порядок не задан",
|
||
"accept": [
|
||
"нет",
|
||
"не определён",
|
||
"не задан",
|
||
"неопределён"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (UB)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что проверяет ASAN?",
|
||
"a": "выходы за границы, use-after-free, утечки",
|
||
"accept": [
|
||
"выходы за границы",
|
||
"use-after-free",
|
||
"память: границы и use-after-free"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (ASAN)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что проверяет UBSAN?",
|
||
"a": "неопределённое поведение: overflow, сдвиги, выравнивание",
|
||
"accept": [
|
||
"undefined behavior",
|
||
"неопределённое поведение",
|
||
"overflow"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (UBSAN)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Правило трёх/пяти — в чём суть?",
|
||
"a": "владеющий ресурсом класс задаёт деструктор, копирование и перемещение",
|
||
"accept": [
|
||
"деструктор + копирование + перемещение",
|
||
"деструктор, копирование, перемещение",
|
||
"нужно определить деструктор и копирование/перемещение"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (правило 0/3/5)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Чем unique_ptr отличается от shared_ptr?",
|
||
"a": "unique_ptr — единственный владелец без счётчика; shared_ptr считает ссылки",
|
||
"accept": [
|
||
"единственный владелец",
|
||
"нет счётчика ссылок",
|
||
"счётчик ссылок у shared_ptr"
|
||
],
|
||
"level": "core",
|
||
"ref": "урок D2 (умные указатели)",
|
||
"why": ""
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое сложность O(n) словами?",
|
||
"a": "время растёт линейно с числом данных",
|
||
"accept": [
|
||
"линейно",
|
||
"время растёт линейно",
|
||
"растёт линейно с данными"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Правило: O(n) — во сколько раз больше данных, во столько раз больше работы."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность доступа к элементу массива по индексу?",
|
||
"a": "O(1)",
|
||
"accept": [
|
||
"o(1)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Массив лежит подряд: адрес = начало + индекс × размер, одно действие."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность поиска значения в неотсортированном массиве?",
|
||
"a": "O(n)",
|
||
"accept": [
|
||
"o(n)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Приходится смотреть каждый элемент — других зацепок нет."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность бинарного поиска в отсортированном массиве?",
|
||
"a": "O(log n)",
|
||
"accept": [
|
||
"o(log n)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Каждый шаг отбрасывает половину — это и есть log n."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сколько шагов у бинарного поиска в 1000 элементах (примерно)?",
|
||
"a": "10",
|
||
"accept": [
|
||
"10",
|
||
"около 10"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "log2(1000) ≈ 10. Помни: ×1000 данных ≈ +10 шагов."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Стек — какой порядок обработки?",
|
||
"a": "LIFO (последний пришёл — первый вышел)",
|
||
"accept": [
|
||
"lifo",
|
||
"последний вошёл первый вышел",
|
||
"lifo (стек)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Стек: кладём и снимаем с одного конца, как стопку тарелок."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Очередь — какой порядок обработки?",
|
||
"a": "FIFO (первый пришёл — первый вышел)",
|
||
"accept": [
|
||
"fifo",
|
||
"первый вошёл первый вышел"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Очередь: добавление с одного конца, изъятие с другого."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое амортизированная сложность?",
|
||
"a": "средняя стоимость операции с учётом редких дорогих операций",
|
||
"accept": [
|
||
"средняя с учётом редких дорогих",
|
||
"усреднение дорогих операций",
|
||
"средняя стоимость"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Пример: push_back у vector обычно O(1), изредка O(n) при росте — в среднем O(1)."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое устойчивость сортировки?",
|
||
"a": "равные элементы сохраняют исходный порядок",
|
||
"accept": [
|
||
"равные сохраняют порядок",
|
||
"порядок равных сохраняется"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Устойчивы merge/insertion, неустойчивы quick/heap/selection."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что быстрее для поиска по ключу: отсортированный массив или хеш-таблица?",
|
||
"a": "хеш-таблица (в среднем O(1) против O(log n))",
|
||
"accept": [
|
||
"хеш таблица",
|
||
"хеш-таблица o(1)",
|
||
"хеш таблица o(1)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Массив даёт O(log n) и порядок, хеш — O(1) в среднем, но без порядка."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое процесс?",
|
||
"a": "программа в исполнении со своим адресным пространством и PID",
|
||
"accept": [
|
||
"программа в исполнении",
|
||
"исполняемая программа со своим адресным пространством"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Процесс = код + данные + стек + открытые дескрипторы + PID."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое PID?",
|
||
"a": "номер процесса",
|
||
"accept": [
|
||
"номер процесса",
|
||
"идентификатор процесса"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Ядро выдаёт каждому процессу уникальный номер."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое файловый дескриптор?",
|
||
"a": "число, по которому программа обращается к открытому файлу или сокету",
|
||
"accept": [
|
||
"число ссылающееся на открытый файл",
|
||
"номер открытого файла",
|
||
"дескриптор открытого файла"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "open() возвращает fd; 0/1/2 — это stdin/stdout/stderr."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Какие дескрипторы 0, 1, 2?",
|
||
"a": "stdin, stdout, stderr",
|
||
"accept": [
|
||
"stdin stdout stderr",
|
||
"ввод вывод ошибки"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "0 — ввод, 1 — вывод, 2 — ошибки; перенаправление 2>&1 склеивает 2 с 1."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое системный вызов?",
|
||
"a": "запрос программы к ядру (open, read, write, fork)",
|
||
"accept": [
|
||
"запрос к ядру",
|
||
"обращение программы к ядру",
|
||
"запрос программе к ядру"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Программа не работает с железом напрямую — только через ядро."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Разница SIGTERM и SIGKILL?",
|
||
"a": "SIGTERM можно перехватить и завершиться корректно, SIGKILL — нет",
|
||
"accept": [
|
||
"sigterm перехватывается sigkill нет",
|
||
"sigterm можно перехватить"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Поэтому сначала kill (SIGTERM), и только потом kill -9."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что делает chmod 755 file?",
|
||
"a": "владелец rwx, остальные rx",
|
||
"accept": [
|
||
"владелец rwx остальные rx",
|
||
"rwx для владельца rx для остальных"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "7 = rwx, 5 = r-x. Права читаются как три группы по три бита."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое PATH?",
|
||
"a": "список каталогов, где оболочка ищет программы по имени",
|
||
"accept": [
|
||
"список каталогов для поиска программ",
|
||
"переменная со списком каталогов программ"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Поэтому ./prog и prog — разные вещи: второе ищется в PATH."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое конвейер (|) в оболочке?",
|
||
"a": "вывод одной программы идёт на вход другой",
|
||
"accept": [
|
||
"передача вывода на вход другой программы",
|
||
"соединяет вывод со входом"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "`ps aux | grep ssh` — фильтрация вывода без временных файлов."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое демон?",
|
||
"a": "фоновый процесс без управляющего терминала",
|
||
"accept": [
|
||
"фоновый процесс",
|
||
"процесс работающий в фоне"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Демоны обычно запускает systemd, а не пользователь из терминала."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Сколько бит в IPv4-адресе?",
|
||
"a": "32 (четыре октета)",
|
||
"accept": [
|
||
"32",
|
||
"32 бита"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Отсюда маски: /24 — 24 бита на сеть, 8 на узлы."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Сколько бит в MAC-адресе?",
|
||
"a": "48",
|
||
"accept": [
|
||
"48",
|
||
"48 бит"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "6 байт, обычно записывают как aa:bb:cc:dd:ee:ff."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое маска подсети?",
|
||
"a": "показывает, какая часть адреса — сеть, какая — узел",
|
||
"accept": [
|
||
"деление адреса на сеть и узел",
|
||
"какая часть адреса сеть"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Маска /24 = 255.255.255.0: первые 24 бита — сеть."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое порт?",
|
||
"a": "номер приложения на узле",
|
||
"accept": [
|
||
"номер приложения",
|
||
"номер программы на узле"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "IP находит машину, порт — конкретную программу на ней."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Чем TCP отличается от UDP?",
|
||
"a": "TCP с установкой соединения и гарантией доставки, UDP — без",
|
||
"accept": [
|
||
"tcp надёжный udp быстрый",
|
||
"tcp с соединением udp без",
|
||
"надёжность против скорости"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "TCP: порядок и повторы. UDP: быстро, но можно потерять — как в DNS-запросах."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое шлюз (gateway)?",
|
||
"a": "узел, через который уходят пакеты за пределы подсети",
|
||
"accept": [
|
||
"узел для выхода из подсети",
|
||
"маршрутизатор по умолчанию"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Если адрес не в нашей подсети — отправляем на шлюз."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что делает DNS?",
|
||
"a": "превращает имя в IP-адрес",
|
||
"accept": [
|
||
"имя в ip",
|
||
"преобразует имя в ip",
|
||
"разрешает имена в ip"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Поэтому сначала DNS-запрос, потом соединение с полученным IP."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что делает DHCP?",
|
||
"a": "выдаёт узлу IP-адрес автоматически",
|
||
"accept": [
|
||
"выдаёт ip автоматически",
|
||
"автоматическая выдача ip"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Иначе адрес пришлось бы прописывать руками."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое 127.0.0.1?",
|
||
"a": "localhost — сам узел (петля)",
|
||
"accept": [
|
||
"localhost",
|
||
"локальный адрес самого узла",
|
||
"петля"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Пакеты не уходят в сеть, а возвращаются на ту же машину."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое NAT?",
|
||
"a": "подмена адресов при выходе в интернет",
|
||
"accept": [
|
||
"подмена адресов",
|
||
"трансляция адресов"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Много устройств в локальной сети выходят через один внешний IP."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что делает ping?",
|
||
"a": "проверяет доступность узла через ICMP echo",
|
||
"accept": [
|
||
"проверка доступности через icmp",
|
||
"icmp эхо",
|
||
"проверяет доступность"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "ICMP — служебные сообщения; ping не использует TCP/UDP-порты."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое указатель?",
|
||
"a": "переменная, хранящая адрес в памяти",
|
||
"accept": [
|
||
"адрес в памяти",
|
||
"хранит адрес"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Указатель = адрес. Разыменование (*p) — доступ по этому адресу."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Чем стек отличается от кучи?",
|
||
"a": "стек — автоматическая память (локальные переменные), куча — динамическая (new/malloc)",
|
||
"accept": [
|
||
"стек автоматическая куча динамическая",
|
||
"автоматическая против динамической"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Стек быстрый и ограничен, куча больше, но требует освобождения."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое утечка памяти?",
|
||
"a": "выделили и не освободили",
|
||
"accept": [
|
||
"не освободили выделенную память",
|
||
"память не освобождена"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "ASAN с `detect_leaks=1` находит такие места с трассировкой."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое segmentation fault?",
|
||
"a": "обращение к памяти, которая программе не принадлежит",
|
||
"accept": [
|
||
"обращение к чужой памяти",
|
||
"доступ к недопустимой памяти"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Частые причины: нулевой указатель, выход за границы, use-after-free."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое конструктор и деструктор?",
|
||
"a": "конструктор инициализирует объект, деструктор освобождает ресурсы",
|
||
"accept": [
|
||
"создание и уничтожение объекта",
|
||
"инициализация и освобождение"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Деструктор вызывается автоматически при выходе из области видимости."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое RAII?",
|
||
"a": "ресурс захватывается в конструкторе и освобождается в деструкторе",
|
||
"accept": [
|
||
"ресурс в конструкторе освобождение в деструкторе",
|
||
"захват в конструкторе освобождение в деструкторе"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Благодаря этому не бывает утечек при исключениях."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое виртуальная функция?",
|
||
"a": "функция, которую вызывают по фактическому типу объекта (полиморфизм)",
|
||
"accept": [
|
||
"полиморфизм",
|
||
"вызов по фактическому типу"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Реализуется через таблицу виртуальных функций (vtable)."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое шаблон (template)?",
|
||
"a": "обобщённый код, подставляющий тип при компиляции",
|
||
"accept": [
|
||
"обобщённый код",
|
||
"код обобщённый по типу"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Так устроены std::vector<T> и std::sort — код один, типы разные."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое компиляция по шагам?",
|
||
"a": "препроцессор → компиляция → сборка (линковка)",
|
||
"accept": [
|
||
"препроцессор компиляция линковка",
|
||
"препроцессинг компиляция сборка"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "На каждом шаге свои ошибки: `#include` — препроцессор, неразрешённый символ — линковщик."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Зачем флаг -Wall -Wextra?",
|
||
"a": "включает предупреждения компилятора о подозрительном коде",
|
||
"accept": [
|
||
"включает предупреждения",
|
||
"предупреждения компилятора"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "С -Werror предупреждения становятся ошибками — полезная привычка."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность доступа к элементу по индексу в массиве (vector)?",
|
||
"a": "O(1)",
|
||
"accept": [
|
||
"o(1)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Массив лежит подряд: адрес считается арифметикой, без перебора."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность вставки в конец vector (push_back)?",
|
||
"a": "амортизированное O(1)",
|
||
"accept": [
|
||
"o(1)",
|
||
"амортизированное o(1)",
|
||
"амортизированно o(1)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Обычно O(1); при переполнении массив копируется за O(n), но редко — в среднем O(1)."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность вставки или удаления в середине vector?",
|
||
"a": "O(n)",
|
||
"accept": [
|
||
"o(n)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Надо сдвинуть все элементы после места вставки."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность поиска в неотсортированном массиве и в отсортированном?",
|
||
"a": "O(n) и O(log n)",
|
||
"accept": [
|
||
"o(n) и o(log n)",
|
||
"o(n) против o(log n)",
|
||
"o(n), o(log n)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Отсортированность — то, за что платят O(n log n) при сортировке и получают O(log n) поиска."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность доступа к элементу связного списка по номеру?",
|
||
"a": "O(n)",
|
||
"accept": [
|
||
"o(n)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "К узлам нет произвольного доступа — только идти по указателям от начала."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность вставки и удаления в связном списке, если узел уже известен?",
|
||
"a": "O(1)",
|
||
"accept": [
|
||
"o(1)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Меняются два указателя, сдвигать ничего не надо — в этом плюс списка."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность поиска в бинарном дереве поиска (BST)?",
|
||
"a": "O(log n) в среднем, O(n) в худшем",
|
||
"accept": [
|
||
"o(log n) в среднем o(n) в худшем",
|
||
"o(log n), o(n)",
|
||
"o(log n) в среднем"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Худший случай — вырожденное дерево в список; лечится балансировкой (AVL, красно-чёрное)."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что быстрее по памяти: vector или list?",
|
||
"a": "vector (нет указателей и отдельных аллокаций)",
|
||
"accept": [
|
||
"vector",
|
||
"вектор"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "У list на каждый узел ещё два указателя и аллокация; зато вставка в середину дешевле."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность поиска, вставки и удаления в std::map?",
|
||
"a": "O(log n)",
|
||
"accept": [
|
||
"o(log n)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Красно-чёрное дерево: операции логарифмические и порядок ключей сохраняется."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность тех же операций в std::unordered_map?",
|
||
"a": "O(1) в среднем, O(n) в худшем",
|
||
"accept": [
|
||
"o(1) в среднем",
|
||
"o(1) в среднем o(n) в худшем"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Хеш-таблица: порядок не сохраняется, зато быстрее в среднем."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность поиска в std::set и std::unordered_set?",
|
||
"a": "O(log n) и O(1) в среднем",
|
||
"accept": [
|
||
"o(log n) и o(1)",
|
||
"o(log n), o(1) в среднем"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "set — дерево, unordered_set — хеш-таблица."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое in-place сортировка и пример?",
|
||
"a": "сортировка без дополнительной памяти O(1), например heapsort",
|
||
"accept": [
|
||
"без дополнительной памяти",
|
||
"сортировка на месте"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "quicksort тоже in-place, но у него O(log n) на стек рекурсии."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Какие операции у стека и очереди и их сложность?",
|
||
"a": "push/pop за O(1), доступ только к одному концу",
|
||
"accept": [
|
||
"push pop o(1)",
|
||
"o(1) на push и pop"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Стек — LIFO, очередь — FIFO; произвольного доступа нет."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Сложность доступа к элементу std::deque по индексу?",
|
||
"a": "O(1)",
|
||
"accept": [
|
||
"o(1)"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "deque — массив блоков фиксированного размера, индекс считается арифметикой."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое структура данных?",
|
||
"a": "способ организации данных, определяющий доступ и сложность операций",
|
||
"accept": [
|
||
"способ организации данных",
|
||
"организация данных для эффективного доступа"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Массив, список, хеш-таблица, дерево, куча — разные компромиссы время/память."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое алгоритм?",
|
||
"a": "конечная последовательность шагов, превращающая вход в выход",
|
||
"accept": [
|
||
"последовательность шагов",
|
||
"конечная последовательность действий"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Оценивается по времени и памяти, чаще всего через O-нотацию."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое рекурсия и её цена?",
|
||
"a": "функция вызывает себя; цена — стек вызовов O(глубины)",
|
||
"accept": [
|
||
"функция вызывает себя",
|
||
"самовызов функции"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Глубина важна: на 10⁵ уровнях стек переполняется, нужна итерация."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое жадный алгоритм?",
|
||
"a": "на каждом шаге берём локально лучшее решение",
|
||
"accept": [
|
||
"локально лучшее на каждом шаге",
|
||
"выбор лучшего на каждом шаге"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Работает не всегда: пример — размен монет; для интервального расписания работает."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое динамическое программирование?",
|
||
"a": "разбиение задачи на подзадачи с сохранением результатов",
|
||
"accept": [
|
||
"разбиение на подзадачи с запоминанием",
|
||
"запоминание результатов подзадач"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Отличие от рекурсии — мемоизация: каждая подзадача считается один раз."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое граф, вершина и ребро?",
|
||
"a": "набор вершин и связей между ними",
|
||
"accept": [
|
||
"вершины и рёбра",
|
||
"набор вершин и связей"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Дерево — это связный граф без циклов на n вершинах с n−1 рёбрами."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое DAG?",
|
||
"a": "ориентированный ациклический граф",
|
||
"accept": [
|
||
"ориентированный ациклический граф",
|
||
"направленный без циклов"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Только на DAG возможна топологическая сортировка — порядок зависимостей."
|
||
},
|
||
{
|
||
"domain": "algo",
|
||
"q": "Что такое связный компонент графа?",
|
||
"a": "максимальный набор вершин, достижимых друг из друга",
|
||
"accept": [
|
||
"набор вершин достижимых друг из друга",
|
||
"максимальная связная часть графа"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Число компонент ищется обходом BFS/DFS или union-find."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое поток (thread) и чем отличается от процесса?",
|
||
"a": "единица выполнения внутри процесса; общая память, свой стек",
|
||
"accept": [
|
||
"единица выполнения внутри процесса",
|
||
"общая память но свой стек"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Потоки дешевле по переключению, но требуют синхронизации общей памяти."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое виртуальная память?",
|
||
"a": "каждому процессу — своё адресное пространство, страницы отображаются на физическую память",
|
||
"accept": [
|
||
"своё адресное пространство",
|
||
"адреса процессов транслируются в физические"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Изоляция процессов и возможность swap — следствие виртуальной памяти."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое страница памяти?",
|
||
"a": "блок памяти фиксированного размера (обычно 4 КБ)",
|
||
"accept": [
|
||
"блок фиксированного размера",
|
||
"4 кб"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Страницами оперируют ядро, mmap, copy-on-write и swap."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое планировщик и контекст-свитч?",
|
||
"a": "компонент ядра, решающий кто исполняется; переключение потоков",
|
||
"accept": [
|
||
"переключение между задачами",
|
||
"ядро выбирает кому исполняться"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Свитч — дорого: сохранить регистры и стек, поэтому меньше потоков ≠ хуже."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое мьютекс и что такое гонка данных?",
|
||
"a": "мьютекс — блокировка на одного владельца; гонка — несинхронизированный доступ",
|
||
"accept": [
|
||
"блокировка и несинхронизированный доступ",
|
||
"мьютекс блокировка, гонка одновременный доступ"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Гонки ловит ThreadSanitizer, взаимные блокировки — анализ порядка захвата."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое дедлок?",
|
||
"a": "взаимная блокировка: потоки ждут ресурсы друг друга",
|
||
"accept": [
|
||
"взаимная блокировка",
|
||
"потоки ждут друг друга вечно"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Четыре условия Коффмана; профилактика — единый порядок захвата мьютексов."
|
||
},
|
||
{
|
||
"domain": "linux",
|
||
"q": "Что такое семафор?",
|
||
"a": "счётчик, разрешающий доступ N потокам",
|
||
"accept": [
|
||
"счётчик доступа",
|
||
"разрешение N потокам"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Мьютекс — частный случай семафора с единицей."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое инкапсуляция в сетях?",
|
||
"a": "каждый уровень добавляет свой заголовок к данным верхнего",
|
||
"accept": [
|
||
"добавление заголовка уровнем",
|
||
"заголовок уровня добавляется к данным"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Поэтому кадр = Ethernet-заголовок + IP + TCP + данные."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое кадр (frame) и пакет (packet)?",
|
||
"a": "кадр — единица L2, пакет — единица L3",
|
||
"accept": [
|
||
"кадр l2 пакет l3",
|
||
"кадр на канальном пакет на сетевом"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Пакет едет внутри кадра; на каждом узле кадр пересобирается заново."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое CIDR-запись /24?",
|
||
"a": "24 бита на сеть, 8 на узлы: 256 адресов",
|
||
"accept": [
|
||
"24 бита сети",
|
||
"256 адресов 24 бита сети"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Чем больше префикс, тем меньше подсеть: /30 — 4 адреса, /26 — 64."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое широковещательный адрес?",
|
||
"a": "все единицы в хостовой части — адрес всех узлов подсети",
|
||
"accept": [
|
||
"все единицы в хостовой части",
|
||
"адрес всех узлов подсети"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Поэтому в /24 последний адрес (.255) — broadcast, он не узел."
|
||
},
|
||
{
|
||
"domain": "net",
|
||
"q": "Что такое время жизни (TTL) и зачем он?",
|
||
"a": "счётчик переходов в IPv4, уменьшается на каждом маршрутизаторе",
|
||
"accept": [
|
||
"счётчик переходов",
|
||
"уменьшается на каждом маршрутизаторе"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Защита от вечных петель; traceroute использует истечение TTL."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое объект и класс?",
|
||
"a": "класс — описание, объект — экземпляр в памяти",
|
||
"accept": [
|
||
"класс описание объект экземпляр",
|
||
"класс это описание, объект это экземпляр"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Класс не занимает память, объект занимает."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Три кита ООП?",
|
||
"a": "инкапсуляция, наследование, полиморфизм",
|
||
"accept": [
|
||
"инкапсуляция наследование полиморфизм"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Инкапсуляция — скрыть состояние, наследование — переиспользовать, полиморфизм — один интерфейс, разные реализации."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое инкапсуляция?",
|
||
"a": "сокрытие внутреннего состояния за публичным интерфейсом",
|
||
"accept": [
|
||
"сокрытие состояния за интерфейсом",
|
||
"скрытие внутреннего состояния"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "В C++ — private/protected + методы доступа."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое полиморфизм в C++?",
|
||
"a": "вызов функции по фактическому типу объекта через virtual",
|
||
"accept": [
|
||
"virtual вызов по фактическому типу",
|
||
"вызов по фактическому типу"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Без virtual будет раннее связывание по типу указателя — классическая ловушка."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое абстрактный класс?",
|
||
"a": "класс с чисто виртуальной функцией, экземпляр создать нельзя",
|
||
"accept": [
|
||
"с чисто виртуальной функцией",
|
||
"нельзя создать экземпляр"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "В C++ нет отдельного `interface` — его роль играет класс из чисто виртуальных методов."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Чем перегрузка отличается от переопределения?",
|
||
"a": "перегрузка — разные параметры в одной области, переопределение — virtual в наследнике",
|
||
"accept": [
|
||
"перегрузка параметры, переопределение virtual",
|
||
"разные параметры против virtual"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Перегрузка решается на компиляции, переопределение — в рантайме."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое static-член класса?",
|
||
"a": "общий для всех объектов, живёт вне объекта",
|
||
"accept": [
|
||
"общий для всех объектов",
|
||
"принадлежит классу а не объекту"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "У static-метода нет this, поэтому он не может быть const."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое шаблон и зачем он?",
|
||
"a": "обобщённый код, тип подставляется при компиляции",
|
||
"accept": [
|
||
"обобщённый код",
|
||
"код обобщённый по типу"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Так устроены контейнеры STL: код один, тип разный, цена — ошибки на компиляции."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое виртуальная таблица (vtable)?",
|
||
"a": "таблица указателей на виртуальные функции объекта",
|
||
"accept": [
|
||
"таблица указателей на виртуальные функции",
|
||
"таблица виртуальных методов"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Отсюда +8 байт на объект и невозможность virtual в конструкторе."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое header guard / #pragma once?",
|
||
"a": "защита от повторного включения заголовка",
|
||
"accept": [
|
||
"защита от повторного включения",
|
||
"защита от двойного включения"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Без неё повторное определение типа — ошибка компиляции."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что делает линковщик?",
|
||
"a": "собирает объектные файлы в один исполняемый, разрешает внешние символы",
|
||
"accept": [
|
||
"собирает объектные файлы",
|
||
"разрешает внешние символы"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "«undefined reference» — ошибка линковщика, а не компилятора."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что такое std::vector внутри?",
|
||
"a": "динамический массив с удвоением ёмкости",
|
||
"accept": [
|
||
"динамический массив",
|
||
"динамический массив с удвоением"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Отсюда амортизированное O(1) на push_back и invalidate итераторов при росте."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Чем emplace_back лучше push_back?",
|
||
"a": "строит объект на месте, без копирования/перемещения",
|
||
"accept": [
|
||
"строит на месте",
|
||
"конструирует на месте без копии"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Разница видна на тяжёлых объектах и типах без копирования."
|
||
},
|
||
{
|
||
"domain": "c_cpp",
|
||
"q": "Что делает reserve и зачем?",
|
||
"a": "резервирует ёмкость, убирая реаллокации",
|
||
"accept": [
|
||
"резервирует ёмкость",
|
||
"выделяет память заранее"
|
||
],
|
||
"level": "base",
|
||
"ref": "",
|
||
"why": "Когда размер известен, reserve — дешёвая оптимизация."
|
||
}
|
||
]
|
||
}
|