Upload 8 files

README.md

@@ -1,103 +1,101 @@
 ---
-# For reference on model card metadata, see the spec: https://github.com/huggingface/hub-docs/blob/main/datasetcard.md?plain=1
-# Doc / guide: https://huggingface.co/docs/hub/datasets-cards
-{}
+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
 ---
-
-# Dataset Card for "intro_prog"
-
-## Dataset Description
-
-- **Homepage:** 
-- **Repository:** 
-- **Paper:** 
-- **Leaderboard:** 
-- **Point of Contact:** 
-
-### Dataset Summary
-
-This dataset card aims to be a base template for new datasets. It has been generated using [this raw template](https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/datasetcard_template.md?plain=1).
-
-### Supported Tasks and Leaderboards
-
-[More Information Needed]
-
-### Languages
-
-[More Information Needed]
-
-## Dataset Structure
-
-### Data Instances
-
-[More Information Needed]
-
-### Data Fields
-
-[More Information Needed]
-
-### Data Splits
-
-[More Information Needed]
-
-## Dataset Creation
-
-### Curation Rationale
-
-[More Information Needed]
-
-### Source Data
-
-#### Initial Data Collection and Normalization
-
-[More Information Needed]
-
-#### Who are the source language producers?
-
-[More Information Needed]
-
-### Annotations
-
-#### Annotation process
-
-[More Information Needed]
-
-#### Who are the annotators?
-
-[More Information Needed]
-
-### Personal and Sensitive Information
-
-[More Information Needed]
-
-## Considerations for Using the Data
-
-### Social Impact of Dataset
-
-[More Information Needed]
-
-### Discussion of Biases
-
-[More Information Needed]
-
-### Other Known Limitations
-
-[More Information Needed]
-
-## Additional Information
-
-### Dataset Curators
-
-[More Information Needed]
-
-### Licensing Information
-
-[More Information Needed]
-
-### Citation Information
-
-[More Information Needed]
-
-### Contributions
-
-[More Information Needed]

data/singapore_repair_train.jsonl

@@ -0,0 +1,18 @@
+{"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"}

intro_prog.py

@@ -0,0 +1,133 @@
+# 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