Kodlo-chan
1271 lines
42 KiB
JSON
1271 lines
42 KiB
JSON
{
|
||
"version": 2,
|
||
"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 предупреждения становятся ошибками — полезная привычка."
|
||
}
|
||
]
|
||
}
|