{
  "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 предупреждения становятся ошибками — полезная привычка."
    }
  ]
}