VeriContest
Collection
A competitive-programming benchmark for verifiable code generation • 2 items • Updated • 1
Datasets:
Tasks:
Text Generation
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
ArXiv:
Tags:
competitive-programming
code-generation
specification-generation
proof-generation
verification
rust
License:
problem stringlengths 3 7 | family stringclasses 2
values | description stringlengths 513 6.02k | tags stringlengths 17 139 | spec stringlengths 306 6.78k | code stringlengths 109 3.75k | code_spec stringlengths 442 8.81k | verified stringlengths 449 65k | main stringlengths 558 3.69k ⌀ | checker null | testcases_path stringlengths 34 40 | mutated_testcases_path stringlengths 42 48 |
|---|---|---|---|---|---|---|---|---|---|---|---|
cf1036D | codeforces | # Vasya and Arrays
Time limit: 1 second | Memory limit: 256 megabytes
Vasya has two arrays $$$A$$$ and $$$B$$$ of lengths $$$n$$$ and $$$m$$$, respectively.
He can perform the following operation arbitrary number of times (possibly zero): he takes some consecutive subsegment of the array and replaces it with a singl... | Rating: 1600
greedy, two pointers
Solved by: 10509 users
| use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn prefix_sum(nums: Seq<i64>, end: int) -> int
recommends
0 <= end <= nums.len(),
decreases end,
{
if end <= 0 {
0
} else {
Self::prefix_sum(nums... | impl Solution {
pub fn max_equal_block_count(a: Vec<i64>, b: Vec<i64>) -> i64 {
let n = a.len();
let m = b.len();
let mut ta: i64 = 0;
let mut tb: i64 = 0;
let mut u = 0usize;
while u < n {
ta = ta + a[u];
u = u + 1;
}
u = 0usiz... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn prefix_sum(nums: Seq<i64>, end: int) -> int
recommends
0 <= end <= nums.len(),
decreases end,
{
if end <= 0 {
0
} else {
Self::prefix_sum(nums... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn prefix_sum(nums: Seq<i64>, end: int) -> int
recommends
0 <= end <= nums.len(),
decreases end,
{
if end <= 0 {
0
} else {
Self::prefix_sum(nums... | use std::io::{self, Read};
struct Solution;
impl Solution {
pub fn max_equal_block_count(a: Vec<i64>, b: Vec<i64>) -> i64 {
let n = a.len();
let m = b.len();
let mut ta: i64 = 0;
let mut tb: i64 = 0;
let mut u = 0usize;
while u < n {
ta = ta + a[u];
... | null | codeforces/cf1036D/tests/testcases.jsonl | codeforces/cf1036D/tests/mutated_testcases.jsonl |
cf1118B | codeforces | # Tanya and Candies
Time limit: 1 second | Memory limit: 256 megabytes
Tanya has $$$n$$$ candies numbered from $$$1$$$ to $$$n$$$. The $$$i$$$-th candy has the weight $$$a_i$$$.
She plans to eat exactly $$$n-1$$$ candies and give the remaining candy to her dad. Tanya eats candies in order of increasing their numbers... | Rating: 1200
implementation
Solved by: 13127 users
| use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn odd_sum_before(nums: Seq<i64>, end_pos: int) -> int
recommends
0 <= end_pos <= nums.len(),
decreases end_pos,
{
if end_pos <= 0 {
0
} else {
S... | impl Solution {
pub fn count_equal_sums(a: Vec<i64>) -> i32 {
let n = a.len();
let mut total_even_idx = 0i64;
let mut total_odd_idx = 0i64;
let mut t = 0;
while t < n {
if t % 2 == 0 {
total_even_idx = total_even_idx + a[t];
} else {
... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn odd_sum_before(nums: Seq<i64>, end_pos: int) -> int
recommends
0 <= end_pos <= nums.len(),
decreases end_pos,
{
if end_pos <= 0 {
0
} else {
S... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn odd_sum_before(nums: Seq<i64>, end_pos: int) -> int
recommends
0 <= end_pos <= nums.len(),
decreases end_pos,
{
if end_pos <= 0 {
0
} else {
S... | use std::io;
struct Solution;
impl Solution {
pub fn count_equal_sums(a: Vec<i64>) -> i32 {
let n = a.len();
let mut total_even_idx = 0i64;
let mut total_odd_idx = 0i64;
let mut t = 0;
while t < n {
if t % 2 == 0 {
total_even_idx = total_even_idx... | null | codeforces/cf1118B/tests/testcases.jsonl | codeforces/cf1118B/tests/mutated_testcases.jsonl |
cf1141B | codeforces | # Maximal Continuous Rest
Time limit: 2 seconds | Memory limit: 256 megabytes
Each day in Berland consists of $$$n$$$ hours. Polycarp likes time management. That's why he has a fixed schedule for each day — it is a sequence $$$a_1, a_2, \dots, a_n$$$ (each $$$a_i$$$ is either $$$0$$$ or $$$1$$$), where $$$a_i=0$$$ if... | Rating: 900
implementation
Solved by: 22887 users
| use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn circ_rest_segment(a: Seq<i32>, n: int, start: int, len: int) -> bool {
&&& 0 <= start < n
&&& 0 <= len
&&& forall|k: int|
0 <= k < len ==> #[trigger] a[(start + k) % n] == 1
}
pub open spec fn rest_run_len_ending_... | impl Solution {
pub fn maximal_continuous_rest(a: Vec<i32>) -> i32 {
let n = a.len();
let mut best: i32 = 0;
let mut cur: i32 = 0;
let mut i: usize = 0;
let total: usize = 2 * n;
while i < total {
let idx: usize = i % n;
if a[idx] == 1 {
... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn circ_rest_segment(a: Seq<i32>, n: int, start: int, len: int) -> bool {
&&& 0 <= start < n
&&& 0 <= len
&&& forall|k: int|
0 <= k < len ==> #[trigger] a[(start + k) % n] == 1
}
pub open spec fn rest_run_len_ending_... | use vstd::prelude::*;
use vstd::arithmetic::div_mod::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn circ_rest_segment(a: Seq<i32>, n: int, start: int, len: int) -> bool {
&&& 0 <= start < n
&&& 0 <= len
&&& forall|k: int|
0 <= k < len ==> #[trigger] a[(start + k) % n] == 1
}
pub... | use std::io::{self, Read};
struct Solution;
impl Solution {
pub fn maximal_continuous_rest(a: Vec<i32>) -> i32 {
let n = a.len();
let mut best: i32 = 0;
let mut cur: i32 = 0;
let mut i: usize = 0;
let total: usize = 2 * n;
while i < total {
let idx: usiz... | null | codeforces/cf1141B/tests/testcases.jsonl | codeforces/cf1141B/tests/mutated_testcases.jsonl |
cf1200C | codeforces | # Round Corridor
Time limit: 1 second | Memory limit: 256 megabytes
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by $$$n$$$ sectors, and the outer area is equally divided by $$$m$$$ sectors. A wall exists between each pair of sectors of same area (inn... | Rating: 1400
math, number theory
Solved by: 10540 users
| use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn spec_gcd_u64(a: u64, b: u64) -> u64
decreases b,
{
if b == 0 {
a
} else {
Self::spec_gcd_u64(b, a % b)
}
}
pub open spec fn spec_component_id_u64... | impl Solution {
pub fn corridor_same_component(
n: i64,
m: i64,
t1: i32,
y1: i64,
t2: i32,
y2: i64,
) -> bool {
let nu = n as u64;
let mu = m as u64;
let mut a: u64 = nu;
let mut b: u64 = mu;
while b != 0 {
let r... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn spec_gcd_u64(a: u64, b: u64) -> u64
decreases b,
{
if b == 0 {
a
} else {
Self::spec_gcd_u64(b, a % b)
}
}
pub open spec fn spec_component_id_u64... | use vstd::prelude::*;
use vstd::arithmetic::div_mod::*;
fn main() {}
verus! {
proof fn lemma_spec_gcd_u64_min(a: u64, b: u64)
requires
a >= 1,
b >= 1,
ensures
Solution::spec_gcd_u64(a, b) >= 1,
decreases b,
{
reveal_with_fuel(Solution::spec_gcd_u64, 2);
assert(Solution::sp... | use std::io::{self, Read};
struct Solution;
impl Solution {
pub fn corridor_same_component(
n: i64,
m: i64,
t1: i32,
y1: i64,
t2: i32,
y2: i64,
) -> bool {
let nu = n as u64;
let mu = m as u64;
let mut a: u64 = nu;
let mut b: u64 ... | null | codeforces/cf1200C/tests/testcases.jsonl | codeforces/cf1200C/tests/mutated_testcases.jsonl |
cf1203C | codeforces | # Common Divisors
Time limit: 2 seconds | Memory limit: 256 megabytes
You are given an array $$$a$$$ consisting of $$$n$$$ integers.
Your task is to say the number of such positive integers $$$x$$$ such that $$$x$$$ divides **each** number from the array. In other words, you have to find the number of common divisor... | Rating: 1300
implementation, math
Solved by: 23835 users
| use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn spec_gcd_nat(a: nat, b: nat) -> nat
decreases b,
{
if b == 0 {
a
} else {
Self::spec_gcd_nat(b, a % b)
}
}
pub open spec fn spec_gcd(a: int, b: i... | impl Solution {
pub fn count_common_divisors(n: usize, a: Vec<i64>) -> i64 {
let mut g: i64 = a[0];
let mut i: usize = 1;
while i < n {
let mut x: i64 = g;
let mut y: i64 = a[i];
while y != 0 {
let t: i64 = y;
y = x % y;
... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn spec_gcd_nat(a: nat, b: nat) -> nat
decreases b,
{
if b == 0 {
a
} else {
Self::spec_gcd_nat(b, a % b)
}
}
pub open spec fn spec_gcd(a: int, b: i... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn spec_gcd_nat(a: nat, b: nat) -> nat
decreases b,
{
if b == 0 {
a
} else {
Self::spec_gcd_nat(b, a % b)
}
}
pub open spec fn spec_gcd(a: int, b: i... | use std::io::{self, BufRead};
struct Solution;
impl Solution {
pub fn count_common_divisors(n: usize, a: Vec<i64>) -> i64 {
let mut g: i64 = a[0];
let mut i: usize = 1;
while i < n {
let mut x: i64 = g;
let mut y: i64 = a[i];
while y != 0 {
... | null | codeforces/cf1203C/tests/testcases.jsonl | codeforces/cf1203C/tests/mutated_testcases.jsonl |
cf1343D | codeforces | # Constant Palindrome Sum
Time limit: 1 second | Memory limit: 256 megabytes
You are given an array $$$a$$$ consisting of $$$n$$$ integers (it is guaranteed that $$$n$$$ is even, i.e. divisible by $$$2$$$). All $$$a_i$$$ does not exceed some integer $$$k$$$.
Your task is to replace the **minimum** number of elements... | Rating: 1700
brute force, data structures, greedy, two pointers
Solved by: 13487 users
| use vstd::prelude::*;
fn main() {}
verus! {
pub open spec fn pair_cost(ai: i64, aj: i64, k: i64, x: i64) -> int {
if ai + aj == x { 0 }
else if x >= ({let lo = if ai < aj { ai } else { aj }; lo} + 1) &&
x <= ({let hi = if ai > aj { ai } else { aj }; hi} + k) { 1 }
else { 2 }
}
pub open spec ... | impl Solution {
fn build_tables(n: usize, k: i64, a: &Vec<i64>) -> (Vec<i64>, Vec<i64>) {
let half = n / 2;
let size = (2 * k + 2) as usize;
let mut diff: Vec<i64> = Vec::new();
let mut exact: Vec<i64> = Vec::new();
let mut idx: usize = 0;
while idx < size {
... | use vstd::prelude::*;
fn main() {}
verus! {
pub open spec fn pair_cost(ai: i64, aj: i64, k: i64, x: i64) -> int {
if ai + aj == x { 0 }
else if x >= ({let lo = if ai < aj { ai } else { aj }; lo} + 1) &&
x <= ({let hi = if ai > aj { ai } else { aj }; hi} + k) { 1 }
else { 2 }
}
pub open spec ... | use vstd::prelude::*;
fn main() {}
verus! {
pub open spec fn pair_cost(ai: i64, aj: i64, k: i64, x: i64) -> int {
if ai + aj == x { 0 }
else if x >= ({let lo = if ai < aj { ai } else { aj }; lo} + 1) &&
x <= ({let hi = if ai > aj { ai } else { aj }; hi} + k) { 1 }
else { 2 }
}
pub open spec ... | use std::io::{self, BufRead, Write, BufWriter};
struct Solution;
impl Solution {
fn build_tables(n: usize, k: i64, a: &Vec<i64>) -> (Vec<i64>, Vec<i64>) {
let half = n / 2;
let size = (2 * k + 2) as usize;
let mut diff: Vec<i64> = Vec::new();
let mut exact: Vec<i64> = Vec::new();
... | null | codeforces/cf1343D/tests/testcases.jsonl | codeforces/cf1343D/tests/mutated_testcases.jsonl |
cf1358C | codeforces | # Celex Update
Time limit: 2 seconds | Memory limit: 256 megabytes
During the quarantine, Sicromoft has more free time to create the new functions in "`Celex-2021`". The developers made a new function `GAZ-GIZ`, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
T... | Rating: 1600
math
Solved by: 18296 users
| use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn spec_celex_distinct_sums(x1: int, y1: int, x2: int, y2: int) -> int {
(x2 - x1) * (y2 - y1) + 1
}
impl Solution {
pub fn celex_distinct_sums(x1: i64, y1: i64, x2: i64, y2: i64) -> (r: i64)
requires
1 <= x1... | impl Solution {
pub fn celex_distinct_sums(x1: i64, y1: i64, x2: i64, y2: i64) -> i64 {
let dx = x2 - x1;
let dy = y2 - y1;
dx * dy + 1
}
}
| use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn spec_celex_distinct_sums(x1: int, y1: int, x2: int, y2: int) -> int {
(x2 - x1) * (y2 - y1) + 1
}
impl Solution {
pub fn celex_distinct_sums(x1: i64, y1: i64, x2: i64, y2: i64) -> (r: i64)
requires
1 <= x1... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn spec_celex_distinct_sums(x1: int, y1: int, x2: int, y2: int) -> int {
(x2 - x1) * (y2 - y1) + 1
}
impl Solution {
pub fn celex_distinct_sums(x1: i64, y1: i64, x2: i64, y2: i64) -> (r: i64)
requires
1 <= x1... | use std::io::{self, BufRead};
struct Solution;
impl Solution {
pub fn celex_distinct_sums(x1: i64, y1: i64, x2: i64, y2: i64) -> i64 {
let dx = x2 - x1;
let dy = y2 - y1;
dx * dy + 1
}
}
fn main() {
let stdin = io::stdin();
let mut lines = stdin.lock().lines();
let t: usiz... | null | codeforces/cf1358C/tests/testcases.jsonl | codeforces/cf1358C/tests/mutated_testcases.jsonl |
cf136A | codeforces | # Presents
Time limit: 2 seconds | Memory limit: 256 megabytes
Little Petya very much likes gifts. Recently he has received a new laptop as a New Year gift from his mother. He immediately decided to give it to somebody else as what can be more pleasant than giving somebody gifts. And on this occasion he organized a N... | Rating: 800
implementation
Solved by: 144275 users
| use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn value_occurs(p: Seq<i32>, n: int, v: int) -> bool {
exists|i: int| 0 <= i < n && p[i] == v
}
pub open spec fn is_permutation_1_to_n(p: Seq<i32>, n: int) -> bool {
p.len() == n
&& 1 <= n <= 100
&& forall|i: int... | impl Solution {
pub fn inverse_presents(p: Vec<i32>, n: usize) -> Vec<i32> {
let mut result = Vec::new();
let mut i = 0usize;
while i < n {
result.push(0i32);
i += 1;
}
i = 0usize;
while i < n {
let idx = (p[i] as usize) - 1;
... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn value_occurs(p: Seq<i32>, n: int, v: int) -> bool {
exists|i: int| 0 <= i < n && p[i] == v
}
pub open spec fn is_permutation_1_to_n(p: Seq<i32>, n: int) -> bool {
p.len() == n
&& 1 <= n <= 100
&& forall|i: int... | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
pub open spec fn value_occurs(p: Seq<i32>, n: int, v: int) -> bool {
exists|i: int| 0 <= i < n && p[i] == v
}
pub open spec fn is_permutation_1_to_n(p: Seq<i32>, n: int) -> bool {
p.len() == n
&& 1 <= n <= 100
&& forall|i: int... | use std::io::{self, BufRead};
struct Solution;
impl Solution {
pub fn inverse_presents(p: Vec<i32>, n: usize) -> Vec<i32> {
let mut result = Vec::new();
let mut i = 0usize;
while i < n {
result.push(0i32);
i += 1;
}
i = 0usize;
while i < n {
... | null | codeforces/cf136A/tests/testcases.jsonl | codeforces/cf136A/tests/mutated_testcases.jsonl |
cf1433B | codeforces | "# Yet Another Bookshelf\n\nTime limit: 1 second | Memory limit: 256 megabytes\n\nThere is a bookshe(...TRUNCATED) | Rating: 800
greedy, implementation
Solved by: 29831 users
| "use vstd::prelude::*;\n\nfn main() {}\n\nverus! {\n\npub struct Solution;\n\npub open spec fn first(...TRUNCATED) | "impl Solution {\n pub fn min_moves_books(n: usize, a: Vec<u8>) -> usize {\n let mut first(...TRUNCATED) | "use vstd::prelude::*;\n\nfn main() {}\n\nverus! {\n\npub struct Solution;\n\npub open spec fn first(...TRUNCATED) | "use vstd::prelude::*;\n\nfn main() {}\n\nverus! {\n\npub struct Solution;\n\npub open spec fn first(...TRUNCATED) | "use std::io::{self, Read, Write, BufWriter};\n\nstruct Solution;\n\nimpl Solution {\n pub fn min(...TRUNCATED) | null | codeforces/cf1433B/tests/testcases.jsonl | codeforces/cf1433B/tests/mutated_testcases.jsonl |
cf1462D | codeforces | "# Add to Neighbour and Remove\n\nTime limit: 3 seconds | Memory limit: 256 megabytes\n\nPolycarp wa(...TRUNCATED) | Rating: 1400
greedy, math, number theory
Solved by: 18025 users
| "use vstd::prelude::*;\n\nfn main() {}\n\nverus! {\n\npub open spec fn sum_range(a: Seq<i64>, start:(...TRUNCATED) | "impl Solution {\n fn compute_sum(n: usize, a: &Vec<i64>) -> i64 {\n let mut total: i64 = (...TRUNCATED) | "use vstd::prelude::*;\n\nfn main() {}\n\nverus! {\n\npub open spec fn sum_range(a: Seq<i64>, start:(...TRUNCATED) | "use vstd::prelude::*;\n\nfn main() {}\n\nverus! {\n\npub open spec fn sum_range(a: Seq<i64>, start:(...TRUNCATED) | "use std::io::{self, BufRead, Write, BufWriter};\n\nstruct Solution;\n\nimpl Solution {\n fn comp(...TRUNCATED) | null | codeforces/cf1462D/tests/testcases.jsonl | codeforces/cf1462D/tests/mutated_testcases.jsonl |
End of preview. Expand in Data Studio
VeriContest Lite
A 300-problem subset of VeriContest for smaller evaluations
Paper · Leaderboard · GitHub · Full dataset
VeriContest Lite is a fixed 300-problem subset of VeriContest, a benchmark of competitive-programming problems from LeetCode and Codeforces for verifiable code generation in Rust with Verus. VeriContest accompanies the paper "VeriContest: A Competitive-Programming Benchmark for Verifiable Code Generation" (arXiv:2605.08553), accepted at NeurIPS 2026 in the Evaluations & Datasets Track.
Lite is for smaller, cheaper evaluations. It keeps the full benchmark's mix of sources, difficulty levels and reference proof sizes, and supports the same tasks: specification generation, code generation, proof generation, and end-to-end verified program synthesis. The problems and test cases are identical to those in VeriContest release v2026.10.1. Lite has its own leaderboard, where every full-benchmark entry is also scored on the Lite problems.
The GitHub repository with the problem artifacts, tooling, and the Lite problem list is available at HIPREL-Group/VeriContest.
Selection Criteria
Starting from the 1,006 problems of VeriContest v2026.10.1, a problem is removed when:
- its description contains an image or a hyperlink;
- its description refers to another problem;
- its outputs are judged by a problem-specific checker (several valid answers) rather than by exact comparison;
- its reference solution uses more than half of the 1 s per-case time limit on some test case.
No rule looks at the proof. 914 problems remain. From them, 300 are sampled with a fixed seed: each source and difficulty level gets its full-benchmark share of the places; within each group, problems are ranked by reference proof size and cut into one interval per place, and one problem is drawn from each interval. When the drawn problem is removed by a rule, the remaining problem of the same group closest to it in proof size takes its place. Model results are never used.
| Source | Level | VeriContest | Lite |
|---|---|---|---|
| LeetCode | Easy | 359 | 107 |
| LeetCode | Medium | 302 | 90 |
| LeetCode | Hard | 61 | 18 |
| Codeforces | Rating 800 | 118 | 35 |
| Codeforces | 900–1000 | 40 | 12 |
| Codeforces | 1100–1200 | 49 | 15 |
| Codeforces | 1300–1400 | 40 | 12 |
| Codeforces | 1500+ | 37 | 11 |
| Total | 1,006 | 300 |
Loading the Problems
problems.jsonl has one row per problem (300 rows) and is what the Dataset
Viewer shows. Load it with:
from datasets import load_dataset
problems = load_dataset("Gax-c/VeriContest_Lite", split="test")
Each row has these columns:
problem: Problem id, such ascf1036Dorlc1004.family:codeforcesorleetcode.description,tags,spec,code,code_spec,verified,main: The contents of the matching files described in File Meanings.mainisnullfor LeetCode problems.checker: Alwaysnull; Lite problems are judged by exact comparison.testcases_path,mutated_testcases_path: Repository paths of the problem's positive and negative test case files.
The test cases (about 17 GiB in total) are not embedded in this table. Download
the whole dataset to evaluate with the VeriContest scorer
(python3 evaluation/score.py --split lite --testcases <this folder> ...), or
download only the problems you need, for example:
import json
from huggingface_hub import hf_hub_download
path = hf_hub_download("Gax-c/VeriContest_Lite", problems[0]["testcases_path"],
repo_type="dataset")
with open(path) as f:
testcases = [json.loads(line) for line in f]
Layout
problems.jsonl
manifest.jsonl
codeforces/
cf1036D/
description.md
tags
code.rs
spec.rs
code_spec.rs
verified.rs
main.rs
tests/
testcases.jsonl
mutated_testcases.jsonl
leetcode/
lc1004/
description.md
tags
code.rs
spec.rs
code_spec.rs
verified.rs
tests/
testcases.jsonl
mutated_testcases.jsonl
File Meanings
description.md: The natural-language problem statement sourced from LeetCode or Codeforces, supplemented with starter code to support evaluation.tags: Metadata such as problem ID, difficulty level, acceptance rate, and algorithm tags, when available.spec.rs: The ground-truth formal specification, with preconditions on the inputs and postconditions relating inputs and outputs.code.rs: Ground-truth Rust code accepted by the online judge.code_spec.rs: The code and specification artifact used for the proof-generation task.verified.rs: The full Verus-verified program with specification, code, and proofs.main.rs: Codeforces-only executable entry point and stdin/stdout plumbing.tests/testcases.jsonl: Positive test cases, pairing valid inputs with the reference outputs produced by the verified program.tests/mutated_testcases.jsonl: Negative test cases, pairing valid inputs with incorrect outputs that a complete postcondition should reject.
Each line in the test case files is a JSON object with input and output.
Manifest
manifest.jsonl contains one row per problem with family, problem, path
(the problem directory), problem_files, checker (always null), and
testcase_files (the path, source, and bytes of each test case file).
Size
- Problems: 300
- LeetCode problems: 215
- Codeforces problems: 85
Citation
If you use VeriContest Lite, please cite VeriContest:
@article{xie2026vericontest,
title={{VeriContest}: A Competitive-Programming Benchmark for Verifiable Code Generation},
author={Xie, Zichen and Pawagi, Mrigank and Liu, Yuxin and Rai, Aaditi and Shao, Lize and Berberian, Jr., John and Che, Sicong and Wang, Wenxi},
journal={arXiv preprint arXiv:2605.08553},
year={2026}
}
- Downloads last month
- 58