Update parquet files

README.md

@@ -1,101 +0,0 @@
----
-dataset_info:
-- config_name: dublin_data
-  features:
-  - name: submission_id
-    dtype: int32
-  - name: func_code
-    dtype: string
-  - name: assignment_id
-    dtype: string
-  - name: func_name
-    dtype: string
-  - name: description
-    dtype: string
-  - name: test
-    dtype: string
-  - name: user
-    dtype: string
-  - name: academic_year
-    dtype: int32
-  splits:
-  - name: train
-    num_bytes: 3659009
-    num_examples: 6117
-  - name: test
-    num_bytes: 6442216
-    num_examples: 9885
-  download_size: 12774289
-  dataset_size: 10101225
-- config_name: singapore_data
-  features:
-  - name: submission_id
-    dtype: int32
-  - name: func_code
-    dtype: string
-  - name: assignment_id
-    dtype: string
-  - name: func_name
-    dtype: string
-  - name: description
-    dtype: string
-  - name: test
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 5098378
-    num_examples: 4394
-  download_size: 5705043
-  dataset_size: 5098378
-- config_name: dublin_repair
-  features:
-  - name: submission_id
-    dtype: int32
-  - name: func_code
-    dtype: string
-  - name: assignment_id
-    dtype: string
-  - name: func_name
-    dtype: string
-  - name: description
-    dtype: string
-  - name: test
-    dtype: string
-  - name: annotation
-    dtype: string
-  - name: user
-    dtype: string
-  - name: academic_year
-    dtype: int32
-  splits:
-  - name: train
-    num_bytes: 234628
-    num_examples: 307
-  - name: test
-    num_bytes: 1479344
-    num_examples: 1698
-  download_size: 2137031
-  dataset_size: 1713972
-- config_name: singapore_repair
-  features:
-  - name: submission_id
-    dtype: int32
-  - name: func_code
-    dtype: string
-  - name: assignment_id
-    dtype: string
-  - name: func_name
-    dtype: string
-  - name: description
-    dtype: string
-  - name: test
-    dtype: string
-  - name: annotation
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 18979
-    num_examples: 18
-  download_size: 21737
-  dataset_size: 18979
----

data/singapore_repair_train.jsonl

