---
title: "LiveCodeBench"
source: "https://systems-analysis.info/wiki/LiveCodeBench"
wiki: "systems-analysis.info/wiki"
article: "LiveCodeBench"
language: "ru"
categories:
  - "Категория:Russian"
  - "Категория:Бенчмарки LLM"
  - "Категория:Большие языковые модели"
  - "Категория:Машинное обучение"
  - "Категория:Оценка LLM"
revision_id: 3741
wiki_created_at: 2026-11-19T07:47:42Z
wiki_modified_at: 2026-11-19T09:58:57Z
downloaded_at: 2026-11-19T10:11:14Z
---

# LiveCodeBench

**LiveCodeBench** (**LCB**) — непрерывно версионируемый [бенчмарк](https://systems-analysis.info/wiki/%D0%91%D0%B5%D0%BD%D1%87%D0%BC%D0%B0%D1%80%D0%BA_LLM "Бенчмарк LLM") с открытым фреймворком оценки, предназначенный для измерения способностей [больших языковых моделей](https://systems-analysis.info/wiki/%D0%91%D0%BE%D0%BB%D1%8C%D1%88%D0%B8%D0%B5_%D1%8F%D0%B7%D1%8B%D0%BA%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D0%B8 "Большие языковые модели") (LLM) к программированию. Бенчмарк был представлен Наманом Джейном (Naman Jain) и коллегами в статье 2024 года *LiveCodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code*, которая впоследствии была опубликована на Международной конференции по обучению представлений (ICLR) в 2025 году<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Бенчмарк собирает недавно опубликованные задачи спортивного программирования с платформ LeetCode, AtCoder и Codeforces. Каждая задача снабжена датой контеста, что позволяет оценивающим ограничить тест задачами, опубликованными после заявленной даты среза знаний модели или даты её выпуска. Такая **оценка по временным сегментам** призвана снизить влияние загрязнения бенчмарка и запоминания, которым подвержены более старые статические наборы задач по программированию<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Исходный дизайн оценивает четыре отдельные способности:

- **генерация кода** по условию задачи на естественном языке;
- **самоисправление** (self-repair) после получения обратной связи о выполнении или тестах;
- **выполнение кода** (code execution), где модель предсказывает результат запуска программы;
- **предсказание вывода тестов** (test output prediction), где модель выводит ожидаемый результат для заданного тестового входа, не располагая реализацией.

По состоянию на 10 июля 2026 года официальный репозиторий определяет `release_v6` как последний публичный кумулятивный релиз задач генерации кода. Он содержит **1055 задач**, опубликованных с мая 2023 года по апрель 2025 года. Репозиторий использует сокращённую коллекцию `code_generation_lite` как набор данных генерации кода по умолчанию и в настоящее время принимает публичные заявки в таблицу лидеров только для сценария генерации кода<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)[\[3\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_data-3)</sup>.

## Предпосылки и мотивация

Ранние бенчмарки генерации кода, такие как [HumanEval](https://systems-analysis.info/wiki/HumanEval_benchmark "HumanEval benchmark"), MBPP и APPS, позволили сравнивать языковые модели, запуская сгенерированные программы на тестах. Со временем, однако, несколько ограничений становились всё более существенными:

- задачи бенчмарков и эталонные решения были общедоступны и могли попасть в корпуса для претрейна или инструктирования;
- небольшие фиксированные наборы данных были уязвимы к насыщению и тонкой настройке под конкретный бенчмарк;
- некоторые наборы содержали слишком мало тестов, чтобы надёжно выявлять некорректные реализации;
- коллекции задач спортивного программирования могли включать интерактивные задачи или задачи, допускающие несколько верных ответов, из-за чего обычная проверка точного совпадения вывода становится ненадёжной;
- большинство известных бенчмарков измеряли только генерацию кода из описания на естественном языке, хотя практическим системам также нужны отладка, трассировка выполнения и работа с тестами.

LiveCodeBench был разработан, чтобы устранить эти проблемы за счёт регулярного сбора новых контестных задач, фильтрации по датам, более строгих исполняемых тестов и нескольких сценариев оценки. Авторы описывали бенчмарк как «contamination free» («свободный от загрязнения»); на практике методологию точнее понимать как **contamination-aware** («учитывающую загрязнение»). Она снижает риск попадания задач в обучающие данные, оценивая модели на задачах, опубликованных после среза знаний, но не может доказать, что каждая оцениваемая задача отсутствовала на всех этапах разработки модели.

Бенчмарк также стремится сохранить осмысленное разнообразие сложности. Если все включённые задачи слишком лёгкие, ведущие модели сходятся к точности, близкой к 100 %. Если все задачи уровня продвинутых олимпиад — большинство моделей набирает почти ноль. Поэтому LiveCodeBench отображает рейтинги исходных платформ в широкие категории **Easy**, **Medium** и **Hard** и публикует результаты по категориям раздельно<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

## Принципы проектирования

| Принцип                           | Реализация                                                                                                                    | Ожидаемая польза                                                                         |
|-----------------------------------|-------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
| **Актуальность по времени**       | Новые контестные задачи периодически добавляются и снабжаются датами публикации.                                              | Позволяет оценивать модели на задачах, которые вряд ли попали в старые обучающие данные. |
| **Фильтрация по временному окну** | Результаты можно вычислять между заданными датами начала и конца.                                                             | Позволяет выровнять оценку по заявленному срезу знаний или дате выпуска модели.          |
| **Целостная оценка**              | Исходный фреймворк включает генерацию кода, самоисправление, выполнение кода и предсказание вывода тестов.                    | Разделяет способности, которые часто объединены внутри программных агентов.              |
| **Исполняемая проверка**          | Сгенерированные программы и предсказанные ответы проверяются запуском или точным сравнением.                                  | Снижает зависимость от аннотаторов-людей и субъективных LLM-судей.                       |
| **Курирование задач**             | Интерактивные, зависящие от изображений, неоднозначные и не поддающиеся автопроверке задачи по возможности отфильтровываются. | Снижает число ложных неудач из-за неподходящих форматов задач.                           |
| **Надёжные тесты**                | Тесты платформ при необходимости дополняются сгенерированными и состязательными входами.                                      | Выявляет программы, решающие только видимые примеры или распространённые случаи.         |
| **Разнообразие сложности**        | Задачи нормализуются в группы Easy, Medium и Hard.                                                                            | Поддерживает и широкое сравнение моделей, и анализ способностей по сложности.            |
| **Версионируемые релизы**         | Кумулятивные и инкрементальные теги определяют точный использованный набор задач.                                             | Улучшает воспроизводимость и позволяет исторические сравнения.                           |

## Сбор и курирование данных

### Платформы-источники

LiveCodeBench получает задачи с трёх публичных платформ спортивного программирования<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

| Платформа      | Исходная политика сбора                                                                                                                                                                   | Тесты и форматирование                                                                                                                                                                                                   |
|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **LeetCode**   | Собирались задачи еженедельных и двухнедельных контестов, опубликованные после апреля 2023 года. Метки платформы Easy, Medium и Hard сохранялись.                                         | Собирались стартовый код и публичные примеры. Поскольку полные скрытые тесты публично не раскрываются, бенчмарк генерировал дополнительные входы и включал отдельные падающие тесты, возвращаемые проверяющим платформы. |
| **AtCoder**    | Исходное исследование сосредоточилось на контестах AtCoder Beginner Contests; более продвинутые Regular и Grand Contests исключались. Задачи выше выбранного порога сложности опускались. | Публичные и скрытые тесты AtCoder использовались напрямую, где были доступны. Числовые рейтинги платформы отображались в три группы сложности LiveCodeBench.                                                             |
| **Codeforces** | Первоначальная коллекция использовала ограниченное число задач Division 3 и Division 4, поскольку даже они, как правило, были сложнее отобранных задач LeetCode и AtCoder.                | Так как полные длинные тесты на сайте не всегда раскрыты, генераторы тестов строились полуавтоматически.                                                                                                                 |

Автоматические HTML-скрейперы собирают условие задачи и метаданные. Математические выражения разбираются в нормализованное представление, а задачи, зависящие от изображений, исключаются. Процесс сбора также пытается получить публичные тесты, скрытые тесты там, где они доступны, принятые человеческие решения, рейтинги сложности исходной платформы, идентификаторы контестов и даты публикации<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

### Фильтрация задач

Не каждая контестная задача подходит для детерминированной проверки «вход-выход». Исходный процесс фильтрации исключал или пытался обнаружить:

- интерактивные задачи, требующие многократного обмена с проверяющей системой;
- задачи, допускающие несколько структурно разных верных ответов для одного входа;
- конструктивные задачи, для которых одного эталонного ответа недостаточно;
- задачи, существенная информация которых содержится в изображении;
- задачи, которые невозможно надёжно воспроизвести вне исходной платформы;
- задачи за пределами выбранного диапазона сложности бенчмарка.

Система фильтрации использовала эвристики на основе ключевых слов и специализированные для платформ правила. Эти процедуры сделали непрерывный сбор практичным, но не были безошибочными. Поэтому сопровождающие публикуют файл эррата, документирующий задачи с ошибочными тестами, несколькими допустимыми ответами, неподдерживаемыми паттернами взаимодействия или иными проблемами проверки<sup>[\[4\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_errata-4)</sup>.

### Построение тестов

Тесты играют центральную роль в каждом сценарии LiveCodeBench. Когда официальные тесты доступны, они используются напрямую. Иначе исходный конвейер применял языковую модель для написания программ-генераторов входных данных на основе спецификации задачи. Такие генераторы производили разнообразные корректные тестовые входы, а не просили модель перечислить небольшое число тестовых примеров напрямую<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Коллекция может объединять:

- публичные примеры тестов из условия задачи;
- официальные скрытые тесты, предоставленные платформой контеста;
- входы, полученные из сгенерированных генераторов тестовых случаев;
- состязательные или падающие тесты, полученные от проверяющих платформ;
- граничные случаи, выведенные из ограничений в условии задачи.

В срезе май 2023 — май 2024, проанализированном в основной статье, коллекция генерации кода содержала в среднем около 17 тестов на задачу. Авторы обнаружили, что измеренная производительность обычно стабилизируется примерно после 20 скрытых входов, что задаёт компромисс между стоимостью проверки и покрытием тестами<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

### Состав набора данных в исходной статье

Основное исследование ICLR анализировало кумулятивный срез генерации кода, содержащий 511 задач, выпущенных с мая 2023 года по май 2024 года<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

| Источник или подвыборка | Задач   | Easy | Medium | Hard | Среднее число тестов |
|-------------------------|---------|------|--------|------|----------------------|
| **Полный срез**         | **511** | 182  | 206    | 123  | 17,0                 |
| AtCoder                 | 267     | 99   | 91     | 77   | 15,6                 |
| LeetCode                | 235     | 79   | 113    | 43   | 19,0                 |
| Codeforces              | 9       | 4    | 2      | 3    | 11,1                 |

Состав среза генерации кода май 2023 — май 2024

Эти значения описывают исторический срез статьи, а не более позднюю коллекцию `release_v6`. Доли платформ, распределение сложности и число тестов могут меняться по мере добавления новых кумулятивных релизов.

## Сценарии оценки

### Генерация кода

В сценарии генерации кода модель получает:

- условие задачи на естественном языке;
- спецификации входа и выхода;
- ограничения;
- публичные пары «вход-выход»;
- стартовый код там, где исходная задача использует интерфейс на основе функций.

Модель должна сгенерировать полную программу или функцию. Её вывод запускается на скрытых тестах, и задача считается решённой, только если программа выдаёт ожидаемый результат по каждому оцениваемому тесту в пределах ограничений времени и памяти<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Задачи LeetCode обычно используют формат вызова функций с предоставленным стартовым кодом. Задачи AtCoder и Codeforces, как правило, используют обычный для спортивного программирования формат стандартного входа и стандартного выхода.

### Самоисправление

Сценарий самоисправления начинается с программы, сгенерированной в ходе оценки генерации кода. Если программа некорректна, модель получает обратную связь с описанием неудачи и должна предложить исправленную реализацию.

Обратная связь может включать:

- синтаксическую ошибку;
- исключение времени выполнения;
- падающий тестовый вход;
- вывод программы и ожидаемый вывод;
- превышение лимита времени.

Итоговая исправленная программа запускается на тестах бенчмарка. Исходная метрика фиксирует, проходит ли тесты либо исходная реализация, либо реализация после одношагового исправления. Поэтому результат самоисправления отражает и начальную способность к генерации, и умение использовать обратную связь; это не чистая изолированная мера навыка отладки<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

### Выполнение кода

Сценарий выполнения кода проверяет, может ли модель мысленно симулировать программу. Он предоставляет:

- функцию на Python;
- конкретный вызов функции или утверждение (assertion);
- заполнитель для результирующего значения.

Модель должна предсказать буквальный вывод, который даст запуск кода. Ответ проверяется через запуск и точное сравнение. Исходные эксперименты оценивали как прямое предсказание, так и конфигурацию с цепочкой рассуждений, где модель инструктировалась трассировать программу шаг за шагом<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Выполнение кода проверяет понимание потока управления, изменения состояния, рекурсии, структур данных и семантики языка, не требуя от модели проектировать новый алгоритм.

### Предсказание вывода тестов

В предсказании вывода тестов модель получает спецификацию задачи на естественном языке и фиксированный тестовый вход, но не эталонную реализацию. Она должна вывести ответ, который должна дать корректная реализация.

Этот сценарий отличается от обычной генерации тестов. Бенчмарк сам предоставляет вход, поэтому оценивающему достаточно проверить предсказанный вывод. Задача измеряет, насколько хорошо модель понимает спецификацию, чтобы провести рассуждение по конкретному случаю<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

| Сценарий                   | Вход модели                                             | Требуемый ответ                     | Основная способность                            | Проверка                                       |
|----------------------------|---------------------------------------------------------|-------------------------------------|-------------------------------------------------|------------------------------------------------|
| Генерация кода             | Условие задачи и примеры                                | Исполняемое решение                 | Проектирование и реализация алгоритма           | Функциональная корректность на скрытых тестах  |
| Самоисправление            | Задача, некорректное решение и обратная связь о неудаче | Исправленное решение                | Отладка и использование обратной связи          | Функциональная корректность итоговой программы |
| Выполнение кода            | Программа и конкретный вход                             | Фактический вывод при запуске       | Симуляция программы и понимание кода            | Точное сравнение на основе запуска             |
| Предсказание вывода тестов | Условие задачи и фиксированный вход                     | Ожидаемый вывод корректного решения | Понимание спецификации и конкретное рассуждение | Точное сравнение                               |

## Версии набора данных

LiveCodeBench использует кумулятивные релизные теги. Каждый `release_vN` содержит более ранние задачи плюс задачи, добавленные в последующие периоды сбора<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)</sup>.

| Релиз        | Охватываемый интервал публикации | Кумулятивное число задач |
|--------------|----------------------------------|--------------------------|
| `release_v1` | май 2023 — март 2024             | **400**                  |
| `release_v2` | май 2023 — май 2024              | **511**                  |
| `release_v3` | май 2023 — июль 2024             | **612**                  |
| `release_v4` | май 2023 — сентябрь 2024         | **713**                  |
| `release_v5` | май 2023 — январь 2025           | **880**                  |
| `release_v6` | май 2023 — апрель 2025           | **1055**                 |

Раннер по умолчанию использует `release_latest`, который разрешается в последнюю версию, известную установленному коду. Однако оценивающему следует записывать явный релизный тег, поскольку значение `release_latest` может измениться после обновления репозитория.

Проект также определяет мелкие теги, например:

- `v1` — задачи, добавленные в первый период сбора;
- `v2` — задачи, впервые добавленные во второй релиз;
- `v1_v3` — объединение выбранных инкрементальных периодов;
- `v4_v5` — задачи четвёртого и пятого интервалов обновления.

Это различие важно: `release_v5` кумулятивен, тогда как `v5` относится только к задачам, введённым в этом обновлении.

По состоянию на 10 июля 2026 года в официальном репозитории не указана кумулятивная версия новее `release_v6`. Поэтому самые новые задачи в публичном кумулятивном наборе были опубликованы в апреле 2025 года<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)</sup>.

## Формат данных и программное обеспечение

### Записи генерации кода

Публичный набор `code_generation_lite` обычно раскрывает следующие поля<sup>[\[3\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_data-3)</sup>:

| Поле                 | Описание                                                                         |
|----------------------|----------------------------------------------------------------------------------|
| `question_title`     | Человекочитаемое название задачи.                                                |
| `question_content`   | Полное условие задачи, включая ограничения и описания входа-выхода.              |
| `platform`           | Исходная платформа, например LeetCode, AtCoder или Codeforces.                   |
| `question_id`        | Идентификатор задачи бенчмарка или исходной платформы.                           |
| `contest_id`         | Идентификатор исходного контеста.                                                |
| `contest_date`       | Дата публикации, используемая для фильтрации по временному окну.                 |
| `starter_code`       | Сигнатура функции или шаблон кода, где применимо.                                |
| `difficulty`         | Нормализованная метка Easy, Medium или Hard.                                     |
| `public_test_cases`  | Примеры, видимые модели или включённые в условие задачи.                         |
| `private_test_cases` | Скрытые тесты, используемые для исполняемой проверки.                            |
| `metadata`           | Дополнительная информация, необходимая для разбора, запуска или проверки задачи. |

Некоторые поля содержат сериализованные JSON-структуры, а не простые строки. Потребителям следует использовать официальный загрузчик или раннер, а не предполагать, что все тестовые данные можно интерпретировать прямым разбиением строк.

Упрощённая концептуальная запись выглядит так:

    {
      "question_title": "Example Contest Problem",
      "question_content": "Full natural-language specification",
      "platform": "atcoder",
      "question_id": "example_id",
      "contest_id": "example_contest",
      "contest_date": "2025-01-01",
      "starter_code": "",
      "difficulty": "medium",
      "public_test_cases": "serialized public tests",
      "private_test_cases": "serialized private tests",
      "metadata": "serialized grading metadata"
    }

### Code Generation Lite

Исходный набор генерации кода содержал большое число тестов и требовал значительных объёмов хранения и времени оценки. Позднее сопровождающие выпустили `code_generation_lite`, сокращая и выбирая тесты, стараясь сохранить схожие агрегированные рейтинги моделей и оценки производительности. Lite-коллекция стала выбором по умолчанию в раннере; полную версию можно запросить опцией не-fast-оценки<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)[\[3\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_data-3)</sup>.

Lite-версия ускоряет оценку, но создаёт компромисс: меньший набор тестов с большей вероятностью пропустит необычную некорректную реализацию.

### Официальный раннер

Официальный репозиторий содержит шаблоны промптов для конкретных моделей, парсеры ответов, исполняемые чекеры, инструменты агрегации баллов и поддержку локальных или размещённых за API моделей. Типичная команда генерации кода:

    python -m lcb_runner.runner.main \
      --model MODEL_NAME \
      --scenario codegeneration \
      --evaluate \
      --release_version release_v6

Результаты для конкретного окна публикации можно вычислить отдельно:

    python -m lcb_runner.evaluation.compute_scores \
      --eval_all_file PATH_TO_RESULTS \
      --start_date 2024-01-01 \
      --end_date 2025-01-31

Программное обеспечение оценки выпущено под лицензией MIT<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)</sup>. Условия контестных задач, тесты и принятые решения происходят с внешних платформ; в исходной статье указано, что публично видимый материал собирался для академической оценки на основе обоснованного добросовестного использования (fair use). Правовой статус и условия распространения исходного контента отличны от лицензии на программное обеспечение<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

## Методология оценки

### Функциональная корректность

Сгенерированная программа успешна, только если она:

- может быть извлечена из ответа модели;
- компилируется или запускается в целевой среде;
- завершается в отведённое время;
- даёт принятый ответ по каждому выбранному скрытому тесту.

Ответ может не пройти из-за алгоритмической ошибки, ошибки реализации, несоответствия формата вывода, неподдерживаемой зависимости, превышения времени, проблем с памятью или из-за того, что парсер не смог восстановить предполагаемый код.

Основная метрика — **pass@1**. Она оценивает вероятность того, что одна сгенерированная моделью попытка решит задачу. Репозиторий также вычисляет **pass@5**, оценивающий вероятность того, что хотя бы одна из пяти сгенерированных попыток корректна<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)</sup>.

