OpenAI o1横空出世，让我们看看都有哪些训练大模型的代码开源数据集

{
  "task_id":601,
  "text":"Write a function to find the longest chain which can be formed from the given set of pairs.",
  "code":"class Pair(object): def __init__(self, a, b): self.a = a self.b = b def max_chain_length(arr, n): max = 0 mcl = [1 for i in range(n)] for i in range(1, n): for j in range(0, i): if (arr[i].a > arr[j].b and mcl[i] < mcl[j] + 1): mcl[i] = mcl[j] + 1 for i in range(n): if (max < mcl[i]): max = mcl[i] return max",
  "test_list":"[ 'assert max_chain_length([Pair(5, 24), Pair(15, 25),Pair(27, 40), Pair(50, 60)], 4) == 3", "assert max_chain_length([Pair(1, 2), Pair(3, 4),Pair(5, 6), Pair(7, 8)], 4) == 4", "assert max_chain_length([Pair(19, 10), Pair(11, 12),Pair(13, 14), Pair(15, 16), Pair(31, 54)], 5) == 5' ]",
  "test_setup_code":'',
  "challenge_test_list":[]
}

{
    "_id": 131,
    "prompt": "你的任务是生成java代码来解决以下问题，生成的代码必须位于代码块```java和```之间，最多只允许有一个代码块：\n课堂练习：设计一个接受数组的静态方法，数组的每个成员都是个位整数(8到9之间），该方法能以电话号码的形式返回包含这些数字的字符串。例如：\n createPhoneNumber ( new int []{1,2,3,4,5,6,7,8,9,0})//=> returns \"(123) 456-7890\"\n注：别忘了右括号后面的空格！\n\n生成代码时你需要遵循以下测试用例中测试函数体中的函数名或类名，但生成的代码中不允许包含测例：\nclass MainTest {\n\n    @Test\n    void testCreatePhoneNumber1() {\n        assertEquals(\"(123) 456-7890\", PhoneNumberCreator.createPhoneNumber(new int[]{1,2,3,4,5,6,7,8,9,0}));\n    }\n}",
    "problem": "课堂练习：设计一个接受数组的静态方法，数组的每个成员都是个位整数(8到9之间），该方法能以电话号码的形式返回包含这些数字的字符串。例如：\n createPhoneNumber ( new int []{1,2,3,4,5,6,7,8,9,0})//=> returns \"(123) 456-7890\"\n注：别忘了右括号后面的空格！",
    "testcases": "import org.junit.jupiter.api.Test;\nimport static org.junit.jupiter.api.Assertions.*;\n\n\nclass PhoneNumberCreatorTest {\n    @Test\n    void testCreatePhoneNumber2() {\n        assertEquals(\"(987) 654-3210\", PhoneNumberCreator.createPhoneNumber(new int[]{9,8,7,6,5,4,3,2,1,0}));\n    }\n\n    @Test\n    void testCreatePhoneNumber3() {\n        assertEquals(\"(111) 111-1111\", PhoneNumberCreator.createPhoneNumber(new int[]{1,1,1,1,1,1,1,1,1,1}));\n    }\n\n    @Test\n    void testCreatePhoneNumber4() {\n        assertEquals(\"(999) 999-9999\", PhoneNumberCreator.createPhoneNumber(new int[]{9,9,9,9,9,9,9,9,9,9}));\n    }\n\n    @Test\n    void testCreatePhoneNumber5() {\n        assertEquals(\"(123) 456-7890\", PhoneNumberCreator.createPhoneNumber(new int[]{1,2,3,4,5,6,7,8,9,0}));\n    }\n\n    @Test\n    void testCreatePhoneNumber6() {\n        assertEquals(\"(000) 000-0000\", PhoneNumberCreator.createPhoneNumber(new int[]{0,0,0,0,0,0,0,0,0,0}));\n    }\n\n    //boundary cases\n    @Test\n    void testCreatePhoneNumber7() {\n        assertEquals(\"(123) 456-7890\", PhoneNumberCreator.createPhoneNumber(new int[]{1,2,3,4,5,6,7,8,9,0}));\n    }\n\n    @Test\n    void testCreatePhoneNumber8() {\n        assertEquals(\"(000) 000-0000\", PhoneNumberCreator.createPhoneNumber(new int[]{0,0,0,0,0,0,0,0,0,0}));\n    }\n\n    @Test\n    void testCreatePhoneNumber9() {\n        assertEquals(\"(999) 999-9999\", PhoneNumberCreator.createPhoneNumber(new int[]{9,9,9,9,9,9,9,9,9,9}));\n    }\n\n    @Test\n    void testCreatePhoneNumber10() {\n        assertEquals(\"(123) 456-7890\", PhoneNumberCreator.createPhoneNumber(new int[]{1,2,3,4,5,6,7,8,9,0}));\n    }\n}",
    "setup_code": "",
    "reference_solution": "```java\n\npublic class PhoneNumberCreator {\n    public static String createPhoneNumber(int[] numbers) {\n        StringBuilder phoneNumber = new StringBuilder(\"(\");\n        for (int i = 0; i < numbers.length; i++) {\n            if (i == 3) {\n                phoneNumber.append(\") \");\n            } else if (i == 6) {\n                phoneNumber.append(\"-\");\n            }\n            phoneNumber.append(numbers[i]);\n        }\n        return phoneNumber.toString();\n    }\n}\n\n```",
    "classification": "算法和数据结构"
}

