task_id stringclasses 368
values | model_label stringclasses 10
values | model_group stringclasses 2
values | model_id stringclasses 10
values | condition stringclasses 2
values | generated_code stringlengths 0 8.65k | test_status stringclasses 6
values | tests_passed int64 0 15 ⌀ | tests_total int64 0 15 ⌀ | benchmark_test_count int64 15 15 | first_failed_test_id stringclasses 21
values | raw_metrics unknown | response_sha256 stringlengths 64 64 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
boolean_rules_hard_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rules_hard_001(a: bool, b: bool, c: bool, d: bool, mode: str) -> bool:
if mode == "first_two_true_last_two_false":
return a and b and not (c or d)
elif mode == "no_adjacent_true":
return not (a and b) and not (b and c) and not (c and d) and not (d and a)
elif mode == "exactly_thr... | passed | 15 | 15 | 15 | null | {
"total_nloc": 9,
"comment_lines": 0,
"main_function_nloc": 9,
"halstead_volume": 249.982455947,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 9,
"max... | cfc7fc28c6305450120f15197ae7d36bf46c492bd0255e1fb6409fb7fa21ee1e |
boolean_rules_hard_002 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rules_hard_002(a: bool, b: bool, c: bool, d: bool, mode: str) -> bool:
if mode == "ends_opposite_middle_same":
return a != d and b == c
elif mode == "at_least_two_adjacent_true":
return (a and b) or (b and c) or (c and d)
elif mode == "one_true_in_every_pair":
return (a a... | passed | 15 | 15 | 15 | null | {
"total_nloc": 9,
"comment_lines": 0,
"main_function_nloc": 9,
"halstead_volume": 190.164836175,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 9,
"max... | 7ec7777d605dc65efec8393d3adbf0d12545bf09866a98125eb60b590833585b |
boolean_rules_hard_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rules_hard_004(p: bool, q: bool, r: bool, s: bool, mode: str) -> bool:
if mode == "at_least_one_true_at_ends":
return p or s
elif mode == "exactly_three_false_and_middle_true":
count = (not p) + (not q) + (not r) + (not s)
middle = p ^ q ^ r ^ s # XOR operation to check if t... | structure_failure | null | null | 15 | null | {} | fe20afbf68d6629d70a4e4e3c9cc1aa527f42cfd76baa0a77b0d2e6347efb4ae |
boolean_rules_hard_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_mode_check(a: bool, b: bool, c: bool, d: bool, mode: str) -> bool:
if mode == "first_true_and_at_least_two_false":
return a and not (b or c or d)
elif mode == "palindromic":
return a == d and b == c
elif mode == "at_least_three_adjacent_same":
return any(x==y==z for x, y,... | test_failure | 3 | 15 | 15 | visible_04 | {} | 98dbb13d6393ee0821537a1c800a9e35814bf45d095e25a4d96abe2d6fb11b6b |
boolean_rules_hard_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rules_hard_008(a: bool, b: bool, c: bool, d: bool, mode: str) -> bool:
if mode == "first_and_middle_true":
return a and b and c
elif mode == "ends_different_and_two_true":
return (a != d and sum([a, b, c, d]) == 2)
elif mode == "at_least_three_same_and_one_different":
ret... | structure_failure | null | null | 15 | null | {} | 89699daab6eaef46fe28a929f90ad0e6feaa092defcaa9ad4be216dc725510e0 |
boolean_rules_hard_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rules_hard_009(a: bool, b: bool, c: bool, d: bool, mode: str) -> bool:
if mode == "all_adjacent_equal":
return a == b == c == d
elif mode == "exactly_two_true_and_first_false":
return (a and not b and c == d) or (b and not a and c == d) or (c and not b and a == d) or (d and not c and... | test_failure | 2 | 15 | 15 | visible_03 | {} | 3f648035321a5ecbc55f3e7352cac5af31f344900471d77226b88351ddb2e5c2 |
boolean_rules_medium_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rule_switch(a: bool, b: bool, c: bool, d: bool, mode: str) -> bool:
if mode == "all_true":
return a and b and c and d
elif mode == "any_two_true":
return (a and b) or (b and c) or (c and d) or (d and a)
elif mode == "exactly_one_false":
return sum([not a, not b, not c, no... | structure_failure | null | null | 15 | null | {} | ad24eda3ed44767085f92d4a21543fcaa1f657308e610d13201e822d9012ee9c |
boolean_rules_medium_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rule_check(p: bool, q: bool, r: bool, s: bool, operator: str) -> bool:
values = [p, q, r, s]
if operator == "nand":
return not all(values)
elif operator == "majority":
return sum(values) >= 3
elif operator == "xor3":
return sum(values) == 3
return Fa... | structure_failure | null | null | 15 | null | {} | 6be748fdcf684825486589784efef1e5a495cbbce25184c86408bd68dfa76471 |
boolean_rules_medium_006 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rule_checker(flag1: bool, flag2: bool, flag3: bool, flag4: bool, mode: str) -> bool:
flags = [flag1, flag2, flag3, flag4]
if mode == "alternating":
return all(x != y for x, y in zip(flags, flags[1:] + [None]))
elif mode == "at_least_three_false":
return sum(not i for i in fl... | structure_failure | null | null | 15 | null | {} | 8b555dbccfe355e6c94cb26114cef1a4401e59547c2f3fc30f2869deb1fd56a9 |
boolean_rules_medium_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rules_medium_007(x: bool, y: bool, z: bool, w: bool, mode: str) -> bool:
if mode == "even_true":
return sum([int(x), int(y), int(z), int(w)]) % 2 == 0
elif mode == "at_least_two_false":
return sum([int(not x), int(not y), int(not z), int(not w)]) >= 2
elif mode == "exactly_two_tr... | structure_failure | null | null | 15 | null | {} | 2223716abde2e3159f9cba8cbe82d5acbe274f28429d9c5b52ab3a1a27bc2570 |
boolean_rules_medium_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rule_check(a: bool, b: bool, c: bool, d: bool, mode: str) -> bool:
if mode == "first_and_last_same":
return a == d
elif mode == "at_least_three_true":
return sum((a, b, c, d)) >= 3
elif mode == "exactly_two_false_and_nonadjacent":
values = (a, b, c, d)
return valu... | structure_failure | null | null | 15 | null | {} | f7292b6de37f5de49d22a9838cee335a06a1d8d35494b26b69ecdef36134c018 |
boolean_rules_medium_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def boolean_rules_medium_009(a: bool, b: bool, c: bool, d: bool, mode: str) -> bool:
if mode == "exactly_one_true_at_ends":
return (a and not d) != (not a and d) and not b and not c
elif mode == "pairwise_equal":
return a == b and c == d
elif mode == "at_least_one_false_at_middle":
r... | passed | 15 | 15 | 15 | null | {
"total_nloc": 7,
"comment_lines": 0,
"main_function_nloc": 7,
"halstead_volume": 210.9082750332,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 7,
"ma... | a8100bb44a92245e13b357528f086b53b46c71c85445aadc48fbd9d78312a990 |
combinatorial_logic_easy_002 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def symmetric_difference_sorted(list1: list[int], list2: list[int]) -> list[int]:
return sorted(set(list1) ^ set(list2)) | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 4.7548875022,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max_... | 4b1e963951ce8215f9d44976134551a6d87552b2d204301f0aed73566de82c5c |
combinatorial_logic_easy_003 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def diff_sorted_unique(a: list[int], b: list[int]) -> list[int]:
return sorted(set(i for i in a if i not in b)) | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 4.7548875022,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max_... | b3df3fe589101c0e93851d84b6a8b6054934ec18d8d19b2d5c82370005430e9a |
combinatorial_logic_easy_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def at_least_k_occurrences(nums: list[int], k: int) -> list[int]:
from collections import Counter
count = Counter(nums)
return sorted([i for i in count if count[i] >= k]) | passed | 15 | 15 | 15 | null | {
"total_nloc": 4,
"comment_lines": 0,
"main_function_nloc": 4,
"halstead_volume": 4.7548875022,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 4,
"max_... | 18a130920b5c5c26fd03722e92282cc5d4d69b6512c454d5c94be76ac6c49e87 |
combinatorial_logic_easy_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def at_least_two_total(a: list[int], b: list[int]) -> list[int]:
counts = {}
for i in (a + b):
if i not in counts:
counts[i] = 1
else:
counts[i] += 1
return sorted([k for k, v in counts.items() if v >= 2]) | structure_failure | null | null | 15 | null | {} | 9672e3fcb1fcb22e809ec599f8b37f5ae9218e2824101cfbd0fea1081e89b6b6 |
combinatorial_logic_easy_006 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def find_missing_in_universe(lists):
if len(lists) == 0 or any(len(lst) == 0 for lst in lists):
return []
universe = set(range(min([min(lst) for lst in lists]), max([max(lst) for lst in lists]) + 1))
present_numbers = set(n for sublist in lists for n in sublist)
return sorted(universe ... | structure_failure | null | null | 15 | null | {} | b358a888c9b52a07a109dc3d824296a0bf4b7112999d1278fed6fdfc6fb8872c |
combinatorial_logic_easy_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def shared_from_first_and_others(lists):
if len(lists) < 2 or not lists[0]: return []
first = set(lists[0])
others = set().union(*map(set, lists[1:]))
common = sorted((first & others))
return common | structure_failure | null | null | 15 | null | {} | a878d6a86694295e333598e80bfcadfdff491e14e7641a536ec1fb7afc6d8a4a |
combinatorial_logic_easy_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def odd_occurrence_in_lists(lists):
if len(lists) == 0 or any(len(lst) == 0 for lst in lists):
return []
counts = {}
for sublist in lists:
for num in set(sublist): # use a set to remove duplicates within each sublist
if num not in counts:
counts[num] = 1
... | structure_failure | null | null | 15 | null | {} | 02a512a31cbd1740820178e00c5b36799043b52f388d6354aab37c766e454cec |
combinatorial_logic_easy_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def common_elements_with_equal_frequency(a: list[int], b: list[int]) -> list[int]:
from collections import Counter
counterA = Counter(a)
counterB = Counter(b)
intersectionAB = counterA & counterB
commonElements = [item for item, count in intersectionAB.items() if count == min(counterA[item], co... | structure_failure | null | null | 15 | null | {} | c6e23a2430d4811bbfde3eaf6b13b7ee13e5f50761bf2c9f755252a223912818 |
combinatorial_logic_hard_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def integers_in_multiple_lists(lists):
if len(lists) < 2: return []
counts = {}
for lst in lists:
for num in set(lst):
counts[num] = counts.get(num, 0) + 1
return sorted([k for k, v in counts.items() if v > 1]) | passed | 15 | 15 | 15 | null | {
"total_nloc": 7,
"comment_lines": 0,
"main_function_nloc": 7,
"halstead_volume": 27,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 2,
"mean_nloc": 7,
"max_nloc": 7,
... | 5bacc75c894f9754481285236fda00bf8b00dfe9919b9d36a099abb5f3524878 |
combinatorial_logic_hard_002 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def integers_in_all_but_one(lists):
if len(lists) < 2: return []
counts = {}
for inner in lists:
unique_nums = set()
for num in inner:
if num not in unique_nums:
counts[num] = counts.get(num, 0) + 1
unique_nums.add(num)
return sorted([k for k, ... | test_failure | 0 | 15 | 15 | visible_01 | {} | e33630bb9973bbd9a1e5028f0a7a833667924a1731da755ec6fbd9308a367a0e |
combinatorial_logic_hard_003 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def integers_in_exactly_two_lists(lists):
count = {}
for lst in lists:
for num in set(lst):
if num not in count:
count[num] = 0
count[num] += 1
return sorted([num for num, cnt in count.items() if cnt == 2]) | passed | 15 | 15 | 15 | null | {
"total_nloc": 8,
"comment_lines": 0,
"main_function_nloc": 8,
"halstead_volume": 28.529325013,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 8,
"max_... | 15271f9077b73191a91db8195e36068df19104944572f0e543ee680043e79758 |
combinatorial_logic_hard_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def integers_in_at_least_k_lists(lists: list[list[int]], k: int) -> list[int]:
if not lists or k > len(lists): return []
count = {}
for lst in lists:
for num in set(lst): # use a set to avoid counting duplicates within each list
if num in count:
count[num] += 1
... | passed | 15 | 15 | 15 | null | {
"total_nloc": 10,
"comment_lines": 1,
"main_function_nloc": 10,
"halstead_volume": 68,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 10,
"max_nloc": ... | 2daf80a93106ce7e49f89f78805029c71833080277e386dadb07f274863574d9 |
combinatorial_logic_hard_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def integers_in_exactly_half_lists(lists):
if len(lists) < 2: return []
half = len(lists) // 2
counts = {}
for lst in lists:
for num in set(lst):
counts[num] = counts.get(num, 0) + 1
return sorted([k for k, v in counts.items() if v <= half]) | test_failure | 0 | 15 | 15 | visible_01 | {} | 71b1719ce0a04cd1bd8e55a5ee13bbe9a31ea6dfe213a17c8fa4c74d4b31415c |
combinatorial_logic_hard_006 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def unique_maximums(lists):
return sorted({x for lst in lists if lst for x in lst}.difference(*[{x for x in lst} for lst in lists])) | test_failure | 0 | 15 | 15 | visible_01 | {} | 0f49c08b01256e6a1aeb73627bcac315814008184345af6632152d158e4d7136 |
combinatorial_logic_hard_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def integers_not_in_consecutive_lists(lists):
if len(lists) < 2: return []
# Flatten the list and convert to set for unique elements
flat = [i for sublist in lists for i in sublist]
flat_set = set(flat)
# Create a dictionary with counts of each integer
count_dict = {i: flat.count(i) fo... | structure_failure | null | null | 15 | null | {} | a8ebb7d57085d851ad1242b86c4e2cf4d56b6c064c53f770cc8c74ec7586cf98 |
combinatorial_logic_hard_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def integers_in_all_but_one(lists):
if len(lists) < 2: return []
counts = {}
for lst in lists:
unique_elements = set(lst)
for el in unique_elements:
counts[el] = counts.get(el, 0) + 1
result = [k for k, v in counts.items() if v % len(lists) == 0 and v != 0]
return sorted(... | test_failure | 0 | 15 | 15 | visible_01 | {} | d5ceed4149afba9b004e4c239347470b1f7b57252f5891e471dfd27f4895f20d |
combinatorial_logic_hard_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def nonconsecutive_multi_occurrence(lists):
if len(lists) < 2: return []
counts = {}
for i in range(len(lists)-1):
setA, setB = set(lists[i]), set(lists[i+1])
common_elements = setA & setB
if len(common_elements) == 0: continue
for element in common... | structure_failure | null | null | 15 | null | {} | 647dcec30ef3b405b58a4d11253ecc1154bf1938cb8a9dabd98ec1d592966aeb |
combinatorial_logic_hard_010 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def find_integers_appearing_in_two_lists_not_min_max(lists):
if len(lists) < 2: return []
counts = {}
for lst in lists:
min_val, max_val = min(lst), max(lst)
for num in set(lst):
if num != min_val and num != max_val:
counts[num] = counts.get(num, 0) + 1
... | test_failure | 8 | 15 | 15 | hidden_04 | {} | a25ff35d5a985b501e2801ac96bcf13399a7d7d57044236a85d9095928f88719 |
combinatorial_logic_medium_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def intersection_of_two_or_more(lst1, lst2, lst3):
return sorted(set([x for x in lst1 if (x in lst2) + (x in lst3) > 1])) | test_failure | 0 | 15 | 15 | visible_01 | {} | df6280601dce096abfe0a996eb1607d6e18a9eec7a6f5fab20566b6f4b793238 |
combinatorial_logic_medium_002 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def unique_to_first_list(lst1: list[int], lst2: list[int], lst3: list[int]) -> list[int]:
return sorted(set([i for i in lst1 if i not in set().union(lst2, lst3)])) | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 4.7548875022,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 2,
"max_... | 97ab2f10df4f7b1b14f73b1d49bd994f20e8218c05410e5607f709843d0ad817 |
combinatorial_logic_medium_003 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def common_elements_all(lists):
if any(len(lst) == 0 for lst in lists): return []
result = set(lists[0])
for lst in lists[1:]:
result &= set(lst)
return sorted(list(result)) | passed | 15 | 15 | 15 | null | {
"total_nloc": 6,
"comment_lines": 0,
"main_function_nloc": 6,
"halstead_volume": 15.5097750043,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 6,
"max... | 5d5157924a722ccf01142bafa58c52081fcf45c26565a8f1db0f7571b523b7c2 |
combinatorial_logic_medium_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def unique_to_one_list(lists):
counts = {}
for inner in [item for sublist in lists for item in sublist]:
if inner not in counts:
counts[inner] = 0
counts[inner] += 1
return sorted([k for k, v in counts.items() if v == 1]) | passed | 15 | 15 | 15 | null | {
"total_nloc": 7,
"comment_lines": 0,
"main_function_nloc": 7,
"halstead_volume": 27,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 7,
"max_nloc": 7,
... | a23a3b83c6917fb35f5754773042b74c24b2ccacd8efe9d486d63f76200022d5 |
combinatorial_logic_medium_006 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def integers_in_all_but_first(lists):
if len(lists) < 2: return []
common = set(lists[0])
for lst in lists[1:]:
common &= set(lst)
return sorted(list(common)) | test_failure | 3 | 15 | 15 | visible_04 | {} | fb01d29b4560d35a46332c949d2a256bf9ef2b373ec668ef8b66c988f410aeae |
combinatorial_logic_medium_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def first_list_unique_difference(lists):
if len(lists) < 2 or not lists[0]: return []
first = set(lists[0])
other = set().union(*[set(lst) for lst in lists[1:]])
unique = list(first - other)
unique.sort()
return unique | passed | 15 | 15 | 15 | null | {
"total_nloc": 7,
"comment_lines": 0,
"main_function_nloc": 7,
"halstead_volume": 38.053747805,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 2,
"mean_nloc": 7,
"max_... | 0dfa68a2acd01cae972a6c0065d410815df3d91dab74c9be99086ab41376d967 |
combinatorial_logic_medium_010 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def unique_even_index_only(lists):
if len(lists) == 0 or len(lists[0]) == 0: return []
even = set()
odd = set()
for i, lst in enumerate(lists):
if i % 2 == 0:
even.update(lst)
else:
odd = odd | set(lst)
return sorted([i for i in even if i not... | structure_failure | null | null | 15 | null | {} | 7bbe81314b30a0d071980894aa153177c407cb3d55b796884668df63e887006a |
coordinate_geometry_easy_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def manhattan_distance(p1: list[int], p2: list[int]) -> int:
return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1]) | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 27,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max_nloc": 2,
... | eb9b0112730ba92ca3501283cfa40ed7b1906a150d0209aaa4935139f35144b0 |
coordinate_geometry_easy_002 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def are_points_collinear_with_origin(a: list[int], b: list[int]) -> bool:
return (b[0] - a[0]) * (b[1] + a[1]) == (b[0] + a[0]) * (b[1] - a[1]) | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 87.5684250303,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max... | 08b2139e0c384d5d2f2826dfd0d5a874a8c1bba3dcf25f9c70c5eb7b678d1b8d |
coordinate_geometry_easy_003 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def is_axis_parallel(point1: list[int], point2: list[int]) -> bool:
return point1[0] == point2[0] or point1[1] == point2[1] | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 27,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max_nloc": 2,
... | 113099646fc747889149dffc409e545cf9d891674fabbf5e2bce6488540c27b8 |
coordinate_geometry_easy_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def midpoint(point1: list[int], point2: list[int]) -> list[int]:
return [(x+y)//2 for x, y in zip(point1, point2)] | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 15.5097750043,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max... | 12c06e9c3b3ce8c91fb3a14d2d93a70f3c838984e627348f5c5e12504ef8aca0 |
coordinate_geometry_easy_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def is_on_axis(point):
return point[0] == 0 or point[1] == 0 | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 25.2661942985,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max... | bbd3fc0ef99294ad37fe1b5516b17c07f3d1729f1ca771b997d8d5c200288c48 |
coordinate_geometry_easy_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def forms_right_triangle(p1, p2, p3):
def distance(a, b):
return ((b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2) ** 0.5
sides = sorted([distance(p1, p2), distance(p2, p3), distance(p3, p1)])
return abs((sides[0]**2 + sides[1]**2 - sides[2]**2)) < 1e-6 | test_failure | 7 | 15 | 15 | hidden_03 | {} | 52777afc726a35b6d49103144f06f214d7095eb8d50f695049dfde5e5d839edb |
coordinate_geometry_easy_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def segment_passes_through_origin(p1: list[int], p2: list[int]) -> bool:
def on_line(x, y):
return (y[0] * x[1] - y[1] * x[0]) == 0
return on_line((0, 0), (p1, p2)) or p1 == [0, 0] or p2 == [0, 0] | runtime_exception | 0 | 0 | 15 | null | {} | 8a4d9bd1b48ac77208418d3d8f802244262238a64acdfbfec10e046091d8c023 |
coordinate_geometry_easy_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | import math
def are_points_equidistant_from_origin(p1: list[int], p2: list[int]) -> bool:
def distance_from_origin(point):
return math.sqrt(point[0]**2 + point[1]**2)
return math.isclose(distance_from_origin(p1), distance_from_origin(p2)) | passed | 15 | 15 | 15 | null | {
"total_nloc": 5,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 25.2661942985,
"function_count": 2,
"internal_call_links": 1,
"call_graph_depth": 1,
"coupling_density": 0.5,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max_... | 543cc2f7a0c751898e85f4d007bdd5ce09ed18c19a00feb9e76bae56795214a3 |
coordinate_geometry_hard_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def is_convex_quadrilateral(points):
def check_collinear(a, b, c):
return (b[0] - a[0]) * (c[1] - b[1]) == (c[0] - b[0]) * (b[1] - a[1])
def check_area(a, b, c, d):
return (b[0] - a[0])*(c[1]-a[1]) + (c[0]-b[0])*(d[1]-b[1]) + (d[0]-c[0])*(a[1]-c[1]) >= 0
points = sorted(points)
... | runtime_exception | 0 | 0 | 15 | null | {} | 3f0767cacae06ffde20e113d4e3c7c990d6465cc02038396ecb9c4dcd994fd71 |
coordinate_geometry_hard_003 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | import math
def triple_circle_intersection_exists(c1: list[int], c2: list[int], c3: list[int]) -> bool:
def distance(p1, p2):
return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
center_points = [c1[:2], c2[:2], c3[:2]]
radii = [c1[2], c2[2], c3[2]]
# Check if any two circles... | structure_failure | null | null | 15 | null | {} | 47eeabe8ac5384b534e183d44b26e572df8bc0bf92ab4ff140c4c7c4355d61a5 |
coordinate_geometry_hard_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def segments_properly_intersect(seg1: list[int], seg2: list[int]) -> bool:
def ccw(A, B, C):
return (B.x - A.x) * (C.y - A.y) > (B.y - A.y) * (C.x - A.x)
class Point():
def __init__(self, x, y):
self.x = x
self.y = y
A = Point(seg1[0], seg1[1])
B = Point(seg1[2]... | structure_failure | null | null | 15 | null | {} | 922e5e602e2cec5eb1ad37a0c11a63f5566633e36bd1ff24642ba43a31e418f4 |
coordinate_geometry_hard_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_positive_slope_lines(points):
from fractions import Fraction
lines = set()
for i in range(len(points)):
x1, y1 = points[i]
for j in range(i+1, len(points)):
x2, y2 = points[j]
if x2 - x1 == 0: continue # vertical line
slope = Fraction(y2-y1, x2-... | structure_failure | null | null | 15 | null | {} | 533348aad73e55126f9f93e8dd434ee09a4992065b5780eb6954728df4387845 |
coordinate_geometry_hard_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_distinct_triangles(points):
n = len(points)
if n < 3: return 0
def sign(p, q, r):
return (p[0] - r[0]) * (q[1] - p[1]) - (p[1] - r[1]) * (q[0] - p[0])
count = 0
for i in range(n):
for j in range(i + 1, n):
for k in range(j + 1, n):
... | passed | 15 | 15 | 15 | null | {
"total_nloc": 12,
"comment_lines": 0,
"main_function_nloc": 10,
"halstead_volume": 171.1759500779,
"function_count": 2,
"internal_call_links": 1,
"call_graph_depth": 1,
"coupling_density": 0.5,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 6,
"m... | 743cc12ea1dca0b51a053323eb83a564b6c623a8a60b41f5324f60824379fd13 |
coordinate_geometry_hard_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_parallelograms(points):
def check_area(a, b, c, d):
return (b[0] - a[0])*(c[1] - a[1]) == (c[0] - a[0])*(b[1] - a[1])
n = len(points)
count = 0
for i in range(n):
for j in range(i+1, n):
for k in range(j+1, n):
for l in range(k+1, n):
... | test_failure | 3 | 15 | 15 | visible_04 | {} | 4ea0bd67828b087e45691b55fd66bc26547fa5b348e6f6f3661d667108cd98ae |
coordinate_geometry_hard_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_convex_quadrilaterals(points):
n = len(points)
if n < 4: return 0
def sign(p, q, r):
return (p[0] - r[0]) * (q[1] - r[1]) - (p[1] - r[1]) * (q[0] - r[0])
def is_convex():
for i in range(n):
p = points[(i-2)%n]
q = points[(i-1)%n]
... | runtime_exception | 0 | 0 | 15 | null | {} | e6635bc64091af6b3f1e3f38a8efc980c9789229796843450989910d40eab55d |
coordinate_geometry_medium_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def intersection_area(rect1: list[int], rect2: list[int]) -> int:
x1, y1, x2, y2 = max(min(rect1[0], rect1[2]), min(rect2[0], rect2[2])), max(min(rect1[1], rect1[3]), min(rect2[1], rect2[3])), min(max(rect1[0], rect1[2]), max(rect2[0], rect2[2])), min(max(rect1[1], rect1[3]), max(rect2[1], rect2[3]))
return (x2... | passed | 15 | 15 | 15 | null | {
"total_nloc": 3,
"comment_lines": 0,
"main_function_nloc": 3,
"halstead_volume": 64.529325013,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 3,
"max_... | 1b471adcf8c61e685893c5bec9a40bd9035551f465f912c93d5faeab8b42a913 |
coordinate_geometry_medium_002 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def rectangles_overlap(rect1: list[int], rect2: list[int]) -> bool:
return not (rect1[2] <= rect2[0] or # right side of first is left of second
rect1[3] <= rect2[1] or # top of first is below second
rect1[0] >= rect2[2] or # left side of first is right of s... | passed | 15 | 15 | 15 | null | {
"total_nloc": 5,
"comment_lines": 4,
"main_function_nloc": 5,
"halstead_volume": 77.6617939838,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 5,
"max... | fa8a74f4412818c559b023ba0b02e1acaea7d76912a39b516e13c92ff981eee7 |
coordinate_geometry_medium_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def are_circles_tangent(c1: list[int], c2: list[int]) -> bool:
x1, y1, r1 = c1
x2, y2, r2 = c2
# Calculate the distance between the centers of the circles
dist_centers = ((x1-x2)**2 + (y1-y2)**2) ** 0.5
# If the sum of radii equals to the distance between centers, they are tangent
if a... | structure_failure | null | null | 15 | null | {} | f38973e52ff8c72f739d4271a6689615ed8307a9043324cb1f4b9399fa16a06c |
coordinate_geometry_medium_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def is_isosceles_triangle(p1: list[int], p2: list[int], p3: list[int]) -> bool:
def distance(a, b):
return (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2
points = sorted([p1, p2, p3])
if points[0][0] == points[1][0] and points[0][1] == points[1][1]:
return False
dist_12 = dis... | structure_failure | null | null | 15 | null | {} | 464a0b6ae554687aeb9735cdf6f5e241df5652092d874c87d7817d88409d606c |
coordinate_geometry_medium_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def is_axis_aligned_rectangle_vertex_triple(p1: list[int], p2: list[int], p3: list[int]) -> bool:
return (p1[0] == p2[0] and p1[1] != p2[1] and p1[0] != p3[0] and p1[1] == p3[1]) or \
(p2[0] == p3[0] and p2[1] != p3[1] and p2[0] != p1[0] and p2[1] == p1[1]) or \
(p3[0] == p1[0] and p3[1] != p1... | test_failure | 0 | 15 | 15 | visible_01 | {} | 76852943d2ae54dd6e582b26181c850c08e3f3e6d727367136675a980708756a |
coordinate_geometry_medium_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def circle_strict_containment(c1: list[int], c2: list[int]) -> bool:
# Calculate distance between centers
dist = ((c1[0] - c2[0]) ** 2 + (c1[1] - c2[1]) ** 2) ** 0.5
# Check if one circle is contained within the other without touching
return c1[2] > dist + c2[2] | test_failure | 2 | 15 | 15 | visible_03 | {} | 8111cacfcef0bdd5a8c5b4001617577d2753c207a28cc43b0d8cbd9b814a5ac8 |
coordinate_geometry_medium_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def enclosing_rectangle(rect1: list[int], rect2: list[int]) -> list[int]:
return [min(rect1[0], rect2[0]), min(rect1[1], rect2[1]), max(rect1[2], rect2[2]), max(rect1[3], rect2[3])] | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 0,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max_nloc": 2,
... | dc1b3aae7bbbb5f4d586c128ee1248c396a82f300ae7d83bc65e63f075a83a1d |
counting_and_aggregation_easy_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_unique_evens(numbers):
return len({n for n in numbers if n % 2 == 0}) | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 15.5097750043,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max... | d063e99125687ae5558e16d281ad5575504ee088a7d3207b0d1b71b8b5c5f268 |
counting_and_aggregation_easy_002 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_length_three(strings: list[str]) -> int:
return sum(len(s) == 3 for s in strings) | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 4.7548875022,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max_... | 83ec8556a044b29735ad15c554172d96daf66e3a13d1319ccbb9871bee42aeb5 |
counting_and_aggregation_easy_003 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def sum_duplicates(nums):
return sum([i for i in set(nums) if nums.count(i) > 1]) * 2 | test_failure | 0 | 15 | 15 | visible_01 | {} | 5fef39c43c883e4ee1f332b182d84b15dfa57f2fa3f4b1fd790abb6ecd351943 |
counting_and_aggregation_easy_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_a_starting_chars(strings: list[str]) -> int:
return sum(sum(s.lower().startswith('a') for s in strings) for _ in range(5)) | test_failure | 0 | 15 | 15 | visible_01 | {} | 1239687b2aa91dbd28ea2a2aa727b54d21e0e5c7b78150fe73dad897ded9525b |
counting_and_aggregation_easy_006 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_strictly_increasing(nums):
return sum(x < y for x, y in zip(nums, nums[1:])) + 1 | test_failure | 10 | 15 | 15 | hidden_06 | {} | 5b80318c839c64812dc858623da6eacd0c494429269bd395feb4953d3d1949ab |
counting_and_aggregation_easy_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_common_vowels(strings):
vowels = set('aeiouAEIOU')
return sum(any(c in s for c in vowels) for s in strings) - len(set.intersection(*map(set, map(str.lower, strings)))) | test_failure | 0 | 15 | 15 | visible_01 | {} | cd389fe92d786d80e8dc02a36fef85f092b02daf2ebb8c52c9b1880b378d12fa |
counting_and_aggregation_easy_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_strings_with_repeats(strings):
return sum(any(s.count(c) > 1 for c in s) for s in strings) | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 4.7548875022,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 2,
"max_... | 9237411861e9ed3b0155921044cde9fbf0a1b5f4bff102bbcfd58183d519b270 |
counting_and_aggregation_easy_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def count_total_e(strings: list[str]) -> int:
return sum(sum(s.lower().count('e') for s in strings)) | runtime_exception | 0 | 0 | 15 | null | {} | 178e2c4e6d52a858d1c2e8a4235ccffdd3f594cb4c3711fa089102b926983f79 |
counting_and_aggregation_easy_010 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def unique_long_strings(strings):
return sorted([s for s in set(strings) if strings.count(s) == 1 and len(s) > 3]) | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 28.529325013,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 2,
"max_... | 6b6d539c40c3a89ea5d96a561605d01cce2f5117cc77fb6f4b65f5aca1167790 |
counting_and_aggregation_hard_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from math import sqrt
def keys_with_prime_aggregate_sum(dicts):
def check_prime(n):
if n < 2: return False
for i in range(2, int(sqrt(n)) + 1):
if n % i == 0: return False
return True
keys = set()
for d in dicts:
keys.update(d.keys())
result = []... | passed | 15 | 15 | 15 | null | {
"total_nloc": 16,
"comment_lines": 0,
"main_function_nloc": 10,
"halstead_volume": 41.5131794236,
"function_count": 2,
"internal_call_links": 1,
"call_graph_depth": 1,
"coupling_density": 0.5,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 4,
"mean_nloc": 7.5,
"... | 85f484bdc3e3557e988dba8ff7e06b22beb01794857c58304a12bd84f007cce6 |
counting_and_aggregation_hard_002 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def common_bigrams(strings):
from collections import Counter
# Create a list of bigrams for each string and count their occurrences
counts = Counter(s[i:i+2] for s in strings for i in range(len(s)-1))
# Filter out the bigrams that appear less than 3 times
common_bigrams = [k for k, v in co... | test_failure | 12 | 15 | 15 | hidden_08 | {} | 970bf1e713f6360c83a3ca8b4e5e1b262ece5d7e10f27c7ede2aa1ac7b9ecafd |
counting_and_aggregation_hard_003 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def find_common_maxima(lists):
from collections import Counter
maxes = []
for lst in lists:
if not lst: continue
maxes.append(max(lst))
counts = Counter(maxes)
return sorted([num for num, count in counts.items() if count > 1]) | passed | 15 | 15 | 15 | null | {
"total_nloc": 8,
"comment_lines": 0,
"main_function_nloc": 8,
"halstead_volume": 11.6096404744,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 2,
"mean_nloc": 8,
"max... | 28438acc6ffcaba94a05cae84647cbfb4bda7b52a575180b233b0b2c9f3c2c22 |
counting_and_aggregation_hard_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def unique_single_odds_in_multiple_sublists(lists):
odd_counts = {}
for sublist in lists:
if not sublist: continue
for num in set(sublist):
if num % 2 == 1:
odd_counts[num] = odd_counts.get(num, 0) + 1
return sorted([num for num, cou... | test_failure | 4 | 15 | 15 | visible_05 | {} | 9b9f5ef354cc811c430599f202b8a71e4ebb0e66fe65b3d4271c45288be458bd |
counting_and_aggregation_hard_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def find_common_minimums(lists):
from collections import Counter
min_count = Counter()
for sublist in lists:
if not sublist: continue
minimum = min(sublist)
min_count[minimum] += 1
common_min = [num for num, count in min_count.items() if count >= 3]
return ... | passed | 15 | 15 | 15 | null | {
"total_nloc": 9,
"comment_lines": 0,
"main_function_nloc": 9,
"halstead_volume": 24,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 9,
"max_nloc": 9,
... | b5f6edae137d003528f23b562798d39b4020c7e9058e3037e022ae7b066bb573 |
counting_and_aggregation_hard_006 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def indices_with_common_values(lists):
common = set()
for i in range(len(lists[0])):
values = [sublist[i] if len(sublist) > i else None for sublist in lists]
if all(v == values[0] for v in values[1:]):
common.add(values[0])
return sorted(common) | test_failure | 0 | 15 | 15 | visible_01 | {} | 7236aa1ff8b44edb5839ffa944d8ff61e034f2874dbb7e9470f8ed3a9e3ff805 |
counting_and_aggregation_hard_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from math import gcd
from functools import reduce
def gcds_in_multiple_sublists(data):
# Filter out empty sublists and flatten the list of lists
data = [num for sublist in data for num in sublist if sublist]
# Create a dictionary to count occurrences of each number
counts = {}
for i in range(le... | test_failure | 0 | 15 | 15 | visible_01 | {} | 227640cf24d0b730d3c3bfe761a2797350bd80189800574cfdd8930f2829534e |
counting_and_aggregation_hard_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from collections import Counter
def find_modes_in_sublists(sublists):
modes = []
counts = Counter()
for sublist in sublists:
if not sublist: continue # Skip empty lists
counter = Counter(sublist)
max_count = max(counter.values())
if max_count > 1 and (not count... | structure_failure | null | null | 15 | null | {} | aaa15cc2e6fcb337868aff74220f0492d527fec678fbaa889b322c985051e090 |
counting_and_aggregation_hard_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def unique_minimums_in_three_sublists(lists):
counts = {}
for sublist in lists:
if sublist: # ignore empty sublists
min_val = min(sublist)
if min_val not in counts:
counts[min_val] = 1
else:
counts[min_val] += 1
return sorted([k for... | test_failure | 4 | 15 | 15 | visible_05 | {} | 57dafb2490ec30b939b57edbeef197dcc56b0406d47ef40cf9e282d20311e72b |
counting_and_aggregation_hard_010 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def unique_maximums_at_least_three(lists):
from collections import Counter
maxes = []
for sublist in lists:
if sublist: # ignore empty sublists
maxes.append(max(sublist))
counts = Counter(maxes)
return sorted([num for num, count in counts.items() if count >= 3]) | test_failure | 4 | 15 | 15 | visible_05 | {} | e443467b88722cd944f1c8e1cbbf29a189aa23f3aa491885339aa61f360976c4 |
counting_and_aggregation_medium_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def common_characters(strings):
return sorted(set(''.join(strings)).intersection(*map(set, strings))) | test_failure | 1 | 15 | 15 | visible_02 | {} | b3753dd8460d97c303cfc7ddb00c6c5db9b062f84d0d5ddd99bdd63eb76e2762 |
counting_and_aggregation_medium_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from collections import Counter
import math
def common_in_half_lists(nested):
# Flatten the list and count occurrences of each integer
counts = Counter(num for sublist in nested for num in sublist)
# Filter out integers that appear less than halfway through all lists
result = [num for num, count i... | passed | 15 | 15 | 15 | null | {
"total_nloc": 6,
"comment_lines": 3,
"main_function_nloc": 4,
"halstead_volume": 15.5097750043,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 4,
"max... | aed8c136dc576e876b243879de8db80d0ac851ba1151b0d1ea372e40682e06e7 |
counting_and_aggregation_medium_006 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def second_largest_in_multiple_sublists(lists):
second_maxes = set()
for sublist in lists:
if len(set(sublist)) < 2: continue # ignore sublists with fewer than two unique values
max1, max2 = float('-inf'), float('-inf')
for num in sublist:
if num > max1:
max1... | structure_failure | null | null | 15 | null | {} | 48ae59a8d87c4c7d1a4fc73d91d2a870ca97f5e210981599d1ae044c2a00e1e9 |
counting_and_aggregation_medium_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def medians_in_multiple_sublists(lists):
from collections import Counter
# Flatten and filter out empty lists
flat = [num for sublist in lists if sublist for num in sublist]
# Calculate the median of each list
medians = []
for lst in lists:
if not lst: continue # Skip empty li... | structure_failure | null | null | 15 | null | {} | 5b895f1c2c3e9c8fa5c243589f8fc26c70369037183cc834673340b832482033 |
counting_and_aggregation_medium_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from collections import Counter
def most_frequent_in_multiple_sublists(data):
counts = Counter()
for sublist in data:
if not sublist: continue
local_counts = Counter(sublist)
max_local_count = max(local_counts.values())
most_frequent = [k for k, v in local_counts.items() if v == ... | structure_failure | null | null | 15 | null | {} | a0655a1eee2be8e48be5242b95105f7c6d6c673146eb03dbdc8b9b0c6704b081 |
counting_and_aggregation_medium_010 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def common_index_value(lists):
if any('' in sublist for sublist in lists):
raise ValueError("Empty sublists are not allowed")
min_len = min([len(sublist) for sublist in lists])
common_elements = set()
for i in range(min_len):
current_element = [sublist[i] for sublist in lists if len... | structure_failure | null | null | 15 | null | {} | 3c8057dfdf70cc53a06789691bdb19a7fd364c60a000782a99b6ce5f1f86eb36 |
date_and_time_easy_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime
def get_weekday(date_str: str) -> str:
date = datetime.strptime(date_str, '%Y-%m-%d')
return date.strftime('%A') | passed | 15 | 15 | 15 | null | {
"total_nloc": 4,
"comment_lines": 0,
"main_function_nloc": 3,
"halstead_volume": 0,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 3,
"max_nloc": 3,
... | 50c64cb8904560c316b7f93854464464bd82a5366634a414b3038623b21124a9 |
date_and_time_easy_002 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime
def days_between_dates(date1: str, date2: str) -> int:
d1 = datetime.strptime(date1, '%Y-%m-%d')
d2 = datetime.strptime(date2, '%Y-%m-%d')
return (d2 - d1).days | passed | 15 | 15 | 15 | null | {
"total_nloc": 5,
"comment_lines": 0,
"main_function_nloc": 4,
"halstead_volume": 4.7548875022,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 4,
"max_... | c66beb9046a2406527387a9a86272b771b8473ae504d478f696b4e4bacc021c6 |
date_and_time_easy_003 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def seconds_to_time_string(seconds: int) -> str:
hours = seconds // 3600
minutes = (seconds % 3600) // 60
secs = seconds % 60
return f"{hours:02d}:{minutes:02d}:{secs:02d}" | passed | 15 | 15 | 15 | null | {
"total_nloc": 5,
"comment_lines": 0,
"main_function_nloc": 5,
"halstead_volume": 31.0195500087,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 5,
"max... | f1c77668f6b9ced1fba79a240851dc39f62598d62236e2951853939f7f856d87 |
date_and_time_easy_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime
def is_weekend(date_str: str) -> bool:
date = datetime.strptime(date_str, '%Y-%m-%d')
return date.weekday() > 4 # 5 and 6 are Saturday and Sunday respectively | passed | 15 | 15 | 15 | null | {
"total_nloc": 4,
"comment_lines": 1,
"main_function_nloc": 3,
"halstead_volume": 4.7548875022,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 3,
"max_... | cf906e93c76eb3c4803f68a2e9f1dfdc98b0bde93af42fe6df2b5b8eb35b915e |
date_and_time_easy_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime
def is_last_day_of_month(date_str: str) -> bool:
date = datetime.strptime(date_str, '%Y-%m-%d')
next_month = (date.year + (date.month % 12 + 1)) * 100 + ((date.month // 12 + 1) % 12 or 12)
return date.day == (datetime(next_month // 100, next_month % 100, 1) - datetime(1970, 1,... | test_failure | 1 | 15 | 15 | visible_02 | {} | b7e1a1819eadfd51339fade9dbaccd8a9fed392d5e22ad3dd765b094f7993183 |
date_and_time_easy_006 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def is_on_the_hour(time_str: str) -> bool:
return time_str[-3:] == ':00' | passed | 15 | 15 | 15 | null | {
"total_nloc": 2,
"comment_lines": 0,
"main_function_nloc": 2,
"halstead_volume": 11.6096404744,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 2,
"max... | 1e743b7adebb5c95f24b4865fd419f4a51b8ce4daec06007f1de9c5313bd1147 |
date_and_time_easy_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime
def days_in_month(date_str: str) -> int:
date = datetime.strptime(date_str, '%Y-%m-%d')
if date.year % 4 == 0 and (date.year % 100 != 0 or date.year % 400 == 0): # Check for leap year
return [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][date.month - 1]
else:
... | structure_failure | null | null | 15 | null | {} | 11010fc3b75a2e2ccf52e74c8b34227d1b6d765da99a8714306362117861ea2c |
date_and_time_easy_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | def minutes_since_midnight(time_str: str) -> int:
hh, mm = map(int, time_str.split(':'))
return hh * 60 + mm | passed | 15 | 15 | 15 | null | {
"total_nloc": 3,
"comment_lines": 0,
"main_function_nloc": 3,
"halstead_volume": 15.5097750043,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 1,
"mean_nloc": 3,
"max... | 022c68af03855d63027ae8d97c83e1bc69a9b4926222aae99daec60de439c6b8 |
date_and_time_easy_009 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime
def is_first_day_of_month(date_str: str) -> bool:
date = datetime.strptime(date_str, '%Y-%m-%d') # Convert string to datetime object
return date.day == 1 # Check if the day of month is 1 | passed | 15 | 15 | 15 | null | {
"total_nloc": 4,
"comment_lines": 2,
"main_function_nloc": 3,
"halstead_volume": 4.7548875022,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 0,
"mean_nloc": 3,
"max_... | 79e45bec0c2c6d856d402abbb88052957a58681aa3f00860c5e30d2c773ca224 |
date_and_time_hard_001 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime, timedelta
def count_unique_days(intervals):
# Convert string dates to datetime objects and sort them
dates = sorted([[datetime.strptime(date, '%Y-%m-%d') for date in interval] for interval in intervals])
# Flatten the list of lists into a single list
dates = [date fo... | structure_failure | null | null | 15 | null | {} | e2942206e04ec46c92b955b1ce568edd3a6fb24c561785abd678e83f479dd30c |
date_and_time_hard_003 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime as dt
def count_unique_seconds(intervals):
if len(intervals) == 0: return 0
# Convert the strings to datetime objects and sort them
intervals = sorted([[dt.strptime(i, '%Y-%m-%d %H:%M:%S') for i in interval] for interval in intervals])
# Initialize variables
t... | structure_failure | null | null | 15 | null | {} | 04e55ff4f492627bdf69f765e12b97fcea04ab4f116435b948c64f010e3e0d7b |
date_and_time_hard_004 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime as dt, timedelta as td
def count_date_blocks(intervals):
if not intervals: return 0
dates = sorted([[dt.strptime(d, '%Y-%m-%d') for d in i] for i in intervals])
merged = [dates[0]]
for curr in dates[1:]:
prev = merged[-1]
if curr[0] <= prev[1] + td(days=1):
... | structure_failure | null | null | 15 | null | {} | 07f246be40c0a171bd547f253f67ba6365db71b8666e9fd9ac6f63ec9cbd993a |
date_and_time_hard_005 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime as dt, timedelta as td
def merge_datetime_intervals(intervals):
if not intervals: return []
intervals = sorted([[dt.strptime(i, '%Y-%m-%d %H:%M:%S') for i in interval] for interval in intervals])
res = [intervals[0]]
for curr_start, curr_end in intervals[1:]:
prev_s... | structure_failure | null | null | 15 | null | {} | 91b8a37feec1477007c40a8f715a37961fceea8e9a5d295bdb058f0cef3ce26d |
date_and_time_hard_006 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime as dt, timedelta as td
def dates_with_minimum_overlap(intervals: list[list[str]], n: int) -> list[str]:
if not intervals: return []
# Convert string to date and sort the intervals by start time
sorted_intervals = sorted(((dt.strptime(start, '%Y-%m-%d'), dt.strptime(end, '... | structure_failure | null | null | 15 | null | {} | 0bce9fecd383b78ae17464791dfda2b6f3c747e8096e7dac3c2c2c99356b5df6 |
date_and_time_hard_007 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime, timedelta
def earliest_friday_13th(dates: list[str]) -> str | None:
dates = sorted([datetime.strptime(date, '%Y-%m-%d') for date in dates if datetime.strptime(date, '%Y-%m-%d').day == 13 and datetime.strptime(date, '%Y-%m-%d').weekday() == 4])
return None if not dates else dates[... | passed | 15 | 15 | 15 | null | {
"total_nloc": 4,
"comment_lines": 0,
"main_function_nloc": 3,
"halstead_volume": 36.5412090438,
"function_count": 1,
"internal_call_links": 0,
"call_graph_depth": 0,
"coupling_density": null,
"recursive_groups": 0,
"self_calling_functions": 0,
"unresolved_call_count": 2,
"mean_nloc": 3,
"max... | 02d9037306ed8c31045fa07cdd6b3cb37617958afaec9404eb1fef45c4904341 |
date_and_time_hard_008 | DeepSeek-Coder 6.7B | small | deepseek-coder:6.7b | baseline | from datetime import datetime as dt, timedelta as td
def longest_covered_block(intervals):
if not intervals: return None
intervals = sorted([[dt.strptime(d, '%Y-%m-%d') for d in interval] for interval in intervals])
start, end = min(intervals, key=lambda x:x[0])[0], max(intervals, key=lambda x:x[1])[1]
... | structure_failure | null | null | 15 | null | {} | 768f4b6557a241e10ed8b6fb632830f7e5e1c4fd1e5319125cf584509ff06e46 |
End of preview. Expand in Data Studio
LLM Code Complexity Model Predictions
This dataset contains 7,360 final predictions: ten model variants, each answering the same 368 frozen tasks under baseline and guided conditions. data/predictions.jsonl is the browsable table. Each row has the generated code, execution status, available test summary, raw structural metrics, and a saved-response SHA-256. Test counts are null when the saved result did not execute tests, for example after extraction failure. source_results/ preserves the original JSONL result records for nine runs, while raw_responses/ contains compressed original response files for all ten runs. Separate hosted-model prompts are in raw_requests/. Mellum's final task measurements are represented in the normalized table; its raw response files are also archived. audit/ holds the saved ten-model combined analysis and Mellum manifest/verification. manifest.json lists counts and hashes.
The benchmark task specifications, tests, and reference metrics are in the companion public benchmark dataset. The code is in the code-complexity repository. audit/frozen_source_at_original_commit.zip preserves the original source and prompt files used for the saved runs. The reported guided run's archived requests contain three numbered guidance points; a later four-point text file did not produce these saved predictions. Do not infer functional correctness from a static score alone. Model outputs can contain invalid code or failed tests.
The task specifications and reference solutions are public in the companion benchmark dataset. The archived records document the reported results; users should verify any downstream claims independently.
Validation and correction records
The audit/ folder includes the pre-freeze test-correction review and exclusion decision, the final reference validation summary, and the model evaluation audit. These records document work that may be more detailed than the thesis. The pre-freeze review retained 373 of 426 reviewed tasks after validated test corrections and exclusions; the final structural check retained 368. The earlier unresolved cases were excluded, not counted as confirmed reference failures. test_correction_decisions.zip contains the per-task review and before/after test changes. reference_validation_decisions.zip contains the final reference checks and exclusions.
- Downloads last month
- 17