В простом виде:

- `pass@1` — ожидаемый процент успеха при одном сгенерированном решении на задачу;
- `pass@5` — ожидаемый процент успеха, когда можно попробовать до пяти сгенерированных решений.

Pass@5 обычно выше pass@1, но расходует больший бюджет инференса. Эти две метрики не следует сравнивать так, будто они отражают одинаковые условия развёртывания.

### Конфигурация выборки

Исходная оценка ICLR генерировала десять ответов-кандидатов на задачу с nucleus-сэмплированием и параметрами:

- температура: `0,2`;
- top-p: `0,95`;
- десять сгенерированных кандидатов.

Инструктированные модели получали zero-shot промпт генерации кода, а базовые — one-shot промпт, чтобы сократить ошибки форматирования<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Документированные значения по умолчанию официального репозитория в июле 2026 года также используют десять генераций и температуру 0,2, а его оценщик генерации кода сообщает pass@1 и pass@5<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)</sup>.

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

### Оценка по временным сегментам

У каждой задачи есть дата контеста. Оценивающий может выбрать только задачи, даты публикации которых лежат после заявленного среза знаний модели.

Например, модель с заявленным срезом 31 декабря 2024 года может оцениваться на задачах, начиная с 1 января 2025 года. В принципе это снижает вероятность того, что точные вопросы или официальные решения попали в претрейн.