{
    "_id": 131,
    "response": "```java\n\npublic class PhoneNumberCreator {\n    public static String createPhoneNumber(int[] numbers) {\n        StringBuilder phoneNumber = new StringBuilder(\"(\");\n        for (int i = 0; i < numbers.length; i++) {\n            if (i == 3) {\n                phoneNumber.append(\") \");\n            } else if (i == 6) {\n                phoneNumber.append(\"-\");\n            }\n            phoneNumber.append(numbers[i]);\n        }\n        return phoneNumber.toString();\n    }\n}\n\n```"
}

{
    "_id": 131,
    "prompt": "你的任务是生成python代码来解决以下问题，生成的代码必须位于代码块```python和```之间，最多只允许有一个代码块：\n创建一个名为`word_count`的函数，该函数接受一个文件路径作为参数，读取文件内容，并统计文件中每个单词出现的次数。函数应返回一个字典，其中键是单词，值是该单词在文件中出现的次数。要求忽略单词的大小写，并移除标点符号。最后，按照单词出现的次数降序排列字典项。如果有多个单词出现次数相同，按照字母顺序升序排列。函数不需要处理文件不存在的情况。\n\n你需要遵循以下测试用例中测试函数体中的函数名或类名, 生成的代码中不允许包含任何测例：\nclass Testword_count:\n    def test_word_count_basic_file(self, capfd, tmp_path):\n        file_path = tmp_path / 'test_basic.txt'\n        with open(file_path, 'w', encoding='utf-8') as file:\n            file.write(\"This is a basic test file with some common words.\")\n        word_count(file_path)\n        captured = capfd.readouterr()\n        assert \"'this': 1\\n'is': 1\\n'a': 1\\n'basic': 1\\n'test': 1\\n'file': 1\\n'with': 1\\n'some': 1\\n'common': 1\\n'words': 1\\n\" in captured.out\n\n\n",
    "problem": "创建一个名为`word_count`的函数，该函数接受一个文件路径作为参数，读取文件内容，并统计文件中每个单词出现的次数。函数应返回一个字典，其中键是单词，值是该单词在文件中出现的次数。要求忽略单词的大小写，并移除标点符号。最后，按照单词出现的次数降序排列字典项。如果有多个单词出现次数相同，按照字母顺序升序排列。函数不需要处理文件不存在的情况。",
    "testcases": "import string\nfrom collections import Counter\n\n\nclass Testword_count:\n    def test_word_count_case_sensitive_file(self, capfd, tmp_path):\n        file_path = tmp_path / 'test_case_sensitive.txt'\n        with open(file_path, 'w', encoding='utf-8') as file:\n            file.write(\"Case case CASE\")\n        word_count(file_path)\n        captured = capfd.readouterr()\n        assert \"'case': 3\" in captured.out\n\n\n    def test_word_count_punctuation_file(self, capfd, tmp_path):\n        file_path = tmp_path / 'test_punctuation.txt'\n        with open(file_path, 'w', encoding='utf-8') as file:\n            file.write(\"This sentence has some punctuation, like commas and periods.\")\n        word_count(file_path)\n        captured = capfd.readouterr()\n        assert \"'this': 1\\n'sentence': 1\\n'has': 1\\n'some': 1\\n'punctuation': 1\\n'like': 1\\n'commas': 1\\n'and': 1\\n'periods': 1\\n\" in captured.out\n\n\n    def test_word_count_same_word_file(self, capfd, tmp_path):\n        file_path = tmp_path / 'test_same_word_multiple_times.txt'\n        with open(file_path, 'w', encoding='utf-8') as file:\n            file.write(\"word word word word word\")\n        word_count(file_path)\n        captured = capfd.readouterr()\n        assert \"'word': 5\" in captured.out\n\n    def test_word_count_different_words_file(self, capfd, tmp_path):\n        file_path = tmp_path / 'test_different_words_same_count.txt'\n        with open(file_path, 'w', encoding='utf-8') as file:\n            file.write(\"apple banana orange\")\n        word_count(file_path)\n        captured = capfd.readouterr()\n        assert \"'apple': 1\\n'banana': 1\\n'orange': 1\\n\" in captured.out\n\n    def test_word_count_nonexistent_file(self, capfd, tmp_path):\n        file_path = tmp_path / 'nonexistent_file.txt'\n        word_count(file_path)\n        captured = capfd.readouterr()\n        assert \"Error: File\" in captured.out\n\n    def test_word_count_empty_file(self, capfd, tmp_path):\n        file_path = tmp_path / 'test_empty_file.txt'\n        open(file_path, 'w', encoding='utf-8').close()  # 创建一个空文件\n        word_count(file_path)\n        captured = capfd.readouterr()\n        assert captured.out.strip() == \"\"  # 期望输出为空字符串\n\n",
    "setup_code": "",
    "reference_solution": "```python\nimport string\nfrom collections import Counter\n\n\ndef word_count(file_path):\n    try:\n        # 读取文件内容\n        with open(file_path, 'r', encoding='utf-8') as file:\n            content = file.read()\n\n        # 移除标点符号并转换为小写\n        translator = str.maketrans(\"\", \"\", string.punctuation)\n        content = content.translate(translator).lower()\n\n        # 使用 Counter 统计单词出现次数\n        words = content.split()\n        word_counter = Counter(words)\n\n        # 按照出现次数降序排列\n        sorted_word_count = sorted(word_counter.items(), key=lambda x: x[1], reverse=True)\n\n        for word, count in sorted_word_count:\n            print(f\"'{word}': {count}\")\n\n    except FileNotFoundError:\n        print(f\"Error: File '{file_path}' not found.\")\n```",
    "classification": "算法和数据结构"
}