@@ -1,18 +0,0 @@
-{"submission_id":4270,"assignment_id":5,"func_code":"def top_k(lst, k):\n    result = []\n    while k >= 0:\n        big = max(lst)\n        result.append(big)\n        lst.remove(big)\n        k -= 1\n    return result\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    result = []\n    while k > 0:\n        big = max(lst)\n        result.append(big)\n        lst.remove(big)\n        k -= 1\n    return result\n","comments":"# KC# wrong operand \/ wrong number of iterations"}
-{"submission_id":4271,"assignment_id":5,"func_code":"def top_k(lst, k):\n    lst_res = lst\n    sort = []\n    while lst_res:\n        largest = lst_res[0]\n        for elements in lst_res:\n            if element > largest:\n                largest = element\n        lst_res.remove(largest)\n        sort.append(largest)\n    return sort[:k]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    lst_res = lst\n    sort = []\n    while lst_res:\n        largest = lst_res[0]\n        for element in lst_res:\n            if element > largest:\n                largest = element\n        lst_res.remove(largest)\n        sort.append(largest)\n    return sort[:k]\n","comments":"# typo"}
-{"submission_id":4272,"assignment_id":5,"func_code":"def top_k(lst, k):\n    tmp = []\n    while len(lst) > 0:\n        tmp.append(max(lst))\n        lst.remove(max(lst))\n    return tmp[:5]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    tmp = []\n    while len(lst) > 0:\n        tmp.append(max(lst))\n        lst.remove(max(lst))\n    return tmp[:k]\n","comments":"# typo"}
-{"submission_id":4273,"assignment_id":5,"func_code":"def top_k(lst, k):\n    sort = []\n    while lst: \n        biggest = lst[0]\n        for element in lst:\n            if ele > biggest:\n                biggest = ele\n                \n        lst.remove(element)\n        sort.append(element)\n        if len(sort)==k:\n            break\n    return sort\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    sort = []\n    while lst and k:\n        biggest = lst[0]\n        for element in lst:\n            if element > biggest:\n                biggest = element\n        lst.remove(biggest)\n        sort.append(biggest)\n        if len(sort) == k:\n            break\n    return sort\n","comments":"# wrong variable usage# missing input case"}
-{"submission_id":4274,"assignment_id":5,"func_code":"def top_k(lst, k):\n    sort = []\n    while lst: \n        biggest = lst[0]\n        for element in lst:\n            if element > biggest:\n                biggest = element\n                \n        lst.remove(element)\n        sort.append(element)\n        if len(sort)==k:\n            break\n    return sort\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    sort = []\n    while lst and k:\n        biggest = lst[0]\n        for element in lst:\n            if element > biggest:\n                biggest = element\n        lst.remove(biggest)\n        sort.append(biggest)\n        if len(sort) == k:\n            break\n    return sort\n","comments":"# wrong variable usage# missing input case"}
-{"submission_id":4275,"assignment_id":5,"func_code":"def top_k(lst, k):\n    sort = []\n    while lst: \n        biggest = lst[0]\n        for element in lst:\n            if element > biggest:\n                biggest = element\n                \n        lst.remove(biggest)\n        sort.append(biggest)\n        if len(sort)==k:\n            break\n    return sort\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    sort = []\n    while lst and k:\n        biggest = lst[0]\n        for element in lst:\n            if element > biggest:\n                biggest = element\n        lst.remove(biggest)\n        sort.append(biggest)\n        if len(sort) == k:\n            break\n    return sort\n","comments":""}
-{"submission_id":4276,"assignment_id":5,"func_code":"def top_k(lst, k):\n    lst1 = []\n    for i in lst:\n        if i >= k:\n            lst1.append(i) \n    sort = []\n    while lst1: \n        biggest = lst[0]\n        for element in lst1:\n            if element > biggest:\n                biggest = element\n        lst1.remove(biggest)\n        sort.append(biggest)\n    return sort\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    sort = []\n    while lst and k > 0:\n        biggest = lst[0]\n        for element in lst:\n            if element > biggest:\n                biggest = element\n        lst.remove(biggest)\n        sort.append(biggest)\n        k -= 1\n    return sort\n","comments":"# wrong-strategy# missing input case handling"}
-{"submission_id":4277,"assignment_id":5,"func_code":"def top_k(lst, k):\n    sort = []\n    while lst: \n        biggest = lst[0]\n        for element in lst:\n            if element > biggest:\n                biggest = element\n        lst.remove(biggest)\n        sort.append(biggest)\n    return sort[:k+1]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    sort = []\n    while lst:\n        biggest = lst[0]\n        for element in lst:\n            if element > biggest:\n                biggest = element\n        lst.remove(biggest)\n        sort.append(biggest)\n    return sort[:k]\n","comments":""}
-{"submission_id":4278,"assignment_id":5,"func_code":"def top_k(lst, k):\n    n = len(lst) - k\n    counter = 0\n    while counter < k:\n        lst.remove(min(lst))\n        counter = counter + 1\n    sort_list = []\n    while lst != []:\n        sort_lst.append(max(lst))\n        lst.remove(max(lst))\n    return sort_list\n    \n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    n = len(lst) - k\n    counter = 0\n    while counter < n:\n        lst.remove(min(lst))\n        counter = counter + 1\n    sort_list = []\n    while lst != []:\n        sort_list.append(max(lst))\n        lst.remove(max(lst))\n    return sort_list\n","comments":"# wrong variable usage"}
-{"submission_id":4279,"assignment_id":5,"func_code":"def top_k(lst, k):\n    n = len(lst) - k\n    counter = 0\n    while counter < k:\n        lst.remove(min(lst))\n        counter = counter + 1\n    sort_list = []\n    while lst != []:\n        sort_list.append(max(lst))\n        lst.remove(max(lst))\n    return sort_list\n    \n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    n = len(lst) - k\n    counter = 0\n    while counter < n:\n        lst.remove(min(lst))\n        counter = counter + 1\n    sort_list = []\n    while lst != []:\n        sort_list.append(max(lst))\n        lst.remove(max(lst))\n    return sort_list\n","comments":"# wrong variable usage"}
-{"submission_id":4287,"assignment_id":5,"func_code":"def top_k(lst, k):\n    # Fill in your code here\n    sort = []\n    while lst: # a is not []\n        largest = lst[0]\n        for element in lst:\n            if element > largest:\n                largest = element\n        lst.remove(largest)\n        sort.append(largest)\n    return sort[:k+1]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    sort = []\n    while lst:\n        biggest = lst[0]\n        for element in lst:\n            if element > biggest:\n                biggest = element\n        lst.remove(biggest)\n        sort.append(biggest)\n    return sort[:k]\n","comments":""}
-{"submission_id":4281,"assignment_id":5,"func_code":"def top_k(lst, k):\n    \n    if lst == []:\n        return lst\n    \n    lower = []\n    higher = []\n    plist = []\n    \n    pivot = lst[0]\n    for e in lst:\n        if e < pivot:\n            lower.append(e)\n        if x == pivot:\n            plist.append(e)\n        if x > pivot:\n            higher.append(e)\n    sort_list = lower + plist + higher\n    \n    return sort_list[:k]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"","comments":"# KC# complex strategy# partial solution"}
-{"submission_id":4282,"assignment_id":5,"func_code":"def top_k(lst, k):\n    \n    if lst == []:\n        return lst\n    \n    lower = []\n    higher = []\n    plist = []\n    \n    pivot = lst[0]\n    for e in lst:\n        if e < pivot:\n            lower.append(e)\n        if x == pivot:\n            plist.append(e)\n        if x > pivot:\n            higher.append(e)\n    sort_list = higher + plist + lower\n    \n    return sort_list[:k]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"","comments":"# KC# complex strategy# partial solution"}
-{"submission_id":4283,"assignment_id":5,"func_code":"def top_k(lst, k):\n    \n    if lst == []:\n        return lst\n    \n    lower = []\n    higher = []\n    plist = []\n    \n    pivot = lst[0]\n    for e in lst:\n        if e < pivot:\n            lower.append(e)\n        if e == pivot:\n            plist.append(e)\n        if e > pivot:\n            higher.append(e)\n    sort_list = higher + plist + lower\n    \n    return sort_list[:k]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"","comments":"# KC# complex strategy# partial solution"}
-{"submission_id":4284,"assignment_id":5,"func_code":"def top_k(lst, k):\n    \n    if lst == []:\n        return lst\n    \n    lower = []\n    higher = []\n    plist = []\n    \n    pivot = lst[0]\n    for e in lst:\n        if e < pivot:\n            lower.append(e)\n        if e == pivot:\n            plist.append(e)\n        if e > pivot:\n            higher.append(e)\n    sort_list = lower + plist + higher\n    sort_list = sort_list[::-1]\n    \n    return sort_list[:k]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"","comments":"# KC# complex strategy# partial solution"}
-{"submission_id":4285,"assignment_id":5,"func_code":"def top_k(lst, k):\n    \n    if lst == []:\n        return lst\n    \n    lower = []\n    higher = []\n    plist = []\n    \n    pivot = lst[0]\n    for e in lst:\n        if e < pivot:\n            lower.append(e)\n        if e == pivot:\n            plist.append(e)\n        if e > pivot:\n            higher.append(e)\n    sort_list = lower + plist + higher\n    sort_list = sort_list[::-1]\n    \n    if k == len(lst):\n        return sort_list[:k-1]\n    elif k > len(lst):\n        return sort_list\n    else:\n        return sort_list[:k]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"","comments":"# KC# complex strategy# partial solution"}
-{"submission_id":4286,"assignment_id":5,"func_code":"def top_k(lst, k):\n    result = []\n    while lst:\n        biggest = lst[0]\n        for number in lst:\n            if number > biggest:\n                biggest = number\n        lst.remove(biggest)\n        result.append(oldest)\n    return result[:k]\n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    result = []\n    while lst:\n        biggest = lst[0]\n        for number in lst:\n            if number > biggest:\n                biggest = number\n        lst.remove(biggest)\n        result.append(biggest)\n    return result[:k]\n","comments":"# wrong variable usage"}
-{"submission_id":4291,"assignment_id":5,"func_code":"def top_k(lst, k):\n    rs=[]\n    for qwerty in range(0,k):\n        biggest=lst[0]\n        for k in lst:\n            if biggest<k:\n                biggest=k\n        rs.append[biggest]\n        lst.remove[biggest]\n    return r\n        \n","func_name":"top_k","test":"import heapq\nassert top_k([9, 9, 4, 9, 7, 9, 3, 1, 6], 5)==[9, 9, 9, 9, 7] and top_k([9, 8, 4, 5, 7, 2, 3, 1, 6], 5)==[9, 8, 7, 6, 5] and top_k([4, 5, 2, 3, 1, 6], 6)==[6, 5, 4, 3, 2, 1] and top_k([4, 5, 2, 3, 1, 6], 3)==[6, 5, 4] and top_k([4, 5, 2, 3, 1, 6], 0)==[]","description":"Task: Top-K\n\n\nWrite a function top_k that accepts a list of integers as the input and returns the greatest\nk number of values as a list, with its elements sorted in descending order. You may use\nany sorting algorithm you wish, but you are not allowed to use sort and sorted.","annotation":"def top_k(lst, k):\n    rs = []\n    for qwerty in range(0, k):\n        biggest = lst[0]\n        for k in lst:\n            if biggest < k:\n                biggest = k\n        rs.append(biggest)\n        lst.remove(biggest)\n    return rs\n","comments":"# KC # wrong variable usage"}

dublin_data/intro_prog-test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67d38b7cb3c3b1d50b292804c0652fda915df45d278e62e8cf21686d98d10b09
+size 319572

dublin_data/intro_prog-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ecdfa2cb6048dbedb1d2d7dbe4ddfb7ee7710c131d41666d5b1d6b782df2133
+size 213134

dublin_repair/intro_prog-test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b6c26f93bceb2efad605169bb5021d9e4512a3651bab93e3eb5b1b6362f929c
+size 69128

dublin_repair/intro_prog-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05dc59506deff9a908b77a2e0c3ece21e5ae026a10906e762aabfd326c83cfca
+size 23910

intro_prog.py

@@ -1,133 +0,0 @@
-# coding=utf-8
-# Copyright 2023 Charles Koutcheme
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-import json
-import datasets
-from itertools import product
-
-
-_DESCRIPTION = """
-Intro Programming. A dataset of open student submissions to programming assignments.
-
-"""
-
-_DUBLIN_URLS = {
-    "data": {
-        "train": f"./data/dublin_data_train.jsonl",
-        "test": f"./data/dublin_data_test.jsonl",
-    },
-    "repair": {
-        "train": f"./data/dublin_repair_train.jsonl",
-        "test": f"./data/dublin_repair_test.jsonl",
-    }
-}
-
-_SINGAPORE_URLS = {
-     "data": {
-        "train": f"./data/singapore_data_train.jsonl",
-    },
-    "repair": {
-        "train": f"./data/singapore_repair_train.jsonl",
-    }
-}
-
-_URLS = {
-    "dublin": _DUBLIN_URLS,
-    "singapore": _SINGAPORE_URLS
-}
-
-class IntroProgConfig(datasets.BuilderConfig):
-    """ BuilderConfig for StaQC."""
-
-    def __init__(self, **kwargs):
-        """BuilderConfig for StaQC.
-        Args:
-          **kwargs: keyword arguments forwarded to super.
-
-        """
-        super(IntroProgConfig, self).__init__(**kwargs)
-
-
-class IntroProg(datasets.GeneratorBasedBuilder):
-
-    VERSION = datasets.Version("1.0.0")
-
-    # splits "data", "repair", "bugs"
-    # also add here the "metadata" split which will also contain the full metadata 
-    tasks = [("data", "Submissions to the programming assignments."),
-             ("repair", "Buggy programs and ground truth repair(s)."),]
-             # ("bug", "Buggy programs and bug categories.")]
-    
-    sources = ["dublin", "singapore"]
-
-    BUILDER_CONFIGS = []
-    for (task, description), source in product(tasks, sources):
-        BUILDER_CONFIGS.append(
-            IntroProgConfig(
-                name=f"{source}_{task}",
-                description=description,
-                version=VERSION,          
-            )
-        )
-
-
-    def _info(self):
-        
-        features = datasets.Features({
-            "submission_id": datasets.Value("int32"),
-            "func_code": datasets.Value("string"),
-            
-            # assignment information
-            "assignment_id": datasets.Value("string"),
-            "func_name": datasets.Value("string"),
-            "description": datasets.Value(dtype='string'),
-            "test": datasets.Value(dtype='string'),
-        })
-
-        if self.config.name.split("_")[1] == "repair":
-            features["annotation"] = datasets.Value("string")
-        if self.config.name.split("_")[1] == "bug":
-            features["comments"] = datasets.Value("string")
-
-        if self.config.name.split("_")[0] == "dublin":
-            features["user"] = datasets.Value("string")
-            features["academic_year"] = datasets.Value('int32')
-
-        return datasets.DatasetInfo(
-                description=_DESCRIPTION,
-                features=features,
-                supervised_keys=None,
-            )
-    
-
-    def _split_generators(self, dl_manager: datasets.DownloadManager):
-        source, task = self.config.name.split("_")
-        urls = _URLS[source][task]
-        downloaded_files = dl_manager.download_and_extract(urls)
-
-        splits = []
-        for name, files in downloaded_files.items():
-            splits.append(datasets.SplitGenerator(name=name, gen_kwargs={"filepath": files}))
- 
-        return splits 
-
-    def _generate_examples(self, filepath):
-        with open(filepath, "r") as f:
-            lines = f.read().splitlines()
-            for key, line in enumerate(lines):
-                d = json.loads(line)
-                d = {k:v for k, v in d.items() if k in self.info.features}
-                yield key, d 

singapore_data/intro_prog-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:290358eb51e7ed4f11767e1fa3e35f52fb440ddfd8f07d597826206cc7b748d0
+size 268091

singapore_repair/intro_prog-train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da0452041d5c6bcf4c17556ad1f2a56d94d1aaa82b504d23127edf257eb82f80
+size 10967