У процедуры есть несколько оговорок:

- заявленный срез может описывать лишь один из этапов обучения модели;
- пост-трейн, обучение с подкреплением, индексы извлечения (retrieval) или специфическая для оценки разработка могут использовать более новые данные;
- разработчики моделей не всегда раскрывают точный срез;
- дата выпуска модели — лишь грубый заменитель, когда срез неизвестен;
- контестные задачи могли циркулировать приватно или появляться в производных наборах до записанной публичной даты.

Временная фильтрация поэтому даёт свидетельство против прямого загрязнения, но не математическую гарантию независимости данных.

### Отчётность по сложности, платформе и времени

Один агрегированный балл может скрыть важные различия. LiveCodeBench поддерживает разбивку по:

- сложности Easy, Medium и Hard;
- исходной платформе;
- месячному или произвольному временному окну;
- кумулятивному или инкрементальному релизу;
- сценарию оценки.

Результаты по платформам полезны, поскольку стиль задач и построение тестов различаются между LeetCode, AtCoder и Codeforces. Модель может показывать разные результаты на задачах с дописыванием функций и на контестных программах со стандартным входом, даже если лежащая в основе алгоритмическая сложность схожа.

### Вариативность времени выполнения

Официальный репозиторий отмечает, что лимиты времени и конкурентность оценки могут вызывать небольшие вариации величиной менее примерно 0,5 балла. Сопровождающие рекомендуют сократить число параллельных процессов оценки или увеличить таймаут, если появляются более крупные расхождения<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)</sup>.

