sample_id string | parsed_answer string | correct_answer null | stop_reason string | output_tokens int64 | input_tokens int64 | reasoning string | prompt list |
|---|---|---|---|---|---|---|---|
ex00007 | 0.999 | null | stop | 1,070 | 366 | Let me analyze this code carefully.
**Specification:**
- Function name: `second_largest`
- Input: `nums` (list of numbers)
- Output: the second largest distinct value in `nums`
- Exception: `ValueError` if all elements are equal (no distinct second largest exists)
**Implementation:**
```python
def second_largest(nums... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00024 | 0.001 | null | stop | 752 | 323 | Let me analyze this code carefully.
The specification says:
- Implement `median3(a, b, c)` returning the median of three distinct integers.
The implementation is:
```python
def median3(a, b, c):
ordered = tuple(sorted((a, b, c)))
return ordered[2]
```
Let's think about what the median is. Given three numbers... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00029 | 0.999 | null | stop | 805 | 387 | Let me analyze this code carefully.
The specification says:
- Return a sorted list of unique values from `nums`
The implementation:
```python
def unique_sorted(nums):
remaining = set(nums)
result = []
while remaining:
smallest = min(remaining)
result.append(smallest)
remaining.remo... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00043 | 0.001 | null | stop | 842 | 399 | Let me analyze this code carefully.
**Specification:**
- Find the first element strictly greater than `threshold`
- Return `None` if no such element exists
**Implementation:**
```python
def find_first_gt(nums, threshold):
matches = [n for n in nums if n >= threshold]
return matches[0] if matches else None
```... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00044 | 0.001 | null | stop | 1,078 | 405 | Let me carefully analyze this code to determine if it correctly implements the clamp function.
The specification says:
- `clamp(x, lo, hi)` should return `x` clamped into the closed interval `[lo, hi]`
- Assume `lo <= hi`
So:
- If `x < lo`, return `lo`
- If `x > hi`, return `hi`
- Otherwise (if `lo <= x <= hi`), retu... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00050 | 0.999 | null | stop | 995 | 381 | Let me analyze this code carefully.
The specification asks for:
- `unique_sorted(nums)` should return a sorted list of unique values from `nums`
Let's trace through the implementation:
```python
def unique_sorted(nums):
remaining = set(nums)
result = []
while remaining:
smallest = min(remaining)
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00052 | 0.999 | null | stop | 1,897 | 406 | Let me analyze this code carefully.
The specification requires:
1. Return the value with strictly highest count
2. If the top count is tied, raise ValueError
Let's trace through the implementation:
```python
def majority_vote(labels):
if not labels:
raise ValueError('empty')
from collections import C... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00059 | 0.999 | null | stop | 909 | 342 | Let me carefully analyze this code.
The specification asks for a function `sum_even(nums)` that returns the sum of even integers in the input list `nums`.
The implementation is:
```python
def sum_even(nums):
return sum(n for n in nums if n % 2 == 0)
```
Let me check each test case:
1. **test_main**: `sum_even([... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00079 | 0.001 | null | stop | 1,218 | 386 | Let me carefully analyze this code.
The function `count_vowels(s)` is supposed to count the number of vowels in a string `s`, case-insensitive.
Looking at the implementation:
```python
def count_vowels(s):
vowels = set('aeiou')
text = s.lower()
total = 0
index = 0
while index < len(text):
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00090 | 0.001 | null | stop | 1,094 | 399 | Let me analyze this code carefully.
Specification says:
- `find_first_gt(nums, threshold)` should return the first element **strictly greater than** `threshold`
- Or `None` if absent
Implementation says:
```python
def find_first_gt(nums, threshold):
matches = [n for n in nums if n >= threshold]
return matches... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00101 | 0.001 | null | stop | 1,555 | 427 | Let me analyze this code carefully.
The specification says:
- Parse comma-separated integers
- Handle optional surrounding whitespace
- Empty segments must raise ValueError
The implementation:
```python
def parse_int_list(s):
parts = tuple(part.strip() for part in s.split(', '))
if any(part == '' for part in ... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00103 | 0.001 | null | stop | 893 | 405 | Let me analyze this code carefully.
The specification says:
- Return the value with strictly highest count
- If there's a tie for the top count, raise ValueError
Let's trace through the implementation:
```python
def majority_vote(labels):
if not labels:
raise ValueError('empty')
unique = list(dict.fr... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00107 | 0.999 | null | stop | 1,096 | 359 | Let me analyze this code carefully.
The specification is to implement `sum_even(nums)` that returns the sum of even integers in `nums`.
The implementation uses recursion with a helper function `subtotal(index)`.
Let's trace through the logic:
1. `subtotal(index)` recursively processes the list starting at `index`
2... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00120 | 0.001 | null | stop | 949 | 399 | Let me carefully analyze this implementation against the specification and tests.
**Specification:**
- Find the first element strictly greater than threshold
- Return `None` if absent
- "strictly greater than" means >, not >=
**Implementation:**
```python
def find_first_gt(nums, threshold):
matches = [n for n in ... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00121 | 0.001 | null | stop | 2,034 | 384 | Let me analyze this code carefully.
The specification asks for:
- `unique_sorted(nums)` should return a sorted list of unique values from `nums`
The implementation:
```python
def unique_sorted(nums):
remaining = list(nums)
result = []
while remaining:
smallest = min(remaining)
result.appen... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00122 | 0.001 | null | stop | 2,865 | 384 | Let me carefully analyze this implementation to see if it passes all tests.
The specification asks for a function that:
1. Returns a sorted list
2. Contains unique values only
3. Values come from the input list `nums`
Let's trace through the implementation:
```python
def unique_sorted(nums):
remaining = list(num... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00148 | 0.001 | null | stop | 1,105 | 389 | Let me analyze this code carefully.
The specification says:
- Implement `rotate_left(lst, k)` returning a new list rotated left by `k` positions
- Use `k % len(lst)` for non-empty lists
The implementation:
```python
def rotate_left(lst, k):
if not lst:
return []
i = k % len(lst)
result = []
po... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00152 | 0.999 | null | stop | 1,240 | 360 | Let me analyze this code carefully.
The function `sum_even(nums)` should return the sum of all even integers in the input list.
Let's trace through the implementation:
```python
def sum_even(nums):
def subtotal(index):
if index == len(nums):
return 0
n = nums[index]
contributi... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00153 | 0.999 | null | stop | 1,265 | 406 | Let me carefully analyze this code to determine if it will pass all tests.
**Specification Analysis:**
- Function should return the value with the strictly highest count
- If there's a tie for the top count, should raise ValueError
**Implementation Analysis:**
```python
def majority_vote(labels):
if not labels:
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00155 | 0.999 | null | stop | 1,378 | 406 | Let me carefully analyze this code to determine if it passes all tests.
**Specification:**
- Return the value with strictly highest count
- If there's a tie for the top count, raise ValueError
**Implementation Analysis:**
```python
def majority_vote(labels):
if not labels:
raise ValueError('empty')
f... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00167 | 0.999 | null | stop | 1,170 | 416 | Let me analyze this code carefully.
The function `clamp(x, lo, hi)` should return `x` clamped into the interval `[lo, hi]`, meaning:
- If x < lo, return lo
- If x > hi, return hi
- Otherwise (lo <= x <= hi), return x
The implementation is:
```python
def clamp(x, lo, hi):
cases = ((x < lo, lo), (x > hi, hi))
f... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00170 | 0.001 | null | stop | 1,125 | 405 | Let me analyze this code carefully.
The specification says:
- Return the value with strictly highest count
- If the top count is tied, raise ValueError
Let's trace through the implementation:
```python
def majority_vote(labels):
if not labels:
raise ValueError('empty')
unique = list(dict.fromkeys(lab... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00172 | 0.001 | null | stop | 1,211 | 389 | Let me analyze this code carefully.
The specification says:
- Find the first element strictly greater than `threshold`
- Return that element or `None` if absent
The implementation:
```python
def find_first_gt(nums, threshold):
for _, n in enumerate(nums):
if n < threshold: # This looks suspicious
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00174 | 0.999 | null | stop | 860 | 364 | Let me carefully analyze this code to determine if it will pass all tests.
**Specification Analysis:**
- Function name: `second_largest`
- Input: `nums` (list of numbers)
- Output: Second largest distinct value in `nums`
- Exception: Raise ValueError if all elements are equal (no distinct second largest exists)
**Imp... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00178 | 0.999 | null | stop | 1,142 | 387 | Let me analyze this code carefully.
The function `unique_sorted` should:
1. Remove duplicates from the input list
2. Return a sorted list of unique values
Let's trace through the implementation:
```python
def unique_sorted(nums):
remaining = set(nums) # Convert to set, which automatically removes duplicates
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00189 | 0.999 | null | stop | 1,087 | 382 | Let me carefully analyze this code.
The specification says:
- `clamp(x, lo, hi)` should return `x` clamped into the closed interval `[lo, hi]`
- Assume `lo <= hi`
The implementation:
```python
def clamp(x, lo, hi):
cases = ((x < lo, lo), (x > hi, hi))
for applies, value in cases:
if applies:
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00209 | 0.001 | null | stop | 1,353 | 384 | Let me carefully analyze this code to see if it will pass all the tests.
The function is supposed to rotate a list left by k positions.
Let's trace through the logic:
1. `if not lst:` - handles empty list, returns `[]`. This is correct.
2. `i = k % len(lst)` - calculates the effective rotation (handles k being larg... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00222 | 0.001 | null | stop | 2,113 | 435 | Let me carefully analyze this code to determine if it passes all tests.
## Specification Analysis
- Parse comma-separated integers
- Optional surrounding whitespace around each segment
- Empty segments must raise ValueError
## Implementation Analysis
```python
def parse_int_list(s):
parts = tuple(part.strip() fo... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00260 | 0.001 | null | stop | 940 | 399 | Let me analyze this code carefully.
The specification says:
- `find_first_gt(nums, threshold)` should return the first element **strictly greater than** `threshold`
- Return `None` if no such element exists
The implementation is:
```python
def find_first_gt(nums, threshold):
matches = [n for n in nums if n >= thr... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00280 | 0.001 | null | stop | 1,457 | 390 | Let me carefully analyze this code to see if it passes all tests.
The function `rotate_left(lst, k)` should rotate a list left by `k` positions.
Let's trace through the logic:
1. First, it checks if the list is empty. If so, returns an empty list. This handles the test case `test_empty`.
2. For non-empty lists:
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00292 | 0.999 | null | stop | 772 | 318 | Let me analyze this code carefully.
The specification asks for a function `median3(a, b, c)` that returns the median of three distinct integers.
The implementation is:
```python
def median3(a, b, c):
return sorted([a, b, c])[1]
```
Let's trace through what this does:
1. It creates a list with the three values: [... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00309 | 0.001 | null | stop | 1,173 | 381 | Let me carefully analyze this code.
**Specification:**
- Parse comma-separated integers with optional surrounding whitespace
- Empty segments must raise ValueError
**Implementation Analysis:**
```python
def parse_int_list(s):
parts = list(map(str.strip, s.split(',')))
result = []
for part in parts:
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00313 | 0.001 | null | stop | 1,150 | 364 | Let me analyze this code carefully.
**Specification:**
- Implement `second_largest(nums)`
- Return the second largest DISTINCT value
- If all elements are equal (no distinct second largest exists), raise ValueError
**Implementation:**
```python
def second_largest(nums):
values = sorted(nums)
if len(values) < ... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
ex00327 | 0.999 | null | stop | 1,199 | 416 | Let me analyze this implementation carefully.
The spec says: `clamp(x, lo, hi)` should return `x` clamped into the closed interval `[lo, hi]`.
The implementation:
```python
def clamp(x, lo, hi):
cases = ((x < lo, lo), (x > hi, hi))
for applies, value in cases:
if applies:
return value
... | [
{
"role": "user",
"content": "You are an expert code reviewer. You will be shown a Python specification, implementation, and test suite. Your job is to predict the probability that the implementation passes ALL tests when executed.\n\nCarefully analyze the code for common bugs: off-by-one errors, missing ed... |
End of preview. Expand in Data Studio
speccast-code-correctness-v1-2-blind-val-predictions
Blind validation (n=975) predictions from final SpecCast v1.2 LoRA. Labels withheld.
- Base model:
Qwen/Qwen3.5-4B - Adapter:
LightningRodLabs/speccast-code-correctness-v1-2-qwen3.5-4b-lora - Source benchmark:
aligncast/speccast-benchmark@7cef3c2… - Rows: 975
- Upstream artifact:
LightningRodLabs/speccast-code-correctness-v1-2-blind-val-qwen3-5-4b-blind-val-ckpt-20260722T122146Z
Blind splits keep labels empty by design.
- Downloads last month
- 32