OJBench: A Competition Level Code Benchmark For Large Language Models

O artigo apresenta o OJBench, um novo benchmark desafiador composto por 232 problemas de competições de programação (NOI e ICPC) para avaliar a capacidade de raciocínio em código de nível competitivo de modelos de linguagem, revelando que mesmo os modelos mais avançados atuais enfrentam dificuldades significativas nesses cenários.

O essencial

Imagine que os modelos de linguagem (como o ChatGPT ou o DeepSeek) são como estudantes superdotados que leram quase todos os livros do mundo. Eles são ótimos em escrever poemas, resumir textos e até resolver problemas de matemática do ensino médio.

Mas, e se quisermos saber se eles conseguem vencer uma Olimpíada de Matemática ou um Campeonato de Programação contra os melhores gênios do mundo? É aí que entra o OJBench.

Aqui está uma explicação simples do que os autores descobriram, usando algumas analogias:

1. O Problema: A "Prova de Fogo"

Até agora, os testes para ver se esses robôs são bons em programação eram como provas de vestibular. Eram questões difíceis, mas que muitos estudantes bons conseguiam resolver. Era como pedir para um atleta correr 100 metros: todos os modelos de ponta conseguiam fazer um tempo decente, e era difícil saber quem era realmente o campeão.

Os autores criaram o OJBench para mudar isso. Eles pegaram 232 problemas reais de competições de elite (como a Olimpíada Nacional de Informática da China e o ICPC, que é o "Mundial" de programação universitária).

• A analogia: Em vez de pedir para o robô correr 100 metros, eles o colocaram numa maratona na montanha com neve. É um teste muito mais difícil e realista.

2. O Resultado: A Realidade Dura

Quando eles colocaram 37 modelos diferentes (desde os gratuitos e abertos até os mais caros e fechados da OpenAI e Google) para resolver esses problemas, a surpresa foi grande:

• Mesmo os "gênios" tropeçam: Os modelos mais inteligentes do mundo, que usam técnicas avançadas de "raciocínio" (como o o4-mini ou o Gemini-2.5), ainda têm muita dificuldade. Eles conseguem resolver os problemas fáceis, mas na hora dos problemas "difíceis" (nível olímpico), a maioria deles falha.
• A lição: É como se você tivesse um carro de Fórmula 1, mas ele ainda não consegue passar por uma pista de rally cheia de buracos. A tecnologia é incrível, mas ainda não é perfeita para o nível mais alto de desafio.

3. A Linguagem Importa: Python vs. C++

O teste foi feito em duas linguagens: Python (fácil de ler, como falar em português) e C++ (mais complexo, mas super rápido, como falar em código binário).

• O que eles descobriram: Para os modelos mais avançados, usar C++ foi como dar a eles um superpoder. Eles se saíram muito melhor no C++ do que no Python.
• Por que? Em competições reais, os humanos usam C++ porque ele é mais rápido e eficiente. Os modelos, quando treinados para pensar como humanos de elite, também entendem que precisam dessa "velocidade" para ganhar a prova.

4. O "Aprendizado com Erros" (Refinamento)

Os autores testaram uma coisa interessante: e se, quando o robô errasse, eles mostrassem o erro para ele e pedissem para ele tentar de novo?

• O que aconteceu: Funcionou! Quando o robô recebia a mensagem de erro (como "seu código travou" ou "resposta errada"), ele conseguia corrigir e acertar mais problemas.
• O limite: Eles conseguem corrigir erros de digitação ou lógica simples (como um aluno que percebe que esqueceu um ponto e vírgula). Mas, quando o erro era porque o algoritmo era muito lento (o computador demoraria 100 anos para resolver), o robô tinha muita dificuldade em inventar uma solução nova e mais rápida. É como pedir para alguém que está correndo devagar inventar um novo método de corrida para ganhar de um atleta olímpico.

5. Conclusão: O Futuro

O OJBench é como um novo "termômetro" para a inteligência artificial. Ele nos diz que:

1. Os modelos atuais são muito bons, mas não são onipotentes.
2. Para chegar ao próximo nível, eles precisam aprender a pensar como os melhores programadores humanos, não apenas memorizar códigos.
3. A tecnologia está avançando, mas ainda há um "abismo" entre o que os robôs fazem hoje e o que os campeões mundiais de programação fazem.

Resumo em uma frase: O OJBench é a prova de que, embora nossos robôs sejam estudantes brilhantes, eles ainda precisam de muito mais treino para vencer as Olimpíadas de Programação do mundo real.

Resumo técnico

1. Problema Identificado

O avanço recente dos Grandes Modelos de Linguagem (LLMs) orientados ao raciocínio (como OpenAI-o1, DeepSeek-R1 e Gemini-2.5-pro) demonstrou capacidades significativas em matemática e geração de código. No entanto, os benchmarks (conjuntos de testes) de código existentes, como o LiveCodeBench, são limitados:

• Nível de Dificuldade: A maioria dos problemas foca em níveis de entrevista de emprego ou algoritmos básicos, não desafiando adequadamente os modelos de ponta.
• Falta de Discriminação: Muitos modelos atingem desempenho saturado nesses benchmarks, tornando difícil diferenciar suas capacidades reais de raciocínio lógico complexo.
• Ausência de Padrões Competitivos: Falta um benchmark que utilize problemas reais de competições de programação de elite (como Olimpíadas e ICPC) para testar os limites dos modelos.