Эта вариативность особенно влияет на решения, близкие к лимиту времени, программы с нестабильным потреблением ресурсов и совместно используемые среды выполнения.

### Требования к воспроизводимости

Полный результат LiveCodeBench должен указывать:

- точную модель и чекпойнт или версию API;
- тег релиза набора данных;
- даты начала и конца;
- язык программирования;
- сценарий;
- промпт и чат-шаблон;
- число сгенерированных сэмплов;
- температуру, top-p и метод декодирования;
- максимальную длину вывода;
- доступ к инструментам и выполнению;
- был ли текст рассуждений видимым или скрытым;
- процедуру извлечения кода;
- полную или lite-коллекцию тестов;
- pass@1, pass@5 или иную метрику агрегации;
- таймаут и среду выполнения;
- любые этапы исправления, переранжирования, голосования или верификации.

Балл, подписанный просто «LiveCodeBench», неоднозначен: он может относиться к другому релизу, временному окну, языку, бюджету сэмплирования или конвейеру оценки.

## Исходное исследование и результаты

Исследование ICLR оценило **52 модели** от 1,3 до 70 миллиардов параметров, включая базовые модели, инструктированные открытые модели и проприетарные API-системы. Чтобы снизить вероятное загрязнение в семействе DeepSeek, его основные сравнительные результаты использовали задачи, выпущенные с сентября 2023 года<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