{
    "_id": 131,
    "response": "```python\nimport string\nfrom collections import Counter\n\n\ndef word_count(file_path):\n    try:\n        # 读取文件内容\n        with open(file_path, 'r', encoding='utf-8') as file:\n            content = file.read()\n\n        # 移除标点符号并转换为小写\n        translator = str.maketrans(\"\", \"\", string.punctuation)\n        content = content.translate(translator).lower()\n\n        # 使用 Counter 统计单词出现次数\n        words = content.split()\n        word_counter = Counter(words)\n\n        # 按照出现次数降序排列\n        sorted_word_count = sorted(word_counter.items(), key=lambda x: x[1], reverse=True)\n\n        for word, count in sorted_word_count:\n            print(f\"'{word}': {count}\")\n\n    except FileNotFoundError:\n        print(f\"Error: File '{file_path}' not found.\")\n```"
}

{
  "task_id": "Python/0", 
  "prompt": "from typing import List\n\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n    \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n    given threshold.\n    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n    False\n    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n    True\n    \"\"\"\n",
  "declaration": "from typing import List\n\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n", 
  "canonical_solution": "for idx, elem in enumerate(numbers):\n        for idx2, elem2 in enumerate(numbers):\n            if idx != idx2:\n                distance = abs(elem - elem2)\n                if distance < threshold:\n                    return True\n\n    return False\n", 
  "test": "\n\nMETADATA = {\n    'author': 'jt',\n    'dataset': 'test'\n}\n\n\ndef check(has_close_elements):\n    assert has_close_elements([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3) == True\n    assert has_close_elements([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05) == False\n    assert has_close_elements([1.0, 2.0, 5.9, 4.0, 5.0], 0.95) == True\n    assert has_close_elements([1.0, 2.0, 5.9, 4.0, 5.0], 0.8) == False\n    assert has_close_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0], 0.1) == True\n    assert has_close_elements([1.1, 2.2, 3.1, 4.1, 5.1], 1.0) == True\n    assert has_close_elements([1.1, 2.2, 3.1, 4.1, 5.1], 0.5) == False\n\ncheck(has_close_elements)",
  "text": "Check if in given list of numbers, are any two numbers closer to each other than\n    given threshold.\n    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n    False\n    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n    True",
  "example_test": "def check(has_close_elements):\n    assert has_close_elements([1.0, 2.0, 3.0], 0.5) == False\n    assert has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3) == True\ncheck(has_close_elements)\n"
}

{
 'problem_id': 0,
 'question': 'Polycarp has $n$ different binary words. A word called binary if it contains only characters \'0\' and \'1\'. For example...',
 'solutions': ["for _ in range(int(input())):\n    n = int(input())\n    mass = []\n    zo = 0\n    oz = 0\n    zz = 0\n    oo = 0\n...",...],
 'input_output': {'inputs': ['4\n4\n0001\n1000\n0011\n0111\n3\n010\n101\n0\n2\n00000\n00001\n4\n01\n001\n0001\n00001\n'], 
                  'outputs': ['1\n3 \n-1\n0\n\n2\n1 2 \n']},
 'difficulty': 'interview',
 'url': 'https://codeforces.com/problemset/problem/1259/D',
 'starter_code': ''}
}