task_id string | pass_idx int64 | problem dict | judge_prompt list | judge_response string | judge_model string | timestamp string | inference_time float64 | group_idx int64 | solutions list | candidate_passes list | selected_position int64 | correct_positions list | is_correct bool | num_candidates int64 | extraction_error bool |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
3784 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[\\\"jump\\\", \\\"run\\\", \\\"run\\\", \\\"jump\\\", \\\"run\\\"]\\n2\", \"output\": \"[3, 4, 4, 3, 4]\", \"testtype\": \"functional\"}, {\"input\": \"[\\\"dog\\\", \\\"racer\\\", \\\"ca... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-common-prefix-of-k-strings-after-removal\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an array of strings words and an integer k.\nF... | <think>
Okay, let's tackle this problem. So, the task is to find, for each element in the array, the longest common prefix among any k distinct strings after removing that element. The challenge is to do this efficiently given the constraints.
First, I need to understand the problem thoroughly. Let's look at the examp... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.003297 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\nimport heapq\n\nclass Solution:\n def longestCommonPrefix(self, words: List[str], k: int) -> List[int]:\n n = len(words)\n # If after removal there are fewer than k strings, answer is always 0.\n if n <= k... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3784 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[\\\"jump\\\", \\\"run\\\", \\\"run\\\", \\\"jump\\\", \\\"run\\\"]\\n2\", \"output\": \"[3, 4, 4, 3, 4]\", \"testtype\": \"functional\"}, {\"input\": \"[\\\"dog\\\", \\\"racer\\\", \\\"ca... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-common-prefix-of-k-strings-after-removal\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an array of strings words and an integer k.\nF... | <think>
Okay, let's tackle this problem. So, the task is to find, for each element in the words array, the length of the longest common prefix among any k distinct strings after removing that element. The challenge is to handle large inputs efficiently, especially since the constraints mention up to 1e5 words and sum o... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.016478 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def longestCommonPrefix(self, words: List[str], k: int) -> List[int]:\n n = len(words)\n\n # If after removal there are fewer than k strings, answer is 0 for all.\n if n == k:\n ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3784 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[\\\"jump\\\", \\\"run\\\", \\\"run\\\", \\\"jump\\\", \\\"run\\\"]\\n2\", \"output\": \"[3, 4, 4, 3, 4]\", \"testtype\": \"functional\"}, {\"input\": \"[\\\"dog\\\", \\\"racer\\\", \\\"ca... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-common-prefix-of-k-strings-after-removal\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an array of strings words and an integer k.\nF... | <think>
Okay, let's tackle this problem. So, the task is to find, for each element in the words array, the length of the longest common prefix among any k distinct strings after removing that element. If removing the element leaves fewer than k strings, we return 0 for that index.
First, I need to understand the probl... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.032347 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\nimport sys\n\nclass Solution:\n def longestCommonPrefix(self, words: List[str], k: int) -> List[int]:\n sys.setrecursionlimit(300000) # enough for deep tries\n n = len(words)\n # After removing on... | [
true,
false
] | 1 | [
1
] | true | 2 | true |
3784 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[\\\"jump\\\", \\\"run\\\", \\\"run\\\", \\\"jump\\\", \\\"run\\\"]\\n2\", \"output\": \"[3, 4, 4, 3, 4]\", \"testtype\": \"functional\"}, {\"input\": \"[\\\"dog\\\", \\\"racer\\\", \\\"ca... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-common-prefix-of-k-strings-after-removal\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an array of strings words and an integer k.\nF... | <think>
Okay, let's tackle this problem. So, the task is to find, for each element in the words array, the length of the longest common prefix among any k distinct strings after removing that element. Hmm.
First, I need to understand the problem correctly. For each index i, when we remove the i-th string, we have to c... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.053352 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\nimport heapq\n\nclass Solution:\n def longestCommonPrefix(self, words: List[str], k: int) -> List[int]:\n n = len(words)\n # If after removal there are fewer than k strings, answer is always 0.\n if n <= k... | [
true,
false
] | 1 | [
1
] | true | 2 | true |
3785 | 0 | {
"contest_date": "2025-03-01T06:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\\n[[1, 2], [2, 3], [3, 4], [4, 5]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 3, 4]\\n[[1, 10], [2, 9], [3, 8], [4, 7]]\", \"output\": \"4\", ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-number-of-copy-arrays\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an array original of length n and a 2D array bounds of length ... | <think>
Okay, let's tackle this problem. So, the task is to find the number of possible copy arrays that satisfy certain conditions based on the original array and the bounds provided for each element.
First, I need to understand the problem correctly. The key points are:
1. The copy array must satisfy (copy[i] - co... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.027769 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "The problem reduces to finding the number of possible values for the first element `copy[0]` because all other entries are forced by the difference condition. For each index `i`, the condition `copy[i] = copy[0] + (original[i] - original[0])` must lie within its bo... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3785 | 0 | {
"contest_date": "2025-03-01T06:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\\n[[1, 2], [2, 3], [3, 4], [4, 5]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 3, 4]\\n[[1, 10], [2, 9], [3, 8], [4, 7]]\", \"output\": \"4\", ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-number-of-copy-arrays\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an array original of length n and a 2D array bounds of length ... | <think>
Okay, let's tackle this problem. So, the task is to find the number of possible copy arrays that satisfy certain conditions. Let me think about how to approach this.
First, the problem says that for each i from 1 to n-1, the difference between copy[i] and copy[i-1] must equal the difference between original[i]... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.034165 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "We need to count arrays `copy` of length `n` that preserve the same consecutive differences as `original` and respect the per-index bounds. The condition forces `copy` to be a constant shift of `original`: `copy[i] = original[i] + k` for some integer `k` (where `k ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3785 | 0 | {
"contest_date": "2025-03-01T06:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\\n[[1, 2], [2, 3], [3, 4], [4, 5]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 3, 4]\\n[[1, 10], [2, 9], [3, 8], [4, 7]]\", \"output\": \"4\", ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-number-of-copy-arrays\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an array original of length n and a 2D array bounds of length ... | <think>
Okay, let's tackle this problem. So, the task is to find the number of possible copy arrays that satisfy certain conditions. Let me think about how to approach this.
First, the problem says that for each i from 1 to n-1, the difference between copy[i] and copy[i-1] must equal the difference between original[i]... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.038647 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "The problem reduces to a single degree of freedom: all arrays `copy` that satisfy the difference condition are exactly those obtained by shifting the original array by a constant `x = copy[0] - original[0]`. \nSpecifically, `copy[i] = x + (original[i] - original[0... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3785 | 0 | {
"contest_date": "2025-03-01T06:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\\n[[1, 2], [2, 3], [3, 4], [4, 5]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 3, 4]\\n[[1, 10], [2, 9], [3, 8], [4, 7]]\", \"output\": \"4\", ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-number-of-copy-arrays\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an array original of length n and a 2D array bounds of length ... | <think>
Okay, let's tackle this problem. So, the task is to find the number of possible copy arrays that satisfy certain conditions based on the original array and the bounds provided for each element.
First, I need to understand the problem correctly. The copy array must satisfy two main conditions:
1. For each i ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.043007 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "We need to count arrays `copy` of length `n` that preserve the same consecutive differences as `original` and respect the per-index bounds. The condition forces `copy` to be a constant shift of `original`: `copy[i] = original[i] + k` for some integer `k` (where `k ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3785 | 0 | {
"contest_date": "2025-03-01T06:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\\n[[1, 2], [2, 3], [3, 4], [4, 5]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 3, 4]\\n[[1, 10], [2, 9], [3, 8], [4, 7]]\", \"output\": \"4\", ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-number-of-copy-arrays\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an array original of length n and a 2D array bounds of length ... | <think>
Okay, let's tackle this problem. So, the task is to find the number of possible copy arrays that satisfy certain conditions based on the original array and the bounds provided for each element.
First, I need to understand the problem correctly. The key points are:
1. The copy array must satisfy (copy[i] - co... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.058936 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "The problem reduces to finding the number of possible values for the first element `copy[0]` because all other entries are forced by the difference condition. For each index `i`, the condition `copy[i] = copy[0] + (original[i] - original[0])` must lie within its bo... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3785 | 0 | {
"contest_date": "2025-03-01T06:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\\n[[1, 2], [2, 3], [3, 4], [4, 5]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 3, 4]\\n[[1, 10], [2, 9], [3, 8], [4, 7]]\", \"output\": \"4\", ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-number-of-copy-arrays\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an array original of length n and a 2D array bounds of length ... | <think>
Okay, let's tackle this problem. So, the task is to find the number of possible copy arrays that satisfy certain conditions. Let me think about how to approach this.
First, the problem says that for each i from 1 to n-1, the difference between copy[i] and copy[i-1] must equal the difference between original[i]... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.100582 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def countArrays(self, original: List[int], bounds: List[List[int]]) -> int:\n \"\"\"\n Returns the number of arrays `copy` that satisfy:\n 1) For all i, bounds[i][0] <= copy[i] <= bound... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3786 | 0 | {
"contest_date": "2025-03-01T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abced\\\"\\n2\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"\\\"aaazzz\\\"\\n4\", \"output\": \"6\", \"testtype\": \"functional\"}]",
"question_content": "You ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindromic-subsequence-after-at-most-k-operations\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a string s and an integer k.\nIn o... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindromic subsequence after performing at most k operations on the string. Each operation allows replacing a character with the next or previous letter in the alphabet, wrapping around.
First, I need to understand the problem correctly. Th... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.046305 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def longestPalindromicSubsequence(self, s: str, k: int) -> int:\n n = len(s)\n if n == 0:\n return 0\n\n # ----- helper: cyclic distance between two letters -----\n def dist(c1: str, c2: str) ->... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3786 | 0 | {
"contest_date": "2025-03-01T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abced\\\"\\n2\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"\\\"aaazzz\\\"\\n4\", \"output\": \"6\", \"testtype\": \"functional\"}]",
"question_content": "You ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindromic-subsequence-after-at-most-k-operations\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a string s and an integer k.\nIn o... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindromic subsequence after performing at most k operations on the string. Each operation allows changing a character to the next or previous letter, wrapping around the alphabet.
First, I need to understand the problem thoroughly. The key ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.109169 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def longestPalindromicSubsequence(self, s: str, k: int) -> int:\n \"\"\"\n Returns the length of the longest palindromic subsequence obtainable\n after at most k operations. Each operation changes one character t... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3786 | 0 | {
"contest_date": "2025-03-01T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abced\\\"\\n2\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"\\\"aaazzz\\\"\\n4\", \"output\": \"6\", \"testtype\": \"functional\"}]",
"question_content": "You ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindromic-subsequence-after-at-most-k-operations\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a string s and an integer k.\nIn o... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindromic subsequence after performing at most k operations. Each operation allows changing a character to the next or previous letter in the alphabet, wrapping around.
First, I need to understand the problem correctly. The key here is tha... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.065080 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def longestPalindromicSubsequence(self, s: str, k: int) -> int:\n \"\"\"\n Returns the length of the longest palindromic subsequence obtainable\n after at most k operations. Each operation changes one character t... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3786 | 0 | {
"contest_date": "2025-03-01T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abced\\\"\\n2\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"\\\"aaazzz\\\"\\n4\", \"output\": \"6\", \"testtype\": \"functional\"}]",
"question_content": "You ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindromic-subsequence-after-at-most-k-operations\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a string s and an integer k.\nIn o... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindromic subsequence after performing at most k operations. Each operation allows changing a character to the next or previous letter in the alphabet, wrapping around.
First, I need to understand the problem correctly. The key here is tha... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.071805 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\nfrom array import array\n\nclass Solution:\n def longestPalindromicSubsequence(self, s: str, k: int) -> int:\n n = len(s)\n # convert letters to numbers 0..25\n a = [ord(ch) - 97 for ch in s]\n\n # circular distance between... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3786 | 0 | {
"contest_date": "2025-03-01T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abced\\\"\\n2\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"\\\"aaazzz\\\"\\n4\", \"output\": \"6\", \"testtype\": \"functional\"}]",
"question_content": "You ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindromic-subsequence-after-at-most-k-operations\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a string s and an integer k.\nIn o... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindromic subsequence after performing at most k operations on the string. Each operation allows replacing a character with the next or previous letter, wrapping around.
First, I need to understand the problem correctly. The key here is th... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.092699 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def longestPalindromicSubsequence(self, s: str, k: int) -> int:\n n = len(s)\n if n == 0:\n return 0\n\n # Convert letters to numbers 0..25\n a = [ord(ch) - 97 for ch in s]\n K = k\n\n ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3786 | 0 | {
"contest_date": "2025-03-01T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abced\\\"\\n2\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"\\\"aaazzz\\\"\\n4\", \"output\": \"6\", \"testtype\": \"functional\"}]",
"question_content": "You ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindromic-subsequence-after-at-most-k-operations\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a string s and an integer k.\nIn o... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindromic subsequence after performing at most k operations. Each operation allows replacing a character with the next or previous letter in the alphabet, wrapping around.
First, I need to understand the problem correctly. The key here is ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.077109 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\nfrom array import array\n\nclass Solution:\n def longestPalindromicSubsequence(self, s: str, k: int) -> int:\n n = len(s)\n # convert letters to numbers 0..25\n a = [ord(ch) - 97 for ch in s]\n\n # circular distance between... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3788 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4, 5]\", \"output\": \"15\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 0, 1, 1]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, -1, -2, 1, 0, ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-unique-subarray-sum-after-deletion\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array nums.\nYou are allowed to delete an... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum sum of a subarray after deleting some elements so that all elements in the subarray are unique. Hmm, right. The challenge is to select a subarray where all elements are unique and their sum is as large as possible.
First, I need to understand... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.082033 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "The problem simplifies to selecting a subsequence (after deletions) with all unique elements that maximizes the sum. \nSince we can delete any elements, we can keep exactly the chosen subsequence, making it a contiguous subarray in the resulting array. \nThe opti... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3788 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4, 5]\", \"output\": \"15\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 0, 1, 1]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, -1, -2, 1, 0, ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-unique-subarray-sum-after-deletion\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array nums.\nYou are allowed to delete an... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum sum of a subarray after deleting some elements so that all elements in the subarray are unique. Hmm.
First, I need to understand the problem correctly. The key points are that after deletion, the remaining subarray must have all unique elemen... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.128687 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "The problem simplifies to selecting a subsequence (after deletions) with all unique elements that maximizes the sum. \nSince we can delete any elements, we can keep exactly the chosen subsequence, making it a contiguous subarray in the resulting array. \nThe opti... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3788 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4, 5]\", \"output\": \"15\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 0, 1, 1]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, -1, -2, 1, 0, ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-unique-subarray-sum-after-deletion\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array nums.\nYou are allowed to delete an... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum sum of a unique subarray after deleting some elements. Hmm. Let me think about the approach.
First, the problem says that after deleting any number of elements, we need to select a subarray where all elements are unique, and the sum is maximi... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.087373 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "The problem simplifies to selecting a subsequence (after deletions) with all unique elements that maximizes the sum. \nSince we can delete any elements, we can keep exactly the chosen subsequence, making it a contiguous subarray in the resulting array. \nThe opti... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3788 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4, 5]\", \"output\": \"15\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 0, 1, 1]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, -1, -2, 1, 0, ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-unique-subarray-sum-after-deletion\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array nums.\nYou are allowed to delete an... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum sum of a subarray after deleting some elements. The key points are that the subarray must have all unique elements, and we need the maximum sum possible.
First, I need to understand the problem correctly. The allowed deletions can be any numb... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.095221 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "We need to maximize the sum of a subarray after deletions, with the condition that all elements in the subarray are unique. \nAfter deletions, we keep some elements; the chosen subarray must be a contiguous block of the kept elements. \nThis is equivalent to pick... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3788 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4, 5]\", \"output\": \"15\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 0, 1, 1]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, -1, -2, 1, 0, ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-unique-subarray-sum-after-deletion\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array nums.\nYou are allowed to delete an... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum sum of a subarray after deleting some elements. The key points are that the subarray must have all unique elements, and we need the maximum sum possible.
Looking at the two solutions provided, I need to evaluate which one is better. Let's sta... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.106198 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "We can simplify the problem by observing that we can delete any elements we want, and then choose any subarray of the remaining array. In particular, we can delete every element except the ones we intend to use, making the whole remaining array exactly the chosen s... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3788 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4, 5]\", \"output\": \"15\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 0, 1, 1]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, -1, -2, 1, 0, ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-unique-subarray-sum-after-deletion\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array nums.\nYou are allowed to delete an... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum sum of a subarray after deleting some elements. The key points are that the subarray must have all unique elements, and we need the maximum sum possible.
First, I need to understand the problem correctly. The subarray can be any length as lon... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.114841 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "We can simplify the problem by observing that we can delete any elements we want, and then choose any subarray of the remaining array. In particular, we can delete every element except the ones we intend to use, making the whole remaining array exactly the chosen s... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3789 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"4\\n[[2, 3], [1, 4]]\", \"output\": \"9\", \"testtype\": \"functional\"}, {\"input\": \"5\\n[[1, 2], [2, 5], [3, 5]]\", \"output\": \"12\", \"testtype\": \"functional\"}]",
"question_con... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-subarrays-after-removing-one-conflicting-pair\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an integer n which represents an array n... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of non-empty subarrays in an array nums (which is 1 to n in order) after removing exactly one conflicting pair from the given conflictingPairs. The key is to determine which pair to remove so that the number of valid subarrays is maximi... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.117058 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def maxSubarrays(self, n: int, conflictingPairs: List[List[int]]) -> int:\n m = len(conflictingPairs)\n\n # store pairs by their left endpoint (x = min(a,b))\n pairs_by_x = [[] for _ in... | [
true,
false
] | 1 | [
1
] | true | 2 | false |
3789 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"4\\n[[2, 3], [1, 4]]\", \"output\": \"9\", \"testtype\": \"functional\"}, {\"input\": \"5\\n[[1, 2], [2, 5], [3, 5]]\", \"output\": \"12\", \"testtype\": \"functional\"}]",
"question_con... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-subarrays-after-removing-one-conflicting-pair\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an integer n which represents an array n... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of non-empty subarrays in nums (which is 1 to n in order) after removing exactly one conflicting pair from the given conflictingPairs.
First, I need to understand the problem thoroughly. The key points are:
- The original array is nu... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.125476 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def maxSubarrays(self, n: int, conflictingPairs: List[List[int]]) -> int:\n m = len(conflictingPairs)\n\n # store pairs by their left endpoint (x = min(a,b))\n pairs_by_x = [[] for _ in... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3789 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"4\\n[[2, 3], [1, 4]]\", \"output\": \"9\", \"testtype\": \"functional\"}, {\"input\": \"5\\n[[1, 2], [2, 5], [3, 5]]\", \"output\": \"12\", \"testtype\": \"functional\"}]",
"question_con... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-subarrays-after-removing-one-conflicting-pair\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an integer n which represents an array n... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of non-empty subarrays in an array nums (which is 1 to n in order) after removing exactly one conflicting pair from the given conflictingPairs.
First, I need to understand the problem thoroughly. The key points are:
- The original ar... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.131772 | 2.959118 | 2 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 0
},
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def maxSubarrays(self, n: int, conflictingPairs: List[List[int]]) -> int:\n m = len(confli... | [
false,
true
] | 2 | [
2
] | true | 2 | false |
3789 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"4\\n[[2, 3], [1, 4]]\", \"output\": \"9\", \"testtype\": \"functional\"}, {\"input\": \"5\\n[[1, 2], [2, 5], [3, 5]]\", \"output\": \"12\", \"testtype\": \"functional\"}]",
"question_con... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-subarrays-after-removing-one-conflicting-pair\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an integer n which represents an array n... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of non-empty subarrays in the array nums (which is 1 to n in order) after removing exactly one conflicting pair from the given conflictingPairs. The key is to remove one pair so that the remaining pairs don't create any conflicts, and t... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.147975 | 2.959118 | 3 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 2
},
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 0
}
] | [
false,
false
] | 1 | [] | false | 2 | true |
3789 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"4\\n[[2, 3], [1, 4]]\", \"output\": \"9\", \"testtype\": \"functional\"}, {\"input\": \"5\\n[[1, 2], [2, 5], [3, 5]]\", \"output\": \"12\", \"testtype\": \"functional\"}]",
"question_con... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-subarrays-after-removing-one-conflicting-pair\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an integer n which represents an array n... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of non-empty subarrays in nums (which is 1 to n in order) after removing exactly one conflicting pair from the given conflictingPairs.
First, I need to understand the problem thoroughly. The key points are:
- The original array is nu... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.121747 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Fenwick:\n \"\"\"Fenwick tree for frequencies, supports point add and k-th order statistic.\"\"\"\n def __init__(self, n: int):\n self.n = n\n self.bit = [0] * (n + 2)\n\n def add(self, i: int, delt... | [
true,
false
] | 1 | [
1
] | true | 2 | false |
3789 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"4\\n[[2, 3], [1, 4]]\", \"output\": \"9\", \"testtype\": \"functional\"}, {\"input\": \"5\\n[[1, 2], [2, 5], [3, 5]]\", \"output\": \"12\", \"testtype\": \"functional\"}]",
"question_con... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-subarrays-after-removing-one-conflicting-pair\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given an integer n which represents an array n... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of non-empty subarrays in nums (which is 1 to n in order) after removing exactly one conflicting pair from the given conflictingPairs.
First, I need to understand the problem thoroughly. The key points are:
- The original array is nu... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.142566 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Fenwick:\n \"\"\"Fenwick tree for frequencies, supports point add and k-th order statistic.\"\"\"\n def __init__(self, n: int):\n self.n = n\n self.bit = [0] * (n + 2)\n\n def add(self, i: int, delt... | [
true,
false
] | 1 | [
1
] | true | 2 | false |
3791 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[4, 2, 5]\\n[3, 5, 4]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[3, 6, 1]\\n[6, 4, 7]\", \"output\": \"0\", \"testtype\": \"functional\"}]",
"question_content"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: fruits-into-baskets-iii\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two arrays of integers, fruits and baskets, each of length n, where f... | <think>
Okay, let's tackle this problem. So, the task is to determine how many fruit types remain unplaced after trying to put them into baskets according to specific rules. The two solutions provided are Solution 1 and Solution 2. I need to evaluate which one is better.
First, looking at the syntax and completeness. ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.155151 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "We use a segment tree that stores the maximum basket capacity in each segment. For each fruit in order, we need to find the leftmost available basket with capacity ≥ fruit. The segment tree allows us to query the first index where max capacity ≥ fruit in O(log n). ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3791 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[4, 2, 5]\\n[3, 5, 4]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[3, 6, 1]\\n[6, 4, 7]\", \"output\": \"0\", \"testtype\": \"functional\"}]",
"question_content"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: fruits-into-baskets-iii\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two arrays of integers, fruits and baskets, each of length n, where f... | <think>
Okay, let's tackle this problem. So, the task is to find out how many fruit types remain unplaced after trying to put them into baskets according to certain rules. Let me think about the two solutions provided and decide which one is better.
First, I need to understand the problem correctly. Each fruit type mu... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.152634 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "We use a segment tree that maintains the maximum basket capacity over each segment. For each fruit in the given order, we query the tree to find the leftmost basket index with capacity ≥ fruit. If such a basket exists, we mark it as used by setting its capacity to ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3791 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[4, 2, 5]\\n[3, 5, 4]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[3, 6, 1]\\n[6, 4, 7]\", \"output\": \"0\", \"testtype\": \"functional\"}]",
"question_content"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: fruits-into-baskets-iii\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two arrays of integers, fruits and baskets, each of length n, where f... | <think>
Okay, let's tackle this problem. So, the task is to determine how many fruit types remain unplaced after trying to put them into baskets according to specific rules. Let me think about the two solutions provided and decide which one is better.
First, I need to understand the problem correctly. Each fruit type ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.134757 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "We need to simulate placing fruits in baskets left to right. For each fruit, we must choose the smallest-index basket that is still available and has capacity ≥ fruit quantity. A segment tree storing the maximum capacity in each range allows us to find the leftmost... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3791 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[4, 2, 5]\\n[3, 5, 4]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[3, 6, 1]\\n[6, 4, 7]\", \"output\": \"0\", \"testtype\": \"functional\"}]",
"question_content"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: fruits-into-baskets-iii\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two arrays of integers, fruits and baskets, each of length n, where f... | <think>
Okay, let's tackle this problem. So, the task is to determine how many fruit types remain unplaced after trying to put them into baskets according to specific rules. Let me think about the two solutions provided and decide which one is better.
First, looking at Solution 1. It uses a Segment Tree to efficiently... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.138352 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass SegmentTree:\n \"\"\"Segment tree that stores maximum capacity in each segment.\n Supports:\n - update(index, value): set leaf to value\n - find_first_ge(x): return smallest index i with value >= x, or... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3791 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[4, 2, 5]\\n[3, 5, 4]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[3, 6, 1]\\n[6, 4, 7]\", \"output\": \"0\", \"testtype\": \"functional\"}]",
"question_content"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: fruits-into-baskets-iii\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two arrays of integers, fruits and baskets, each of length n, where f... | <think>
Okay, let's tackle this problem. So, the task is to determine how many fruit types remain unplaced after trying to put them into baskets according to specific rules. Let me think about the two solutions provided and decide which one is better.
First, looking at Solution 1. It uses a segment tree to manage the ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.157881 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "We use a segment tree that stores the maximum basket capacity in each segment. For each fruit in order, we need to find the leftmost available basket with capacity ≥ fruit. The segment tree allows us to query the first index where max capacity ≥ fruit in O(log n). ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3791 | 0 | {
"contest_date": "2025-03-08T18:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[4, 2, 5]\\n[3, 5, 4]\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"[3, 6, 1]\\n[6, 4, 7]\", \"output\": \"0\", \"testtype\": \"functional\"}]",
"question_content"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: fruits-into-baskets-iii\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two arrays of integers, fruits and baskets, each of length n, where f... | <think>
Okay, let's tackle this problem. So, the task is to determine how many fruit types remain unplaced after trying to put them into baskets according to specific rules. Let me think about the two solutions provided and decide which one is better.
First, looking at Solution 1. It uses a segment tree approach. The ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.180966 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "We need to simulate placing fruits in baskets left to right. For each fruit, we must choose the smallest-index basket that is still available and has capacity ≥ fruit quantity. A segment tree storing the maximum capacity in each range allows us to find the leftmost... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3793 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"a\\\"\\n\\\"a\\\"\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"\\\"abc\\\"\\n\\\"def\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindrome-after-substring-concatenation-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two strings, s and t.\nYou can create a ne... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindrome that can be formed by concatenating a substring from s and a substring from t. Hmm. Let me think about how to approach this.
First, the examples given. Like in example 1, combining a from s and a from t gives aa, which is a palindr... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.169945 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "We can solve the problem by brute force because the strings are short (length ≤ 30). \nWe consider every possible substring from `s` (including the empty substring) and every possible substring from `t` (including the empty substring). \nFor each pair we concaten... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3793 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"a\\\"\\n\\\"a\\\"\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"\\\"abc\\\"\\n\\\"def\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindrome-after-substring-concatenation-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two strings, s and t.\nYou can create a ne... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindrome that can be formed by concatenating a substring from s and a substring from t. Hmm. Let me think about the approaches.
First, looking at the two provided solutions. The first one is a brute-force approach where it checks all possib... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.186916 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "We can solve the problem by brute force because the strings are short (length ≤ 30). \nWe consider every possible substring from `s` (including the empty substring) and every possible substring from `t` (including the empty substring). \nFor each pair we concaten... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3793 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"a\\\"\\n\\\"a\\\"\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"\\\"abc\\\"\\n\\\"def\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindrome-after-substring-concatenation-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two strings, s and t.\nYou can create a ne... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindrome that can be formed by concatenating a substring from s and a substring from t. Hmm.
First, I need to understand the problem thoroughly. The user can take any substring from s and any from t, concatenate them, and check if the resul... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.175128 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "### Explanation\n\nGiven that both strings have length at most 30, a straightforward brute‑force approach is perfectly acceptable. \nWe consider every possible substring of `s` (including the empty substring) and every possible substring of `t`. \nFor each pair w... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3793 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"a\\\"\\n\\\"a\\\"\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"\\\"abc\\\"\\n\\\"def\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindrome-after-substring-concatenation-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two strings, s and t.\nYou can create a ne... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindrome that can be formed by concatenating a substring from s and a substring from t. Hmm. Let me think about the approaches.
First, looking at the two provided solutions. Solution 1 uses generating all possible substrings of s and t, the... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.205884 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\n\nclass Solution:\n def longestPalindrome(self, s: str, t: str) -> int:\n \"\"\"\n Returns the length of the longest palindrome that can be obtained by\n concatenating a (possibly empty) substring of s and a (possibly empty)\n ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3793 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"a\\\"\\n\\\"a\\\"\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"\\\"abc\\\"\\n\\\"def\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindrome-after-substring-concatenation-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two strings, s and t.\nYou can create a ne... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindrome that can be formed by concatenating a substring from s and a substring from t. Hmm. Let me think about how to approach this.
First, the problem says we can take any substring from s and any from t, concatenate them, and check if th... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.164259 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def longestPalindrome(self, s: str, t: str) -> int:\n \"\"\"\n Returns the length of the longest palindrome that can be formed by\n concatenating a (possibly empty) substring of s and a (possibly empty)\n ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3793 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"a\\\"\\n\\\"a\\\"\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"\\\"abc\\\"\\n\\\"def\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: longest-palindrome-after-substring-concatenation-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two strings, s and t.\nYou can create a ne... | <think>
Okay, let's tackle this problem. So, the task is to find the longest palindrome that can be formed by concatenating a substring from s and a substring from t. Hmm. Let me think about how to approach this.
First, the problem says we can take any substring from s and any from t, concatenate them, and then check ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.193100 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def longestPalindrome(self, s: str, t: str) -> int:\n \"\"\"\n Returns the length of the longest palindrome that can be formed by\n concatenating a (possibly empty) substring of s and a (possibly empty)\n ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3794 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 5, 2, 4]\\n[5, 1, 4, 2]\", \"output\": \"110\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 1]\\n[1, 1, 1]\", \"output\": \"5\", \"testtype\": \"functional\"}, {\"input\": \"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-minimum-amount-of-time-to-brew-potions\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two integer arrays, skill and mana, of length... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum time required for wizards to brew potions in order. Each potion must go through all wizards sequentially, and each wizard's time depends on their skill and the mana of the potion they're brewing.
First, I need to understand the problem thoro... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.197737 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "The problem models a no-wait flow shop: each potion must be processed by all wizards in sequence without any waiting between wizards. The order of potions is fixed (0 to m-1). We need the minimal makespan.\n\nLet `s[j]` be the start time of potion `j` on the first ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3794 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 5, 2, 4]\\n[5, 1, 4, 2]\", \"output\": \"110\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 1]\\n[1, 1, 1]\", \"output\": \"5\", \"testtype\": \"functional\"}, {\"input\": \"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-minimum-amount-of-time-to-brew-potions\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two integer arrays, skill and mana, of length... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum time required for wizards to brew potions in order. Each potion must go through all wizards sequentially, and each wizard's time depends on their skill and the mana of the potion. The key is to determine the optimal starting time for each poti... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.224331 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "We need to compute the minimal makespan for processing `m` potions in fixed order through `n` wizards, where processing time of potion `j` on wizard `i` is `skill[i] * mana[j]`. The potions must be passed immediately between wizards (no waiting), and each wizard ca... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3794 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 5, 2, 4]\\n[5, 1, 4, 2]\", \"output\": \"110\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 1]\\n[1, 1, 1]\", \"output\": \"5\", \"testtype\": \"functional\"}, {\"input\": \"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-minimum-amount-of-time-to-brew-potions\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two integer arrays, skill and mana, of length... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum time required for wizards to brew potions in a specific way. Let me think about the approach.
The problem says that each potion must be passed sequentially through wizards. Each wizard has a certain skill and mana for the potion. The time tak... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.292250 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "We need to compute the minimal makespan for processing `m` potions in fixed order through `n` wizards, where processing time of potion `j` on wizard `i` is `skill[i] * mana[j]`. The potions must be passed immediately between wizards (no waiting), and each wizard ca... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3794 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 5, 2, 4]\\n[5, 1, 4, 2]\", \"output\": \"110\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 1]\\n[1, 1, 1]\", \"output\": \"5\", \"testtype\": \"functional\"}, {\"input\": \"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-minimum-amount-of-time-to-brew-potions\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two integer arrays, skill and mana, of length... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum time required for wizards to brew potions in a specific way. Let me think about the approach.
The problem says that each potion must be passed sequentially through wizards. Each wizard has a certain skill and mana for the potion. The time tak... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.201147 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minTime(self, skill: List[int], mana: List[int]) -> int:\n n = len(skill)\n m = len(mana)\n\n # cumulative skill: cum[i] = sum_{k=0}^{i} skill[k]\n cum = [0] * n\n cum... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3794 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 5, 2, 4]\\n[5, 1, 4, 2]\", \"output\": \"110\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 1]\\n[1, 1, 1]\", \"output\": \"5\", \"testtype\": \"functional\"}, {\"input\": \"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-minimum-amount-of-time-to-brew-potions\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two integer arrays, skill and mana, of length... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum time required for wizards to brew potions in a specific way. Let me understand the problem again.
We have two arrays: skill and mana. The wizards need to brew potions in order. Each potion has a mana capacity, and each wizard works on a potio... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.237054 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minTime(self, skill: List[int], mana: List[int]) -> int:\n n = len(skill)\n m = len(mana)\n\n # cumulative skill: cum[i] = sum_{k=0}^{i} skill[k]\n cum = [0] * n\n cum... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3794 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 5, 2, 4]\\n[5, 1, 4, 2]\", \"output\": \"110\", \"testtype\": \"functional\"}, {\"input\": \"[1, 1, 1]\\n[1, 1, 1]\", \"output\": \"5\", \"testtype\": \"functional\"}, {\"input\": \"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: find-the-minimum-amount-of-time-to-brew-potions\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given two integer arrays, skill and mana, of length... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum time required for all potions to be brewed by wizards in order. The key here is that each potion must go through all wizards sequentially, and each wizard starts working on a potion exactly when it arrives. The time taken by the i-th wizard on... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.231712 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minTime(self, skill: List[int], mana: List[int]) -> int:\n n = len(skill)\n m = len(mana)\n \n # prefix sums of skill: P[i] = sum_{k=0..i} skill[k]\n pref = [0] * n\n ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3795 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[2, 0, 2]\\n[[0, 2, 1], [0, 2, 1], [1, 1, 3]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[4, 3, 2, 1]\\n[[1, 3, 2], [0, 2, 1]]\", \"output\": \"-1\", \"testtype\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: zero-array-transformation-iv\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an integer array nums of length n and a 2D array queries, where ... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum number of queries needed to turn a given array into a zero array. The zero array is one where all elements are zero. Each query affects a range of indices by subtracting a certain value.
First, I need to understand the problem thoroughly. Le... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.207555 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minZeroArray(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n m = len(queries)\n\n # Already zero array\n if all(v == 0 for v in nums):\n ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3795 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[2, 0, 2]\\n[[0, 2, 1], [0, 2, 1], [1, 1, 3]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[4, 3, 2, 1]\\n[[1, 3, 2], [0, 2, 1]]\", \"output\": \"-1\", \"testtype\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: zero-array-transformation-iv\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an integer array nums of length n and a 2D array queries, where ... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum number of queries needed to turn the given array into a zero array. A zero array has all elements as zero. The queries are applied in sequence, and each query subtracts a value from a range of indices.
First, I need to understand the problem ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.212486 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minZeroArray(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n m = len(queries)\n\n # Already zero array\n if all(v == 0 for v in nums):\n ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3795 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[2, 0, 2]\\n[[0, 2, 1], [0, 2, 1], [1, 1, 3]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[4, 3, 2, 1]\\n[[1, 3, 2], [0, 2, 1]]\", \"output\": \"-1\", \"testtype\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: zero-array-transformation-iv\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an integer array nums of length n and a 2D array queries, where ... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum number of queries needed to turn the given array into a zero array. A zero array is one where all elements are zero. The queries are applied in sequence, and each query subtracts a value from a range of indices.
First, I need to understand th... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.218621 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minZeroArray(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n\n # If already zero, no query is needed.\n if all(x == 0 for x in nums):\n return ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3795 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[2, 0, 2]\\n[[0, 2, 1], [0, 2, 1], [1, 1, 3]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[4, 3, 2, 1]\\n[[1, 3, 2], [0, 2, 1]]\", \"output\": \"-1\", \"testtype\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: zero-array-transformation-iv\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an integer array nums of length n and a 2D array queries, where ... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum number of queries needed to turn the given array into a zero array. A zero array is one where all elements are zero. The queries are applied in sequence, and each query subtracts a certain value from a range of indices.
First, I need to under... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.305330 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minZeroArray(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n # Already a zero array\n if all(x == 0 for x in nums):\n return 0\n\n Q = l... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3795 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[2, 0, 2]\\n[[0, 2, 1], [0, 2, 1], [1, 1, 3]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[4, 3, 2, 1]\\n[[1, 3, 2], [0, 2, 1]]\", \"output\": \"-1\", \"testtype\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: zero-array-transformation-iv\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an integer array nums of length n and a 2D array queries, where ... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum number of queries needed to turn the given array into a zero array. A zero array is one where all elements are zero. Each query affects a range of indices by subtracting a certain value from each in that range.
First, I need to understand th... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.263838 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minZeroArray(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n # Already a zero array\n if all(x == 0 for x in nums):\n return 0\n\n Q = l... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3795 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[2, 0, 2]\\n[[0, 2, 1], [0, 2, 1], [1, 1, 3]]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[4, 3, 2, 1]\\n[[1, 3, 2], [0, 2, 1]]\", \"output\": \"-1\", \"testtype\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: zero-array-transformation-iv\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given an integer array nums of length n and a 2D array queries, where ... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum number of queries needed to turn the given array into a zero array. A zero array is one where all elements are zero. Each query allows us to select a subset of indices in a range [l_i, r_i] and subtract a certain value val_i from each selected... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.239631 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minZeroArray(self, nums: List[int], queries: List[List[int]]) -> int:\n n = len(nums)\n\n # If already zero, no query is needed.\n if all(x == 0 for x in nums):\n return ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3799 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\", \"output\": \"12\", \"testtype\": \"functional\"}, {\"input\": \"[0, 2, 2]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[6, 6, 6]\", \"output\": \"1\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: unique-3-digit-even-numbers\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an array of digits called digits. Your task is to determine the num... | <think>
Okay, let's tackle this problem. So, the task is to find the number of distinct three-digit even numbers that can be formed from the given digits. The constraints are that each digit can be used only once per number, and there can't be leading zeros.
First, I need to understand the problem thoroughly. Let's lo... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.274665 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def totalNumbers(self, digits: List[int]) -> int:\n \"\"\"\n Counts distinct three-digit even numbers that can be formed from the given digits.\n Each digit can be used at most once per... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3799 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\", \"output\": \"12\", \"testtype\": \"functional\"}, {\"input\": \"[0, 2, 2]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[6, 6, 6]\", \"output\": \"1\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: unique-3-digit-even-numbers\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an array of digits called digits. Your task is to determine the num... | <think>
Okay, let's tackle this problem. So, the task is to find the number of distinct three-digit even numbers that can be formed from the given digits. The constraints say that each digit can be used only once per number, and there can't be leading zeros.
First, I need to understand the two solutions provided and ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.243250 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "We count all distinct three-digit even numbers (100–998, step 2) that can be formed using the given multiset of digits. For each candidate number we extract its three digits, build a frequency map of those digits, and verify that the required count of each digit do... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3799 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\", \"output\": \"12\", \"testtype\": \"functional\"}, {\"input\": \"[0, 2, 2]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[6, 6, 6]\", \"output\": \"1\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: unique-3-digit-even-numbers\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an array of digits called digits. Your task is to determine the num... | <think>
Okay, let's tackle this problem. So, the task is to find the number of distinct three-digit even numbers that can be formed from the given digits. The constraints say that each digit can be used only as many times as it appears in the input array. Also, leading zeros are not allowed.
First, I need to understan... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.249972 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\nfrom itertools import permutations\n\nclass Solution:\n def totalNumbers(self, digits: List[int]) -> int:\n \"\"\"\n Returns the number of distinct three-digit even numbers that can be formed\n using the g... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3799 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\", \"output\": \"12\", \"testtype\": \"functional\"}, {\"input\": \"[0, 2, 2]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[6, 6, 6]\", \"output\": \"1\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: unique-3-digit-even-numbers\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an array of digits called digits. Your task is to determine the num... | <think>
Okay, let's tackle this problem. So, the task is to find the number of distinct three-digit even numbers that can be formed from the given digits. The constraints say that each digit can be used only as many times as it appears in the array, and there can't be leading zeros.
First, I need to understand the pro... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.247127 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\nfrom itertools import permutations\n\nclass Solution:\n def totalNumbers(self, digits: List[int]) -> int:\n \"\"\"\n Returns the number of distinct three-digit even numbers that can be formed\n using the g... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3799 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\", \"output\": \"12\", \"testtype\": \"functional\"}, {\"input\": \"[0, 2, 2]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[6, 6, 6]\", \"output\": \"1\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: unique-3-digit-even-numbers\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an array of digits called digits. Your task is to determine the num... | <think>
Okay, let's tackle this problem. So, the task is to find the number of distinct three-digit even numbers that can be formed from the given digits. The constraints mention that each digit can be used only once per number, and there can't be leading zeros.
First, I need to understand the two solutions provided ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.253869 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "We count all distinct three-digit even numbers (100–998, step 2) that can be formed using the given multiset of digits. For each candidate number we extract its three digits, build a frequency map of those digits, and verify that the required count of each digit do... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3799 | 0 | {
"contest_date": "2025-03-15T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[1, 2, 3, 4]\", \"output\": \"12\", \"testtype\": \"functional\"}, {\"input\": \"[0, 2, 2]\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"[6, 6, 6]\", \"output\": \"1\"... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: unique-3-digit-even-numbers\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an array of digits called digits. Your task is to determine the num... | <think>
Okay, let's tackle this problem. So, the task is to find the number of distinct three-digit even numbers that can be formed from the given digits. The constraints say that each digit can be used only once per number, and there can't be leading zeros.
First, I need to understand the problem thoroughly. Let's l... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.258469 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def totalNumbers(self, digits: List[int]) -> int:\n \"\"\"\n Counts distinct three-digit even numbers that can be formed from the given digits.\n Each digit can be used at most once per... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3801 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"10\\n20\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"1\\n15\", \"output\": \"10\", \"testtype\": \"functional\"}]",
"question_content": "You are given two positive ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: count-beautiful-numbers\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given two positive integers, l and r. A positive integer is called beautiful ... | <think>
Okay, let's tackle this problem. So, the task is to count the number of beautiful numbers between l and r inclusive. A beautiful number is one where the product of its digits is divisible by the sum of its digits.
First, I need to understand the problem thoroughly. Let's look at the examples. For instance, in... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.272774 | 2.959118 | 0 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 1
},
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def beautifulNumbers(self, l: int, r: int) -> int:\n # ---------- helper: count numbers without any digit 0 ---------... | [
false,
true
] | 2 | [
2
] | true | 2 | false |
3801 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"10\\n20\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"1\\n15\", \"output\": \"10\", \"testtype\": \"functional\"}]",
"question_content": "You are given two positive ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: count-beautiful-numbers\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given two positive integers, l and r. A positive integer is called beautiful ... | <think>
Okay, let's tackle this problem. So, the task is to count the number of beautiful numbers between l and r inclusive. A beautiful number is one where the product of its digits is divisible by the sum of its digits.
First, I need to understand the problem thoroughly. Let's look at the examples. For instance, in... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.285663 | 2.959118 | 1 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 2
},
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def beautifulNumbers(self, l: int, r: int) -> int:\n # ---------- helper: count numbers without any digit 0 ---------... | [
false,
true
] | 2 | [
2
] | true | 2 | false |
3801 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"10\\n20\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"1\\n15\", \"output\": \"10\", \"testtype\": \"functional\"}]",
"question_content": "You are given two positive ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: count-beautiful-numbers\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given two positive integers, l and r. A positive integer is called beautiful ... | <think>
Okay, let's tackle this problem. The task is to count the number of beautiful numbers between l and r inclusive. A beautiful number is one where the product of its digits is divisible by the sum of its digits.
First, I need to understand what makes a number beautiful. Let's take the examples given. For instan... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.267604 | 2.959118 | 2 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 2
},
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 0
}
] | [
false,
false
] | 2 | [] | false | 2 | false |
3801 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"10\\n20\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"1\\n15\", \"output\": \"10\", \"testtype\": \"functional\"}]",
"question_content": "You are given two positive ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: count-beautiful-numbers\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given two positive integers, l and r. A positive integer is called beautiful ... | <think>
Okay, let's tackle this problem. The task is to count the number of beautiful numbers between l and r inclusive. A beautiful number is one where the product of its digits is divisible by the sum of its digits.
First, I need to understand what makes a number beautiful. Let's take the examples given. For instan... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.297128 | 2.959118 | 3 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 1
},
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 2
}
] | [
false,
false
] | 1 | [] | false | 2 | false |
3801 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"10\\n20\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"1\\n15\", \"output\": \"10\", \"testtype\": \"functional\"}]",
"question_content": "You are given two positive ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: count-beautiful-numbers\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given two positive integers, l and r. A positive integer is called beautiful ... | <think>
Okay, let's tackle this problem. The task is to count the number of beautiful numbers between l and r inclusive. A beautiful number is one where the product of its digits is divisible by the sum of its digits.
First, I need to understand what makes a number beautiful. Let's take the examples given. For instan... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.279845 | 2.959118 | 4 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 0
},
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 1
}
] | [
false,
false
] | 1 | [] | false | 2 | false |
3801 | 0 | {
"contest_date": "2025-03-15T19:30:00",
"difficulty": "hard",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"10\\n20\", \"output\": \"2\", \"testtype\": \"functional\"}, {\"input\": \"1\\n15\", \"output\": \"10\", \"testtype\": \"functional\"}]",
"question_content": "You are given two positive ... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: count-beautiful-numbers\nPlatform: leetcode\nDifficulty: hard\n\nProblem Statement:\nYou are given two positive integers, l and r. A positive integer is called beautiful ... | <think>
Okay, let's tackle this problem. So, the task is to count the number of beautiful numbers between l and r inclusive. A beautiful number is one where the product of its digits is divisible by the sum of its digits.
First, I need to understand the problem thoroughly. Let's look at the examples. For instance, in... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.322559 | 2.959118 | 5 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 0
},
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def beautifulNumbers(self, l: int, r: int) -> int:\n # ---------- helper: count numbers without any digit 0 ---------... | [
false,
true
] | 1 | [
2
] | false | 2 | false |
3805 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"01\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"0100\\\"\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"\\\"1000100\\\"\", \"output\... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-active-section-with-trade-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a binary string s of length n, where:\n\n'1' represents ... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of active sections in a binary string after performing at most one trade. The trade allows converting a contiguous block of 1s surrounded by 0s to 0s, then converting a contiguous block of 0s surrounded by 1s to 1s. And we have to consi... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.302881 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def maxActiveSectionsAfterTrade(self, s: str) -> int:\n n = len(s)\n # ----- 1. build runs of the string -----\n runs = [] # list of (type, length), type: 0 for '0', 1 for '1'\n i = 0\n whi... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3805 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"01\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"0100\\\"\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"\\\"1000100\\\"\", \"output\... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-active-section-with-trade-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a binary string s of length n, where:\n\n'1' represents ... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of active sections after performing at most one trade. The trade allows converting a contiguous block of 1s surrounded by 0s to 0s, and then converting a contiguous block of 0s surrounded by 1s to 1s. And we need to consider the augment... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.308839 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def maxActiveSectionsAfterTrade(self, s: str) -> int:\n # original count of ones\n original_ones = s.count('1')\n \n # build runs of the augmented string t = '1' + s + '1'\n runs = [] ... | [
true,
false
] | 1 | [
1
] | true | 2 | false |
3805 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"01\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"0100\\\"\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"\\\"1000100\\\"\", \"output\... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-active-section-with-trade-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a binary string s of length n, where:\n\n'1' represents ... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of active sections after performing at most one trade. The trade allows converting a contiguous block of 1s surrounded by 0s to 0s, and then converting a contiguous block of 0s surrounded by 1s to 1s. And we need to consider the augment... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.299306 | 2.959118 | 2 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 1
},
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def maxActiveSectionsAfterTrade(self, s: str) -> int:\n # original count of ones\n original_ones = s.count('1'... | [
false,
true
] | 2 | [
2
] | true | 2 | false |
3805 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"01\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"0100\\\"\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"\\\"1000100\\\"\", \"output\... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-active-section-with-trade-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a binary string s of length n, where:\n\n'1' represents ... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of active sections after performing at most one trade. The trade allows converting a contiguous block of 1s surrounded by 0s to 0s, and then converting a contiguous block of 0s surrounded by 1s to 1s. And we need to consider the augment... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.328840 | 2.959118 | 3 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 1
},
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 0
}
] | [
false,
false
] | 1 | [] | false | 2 | true |
3805 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"01\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"0100\\\"\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"\\\"1000100\\\"\", \"output\... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-active-section-with-trade-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a binary string s of length n, where:\n\n'1' represents ... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of active sections after performing at most one trade on a binary string. The trade allows converting a contiguous block of 1s surrounded by 0s to 0s, then converting a contiguous block of 0s surrounded by 1s to 1s. And we have to consi... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.331673 | 2.959118 | 4 | [
{
"actual_passed": false,
"full_response": "",
"solution_code": "",
"solution_idx": 0
},
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def maxActiveSectionsAfterTrade(self, s: str) -> int:\n n = len(s)\n # ----- 1. build runs of the string -----... | [
false,
true
] | 1 | [
2
] | false | 2 | true |
3805 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"01\\\"\", \"output\": \"1\", \"testtype\": \"functional\"}, {\"input\": \"\\\"0100\\\"\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"\\\"1000100\\\"\", \"output\... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximize-active-section-with-trade-i\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a binary string s of length n, where:\n\n'1' represents ... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of active sections in a binary string after performing at most one trade. The trade allows converting a contiguous block of 1s surrounded by 0s to 0s, then converting a contiguous block of 0s surrounded by 1s to 1s. And we have to consi... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.315507 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def maxActiveSectionsAfterTrade(self, s: str) -> int:\n n = len(s)\n # ----- 1. build runs of the string -----\n runs = [] # list of (type, length), type: 0 for '0', 1 for '1'\n i = 0\n whi... | [
true,
false
] | 1 | [
1
] | true | 2 | false |
3809 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[[1, 2], [1, 1], [3, 4], [4, 5], [5, 6], [7, 7]]\\n1\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"[[1, 2, 3], [2, 3, 4], [4, 3, 5]]\\n2\", \"output\": \"1\", \"test... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: properties-graph\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a 2D integer array properties having dimensions n x m and an integer k.\nDef... | <think>
Okay, let's tackle this problem. So, the task is to find the number of connected components in a graph where each node represents an element from the properties array. Two nodes are connected if the number of distinct common integers between their properties is at least k.
First, I need to understand the prob... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.318143 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass DSU:\n \"\"\"Disjoint Set Union with union by rank and path compression.\"\"\"\n def __init__(self, n: int):\n self.parent = list(range(n))\n self.rank = [0] * n\n\n def find(self, x: int) -> int:\n... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3809 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[[1, 2], [1, 1], [3, 4], [4, 5], [5, 6], [7, 7]]\\n1\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"[[1, 2, 3], [2, 3, 4], [4, 3, 5]]\\n2\", \"output\": \"1\", \"test... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: properties-graph\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a 2D integer array properties having dimensions n x m and an integer k.\nDef... | <think>
Okay, let's tackle this problem. So, the task is to find the number of connected components in a graph where each node represents an element from the properties array. Two nodes are connected if the number of distinct common integers between their properties is at least k.
First, I need to understand the prob... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.313614 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass DSU:\n \"\"\"Disjoint Set Union with union by rank and path compression.\"\"\"\n def __init__(self, n: int):\n self.parent = list(range(n))\n self.rank = [0] * n\n\n def find(self, x: int) -> int:\n... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3809 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[[1, 2], [1, 1], [3, 4], [4, 5], [5, 6], [7, 7]]\\n1\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"[[1, 2, 3], [2, 3, 4], [4, 3, 5]]\\n2\", \"output\": \"1\", \"test... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: properties-graph\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a 2D integer array properties having dimensions n x m and an integer k.\nDef... | <think>
Okay, let's tackle this problem. So, the task is to find the number of connected components in a graph where each node represents an element from the properties array, and there's an edge between two nodes if their properties have at least k common distinct integers.
First, I need to understand the problem tho... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.320016 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "```python\n\nfrom typing import List\n\nclass Solution:\n def numberOfComponents(self, properties: List[List[int]], k: int) -> int:\n n = len(properties)\n # Convert each row to a set of distinct integers\n distinct_sets = [set(row) for row ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3809 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[[1, 2], [1, 1], [3, 4], [4, 5], [5, 6], [7, 7]]\\n1\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"[[1, 2, 3], [2, 3, 4], [4, 3, 5]]\\n2\", \"output\": \"1\", \"test... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: properties-graph\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a 2D integer array properties having dimensions n x m and an integer k.\nDef... | <think>
Okay, let's tackle this problem. So, the task is to find the number of connected components in a graph where each node represents an element from the properties array. Two nodes are connected if the number of distinct common integers between their properties is at least k.
First, I need to understand the prob... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.321478 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass DSU:\n \"\"\"Disjoint Set Union with union by rank and path compression.\"\"\"\n def __init__(self, n: int):\n self.parent = list(range(n))\n self.rank = [0] * n\n\n def find(self, x: int) -> int:\n... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3809 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[[1, 2], [1, 1], [3, 4], [4, 5], [5, 6], [7, 7]]\\n1\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"[[1, 2, 3], [2, 3, 4], [4, 3, 5]]\\n2\", \"output\": \"1\", \"test... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: properties-graph\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a 2D integer array properties having dimensions n x m and an integer k.\nDef... | <think>
Okay, let's tackle this problem. So, the task is to find the number of connected components in a graph where each node represents an element from the properties array, and there's an edge between two nodes if the intersection of their properties is at least k.
First, I need to understand the problem thoroughl... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.323828 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "We need to compute the number of connected components in a graph where vertices correspond to rows of the input 2D array, and an edge exists between two rows if the number of distinct integers common to both rows is at least `k`. The constraints are small (`n ≤ 100... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3809 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "medium",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[[1, 2], [1, 1], [3, 4], [4, 5], [5, 6], [7, 7]]\\n1\", \"output\": \"3\", \"testtype\": \"functional\"}, {\"input\": \"[[1, 2, 3], [2, 3, 4], [4, 3, 5]]\\n2\", \"output\": \"1\", \"test... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: properties-graph\nPlatform: leetcode\nDifficulty: medium\n\nProblem Statement:\nYou are given a 2D integer array properties having dimensions n x m and an integer k.\nDef... | <think>
Okay, let's tackle this problem. So, the task is to find the number of connected components in a graph where each node represents an element from the properties array, and there's an edge between two nodes if the intersection of their properties is at least k.
First, I need to understand the problem correctly.... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.325141 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "```python\n\nfrom typing import List\n\nclass Solution:\n def numberOfComponents(self, properties: List[List[int]], k: int) -> int:\n n = len(properties)\n # Convert each row to a set of distinct integers\n distinct_sets = [set(row) for row ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3811 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abc\\\"\", \"output\": \"148\", \"testtype\": \"functional\"}, {\"input\": \"\\\"zaza\\\"\", \"output\": \"160\", \"testtype\": \"functional\"}]",
"question_content": "Given a string... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: reverse-degree-of-a-string\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nGiven a string s, calculate its reverse degree.\nThe reverse degree is calculated ... | <think>
Okay, let's tackle this problem. So, the task is to calculate the reverse degree of a string. From the description, the reverse degree is the sum of each character's position in the reversed alphabet multiplied by its position in the string.
First, I need to understand how the reversed alphabet works. The pro... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.327223 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def reverseDegree(self, s: str) -> int:\n \"\"\"\n Calculates the reverse degree of a string.\n For each character, its contribution is (position) * (reverse alphabet value),\n where position is 1-indexed ... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3811 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abc\\\"\", \"output\": \"148\", \"testtype\": \"functional\"}, {\"input\": \"\\\"zaza\\\"\", \"output\": \"160\", \"testtype\": \"functional\"}]",
"question_content": "Given a string... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: reverse-degree-of-a-string\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nGiven a string s, calculate its reverse degree.\nThe reverse degree is calculated ... | <think>
Okay, let's tackle this problem. So, the task is to calculate the reverse degree of a string. From the description, the reverse degree is the sum of each character's position in the reversed alphabet multiplied by its position in the string.
First, I need to understand how the reversed alphabet works. The pro... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.344096 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "**Explanation:**\n\nThe reverse degree is computed by iterating over each character in the string `s`. For a character `c` at index `i` (0‑based), its 1‑based position is `i+1`. The reversed alphabet value is `26 - (ord(c) - ord('a'))` because `'a'` maps to 26 and ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3811 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abc\\\"\", \"output\": \"148\", \"testtype\": \"functional\"}, {\"input\": \"\\\"zaza\\\"\", \"output\": \"160\", \"testtype\": \"functional\"}]",
"question_content": "Given a string... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: reverse-degree-of-a-string\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nGiven a string s, calculate its reverse degree.\nThe reverse degree is calculated ... | <think>
Okay, let's tackle this problem. So, the task is to calculate the reverse degree of a string. From the description, the reverse degree is the sum of each character's reversed alphabet value multiplied by its 1-based index in the string.
First, I need to understand how the reversed alphabet works. The problem s... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.332777 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "```python\n\nclass Solution:\n def reverseDegree(self, s: str) -> int:\n \"\"\"\n Calculates the reverse degree of a string.\n\n For each character, its contribution is:\n (reversed alphabet value) * (1-indexed position in the str... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3811 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abc\\\"\", \"output\": \"148\", \"testtype\": \"functional\"}, {\"input\": \"\\\"zaza\\\"\", \"output\": \"160\", \"testtype\": \"functional\"}]",
"question_content": "Given a string... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: reverse-degree-of-a-string\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nGiven a string s, calculate its reverse degree.\nThe reverse degree is calculated ... | <think>
Okay, let's tackle this problem. So, the task is to calculate the reverse degree of a string. From the description, the reverse degree is the sum of each character's reversed alphabet value multiplied by its position in the string (1-based).
First, I need to understand how the reversed alphabet works. The pro... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.330117 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\n\nclass Solution:\n def reverseDegree(self, s: str) -> int:\n \"\"\"\n Calculates the reverse degree of a string.\n\n For each character, its contribution is:\n (reversed alphabet value) * (1-indexed position in the str... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3811 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abc\\\"\", \"output\": \"148\", \"testtype\": \"functional\"}, {\"input\": \"\\\"zaza\\\"\", \"output\": \"160\", \"testtype\": \"functional\"}]",
"question_content": "Given a string... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: reverse-degree-of-a-string\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nGiven a string s, calculate its reverse degree.\nThe reverse degree is calculated ... | <think>
Okay, let's tackle this problem. So, the task is to calculate the reverse degree of a string. From the description, the reverse degree is the sum of each character's position in the reversed alphabet multiplied by its position in the string.
First, I need to understand how the reversed alphabet works. The pro... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.335767 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "```python\n\nclass Solution:\n def reverseDegree(self, s: str) -> int:\n \"\"\"\n Calculates the reverse degree of a string.\n\n For each character, its contribution is:\n (reversed alphabet value) * (1-indexed position in the str... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3811 | 0 | {
"contest_date": "2025-03-29T07:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"\\\"abc\\\"\", \"output\": \"148\", \"testtype\": \"functional\"}, {\"input\": \"\\\"zaza\\\"\", \"output\": \"160\", \"testtype\": \"functional\"}]",
"question_content": "Given a string... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: reverse-degree-of-a-string\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nGiven a string s, calculate its reverse degree.\nThe reverse degree is calculated ... | <think>
Okay, let's tackle this problem. So, the task is to calculate the reverse degree of a string. From the problem description, the reverse degree is computed by taking each character, finding its position in the reversed alphabet, multiplying it by its position in the original string (1-indexed), and summing all t... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.349888 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "**Explanation:**\n\nThe reverse degree is computed by iterating over each character in the string `s`. For a character `c` at index `i` (0‑based), its 1‑based position is `i+1`. The reversed alphabet value is `26 - (ord(c) - ord('a'))` because `'a'` maps to 26 and ... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3817 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"2\\n3\\n15\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"3\\n5\\n20\", \"output\": \"4\", \"testtype\": \"functional\"}]",
"question_content": "You are given a posit... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-containers-on-a-ship\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given a positive integer n representing an n x n cargo deck on a ship. E... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of containers that can be loaded onto a ship's deck. The deck is n x n, each cell can hold one container weighing w. The total weight can't exceed maxWeight.
First, I need to understand the problem correctly. The maximum number of con... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.334470 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "The problem reduces to a simple capacity calculation: the maximum number of containers we can place is limited by both the number of available cells (n²) and the weight capacity (maxWeight). Since each container weighs exactly w, the maximum number allowed by weigh... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3817 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"2\\n3\\n15\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"3\\n5\\n20\", \"output\": \"4\", \"testtype\": \"functional\"}]",
"question_content": "You are given a posit... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-containers-on-a-ship\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given a positive integer n representing an n x n cargo deck on a ship. E... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of containers that can be loaded onto a ship's deck. The deck is n x n, each cell can hold one container weighing exactly w. The total weight can't exceed maxWeight.
First, I need to understand the problem correctly. The maximum numbe... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.362091 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "```python\nclass Solution:\n def maxContainers(self, n: int, w: int, maxWeight: int) -> int:\n \"\"\"\n Returns the maximum number of containers that can be loaded onto an n x n deck,\n each container weighing exactly w, without exceeding th... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3817 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"2\\n3\\n15\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"3\\n5\\n20\", \"output\": \"4\", \"testtype\": \"functional\"}]",
"question_content": "You are given a posit... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-containers-on-a-ship\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given a positive integer n representing an n x n cargo deck on a ship. E... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of containers that can be loaded onto a ship's deck. The deck is n x n, each cell can hold one container weighing exactly w. The total weight can't exceed maxWeight.
First, I need to understand the problem correctly. The maximum numbe... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.338165 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "The problem is straightforward: the deck has `n * n` cells, each container weighs exactly `w`, and the total weight cannot exceed `maxWeight`. Therefore, the maximum number of containers is limited by both the available space and the weight capacity. The weight‑cap... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3817 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"2\\n3\\n15\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"3\\n5\\n20\", \"output\": \"4\", \"testtype\": \"functional\"}]",
"question_content": "You are given a posit... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-containers-on-a-ship\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given a positive integer n representing an n x n cargo deck on a ship. E... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of containers that can be loaded onto a ship's deck. The deck is n x n, each cell can hold one container weighing exactly w. The total weight can't exceed maxWeight.
First, I need to understand the problem correctly. The maximum numbe... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.354231 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "The problem is straightforward: we have a deck of size `n x n`, so there are `n * n` cells. Each container weighs exactly `w`, and the total weight cannot exceed `maxWeight`. The maximum number of containers we can load is therefore the smaller of:\n\n- The total n... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3817 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"2\\n3\\n15\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"3\\n5\\n20\", \"output\": \"4\", \"testtype\": \"functional\"}]",
"question_content": "You are given a posit... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-containers-on-a-ship\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given a positive integer n representing an n x n cargo deck on a ship. E... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of containers that can be loaded onto a ship's deck. The deck is n x n, each cell can hold one container weighing exactly w. The total weight can't exceed maxWeight.
First, I need to understand the problem correctly. The maximum numbe... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.346151 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "The problem is straightforward: the deck has `n * n` cells, each container weighs exactly `w`, and the total weight cannot exceed `maxWeight`. Therefore, the maximum number of containers is limited by both the available space and the weight capacity. The weight‑cap... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3817 | 0 | {
"contest_date": "2025-03-22T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"2\\n3\\n15\", \"output\": \"4\", \"testtype\": \"functional\"}, {\"input\": \"3\\n5\\n20\", \"output\": \"4\", \"testtype\": \"functional\"}]",
"question_content": "You are given a posit... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: maximum-containers-on-a-ship\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given a positive integer n representing an n x n cargo deck on a ship. E... | <think>
Okay, let's tackle this problem. So, the task is to find the maximum number of containers that can be loaded onto a ship's deck. The deck is n x n, each cell can hold a container of weight w. The total weight can't exceed maxWeight.
First, I need to understand the problem correctly. The maximum number of cont... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.397851 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "The problem is straightforward: we have a deck of size `n x n`, so there are `n * n` cells. Each container weighs exactly `w`, and the total weight cannot exceed `maxWeight`. The maximum number of containers we can load is therefore the smaller of:\n\n- The total n... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3832 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[5, 3, 4, 1, 3, 2]\", \"output\": \"[5, 3, 3, 1, 1, 1]\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 4, 6, 7]\", \"output\": \"[1, 1, 1, 1, 1]\", \"testtype\": \"functional\"}]",
... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: minimum-cost-to-reach-every-position\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array cost of size n. You are currently at posi... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum cost to reach each position in a line, where swapping with someone in front of you costs some amount, but swapping with someone behind you is free. Hmm.
Looking at the examples, like the first one where cost is [5,3,4,1,3,2], the output is [5... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.361282 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "The minimal cost to reach position `i` is simply the minimum cost among the first `i+1` people. \n- You must pay at least one person with index ≤ `i` to move forward (free swaps only move backward). \n- The cheapest strategy is to pay the cheapest such person (co... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3832 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[5, 3, 4, 1, 3, 2]\", \"output\": \"[5, 3, 3, 1, 1, 1]\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 4, 6, 7]\", \"output\": \"[1, 1, 1, 1, 1]\", \"testtype\": \"functional\"}]",
... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: minimum-cost-to-reach-every-position\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array cost of size n. You are currently at posi... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum cost to reach each position in a line of people. The key here is understanding the swapping rules.
The problem says that when moving forward, each person in front of you has a cost to swap with. But if they're behind you, you can swap for fr... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.363494 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "The minimum cost to reach position `i` is the minimum cost among all persons with index ≤ `i`. \n- If we pay `cost[j]` to swap with person `j` (j ≤ i), we can then freely swap backward (to larger indices) to reach `i` because any person behind us can be swapped fo... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | true |
3832 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[5, 3, 4, 1, 3, 2]\", \"output\": \"[5, 3, 3, 1, 1, 1]\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 4, 6, 7]\", \"output\": \"[1, 1, 1, 1, 1]\", \"testtype\": \"functional\"}]",
... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: minimum-cost-to-reach-every-position\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array cost of size n. You are currently at posi... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum cost to reach each position in a line. The key here is understanding how the swapping works.
The problem says that when you move forward, each person in front of you charges a cost to swap. But if they're behind you, you can swap for free. S... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.359160 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "The problem reduces to computing the prefix minimum of the `cost` array. \nStarting from position `n`, we can directly pay `cost[j]` to swap with any person `j` (since all are in front). After paying, we are at position `j` and can then move **for free** to any po... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3832 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[5, 3, 4, 1, 3, 2]\", \"output\": \"[5, 3, 3, 1, 1, 1]\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 4, 6, 7]\", \"output\": \"[1, 1, 1, 1, 1]\", \"testtype\": \"functional\"}]",
... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: minimum-cost-to-reach-every-position\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array cost of size n. You are currently at posi... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum cost to reach each position in a line. The key here is understanding how the swapping works.
The problem says that when you move forward, each person in front of you charges a specific cost to swap. But if they are behind you, you can swap f... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.360371 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\nfrom typing import List\n\nclass Solution:\n def minCosts(self, cost: List[int]) -> List[int]:\n \"\"\"\n Returns an array where answer[i] is the minimum total cost to reach position i.\n The optimal strategy is to pay the smalles... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
3832 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[5, 3, 4, 1, 3, 2]\", \"output\": \"[5, 3, 3, 1, 1, 1]\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 4, 6, 7]\", \"output\": \"[1, 1, 1, 1, 1]\", \"testtype\": \"functional\"}]",
... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: minimum-cost-to-reach-every-position\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array cost of size n. You are currently at posi... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum cost to reach each position in a line of people. The key here is understanding the swapping rules.
The problem says that when moving forward, each person in front of you has a cost to swap with. But if they're behind you, you can swap for fr... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.365156 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "The minimum cost to reach position `i` is the minimum cost among all persons with index ≤ `i`. \n- If we pay `cost[j]` to swap with person `j` (j ≤ i), we can then freely swap backward (to larger indices) to reach `i` because any person behind us can be swapped fo... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
3832 | 0 | {
"contest_date": "2025-03-29T19:30:00",
"difficulty": "easy",
"platform": "leetcode",
"public_test_cases": "[{\"input\": \"[5, 3, 4, 1, 3, 2]\", \"output\": \"[5, 3, 3, 1, 1, 1]\", \"testtype\": \"functional\"}, {\"input\": \"[1, 2, 4, 6, 7]\", \"output\": \"[1, 1, 1, 1, 1]\", \"testtype\": \"functional\"}]",
... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: minimum-cost-to-reach-every-position\nPlatform: leetcode\nDifficulty: easy\n\nProblem Statement:\nYou are given an integer array cost of size n. You are currently at posi... | <think>
Okay, let's tackle this problem. So, the task is to find the minimum cost to reach each position in a line of people. The key point is that when you swap with someone in front of you, you pay their cost, but if you swap with someone behind you, it's free. Hmm.
Looking at the examples, like the first one where ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.384468 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "The minimal cost to reach position `i` is simply the minimum cost among the first `i+1` people. \n- You must pay at least one person with index ≤ `i` to move forward (free swaps only move backward). \n- The cheapest strategy is to pay the cheapest such person (co... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
abc391_a | 0 | {
"contest_date": "2025-02-01T00:00:00",
"difficulty": "easy",
"platform": "atcoder",
"public_test_cases": "[{\"input\": \"N\", \"output\": \"S\", \"testtype\": \"stdin\"}, {\"input\": \"SE\", \"output\": \"NW\", \"testtype\": \"stdin\"}]",
"question_content": "You are given a string D representing one of the... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: Lucky Direction\nPlatform: atcoder\nDifficulty: easy\n\nProblem Statement:\nYou are given a string D representing one of the eight directions (north, east, west, south, n... | <think>
Okay, let's tackle this problem. So, the task is to find the opposite direction of a given direction in eight possible directions. The user provided two candidate solutions, and I need to evaluate which one is better.
First, I'll check the syntax and completeness of both solutions. Both seem to be Python scrip... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.366019 | 2.959118 | 0 | [
{
"actual_passed": true,
"full_response": "We need to output the direction opposite to the given direction. Since there are only eight possible inputs, we can directly map each direction to its opposite using a dictionary.\n\n**Algorithm:**\n1. Read the string `D` from standard input and strip whitespace.\n... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
abc391_a | 0 | {
"contest_date": "2025-02-01T00:00:00",
"difficulty": "easy",
"platform": "atcoder",
"public_test_cases": "[{\"input\": \"N\", \"output\": \"S\", \"testtype\": \"stdin\"}, {\"input\": \"SE\", \"output\": \"NW\", \"testtype\": \"stdin\"}]",
"question_content": "You are given a string D representing one of the... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: Lucky Direction\nPlatform: atcoder\nDifficulty: easy\n\nProblem Statement:\nYou are given a string D representing one of the eight directions (north, east, west, south, n... | <think>
Okay, let's tackle this problem. So, the task is to find the opposite direction of a given direction in eight possible directions. The user provided two solutions, and I need to evaluate which one is better.
First, I'll check the syntax and completeness of both solutions. Both seem okay. They use a dictionary ... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.408393 | 2.959118 | 1 | [
{
"actual_passed": true,
"full_response": "```python\n\nimport sys\n\ndef main():\n # Read the direction string, stripping any surrounding whitespace\n d = sys.stdin.readline().strip()\n \n # Dictionary mapping each direction to its opposite\n opposite = {\n 'N': 'S',\n 'S': 'N'... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
abc391_a | 0 | {
"contest_date": "2025-02-01T00:00:00",
"difficulty": "easy",
"platform": "atcoder",
"public_test_cases": "[{\"input\": \"N\", \"output\": \"S\", \"testtype\": \"stdin\"}, {\"input\": \"SE\", \"output\": \"NW\", \"testtype\": \"stdin\"}]",
"question_content": "You are given a string D representing one of the... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: Lucky Direction\nPlatform: atcoder\nDifficulty: easy\n\nProblem Statement:\nYou are given a string D representing one of the eight directions (north, east, west, south, n... | <think>
Okay, let's tackle this problem. So, the task is to find the opposite direction of a given direction in eight possible directions. The user provided two solutions, and I need to determine which one is better.
First, I'll check the syntax and completeness of both solutions. Both seem to be valid. They use a dic... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.378637 | 2.959118 | 2 | [
{
"actual_passed": true,
"full_response": "```python\n\nimport sys\n\ndef main():\n # Read the direction string, stripping any surrounding whitespace\n d = sys.stdin.readline().strip()\n \n # Dictionary mapping each direction to its opposite\n opposite = {\n 'N': 'S',\n 'S': 'N'... | [
true,
true
] | 2 | [
1,
2
] | true | 2 | false |
abc391_a | 0 | {
"contest_date": "2025-02-01T00:00:00",
"difficulty": "easy",
"platform": "atcoder",
"public_test_cases": "[{\"input\": \"N\", \"output\": \"S\", \"testtype\": \"stdin\"}, {\"input\": \"SE\", \"output\": \"NW\", \"testtype\": \"stdin\"}]",
"question_content": "You are given a string D representing one of the... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: Lucky Direction\nPlatform: atcoder\nDifficulty: easy\n\nProblem Statement:\nYou are given a string D representing one of the eight directions (north, east, west, south, n... | <think>
Okay, let's tackle this problem. So, the task is to find the opposite direction of a given direction in eight possible directions. The user provided two solutions, and I need to evaluate which one is better.
First, I'll check the syntax and completeness of both solutions. Both seem to be valid. They use a dict... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.369727 | 2.959118 | 3 | [
{
"actual_passed": true,
"full_response": "```python\n\nimport sys\n\ndef main():\n # Read the direction string, stripping any surrounding whitespace\n d = sys.stdin.readline().strip()\n \n # Dictionary mapping each direction to its opposite\n opposite = {\n 'N': 'S',\n 'S': 'N'... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
abc391_a | 0 | {
"contest_date": "2025-02-01T00:00:00",
"difficulty": "easy",
"platform": "atcoder",
"public_test_cases": "[{\"input\": \"N\", \"output\": \"S\", \"testtype\": \"stdin\"}, {\"input\": \"SE\", \"output\": \"NW\", \"testtype\": \"stdin\"}]",
"question_content": "You are given a string D representing one of the... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: Lucky Direction\nPlatform: atcoder\nDifficulty: easy\n\nProblem Statement:\nYou are given a string D representing one of the eight directions (north, east, west, south, n... | <think>
Okay, let's tackle this problem. So, the task is to find the opposite direction of a given direction in eight possible directions. The user provided two candidate solutions, and I need to evaluate which one is better.
First, I'll check the syntax and completeness of both solutions. Both seem to be Python funct... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.376235 | 2.959118 | 4 | [
{
"actual_passed": true,
"full_response": "We need to output the direction opposite to the given direction. Since there are only eight possible inputs, we can directly map each direction to its opposite using a dictionary.\n\n**Algorithm:**\n1. Read the string `D` from standard input and strip whitespace.\n... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
abc391_a | 0 | {
"contest_date": "2025-02-01T00:00:00",
"difficulty": "easy",
"platform": "atcoder",
"public_test_cases": "[{\"input\": \"N\", \"output\": \"S\", \"testtype\": \"stdin\"}, {\"input\": \"SE\", \"output\": \"NW\", \"testtype\": \"stdin\"}]",
"question_content": "You are given a string D representing one of the... | [
{
"content": "You are an expert code evaluation system.",
"role": "system"
},
{
"content": "=== PROGRAMMING PROBLEM ===\n\nTitle: Lucky Direction\nPlatform: atcoder\nDifficulty: easy\n\nProblem Statement:\nYou are given a string D representing one of the eight directions (north, east, west, south, n... | <think>
Okay, let's tackle this problem. So, the task is to find the opposite direction of a given direction in eight possible directions. The user provided two candidate solutions, and I need to evaluate which one is better.
First, I'll check the syntax and completeness of both solutions. Both seem to be Python scrip... | Qwen/Qwen3-1.7B | 2026-09-25T06:12:54.392730 | 2.959118 | 5 | [
{
"actual_passed": true,
"full_response": "The problem requires mapping a given direction to its opposite. Since there are only eight possible inputs, a simple dictionary lookup suffices. This approach runs in O(1) time and memory.\n\n```python\nimport sys\n\ndef main():\n d = sys.stdin.readline().strip(... | [
true,
true
] | 1 | [
1,
2
] | true | 2 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.