### Исторические результаты генерации кода

Избранные результаты генерации кода из статьи приведены ниже. Они используют временное окно после августа 2023 года, десять сгенерированных ответов на задачу, температуру 0,2 и top-p 0,95<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

| Модель                                                                                           | Easy pass@1 | Medium pass@1 | Hard pass@1 | Итоговый pass@1 |
|--------------------------------------------------------------------------------------------------|-------------|---------------|-------------|-----------------|
| [GPT-4o](https://systems-analysis.info/wiki/GPT-4o "GPT-4o") (13 мая 2024 года)                  | **88,3 %**  | **33,2 %**    | 4,2 %       | **41,9 %**      |
| [GPT-4 Turbo](https://systems-analysis.info/wiki/GPT-4_Turbo "GPT-4 Turbo") (9 апреля 2024 года) | 85,3 %      | 33,0 %        | **5,1 %**   | 41,1 %          |
| Claude 3 Opus                                                                                    | 78,8 %      | 16,3 %        | 3,2 %       | 32,8 %          |
| Llama 3 70B Instruct                                                                             | 60,7 %      | 15,8 %        | 1,4 %       | 26,0 %          |

Избранные результаты исследования ICLR

Это исторические результаты набора моделей эпохи 2024 года, а не текущая таблица лидеров. Тем не менее они иллюстрируют резкий градиент сложности: даже самые сильные из оценённых систем решали большинство лёгких (Easy) задач, но лишь малую долю трудных (Hard).

### Признаки загрязнения данных

Исследователи построили графики производительности моделей по месяцам публикации задач. Несколько систем показали резкие спады около своих заявленных срезов знаний или дат выпуска, особенно на задачах LeetCode.

Обсуждавшиеся в статье примеры включали:

- модели DeepSeek-Coder, деградирующие на задачах LeetCode, опубликованных после августа 2023 года;
- спад GPT-4o на задачах, опубликованных после заявленного среза конца 2023 года;
- аналогичные границы около периодов выпуска у более новых систем;
- заметно более плавную помесячную производительность на AtCoder у тех же моделей.

Авторы интерпретировали эти паттерны как свидетельство того, что более высокие баллы на старых вопросах LeetCode отчасти объясняются попаданием задач в обучающие данные. Результат также показал, почему один фиксированный агрегированный балл может скрыть временное загрязнение<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Временной спад не является окончательным доказательством запоминания. Новые задачи могут отличаться стилем или сложностью, а исходная платформа может со временем менять распределение контестов. Свидетельство сильнее всего, когда разрыв совпадает с независимо заявленным срезом и не воспроизводится на других платформах.

### Различия по целостным сценариям

Баллы по четырём сценариям сильно коррелировали: в исходном исследовании попарные корреляции превышали 0,88. Сильные модели генерации кода, как правило, хорошо выступали и в исправлении, и в выполнении кода, и в предсказании вывода<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Однако относительные разрывы не были постоянными. В статье отмечено, что:

- GPT-4 Turbo получал большее преимущество в самоисправлении, чем в прямой генерации;
- Claude 3 Opus и Mistral Large сравнительно хорошо выступали на задачах, требующих рассуждений о выполнении кода;
- Claude 3 Opus превосходил GPT-4 Turbo в предсказании вывода тестов в оцениваемой конфигурации;
- цепочка рассуждений существенно улучшала выполнение кода у нескольких проприетарных моделей, но у открытых моделей приносила пользу менее стабильно.

Эти различия подтверждают исходный тезис бенчмарка: один балл генерации кода не характеризует программную модель исчерпывающе.

### Сравнение с HumanEval

Авторы сравнили pass@1 на HumanEval+ с результатами на подмножестве Easy в LiveCodeBench. Заявленная корреляция составила лишь **0,72**, а несколько дообученных открытых моделей выступали на HumanEval+ значительно лучше, чем на свежих контестных задачах<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Например, DeepSeek-Coder-Instruct 1,3B набрал около 60 % на HumanEval+, но лишь 26 % на LCB-Easy в оценке статьи. Другие дообученные системы показывали схожие разрывы.

Авторы описали это как свидетельство возможного переобучения под HumanEval или тесно связанные распределения обучающих данных. Сравнение не доказывает, что какая-то конкретная модель обучалась напрямую на HumanEval, но показывает, что высокая эффективность на коротких задачах с дописыванием функций не всегда переносилась на более разнообразные контестные задачи.

## Принятие и текущий статус

LiveCodeBench стал часто упоминаемым бенчмарком в технических отчётах кодовых моделей, карточках моделей, оценках рассуждающих моделей, исследованиях обучения с подкреплением и работах по агентной генерации кода. Его основные привлекательные стороны:

- публичные исполняемые тесты;
- простые метрики pass@k;
- явные даты задач;
- несколько уровней сложности;
- более сложные задачи, чем у малых бенчмарков синтеза функций;
- переиспользуемый локальный раннер оценки;
- поддержка произвольных временных срезов.

Тем не менее публичная идентичность проекта сместилась в сторону генерации кода. Репозиторий по-прежнему содержит команды для самоисправления, предсказания вывода тестов и выполнения кода, но его инструкции июля 2026 года принимают новые записи в таблицу лидеров только для генерации кода<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)</sup>.

Другое важное различие статуса — публичная частота релизов. Хотя LiveCodeBench проектировался как постоянно обновляемый бенчмарк, последний кумулятивный публичный релиз, указанный на 10 июля 2026 года, заканчивается апрелем 2025 года. Поэтому свойство «live» зависит от продолжения сбора и релизной активности, а не является автоматическим свойством программного обеспечения оценки.

## Связанные расширения

### LiveCodeBench Pro

**LiveCodeBench Pro** — отдельный бенчмарк, представленный в 2025 году для оценки значительно более трудных задач спортивного программирования. Он черпает задачи из Codeforces, Международной студенческой олимпиады по программированию (ICPC) и Международной олимпиады по информатике (IOI)<sup>[\[5\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_pro_paper-5)</sup>.

Команда международных медалистов программных контестов разметила задачи по алгоритмическим категориям и провела построчный анализ неудачных посылок (submissions) моделей. В конфигурации без инструментов исходного исследования самая сильная из оценённых моделей достигла 53 % pass@1 на задачах Medium и 0 % на задачах Hard<sup>[\[5\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_pro_paper-5)</sup>.

Исследователи сообщали, что модели сравнительно сильны в задачах, насыщенных реализацией, но продолжают испытывать трудности с:

- распознаванием тонких алгоритмических инвариантов;
- сложным разбором случаев (case analysis);
- доказательством корректности предложенного алгоритма;
- различением правдоподобной эвристики и полного решения;
- обнаружением уверенно сформулированного, но некорректного рассуждения.

LiveCodeBench Pro не является `release_v7`, и его не следует рассматривать как кумулятивное обновление стандартного набора LiveCodeBench. У него другое распределение задач, процесс курирования и целевая сложность.

### Multi-LCB

**Multi-LCB** — мультиязычное расширение по языкам программирования, представленное в препринте июня 2026 года. Оно преобразует задачи генерации кода LiveCodeBench в эквивалентные задачи оценки для **12 языков программирования**, включая Python<sup>[\[6\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-multi_lcb_paper-6)</sup>.

Поддерживаемый набор языков включает:

- Python;
- C++;
- C#;
- Java;
- Rust;
- Go;
- TypeScript;
- JavaScript;
- Ruby;
- PHP;
- Kotlin;
- Scala.

Multi-LCB сохраняет семантику исходных задач, временны́е метаданные и принцип исполняемой оценки, преобразуя задачи, ориентированные на функции, в более унифицированное представление со стандартным входом и стандартным выходом. Его исходное исследование оценило 24 языковые модели и сообщило о признаках переобучения под Python, зависящего от языка загрязнения и существенных межъязыковых различий в результатах<sup>[\[6\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-multi_lcb_paper-6)</sup>.

Multi-LCB устраняет ключевое языковое ограничение исходного бенчмарка, но является независимым расширением, а не официальным кумулятивным релизом LiveCodeBench.

| Бенчмарк              | Представлен | Основной фокус                                                              | Отношение к LiveCodeBench                                 |
|-----------------------|-------------|-----------------------------------------------------------------------------|-----------------------------------------------------------|
| **LiveCodeBench**     | 2024        | Свежие контестные задачи от Easy до Hard и четыре сценария программирования | Исходная программа-бенчмарк                               |
| **LiveCodeBench Pro** | 2025        | Задачи экспертного уровня из Codeforces, ICPC и IOI                         | Отдельный более сложный бенчмарк с разметкой специалистов |
| **Multi-LCB**         | 2026        | Генерация кода на 12 языках программирования                                | Независимое расширение на несколько языков                |

## Ограничения и критика

### Условный контроль загрязнения

Термин «contamination free» может вводить в заблуждение, если понимать его как абсолютное свойство. LiveCodeBench не проверяет каждый токен, использованный во время претрейна, пост-трейна, обучения с подкреплением, индексации извлечения, оценки модели или разработки промптов.

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

- заявленный срез относится только к претрейну;
- более поздний корпус инструктирования включает свежие контестные задачи;
- модель имеет доступ к внешнему поиску или извлечению;
- задача была распространена до официальной даты контеста;
- производная или переведённая версия попала в обучающие данные;
- разработчик не раскрывает соответствующую хронологию разработки.

Поэтому бенчмарк корректнее описывать как снижающий вероятность загрязнения при документированных условиях оценки.

### Публичные данные со временем становятся обучающими

После публикации релиза LiveCodeBench его условия, тесты, метаданные, промпты и код оценки становятся доступными разработчикам моделей. В публичных репозиториях моделей уже идентифицированы системы, обученные или дообученные на наборе генерации кода.

В результате модель может быть оптимизирована напрямую под старые релизы LiveCodeBench. Временная фильтрация остаётся полезной, только если достаточно новые отложенные задачи продолжают добавляться.

### Частота обновлений

По состоянию на июль 2026 года `release_v6` остаётся последней кумулятивной версией и не содержит задач новее апреля 2025 года<sup>[\[2\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_repo-2)</sup>. Это создаёт растущий разрыв между новейшими публичными задачами бенчмарка и недавно разработанными моделями.

Версионируемый, но уже нечасто обновляемый бенчмарк сохраняет ценность для воспроизводимости, однако постепенно теряет устойчивость к загрязнению, подразумеваемую словом «Live».

### Сокращение выборки после среза знаний

Оценка только на задачах после среза сокращает доступную выборку. В исходной статье фильтрация коллекции из 511 задач до интервала после августа 2023 года оставляла 349 задач генерации кода. Бутстреп-анализ показывал примерно один-два процентных пункта вариации для выборок такого размера<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Для новых моделей проблема обостряется. Поздний срез может оставить лишь небольшое число подходящих вопросов, особенно после разбиения данных по платформам и сложности.

Различия между соседними баллами в таблице лидеров могут быть статистически неинформативными, если не приводятся доверительные интервалы или повторные выборки.

### Сопоставимость между версиями

Баллы `release_v1`, `release_v4` и `release_v6` напрямую не взаимозаменяемы. Более поздние релизы содержат больше задач и могут иметь другие пропорции:

- исходных платформ;
- уровней сложности;
- форматов на основе функций и стандартного входа;
- алгоритмических тем;
- размеров наборов тестов;
- периодов публикации.

Два отчёта с ярлыком «LiveCodeBench v6» могут также выбирать разные временные окна. Для осмысленного сравнения необходимы точные параметры релиза и фильтрации.

### Ошибки тестов и проверки

Исполняемые тесты дают более сильное свидетельство, чем суждение на естественном языке, но ни один конечный набор тестов не доказывает корректность программы на всех допустимых входах.

Возможные проблемы включают:

- пропущенные граничные случаи;
- некорректные ожидаемые выводы;
- сгенерированные некорректные входы;
- несколько верных ответов, не распознаваемых чекером;
- ошибки нормализации чисел с плавающей точкой или пробелов;
- платформо-специфичное поведение;
- нестабильность таймаутов;
- отклонение корректного, но необычно медленного решения;
- прохождение некорректного решения по сокращённому lite-набору тестов.

Официальная эррата показывает, что часть неподходящих задач и ошибочных тестов прошла автоматическое курирование<sup>[\[4\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_errata-4)</sup>. Результаты могут измениться при исправлении затронутых задач или тестов.

### Компромисс lite-набора тестов

Коллекция `code_generation_lite` снижает стоимость оценки, удаляя или выбирая тесты. Сопровождающие сообщают, что она даёт оценки производительности, схожие с исходной коллекцией, но агрегированное сходство не гарантирует идентичных решений для каждой модели или задачи<sup>[\[3\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_data-3)</sup>.

Сгенерированная программа может пройти lite-набор и провалить удалённый тест. Сравнения не должны смешивать полную и lite-оценки без указания различия.

### Спортивное программирование — не разработка ПО в целом

**LiveCodeBench** измеряет способность решать самодостаточные алгоритмические задачи. Это лишь часть программирования.

Бенчмарк не оценивает всесторонне:

- навигацию по большому существующему репозиторию;
- понимание недокументированных архитектурных соглашений;
- модификацию нескольких взаимодействующих файлов;
- использование незнакомых сторонних API;
- написание миграций базы данных;
- отладку распределённых систем;
- сохранение обратной совместимости;
- ревью кода, написанного другим разработчиком;
- работу с требованиями безопасности, приватности и надёжности;
- коммуникацию с пользователями и сопровождающими;
- долгосрочную поддержку программного проекта.

Система может получать высокий балл LiveCodeBench, оставаясь слабой в задачах разработки на уровне репозитория. Бенчмарки вроде [SWE-bench](https://systems-analysis.info/wiki/SWE-bench "SWE-bench") направлены на другую и дополнительную способность.

### Ориентация на Python

Основные задачи, промпты, инструментарий и анализ исходного бенчмарка сосредоточены на Python, хотя статья ICLR включала ограниченное дополнительное сравнение на C++<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

Производительность на Python не переносится автоматически на языки с:

- ручным управлением памятью;
- статическими системами типов;
- правилами владения (ownership) и заимствования (borrowing);
- сложными моделями компиляции;
- другими стандартными библиотеками;
- семантикой конкурентности;
- более многословными требованиями ввода-вывода.

Multi-LCB был представлен именно для систематического охвата дополнительных языков программирования<sup>[\[6\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-multi_lcb_paper-6)</sup>.

### Слепые зоны метрик

Pass@k оценивает наблюдаемую функциональную корректность на предоставленных тестах. Она напрямую не вознаграждает:

- читаемость;
- поддерживаемость;
- модульность;
- документацию;
- безопасность;
- численную робастность за пределами протестированных входов;
- качество пояснений;
- алгоритмическую оригинальность;
- достоверность рассуждений модели;
- энергозатраты или стоимость инференса;
- соблюдение стилистических правил проекта.

Программа с некорректным рассуждением может получить полный балл, если итоговая реализация проходит тесты. Наоборот, корректное решение может провалиться из-за мелкой ошибки формата вывода или извлечения кода.

### Выборка и вычисления на этапе тестирования

Pass@1 из одного жадного ответа не эквивалентен pass@1, оценённому по десяти стохастическим сэмплам. Pass@5, голосование большинством, переранжирование с верификатором, исправление с управлением исполнением и мультиагентные процессы используют всё больший вычислительный бюджет.

Современные рассуждающие модели могут также генерировать очень длинные внутренние цепочки или многократно исполнять программы-кандидаты. Более высокий балл может отражать:

- более сильную базовую модель;
- большее число сгенерированных кандидатов;
- больший лимит reasoning-токенов;
- лучшую генерацию тестов;
- внешнего верификатора;
- больше итераций исправления;
- поиск с инструментами.

Отчёты должны отличать способность модели от вычислительной системы, окружающей модель на этапе оценки.

### Чувствительность к промптам и парсерам

Выводы моделей зависят от системных промптов, чат-шаблонов, ограждений кода (code fences), языковых инструкций и правил извлечения ответа. Модель может сгенерировать корректную программу в окружении пояснительного текста, который парсер не сумеет извлечь. Другой парсер может успешно восстановить тот же код.

Исходная статья использовала в основном стандартизованные промпты с ограниченными адаптациями по семействам моделей, но признавала, что выбор промпта может изменить результаты<sup>[\[1\]](https://systems-analysis.info/wiki/LiveCodeBench#cite_note-lcb_paper-1)</sup>.

### Интерпретация метрики самоисправления

Исходный балл самоисправления засчитывает успех после первого решения или после попытки исправления. Поэтому модель с сильной начальной генерацией и слабой отладкой может превзойти более сильного отладчика, чьи стартовые решения хуже.

Специальный анализ исправления должен сообщать как минимум:

- начальную точность генерации кода;
- число изначально неудачных программ, подходящих для исправления;
- долю неудачных программ, успешно исправленных;
- категорию ошибки;
- число итераций исправления;
- состав информации в обратной связи.

### Исходный контент и распространение

Программное обеспечение оценки имеет явную открытую лицензию, но сами задачи происходят с внешних контестных платформ. Условия, редакторские разборы, принятые решения и скрытые тесты могут иметь отдельные условия использования или правообладателей.

Исследователи, распространяющие изменённые наборы данных, и коммерческие сервисы оценки должны отличать лицензию раннера от правового статуса контента исходных платформ.

## Ссылки

- <a href="https://livecodebench.github.io/" class="external text" rel="nofollow">Официальный сайт LiveCodeBench</a>
- <a href="https://github.com/LiveCodeBench/LiveCodeBench" class="external text" rel="nofollow">Официальный репозиторий LiveCodeBench</a>
- <a href="https://huggingface.co/datasets/livecodebench/code_generation_lite" class="external text" rel="nofollow">Набор данных генерации кода LiveCodeBench</a>
- <a href="https://livecodebench.github.io/leaderboard.html" class="external text" rel="nofollow">Официальная таблица лидеров</a>
- <a href="https://aiwiki.ai/wiki/livecodebench" class="external text" rel="nofollow">LiveCodeBench — AI Wiki</a>
- <a href="https://systems-analysis.info/eng/LiveCodeBench" class="external text" rel="nofollow">LiveCodeBench — англоязычная версия Systems Analysis Wiki</a>

## См. также

- [Бенчмарки LLM](https://systems-analysis.info/wiki/%D0%91%D0%B5%D0%BD%D1%87%D0%BC%D0%B0%D1%80%D0%BA%D0%B8_LLM "Бенчмарки LLM")
- [HumanEval](https://systems-analysis.info/wiki/HumanEval_benchmark "HumanEval benchmark")
- [SWE-bench](https://systems-analysis.info/wiki/SWE-bench "SWE-bench")
- [Большие языковые модели](https://systems-analysis.info/wiki/%D0%91%D0%BE%D0%BB%D1%8C%D1%88%D0%B8%D0%B5_%D1%8F%D0%B7%D1%8B%D0%BA%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D0%B8 "Большие языковые модели")

## Литература

- Jain, N. et al. (2025). *LiveCodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code*. ICLR 2025. <a href="https://arxiv.org/abs/2403.07974" class="external text" rel="nofollow">arXiv:2403.07974</a>.
- Chen, M. et al. (2021). *Evaluating Large Language Models Trained on Code*. <a href="https://arxiv.org/abs/2107.03374" class="external text" rel="nofollow">arXiv:2107.03374</a>.
- Hendrycks, D. et al. (2021). *Measuring Coding Challenge Competence With APPS*. NeurIPS. <a href="https://arxiv.org/abs/2105.09938" class="external text" rel="nofollow">arXiv:2105.09938</a>.
- Liu, J. et al. (2023). *Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation*. NeurIPS. <a href="https://arxiv.org/abs/2305.01210" class="external text" rel="nofollow">arXiv:2305.01210</a>.
- Zheng, Z. et al. (2025). *LiveCodeBench Pro: How Do Olympiad Medalists Judge LLMs in Competitive Programming?*. <a href="https://arxiv.org/abs/2506.11928" class="external text" rel="nofollow">arXiv:2506.11928</a>.
- Ivanova, M. et al. (2026). *Multi-LCB: Extending LiveCodeBench to Multiple Programming Languages*. <a href="https://arxiv.org/abs/2606.20517" class="external text" rel="nofollow">arXiv:2606.20517</a>.

## Примечания

1.  <span id="cite_note-lcb_paper-1">↑ <sup>[1,00](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-0)</sup> <sup>[1,01](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-1)</sup> <sup>[1,02](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-2)</sup> <sup>[1,03](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-3)</sup> <sup>[1,04](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-4)</sup> <sup>[1,05](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-5)</sup> <sup>[1,06](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-6)</sup> <sup>[1,07](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-7)</sup> <sup>[1,08](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-8)</sup> <sup>[1,09](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-9)</sup> <sup>[1,10](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-10)</sup> <sup>[1,11](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-11)</sup> <sup>[1,12](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-12)</sup> <sup>[1,13](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-13)</sup> <sup>[1,14](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-14)</sup> <sup>[1,15](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-15)</sup> <sup>[1,16](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-16)</sup> <sup>[1,17](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-17)</sup> <sup>[1,18](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-18)</sup> <sup>[1,19](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-19)</sup> <sup>[1,20](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-20)</sup> <sup>[1,21](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_paper_1-21)</sup> Jain, N. et al. "LiveCodeBench: Holistic and Contamination Free Evaluation of Large Language Models for Code". *International Conference on Learning Representations*, 2025. <a href="https://proceedings.iclr.cc/paper_files/paper/2025/hash/94074dd5a072d28ff75a76dabed43767-Abstract-Conference.html" class="external text" rel="nofollow">ICLR proceedings</a>; <a href="https://arxiv.org/abs/2403.07974" class="external text" rel="nofollow">arXiv:2403.07974</a>.</span>
2.  <span id="cite_note-lcb_repo-2">↑ <sup>[2,00](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-0)</sup> <sup>[2,01](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-1)</sup> <sup>[2,02](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-2)</sup> <sup>[2,03](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-3)</sup> <sup>[2,04](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-4)</sup> <sup>[2,05](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-5)</sup> <sup>[2,06](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-6)</sup> <sup>[2,07](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-7)</sup> <sup>[2,08](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-8)</sup> <sup>[2,09](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_repo_2-9)</sup> LiveCodeBench. "Official repository for LiveCodeBench". GitHub. Accessed 10 July 2026. <a href="https://github.com/LiveCodeBench/LiveCodeBench" class="external autonumber" rel="nofollow">[1]</a></span>
3.  <span id="cite_note-lcb_data-3">↑ <sup>[3,0](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_data_3-0)</sup> <sup>[3,1](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_data_3-1)</sup> <sup>[3,2](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_data_3-2)</sup> <sup>[3,3](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_data_3-3)</sup> LiveCodeBench. "code_generation_lite". *Hugging Face Datasets*. <a href="https://huggingface.co/datasets/livecodebench/code_generation_lite" class="external autonumber" rel="nofollow">[2]</a></span>
4.  <span id="cite_note-lcb_errata-4">↑ <sup>[4,0](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_errata_4-0)</sup> <sup>[4,1](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_errata_4-1)</sup> LiveCodeBench. "ERRATA". GitHub. <a href="https://github.com/LiveCodeBench/LiveCodeBench/blob/main/ERRATA.md" class="external autonumber" rel="nofollow">[3]</a></span>
5.  <span id="cite_note-lcb_pro_paper-5">↑ <sup>[5,0](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_pro_paper_5-0)</sup> <sup>[5,1](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-lcb_pro_paper_5-1)</sup> Zheng, Z. et al. "LiveCodeBench Pro: How Do Olympiad Medalists Judge LLMs in Competitive Programming?". *arXiv:2506.11928*, 2025. <a href="https://arxiv.org/abs/2506.11928" class="external autonumber" rel="nofollow">[4]</a></span>
6.  <span id="cite_note-multi_lcb_paper-6">↑ <sup>[6,0](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-multi_lcb_paper_6-0)</sup> <sup>[6,1](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-multi_lcb_paper_6-1)</sup> <sup>[6,2](https://systems-analysis.info/wiki/LiveCodeBench#cite_ref-multi_lcb_paper_6-2)</sup> Ivanova, M. et al. "Multi-LCB: Extending LiveCodeBench to Multiple Programming Languages". *arXiv:2606.20517*, 2026. <a href="https://arxiv.org/abs/2606.20517" class="external autonumber" rel="nofollow">[5]</a></span>