2. Metodologia: OJBench

Para preencher essa lacuna, os autores introduzem o OJBench, um novo benchmark de nível competitivo.

• Coleta de Dados:
  • O conjunto de dados contém 232 problemas extraídos de duas fontes de elite: a NOI (Olimpíada Nacional de Informática da China) e a ICPC (Competição Internacional de Programação Universitária).
  • Os dados foram filtrados rigorosamente: apenas problemas com casos de teste completos e verificáveis foram mantidos. Problemas que exigiam juízes especiais (special judges) complexos ou não disponíveis foram excluídos.
  • As descrições dos problemas da NOI foram traduzidas para o inglês e validadas manualmente.
• Classificação de Dificuldade:
  • NOI: Baseada em votos dos participantes que resolveram o problema (escala 0-7).
  • ICPC: Calculada por uma fórmula que combina a taxa de aceitação e a proporção de times que tentaram resolver o problema em competições reais.
  • As categorias são: Fácil (2-3 pontos), Médio (4-5 pontos) e Difícil (6-7 pontos).
• Método de Avaliação:
  • Métrica: Utiliza-se o Pass@n (probabilidade de pelo menos uma solução correta em n tentativas).
  • Validação Rigorosa: Diferente de benchmarks que usam poucos casos de teste, o OJBench exige que a solução do modelo passe em todos os casos de teste fornecidos para ser considerada correta, evitando falsos positivos.
  • Suporte Dual: Avaliação realizada tanto em Python quanto em C++, reconhecendo que o C++ é o padrão em competições de alto nível devido à eficiência de tempo.
  • Refinamento (Refinement): Testou-se a capacidade dos modelos de corrigir seus próprios erros com base em mensagens de feedback do ambiente de execução (ex: Time Limit Exceeded, Wrong Answer).

3. Principais Contribuições

1. Criação do OJBench: Um benchmark de nível competitivo com 232 problemas de alto nível (NOI e ICPC), superando a dificuldade de conjuntos de dados anteriores.
2. Avaliação Abrangente: Teste de 37 modelos, incluindo modelos de código de código aberto (Open-source), modelos orientados ao raciocínio (Reasoning-oriented), modelos fechados (Closed-source) e de diferentes tamanhos.
3. Análise de Linguagem e Refinamento: Investigação profunda sobre o impacto do uso de C++ vs. Python e a eficácia da correção iterativa baseada em feedback de erro.

4. Resultados Chave

• Desempenho Geral: Mesmo os modelos de última geração (SOTA) orientados ao raciocínio, como o4-mini e Gemini-2.5-pro-exp, enfrentam dificuldades significativas com problemas de nível competitivo.
  • No nível Difícil, a taxa de aprovação da maioria dos modelos não orientados ao raciocínio é 0%.
  • Modelos como o DeepSeek-V3-0324 (671B parâmetros) atingiram apenas 3,74% de acerto em problemas difíceis.
• Orientação ao Raciocínio: Modelos orientados ao raciocínio (ex: o4-mini, Qwen3-235B-A22B, DeepSeek-R1) superam consistentemente os modelos não orientados, destacando a importância do fine-tuning com Aprendizado por Reforço (RL) e distillation.
• Código Aberto vs. Fechado: Modelos fechados ainda lideram, mas os modelos de código aberto orientados ao raciocínio (como Qwen3 e DeepSeek-R1) estão se aproximando rapidamente do desempenho dos modelos fechados.
• Impacto da Linguagem (C++ vs. Python):
  • Para modelos de raciocínio avançados (ex: o4-mini, Gemini), o uso de C++ resultou em desempenho significativamente melhor do que o Python, alinhando-se com a prática humana em competições.
  • Alguns modelos de código aberto (como a série Qwen derivada do DeepSeek-R1) performaram melhor em Python, possivelmente devido aos dados de treinamento específicos.
• Refinamento: A capacidade de corrigir erros baseada em feedback (ex: corrigir erros de compilação) melhorou o desempenho. No entanto, os modelos ainda lutam para resolver erros de Tempo Limitado Excedido (TLE), pois isso exige o redesenho de algoritmos e estruturas de dados, uma habilidade de raciocínio complexa.

5. Significado e Conclusão

O OJBench estabelece um novo padrão para avaliar a verdadeira capacidade de raciocínio em código dos LLMs. Os resultados indicam que:

• O aumento do tamanho do modelo (parâmetros) sozinho não é suficiente para resolver problemas de programação competitiva complexa; técnicas de pós-treinamento focadas em raciocínio são essenciais.
• Existe um "teto" de desempenho atual, onde mesmo os modelos mais avançados falham em uma grande parcela de problemas difíceis, especialmente aqueles que exigem otimização algorítmica rigorosa.
• O benchmark serve como uma ferramenta crítica para guiar o desenvolvimento futuro de LLMs de código, apontando a necessidade de melhorias na geração de algoritmos eficientes e na adaptação a linguagens de baixo nível como C++.

Em suma, o OJBench revela que, embora os LLMs tenham progredido muito, o domínio da programação competitiva de elite ainda representa um desafio significativo e não resolvido para a inteligência artificial atual.