{
  "version": 1,
  "note": "Карточки под промахи квиза 23.09: точные числа, сложности и условия.",
  "facts": [
    {
      "domain": "algo",
      "q": "Средняя сложность поиска в хеш-таблице при разумной загрузке?",
      "a": "амортизированное O(1)",
      "accept": [
        "o(1)",
        "амортизированное o(1)",
        "o(1) амортизированное",
        "амортизированно o(1)"
      ]
    },
    {
      "domain": "algo",
      "q": "Худшая сложность поиска в хеш-таблице (все ключи в одну корзину)?",
      "a": "O(n)",
      "accept": [
        "o(n)"
      ]
    },
    {
      "domain": "algo",
      "q": "Сколько сравнений в худшем случае у бинарного поиска в массиве из 1 000 000 элементов?",
      "a": "20",
      "accept": [
        "20",
        "log2 1e6 = 20",
        "около 20"
      ]
    },
    {
      "domain": "algo",
      "q": "При каком условии применим алгоритм Дейкстры?",
      "a": "веса рёбер неотрицательны",
      "accept": [
        "неотрицательные веса",
        "все веса >= 0",
        "веса неотрицательны",
        "нет отрицательных рёбер"
      ]
    },
    {
      "domain": "algo",
      "q": "Чем заменить Дейкстру при отрицательных рёбрах?",
      "a": "Беллман–Форд",
      "accept": [
        "беллман-форд",
        "беллман форд",
        "bellman-ford"
      ]
    },
    {
      "domain": "algo",
      "q": "Сложность построения кучи (heapify) из произвольного массива?",
      "a": "O(n)",
      "accept": [
        "o(n)",
        "о(n)"
      ]
    },
    {
      "domain": "algo",
      "q": "Сложность вставки одного элемента в кучу?",
      "a": "O(log n)",
      "accept": [
        "o(log n)"
      ]
    },
    {
      "domain": "algo",
      "q": "Какая сортировка устойчивая: merge, quick, heap или selection?",
      "a": "merge sort",
      "accept": [
        "merge",
        "merge sort",
        "слиянием",
        "сортировка слиянием"
      ]
    },
    {
      "domain": "algo",
      "q": "Худшая сложность quicksort?",
      "a": "O(n²)",
      "accept": [
        "o(n^2)",
        "o(n²)",
        "o(n2)"
      ]
    },
    {
      "domain": "algo",
      "q": "Средняя сложность quicksort и mergesort?",
      "a": "O(n log n)",
      "accept": [
        "o(n log n)",
        "o(n*logn)",
        "o(nlogn)"
      ]
    },
    {
      "domain": "algo",
      "q": "Для какого графа возможна топологическая сортировка?",
      "a": "для ациклического (DAG)",
      "accept": [
        "dag",
        "ациклический",
        "без циклов",
        "dag (ациклический)"
      ]
    },
    {
      "domain": "algo",
      "q": "Как найти цикл в связном списке за O(1) дополнительной памяти?",
      "a": "алгоритм Флойда: черепаха и заяц",
      "accept": [
        "флойд",
        "черепаха и заяц",
        "алгоритм флойда"
      ]
    },
    {
      "domain": "algo",
      "q": "BFS или DFS даёт кратчайший путь в невзвешенном графе?",
      "a": "BFS",
      "accept": [
        "bfs",
        "обход в ширину"
      ]
    },
    {
      "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)"
      ]
    },
    {
      "domain": "algo",
      "q": "За какую сложность ищется НВП (LIS) в оптимальном решении?",
      "a": "O(n log n)",
      "accept": [
        "o(n log n)",
        "o(nlogn)",
        "o(n*log n)"
      ]
    },
    {
      "domain": "algo",
      "q": "Сложность задачи о рюкзаке 0/1 через ДП по вместимости?",
      "a": "O(n * W)",
      "accept": [
        "o(n*w)",
        "o(nw)",
        "o(n*w)"
      ]
    },
    {
      "domain": "algo",
      "q": "Насколько быстро работают операции union-find с эвристиками?",
      "a": "почти O(1), O(α(n))",
      "accept": [
        "почти o(1)",
        "o(alpha(n))",
        "o(α(n))",
        "обратная функция аккермана"
      ]
    },
    {
      "domain": "algo",
      "q": "Какова сложность по памяти рекурсивного DFS в графе в худшем случае?",
      "a": "O(V) — глубина стека рекурсии",
      "accept": [
        "o(v)",
        "o(h)",
        "o(v) в худшем случае"
      ]
    },
    {
      "domain": "algo",
      "q": "Какова нижняя оценка сложности сортировки сравнениями?",
      "a": "O(n log n)",
      "accept": [
        "o(n log n)",
        "o(nlogn)"
      ]
    },
    {
      "domain": "algo",
      "q": "Структура для поиска слов по префиксу за O(len)?",
      "a": "trie (префиксное дерево)",
      "accept": [
        "trie",
        "префиксное дерево",
        "бор"
      ]
    },
    {
      "domain": "linux",
      "q": "Что делает fork()?",
      "a": "создаёт новый процесс (свой PID, COW-копия памяти)",
      "accept": [
        "создаёт новый процесс",
        "создает новый процесс",
        "новый процесс"
      ]
    },
    {
      "domain": "linux",
      "q": "Что происходит со страницами памяти при fork()?",
      "a": "copy-on-write: копируются при первой записи",
      "accept": [
        "cow",
        "copy-on-write",
        "копирование при записи"
      ]
    },
    {
      "domain": "linux",
      "q": "Какой механизм держит десятки тысяч соединений в одном потоке?",
      "a": "epoll",
      "accept": [
        "epoll",
        "эполл"
      ]
    },
    {
      "domain": "linux",
      "q": "Сложность select против epoll на большом числе дескрипторов?",
      "a": "select — O(n) по всем, epoll — O(1) на готовое событие",
      "accept": [
        "select o(n), epoll o(1)",
        "epoll o(1)",
        "o(1) на готовое"
      ]
    },
    {
      "domain": "linux",
      "q": "Что даёт mmap() на файл?",
      "a": "отображает файл в память; страницы подгружаются по обращению",
      "accept": [
        "отображает файл в память",
        "mmap файла в память",
        "отображение файла в память"
      ]
    },
    {
      "domain": "linux",
      "q": "Зачем родителю waitpid()?",
      "a": "чтобы забрать код возврата и не оставлять зомби",
      "accept": [
        "забрать код возврата",
        "убрать зомби",
        "чтобы не остались зомби"
      ]
    },
    {
      "domain": "linux",
      "q": "Что такое процесс-зомби?",
      "a": "завершившийся процесс, чья запись ждёт wait/waitpid",
      "accept": [
        "завершившийся процесс без wait",
        "ждёт wait",
        "запись ждёт wait"
      ]
    },
    {
      "domain": "linux",
      "q": "Код возврата 137 — что это?",
      "a": "SIGKILL (128+9) — убит",
      "accept": [
        "sigkill",
        "128+9",
        "убит sigkill"
      ]
    },
    {
      "domain": "linux",
      "q": "Код возврата 139 — что это?",
      "a": "SIGSEGV (128+11) — падение по памяти",
      "accept": [
        "sigsegv",
        "128+11",
        "сегфолт"
      ]
    },
    {
      "domain": "linux",
      "q": "Что означает errno EAGAIN на неблокирующем сокете?",
      "a": "данных сейчас нет, повторить позже",
      "accept": [
        "повторить позже",
        "нет данных, попробовать снова",
        "данных нет"
      ]
    },
    {
      "domain": "linux",
      "q": "Что такое TID (Thread ID) в /proc?",
      "a": "номер задачи в /proc/<pid>/task/",
      "accept": [
        "номер задачи",
        "task",
        "в /proc/<pid>/task"
      ]
    },
    {
      "domain": "linux",
      "q": "Что делает ulimit -n?",
      "a": "показывает/меняет лимит открытых файловых дескрипторов",
      "accept": [
        "лимит дескрипторов",
        "лимит открытых файлов",
        "число открытых файлов"
      ]
    },
    {
      "domain": "linux",
      "q": "Сигнал с номером 15?",
      "a": "SIGTERM — запрос на завершение",
      "accept": [
        "sigterm",
        "sigterm (мягкое завершение)",
        "запрос на завершение"
      ]
    },
    {
      "domain": "linux",
      "q": "Сколько байт в заголовке TCP без опций?",
      "a": "20",
      "accept": [
        "20",
        "20 байт"
      ]
    },
    {
      "domain": "net",
      "q": "Сколько байт в Ethernet-заголовке без VLAN?",
      "a": "14",
      "accept": [
        "14",
        "14 байт"
      ]
    },
    {
      "domain": "net",
      "q": "Сколько байт добавляет VLAN-тег 802.1Q?",
      "a": "4",
      "accept": [
        "4",
        "4 байта"
      ]
    },
    {
      "domain": "net",
      "q": "Сколько адресов узлов в подсети /26?",
      "a": "62",
      "accept": [
        "62",
        "62 узла"
      ]
    },
    {
      "domain": "net",
      "q": "Сколько адресов узлов в подсети /24?",
      "a": "254",
      "accept": [
        "254"
      ]
    },
    {
      "domain": "net",
      "q": "Какое поле IPv4-заголовка уменьшается на 1 на каждом маршрутизаторе?",
      "a": "TTL",
      "accept": [
        "ttl"
      ]
    },
    {
      "domain": "net",
      "q": "Правильная последовательность установки TCP-соединения?",
      "a": "SYN -> SYN-ACK -> ACK",
      "accept": [
        "syn, syn-ack, ack",
        "syn syn-ack ack",
        "syn -> syn-ack -> ack"
      ]
    },
    {
      "domain": "net",
      "q": "Что делает ARP?",
      "a": "находит MAC по IP в локальном сегменте",
      "accept": [
        "mac по ip",
        "ip -> mac",
        "находит mac по ip"
      ]
    },
    {
      "domain": "net",
      "q": "Размер MTU Ethernet по умолчанию?",
      "a": "1500 байт",
      "accept": [
        "1500"
      ]
    },
    {
      "domain": "net",
      "q": "На каком уровне OSI работает обычный коммутатор?",
      "a": "L2 (канальный)",
      "accept": [
        "l2",
        "канальный",
        "2"
      ]
    },
    {
      "domain": "net",
      "q": "На каком уровне OSI работает маршрутизатор?",
      "a": "L3 (сетевой)",
      "accept": [
        "l3",
        "сетевой",
        "3"
      ]
    },
    {
      "domain": "net",
      "q": "Сколько байт в минимальном IPv4-заголовке?",
      "a": "20",
      "accept": [
        "20"
      ]
    },
    {
      "domain": "net",
      "q": "По какому протоколу и порту работает DNS?",
      "a": "UDP/53 (при больших ответах TCP/53)",
      "accept": [
        "udp 53",
        "53",
        "udp/53"
      ]
    },
    {
      "domain": "net",
      "q": "Что означает маска /30 в адресах?",
      "a": "4 адреса: сеть, 2 узла, broadcast",
      "accept": [
        "4 адреса, 2 узла",
        "2 узла",
        "сеть+2 узла+broadcast"
      ]
    },
    {
      "domain": "net",
      "q": "Что делает ICMP Time Exceeded?",
      "a": "сообщает, что TTL истёк (используется в traceroute)",
      "accept": [
        "ttl истёк",
        "истёк ttl",
        "сообщает об истечении ttl"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Чему равен sizeof(struct S { char a; int b; char c; }) на x86-64 без pack?",
      "a": "12 (паддинг до выравнивания)",
      "accept": [
        "12",
        "12 байт"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Что такое UB?",
      "a": "undefined behavior: стандарт не накладывает требований",
      "accept": [
        "undefined behavior",
        "неопределённое поведение",
        "неопределенное поведение"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Что делает std::move сам по себе?",
      "a": "static_cast к rvalue-ссылке; перемещение делает конструктор/присваивание",
      "accept": [
        "static_cast к rvalue",
        "ничего, это каст",
        "это каст к rvalue"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Чем new отличается от malloc?",
      "a": "new вызывает конструктор и возвращает типизированный указатель",
      "accept": [
        "вызывает конструктор",
        "конструктор",
        "конструктор + типизированный указатель"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Класс владеет ресурсом и имеет деструктор, копирование не объявлено. Что будет?",
      "a": "сгенерируется поверхностное копирование — двойное освобождение",
      "accept": [
        "двойное освобождение",
        "двойное free",
        "поверхностное копирование"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Зачем нужен виртуальный деструктор у базового класса?",
      "a": "иначе delete через Base* — UB, деструктор наследника не вызовется",
      "accept": [
        "деструктор наследника не вызовется",
        "иначе ub",
        "чтобы вызвался деструктор наследника"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Что делает const после сигнатуры метода?",
      "a": "делает this const, запрещает менять поля",
      "accept": [
        "this const",
        "запрещает менять поля",
        "метод не меняет объект"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Определён ли стандартом порядок вычисления аргументов f(a(), b())?",
      "a": "нет, порядок не задан",
      "accept": [
        "нет",
        "не определён",
        "не задан",
        "неопределён"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Что проверяет ASAN?",
      "a": "выходы за границы, use-after-free, утечки",
      "accept": [
        "выходы за границы",
        "use-after-free",
        "память: границы и use-after-free"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Что проверяет UBSAN?",
      "a": "неопределённое поведение: overflow, сдвиги, выравнивание",
      "accept": [
        "undefined behavior",
        "неопределённое поведение",
        "overflow"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Правило трёх/пяти — в чём суть?",
      "a": "владеющий ресурсом класс задаёт деструктор, копирование и перемещение",
      "accept": [
        "деструктор + копирование + перемещение",
        "деструктор, копирование, перемещение",
        "нужно определить деструктор и копирование/перемещение"
      ]
    },
    {
      "domain": "c_cpp",
      "q": "Чем unique_ptr отличается от shared_ptr?",
      "a": "unique_ptr — единственный владелец без счётчика; shared_ptr считает ссылки",
      "accept": [
        "единственный владелец",
        "нет счётчика ссылок",
        "счётчик ссылок у shared_ptr"
      ]
    }
  ]
}