all_problems.json

{
    "problem_set": [
        {
            "problem_id": "sort_even_numbers_in_array",
            "description": "This problem tests the ability to work with arrays and sorting algorithms. The task is to implement a function that takes an array of integers and sorts the even numbers in ascending order, while leaving the odd numbers in their original positions.",
            "function_prototype": {
                "function_name": "sort_even_numbers",
                "parameters": [
                    {
                        "name": "arr",
                        "type": "List[int]"
                    }
                ],
                "return_values": [
                    {
                        "type": "List[int]"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that takes an array of integers and sorts the even numbers in ascending order while leaving the odd numbers in their original positions."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that takes an array of integers and sorts the even numbers in ascending order while leaving the odd numbers in their original positions.\n\nTest Cases:\n- Input: [5, 3, 2, 8, 1, 4]\n  Expected Output: [5, 3, 2, 4, 1, 8]\n- Input: [0, 1, 2, 3, 4, 5]\n  Expected Output: [0, 1, 2, 3, 4, 5]"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_sort_even_numbers():\n  assert sort_even_numbers([5, 3, 2, 8, 1, 4]) == [5, 3, 2, 4, 1, 8]\n  assert sort_even_numbers([0, 1, 2, 3, 4, 5]) == [0, 1, 2, 3, 4, 5]"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_0():\n  assert function([5, 3, 2, 8, 1, 4]) == [5, 3, 2, 4, 1, 8]\n  assert function([0, 1, 2, 3, 4, 5]) == [0, 1, 2, 3, 4, 5]"
                }
            ],
            "id": "0",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "arr": "[5,3,2,8,1,4]"
                    },
                    "expected_output": [
                        "[5, 3, 2, 4, 1, 8]"
                    ]
                },
                {
                    "parameters": {
                        "arr": "[0,1,2,3,4,5]"
                    },
                    "expected_output": [
                        "[0, 1, 2, 3, 4, 5]"
                    ]
                }
            ]
        },
        {
            "problem_id": "reverse_vowels_in_string",
            "description": "This problem tests the ability to manipulate strings. The task is to implement a function that reverses the vowels in a given string.",
            "function_prototype": {
                "function_name": "reverse_vowels",
                "parameters": [
                    {
                        "name": "s",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that reverses the vowels in a given string."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that reverses the vowels in a given string.\n\nTest Cases:\n- Input: 'hello'\n  Expected Output: 'holle'\n- Input: 'world'\n  Expected Output: 'world'"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_reverse_vowels():\n  assert reverse_vowels('hello') == 'holle'\n  assert reverse_vowels('world') == 'world'"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_1():\n  assert function('hello') == 'holle'\n  assert function('world') == 'world'"
                }
            ],
            "id": "1",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "s": "'hello'"
                    },
                    "expected_output": [
                        "'holle'"
                    ]
                },
                {
                    "parameters": {
                        "s": "'world'"
                    },
                    "expected_output": [
                        "'world'"
                    ]
                }
            ]
        },
        {
            "problem_id": "merge_sorted_lists",
            "description": "This problem tests the ability to manipulate lists and sort elements. The task is to implement a function that merges two sorted lists into a single sorted list.",
            "function_prototype": {
                "function_name": "merge_sorted_lists",
                "parameters": [
                    {
                        "name": "list1",
                        "type": "List[int]"
                    },
                    {
                        "name": "list2",
                        "type": "List[int]"
                    }
                ],
                "return_values": [
                    {
                        "type": "List[int]"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that merges two sorted lists into a single sorted list."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that merges two sorted lists into a single sorted list.\n\nTest Cases:\n- Input: [1, 3, 5], [2, 4, 6]\n  Expected Output: [1, 2, 3, 4, 5, 6]\n- Input: [7, 9], [8, 10]\n  Expected Output: [7, 8, 9, 10]"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_merge_sorted_lists():\n  assert merge_sorted_lists([1, 3, 5], [2, 4, 6]) == [1, 2, 3, 4, 5, 6]\n  assert merge_sorted_lists([7, 9], [8, 10]) == [7, 8, 9, 10]"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_1():\n  assert function([1, 3, 5], [2, 4, 6]) == [1, 2, 3, 4, 5, 6]\n  assert function([7, 9], [8, 10]) == [7, 8, 9, 10]"
                }
            ],
            "id": "2",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "list1": "[1, 3, 5]",
                        "list2": "[2, 4, 6]"
                    },
                    "expected_output": [
                        "[1, 2, 3, 4, 5, 6]"
                    ]
                },
                {
                    "parameters": {
                        "list1": "[7, 9]",
                        "list2": "[8, 10]"
                    },
                    "expected_output": [
                        "[7, 8, 9, 10]"
                    ]
                }
            ]
        },
        {
            "problem_id": "fibonacci_recursive",
            "description": "This problem tests the ability to work with recursion. The task is to implement a function that calculates the nth Fibonacci number using recursion.",
            "function_prototype": {
                "function_name": "fibonacci",
                "parameters": [
                    {
                        "name": "n",
                        "type": "int"
                    }
                ],
                "return_values": [
                    {
                        "type": "int"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that calculates the nth Fibonacci number using recursion."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that calculates the nth Fibonacci number using recursion.\n\nTest Cases:\n- Input: 0\n  Expected Output: 0\n- Input: 1\n  Expected Output: 1 \n- Input: 6\n Expected Output: 8"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_fibonacci():\n  assert fibonacci(0) == 0\n  assert fibonacci(1) == 1 \n assert fibonacci(6) = 8"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_3():\n  assert function(0) == 0\n  assert function(1) == 1\n assert function(6) == 8"
                }
            ],
            "id": "3",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "n": "0"
                    },
                    "expected_output": [
                        "0"
                    ]
                },
                {
                    "parameters": {
                        "n": "1"
                    },
                    "expected_output": [
                        "1"
                    ]
                },
                {
                    "parameters": {
                        "n": "6"
                    },
                    "expected_output": [
                        "8"
                    ]
                }
            ]
        },
        {
            "problem_id": "max_product_of_two_integers",
            "description": "This problem tests the ability to work with basic algorithms. The task is to find the maximum product of any two integers in a given list.",
            "function_prototype": {
                "function_name": "max_product",
                "parameters": [
                    {
                        "name": "nums",
                        "type": "List[int]"
                    }
                ],
                "return_values": [
                    {
                        "type": "int"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that finds the maximum product of any two integers in a given list."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that finds the maximum product of any two integers in a given list.\n\nTest Cases:\n- Input: [1, 2, 3, 4]\n  Expected Output: 12\n- Input: [-1, -2, -3, -4]\n  Expected Output: 12"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_max_product():\n  assert max_product([1, 2, 3, 4]) == 12\n  assert max_product([-1, -2, -3, -4]) == 12"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_4():\n  assert function([1, 2, 3, 4]) == 12\n  assert function([-1, -2, -3, -4]) == 12"
                }
            ],
            "id": "4",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "nums": "[1,2,3,4]"
                    },
                    "expected_output": [
                        "12"
                    ]
                },
                {
                    "parameters": {
                        "nums": "[-1,-2,-3,-4]"
                    },
                    "expected_output": [
                        "12"
                    ]
                }
            ]
        },
        {
            "problem_id": "count_occurrences",
            "description": "This problem tests the ability to search and count occurrences within strings. The task is to implement a function that counts the occurrences of a substring in a given string.",
            "function_prototype": {
                "function_name": "count_occurrences",
                "parameters": [
                    {
                        "name": "s",
                        "type": "str"
                    },
                    {
                        "name": "substr",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "int"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that counts the occurrences of a substring in a given string."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that counts the occurrences of a substring in a given string.\n\nTest Cases:\n- Input: 'hello world', 'o'\n  Expected Output: 2\n- Input: 'mississippi', 'is'\n  Expected Output: 2"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_count_occurrences():\n  assert count_occurrences('hello world', 'o') == 2\n  assert count_occurrences('mississippi', 'is') == 2"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_1():\n  assert function('hello world', 'o') == 2\n  assert function('mississippi', 'is') == 2"
                }
            ],
            "id": "5",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "s": "'hello world'",
                        "substr": "'o'"
                    },
                    "expected_output": [
                        "2"
                    ]
                },
                {
                    "parameters": {
                        "s": "'mississippi'",
                        "substr": "'is'"
                    },
                    "expected_output": [
                        "2"
                    ]
                }
            ]
        },
        {
            "problem_id": "validate_email_address",
            "description": "This problem tests the ability to work with string manipulation and regular expressions. The task is to implement a function that validates an email address according to certain rules.",
            "function_prototype": {
                "function_name": "validate_email",
                "parameters": [
                    {
                        "name": "email",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "bool"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that validates an email address according to certain rules."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that validates an email address according to certain rules.\n\nTest Cases:\n- Input: 'test@example.com'\n  Expected Output: True\n- Input: 'test.example.com'\n  Expected Output: False"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_validate_email():\n  assert validate_email('test@example.com') == True\n  assert validate_email('test.example.com') == False"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_6():\n  assert function('test@example.com') == True\n  assert function('test.example.com') == False"
                }
            ],
            "id": "6",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "email": "'test@example.com'"
                    },
                    "expected_output": [
                        "True"
                    ]
                },
                {
                    "parameters": {
                        "email": "'test.example.com'"
                    },
                    "expected_output": [
                        "False"
                    ]
                }
            ]
        },
        {
            "problem_id": "range_bitwise_and",
            "description": "This problem tests the ability to work with bitwise operations. The task is to implement a function that calculates the bitwise AND of all numbers in a range from m to n.",
            "function_prototype": {
                "function_name": "range_bitwise_and",
                "parameters": [
                    {
                        "name": "m",
                        "type": "int"
                    },
                    {
                        "name": "n",
                        "type": "int"
                    }
                ],
                "return_values": [
                    {
                        "type": "int"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that calculates the bitwise AND of all numbers in a range from m to n."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that calculates the bitwise AND of all numbers in a range from m to n.\n\nTest Cases:\n- Input: m = 5, n = 7\n  Expected Output: 4\n- Input: m = 0, n = 1\n  Expected Output: 0"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_range_bitwise_and():\n  assert range_bitwise_and(5, 7) == 4\n  assert range_bitwise_and(0, 1) == 0"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_7():\n  assert function(5, 7) == 4\n  assert function(0, 1) == 0"
                }
            ],
            "id": "7",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "m": "5",
                        "n": "7"
                    },
                    "expected_output": [
                        "4"
                    ]
                },
                {
                    "parameters": {
                        "m": "0",
                        "n": "1"
                    },
                    "expected_output": [
                        "0"
                    ]
                }
            ]
        },
        {
            "problem_id": "bubble_sort_array",
            "description": "This problem tests the ability to work with arrays and sorting. The task is to implement a function that sorts an array using the bubble sort algorithm.",
            "function_prototype": {
                "function_name": "bubble_sort",
                "parameters": [
                    {
                        "name": "arr",
                        "type": "List[int]"
                    }
                ],
                "return_values": [
                    {
                        "type": "List[int]"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that sorts an array using the bubble sort algorithm."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that sorts an array using the bubble sort algorithm.\n\nTest Cases:\n- Input: [5, 3, 1, 4, 6]\n  Expected Output: [1, 3, 4, 5, 6]\n- Input: [1, 2, 3, 4, 5]\n  Expected Output: [1, 2, 3, 4, 5]"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_bubble_sort():\n  assert bubble_sort([5, 3, 1, 4, 6]) == [1, 3, 4, 5, 6]\n  assert bubble_sort([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_8():\n  assert function([5, 3, 1, 4, 6]) == [1, 3, 4, 5, 6]\n  assert function([1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]"
                }
            ],
            "id": "8",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "arr": "[5,3,1,4,6]"
                    },
                    "expected_output": [
                        "[1, 3, 4, 5, 6]"
                    ]
                },
                {
                    "parameters": {
                        "arr": "[1,2,3,4,5]"
                    },
                    "expected_output": [
                        "[1, 2, 3, 4, 5]"
                    ]
                }
            ]
        },
        {
            "problem_id": "depth_first_search",
            "description": "This problem tests the ability to work with graphs. The task is to implement a function that performs a depth-first search on a graph represented as an adjacency list.",
            "function_prototype": {
                "function_name": "depth_first_search",
                "parameters": [
                    {
                        "name": "graph",
                        "type": "Dict[int, List[int]]"
                    },
                    {
                        "name": "start",
                        "type": "int"
                    }
                ],
                "return_values": [
                    {
                        "type": "List[int]"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that performs a depth-first search on a graph represented as an adjacency list."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that performs a depth-first search on a graph represented as an adjacency list.\n\nTest Cases:\n- Input: graph = {1: [2, 3], 2: [4], 3: [], 4: []}, start = 1\n  Expected Output: [1, 2, 4, 3]\n- Input: graph = {1: [2, 3], 2: [1], 3: [1]}, start = 1\n  Expected Output: [1, 2, 3]"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: Test Cases:\n- Input: graph = {1: [2, 3], 2: [4], 3: [], 4: []}, start = 1\n  Expected Output: [1, 2, 4, 3]\n- Input: graph = {1: [2, 3], 2: [1], 3: [1]}, start = 1\n  Expected Output: [1, 2, 3]"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_9():\n  assert function({1: [2, 3], 2: [1], 3: [1]}, 1) == [1, 2, 3]\n  assert function({1: [2, 3], 2: [4], 3: [], 4: []}, 1) == [1, 2, 4, 3]"
                }
            ],
            "id": "9",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "graph": "{1: [2, 3], 2: [4], 3: [], 4: []}",
                        "start": "1"
                    },
                    "expected_output": [
                        "[1, 2, 4, 3]"
                    ]
                },
                {
                    "parameters": {
                        "graph": "{1: [2, 3], 2: [1], 3: [1]}",
                        "start": "1"
                    },
                    "expected_output": [
                        "[1, 2, 3]"
                    ]
                }
            ]
        },
        {
            "problem_id": "factorial_recursive_2",
            "description": "This problem tests the ability to work with recursion. The task is to implement a function that calculates the factorial of a given number using recursion.",
            "function_prototype": {
                "function_name": "factorial_recursive_2",
                "parameters": [
                    {
                        "name": "n",
                        "type": "int"
                    }
                ],
                "return_values": [
                    {
                        "type": "int"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that calculates the factorial of a given number using recursion."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that calculates the factorial of a given number using recursion.\n\nTest Cases:\n- Input: 5\n  Expected Output: 120\n- Input: 1\n  Expected Output: 1"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: Test Cases:\n- Input: 5\n  Expected Output: 120\n- Input: 1\n  Expected Output: 1"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_10():\n  assert function(5) == 120\n  assert function(1) == 1"
                }
            ],
            "id": "10",
            "model": "GPT-4",
            "test_cases": [
                {
                    "parameters": {
                        "n": "5"
                    },
                    "expected_output": [
                        "120"
                    ]
                },
                {
                    "parameters": {
                        "n": "1"
                    },
                    "expected_output": [
                        "1"
                    ]
                }
            ]
        },
        {
            "category": "Math",
            "problem_id": "multiply_list",
            "model": "Claude-2",
            "id": "11",
            "function_prototype": {
                "function_name": "multiply_list",
                "parameters": [
                    {
                        "name": "nums",
                        "type": "List[int]"
                    }
                ],
                "return_values": [
                    {
                        "type": "int"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Write a function to multiply numbers in a list"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `multiply_list` that takes a list of numbers and returns the product of all the numbers. \n\nTest Cases:\n- Input: nums = []\n  Expected Output: 1\n- Input: nums = [2]\n  Expected Output: 2\n- Input: nums = [1, 2, 3]\n  Expected Output: 6"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_empty():\n  nums = []\n  assert multiply_list(nums) == 1\n\ndef test_single():\n  nums = [2]\n  assert multiply_list(nums) == 2\n  \ndef test_multi():\n  nums = [1, 2, 3]\n  assert multiply_list(nums) == 6"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = []\n  assert function(input) == 1\n\ndef test_2():\n  input = [2]\n  assert function(input) == 2\n\ndef test_3():\n  input = [1, 2, 3]\n  assert function(input) == 6"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "nums": "[]"
                    },
                    "expected_output": [
                        "1"
                    ]
                },
                {
                    "parameters": {
                        "nums": "[2]"
                    },
                    "expected_output": [
                        "2"
                    ]
                },
                {
                    "parameters": {
                        "nums": "[1, 2, 3]"
                    },
                    "expected_output": [
                        "6"
                    ]
                }
            ]
        },
        {
            "category": "String",
            "problem_id": "count_vowels",
            "model": "Claude-2",
            "id": "12",
            "function_prototype": {
                "function_name": "count_vowels",
                "parameters": [
                    {
                        "name": "text",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "int"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Count vowels in a string"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `count_vowels` that takes a string and returns the number of vowels. \n\nTest Cases:\n- Input: text = ''\n  Expected Output: 0\n- Input: text = 'try'\n  Expected Output: 0\n- Input: text = 'apple'\n  Expected Output: 2"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_empty():\n  text = ''\n  assert count_vowels(text) == 0\n\ndef test_no_vowels():\n  text = 'try'\n  assert count_vowels(text) == 0\n\ndef test_multi():\n  text = 'apple'\n  assert count_vowels(text) == 2"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = ''\n  assert function(input) == 0\n\ndef test_2():\n  input = 'try'\n  assert function(input) == 0\n\ndef test_3():\n  input = 'apple'\n  assert function(input) == 2"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "text": "''"
                    },
                    "expected_output": [
                        "0"
                    ]
                },
                {
                    "parameters": {
                        "text": "'try'"
                    },
                    "expected_output": [
                        "0"
                    ]
                },
                {
                    "parameters": {
                        "text": "'apple'"
                    },
                    "expected_output": [
                        "2"
                    ]
                }
            ]
        },
        {
            "category": "String",
            "problem_id": "is_palindrome",
            "id": "13",
            "model": "Claude-2",
            "function_prototype": {
                "function_name": "is_palindrome",
                "parameters": [
                    {
                        "name": "text",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "bool"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Check if a string is a palindrome"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `is_palindrome` that takes a string and returns `True` if it is a palindrome, `False` otherwise. \n\nTest Cases:\n- Input: text = ''\n  Expected Output: True\n- Input: text = 'hello'\n  Expected Output: False\n- Input: text = 'racecar'\n  Expected Output: True"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_empty():\n  text = ''\n  assert is_palindrome(text) == True\n\ndef test_not_palindrome():\n  text = 'hello'\n  assert is_palindrome(text) == False\n\ndef test_palindrome():\n  text = 'racecar'\n  assert is_palindrome(text) == True"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = ''\n  assert function(input) == True\n\ndef test_2():\n  input = 'hello'\n  assert function(input) == False\n\ndef test_3():\n  input = 'racecar'\n  assert function(input) == True"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "text": "''"
                    },
                    "expected_output": [
                        "True"
                    ]
                },
                {
                    "parameters": {
                        "text": "'hello'"
                    },
                    "expected_output": [
                        "False"
                    ]
                },
                {
                    "parameters": {
                        "text": "'racecar'"
                    },
                    "expected_output": [
                        "True"
                    ]
                }
            ]
        },
        {
            "category": "String",
            "problem_id": "longest_word",
            "id": "14",
            "model": "Claude-2",
            "function_prototype": {
                "function_name": "longest_word",
                "parameters": [
                    {
                        "name": "sentence",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Find longest word in sentence"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `longest_word` that takes a sentence and returns the longest word. \n\nTest Cases:\n- Input: sentence = ''\n  Expected Output: ''\n- Input: sentence = 'hi'\n  Expected Output: 'hi'\n- Input: sentence = 'hello there my friend'\n  Expected Output: 'hello'"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_empty():\n  sentence = ''\n  assert longest_word(sentence) == ''\n\ndef test_single():\n  sentence = 'hi'\n  assert longest_word(sentence) == 'hi'\n\ndef test_multi():\n  sentence = 'hello there my friend'\n  assert longest_word(sentence) == 'hello'"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = ''\n  assert function(input) == ''\n\ndef test_2(): \n  input = 'hi'\n  assert function(input) == 'hi'\n\ndef test_3():\n  input = 'hello there my friend'\n  assert function(input) == 'hello'"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "sentence": "''"
                    },
                    "expected_output": [
                        "''"
                    ]
                },
                {
                    "parameters": {
                        "sentence": "'hi'"
                    },
                    "expected_output": [
                        "'hi'"
                    ]
                },
                {
                    "parameters": {
                        "sentence": "'hello there my friend'"
                    },
                    "expected_output": [
                        "'hello'"
                    ]
                }
            ]
        },
        {
            "category": "String",
            "problem_id": "capitalize",
            "id": "15",
            "model": "Claude-2",
            "function_prototype": {
                "function_name": "capitalize",
                "parameters": [
                    {
                        "name": "text",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Capitalize words in string"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `capitalize` that takes a string and returns a copy with the first letter of each word capitalized. \n\nTest Cases:\n- Input: text = ''\n  Expected Output: ''\n- Input: text = 'hello'\n  Expected Output: 'Hello'\n- Input: text = 'hello world'\n  Expected Output: 'Hello World'"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_empty():\n  text = ''\n  assert capitalize(text) == ''\n\ndef test_single():\n  text = 'hello'\n  assert capitalize(text) == 'Hello'\n\ndef test_multi():\n  text = 'hello world'\n  assert capitalize(text) == 'Hello World'"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = ''\n  assert function(input) == ''\n\ndef test_2():\n  input = 'hello'\n  assert function(input) == 'Hello'\n\ndef test_3():\n  input = 'hello world'\n  assert function(input) == 'Hello World'"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "text": "''"
                    },
                    "expected_output": [
                        "''"
                    ]
                },
                {
                    "parameters": {
                        "text": "'hello'"
                    },
                    "expected_output": [
                        "'Hello'"
                    ]
                },
                {
                    "parameters": {
                        "text": "'hello world'"
                    },
                    "expected_output": [
                        "'Hello World'"
                    ]
                }
            ]
        },
        {
            "category": "String",
            "problem_id": "reverse_string",
            "id": "16",
            "model": "Claude-2",
            "function_prototype": {
                "function_name": "reverse_string",
                "parameters": [
                    {
                        "name": "text",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Reverse a string"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `reverse_string` that takes a string and returns it reversed. \n\nTest Cases:\n- Input: text = ''\n  Expected Output: ''\n- Input: text = 'a'\n  Expected Output: 'a'\n- Input: text = 'abc'\n  Expected Output: 'cba'"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_empty():\n  text = ''\n  assert reverse_string(text) == ''\n\ndef test_single():\n  text = 'a'\n  assert reverse_string(text) == 'a'\n\ndef test_multi():\n  text = 'abc'\n  assert reverse_string(text) == 'cba'"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = ''\n  assert function(input) == ''\n\ndef test_2():\n  input = 'a'\n  assert function(input) == 'a'\n\ndef test_3():\n  input = 'abc'\n  assert function(input) == 'cba'"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "text": "''"
                    },
                    "expected_output": [
                        "''"
                    ]
                },
                {
                    "parameters": {
                        "text": "'a'"
                    },
                    "expected_output": [
                        "'a'"
                    ]
                },
                {
                    "parameters": {
                        "text": "'abc'"
                    },
                    "expected_output": [
                        "'cba'"
                    ]
                }
            ]
        },
        {
            "category": "Math",
            "problem_id": "count_digits",
            "id": "17",
            "model": "Claude-2",
            "function_prototype": {
                "function_name": "count_digits",
                "parameters": [
                    {
                        "name": "num",
                        "type": "int"
                    }
                ],
                "return_values": [
                    {
                        "type": "int"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Count digits in number"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `count_digits` that takes an integer and returns the number of digits. \n\nTest Cases:\n- Input: num = 0\n  Expected Output: 1\n- Input: num = 5\n  Expected Output: 1\n- Input: num = 348\n  Expected Output: 3"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_zero():\n  num = 0\n  assert count_digits(num) == 1\n   \ndef test_single():\n  num = 5\n  assert count_digits(num) == 1\n\ndef test_multi():\n  num = 348\n  assert count_digits(num) == 3"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = 0\n  assert function(input) == 1\n\ndef test_2():\n  input = 5\n  assert function(input) == 1\n\ndef test_3():\n  input = 348\n  assert function(input) == 3"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "num": "0"
                    },
                    "expected_output": [
                        "1"
                    ]
                },
                {
                    "parameters": {
                        "num": "5"
                    },
                    "expected_output": [
                        "1"
                    ]
                },
                {
                    "parameters": {
                        "num": "348"
                    },
                    "expected_output": [
                        "3"
                    ]
                }
            ]
        },
        {
            "category": "Math",
            "problem_id": "factorial",
            "id": "18",
            "model": "Claude-2",
            "function_prototype": {
                "function_name": "factorial",
                "parameters": [
                    {
                        "name": "num",
                        "type": "int"
                    }
                ],
                "return_values": [
                    {
                        "type": "int"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Calculate factorial"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `factorial` that takes a number and returns its factorial. \n\nTest Cases:\n- Input: num = 0\n  Expected Output: 1\n- Input: num = 1\n  Expected Output: 1\n- Input: num = 5\n  Expected Output: 120"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_zero():\n  num = 0\n  assert factorial(num) == 1\n\ndef test_single():\n  num = 1\n assert factorial(num) == 1\n\ndef test_multi():\n  num = 5\n  assert factorial(num) == 120"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = 0\n  assert function(input) == 1\n\ndef test_2():\n  input = 1\n  assert function(input) == 1\n\ndef test_3():\n  input = 5\n  assert function(input) == 120"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "num": "0"
                    },
                    "expected_output": [
                        "1"
                    ]
                },
                {
                    "parameters": {
                        "num": "1"
                    },
                    "expected_output": [
                        "1"
                    ]
                },
                {
                    "parameters": {
                        "num": "5"
                    },
                    "expected_output": [
                        "120"
                    ]
                }
            ]
        },
        {
            "category": "Math",
            "problem_id": "fibonacci",
            "id": "19",
            "model": "Claude-2",
            "function_prototype": {
                "function_name": "fibonacci",
                "parameters": [
                    {
                        "name": "num",
                        "type": "int"
                    }
                ],
                "return_values": [
                    {
                        "type": "List[int]"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Generate Fibonacci sequence"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `fibonacci` that takes a number and returns the Fibonacci sequence up to that number. Include test cases for 0, 1, and a larger number.\n\nTest Cases:\n- Input: num = 0\n  Expected Output: [0]\n- Input: num = 1\n  Expected Output: [0, 1]\n- Input: num = 6\n  Expected Output: [0, 1, 1, 2, 3, 5]"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_zero():\n  num = 0\n  assert fibonacci(num) == [0]\n\ndef test_one():\n  num = 1\n  assert fibonacci(num) == [0, 1]\n   \ndef test_multi():\n  num = 6\n  assert fibonacci(num) == [0, 1, 1, 2, 3, 5]"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = 0\n  assert function(input) == [0]\n\ndef test_2():\n  input = 1\n  assert function(input) == [0, 1]\n\ndef test_3():\n  input = 6\n  assert function(input) == [0, 1, 1, 2, 3, 5]"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "num": "0"
                    },
                    "expected_output": [
                        "[0]"
                    ]
                },
                {
                    "parameters": {
                        "num": "1"
                    },
                    "expected_output": [
                        "[0, 1]"
                    ]
                },
                {
                    "parameters": {
                        "num": "6"
                    },
                    "expected_output": [
                        "[0, 1, 1, 2, 3, 5]"
                    ]
                }
            ]
        },
        {
            "category": "Logic",
            "problem_id": "fizzbuzz",
            "id": "20",
            "model": "Claude-2",
            "function_prototype": {
                "function_name": "fizzbuzz",
                "parameters": [
                    {
                        "name": "num",
                        "type": "int"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "FizzBuzz"
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Write a function called `fizzbuzz` that prints the numbers 1 to 100, but printing 'Fizz' for multiples of 3, 'Buzz' for multiples of 5, and 'FizzBuzz' for multiples of both 3 and 5. Include test cases.\n\nTest Cases:\n- Input: num = 3\n  Expected Output: 'Fizz'\n- Input: num = 5\n  Expected Output: 'Buzz'\n- Input: num = 15\n  Expected Output: 'FizzBuzz'"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_fizz():\n  num = 3\n  assert fizzbuzz(num) == 'Fizz'\n\ndef test_buzz():\n  num = 5\n  assert fizzbuzz(num) == 'Buzz'\n\ndef test_fizzbuzz():\n  num = 15\n  assert fizzbuzz(num) == 'FizzBuzz'"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_1():\n  input = 3\n  assert function(input) == 'Fizz'\n\ndef test_2():\n  input = 5 \n  assert function(input) == 'Buzz'\n\ndef test_3():\n input = 15\n assert function(input) == 'FizzBuzz'"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "num": "3"
                    },
                    "expected_output": [
                        "'Fizz'"
                    ]
                },
                {
                    "parameters": {
                        "num": "5"
                    },
                    "expected_output": [
                        "'Buzz'"
                    ]
                },
                {
                    "parameters": {
                        "num": "15"
                    },
                    "expected_output": [
                        "'FizzBuzz'"
                    ]
                }
            ]
        },
        {
            "problem_id": "find_first_non_repeating_char",
            "model": "Bard",
            "id": "21",
            "description": "This problem tests the ability to work with hash tables. The task is to implement a function that finds the first non-repeating character in a given string.",
            "function_prototype": {
                "function_name": "find_first_non_repeating_char",
                "parameters": [
                    {
                        "name": "text",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that finds the first non-repeating character in a given string."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that finds the first non-repeating character in a given string.\n\nTest Cases:\n- Input: 'abca'\n  Expected Output: 'b'\n- Input: 'ccbaab'\n  Expected Output: 'b'"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_find_first_non_repeating_char():\n  assert find_first_non_repeating_char('abca') == 'b'\n  assert find_first_non_repeating_char('ccbaab') == 'b'"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_21():\n  assert function('abca') == 'b'\n  assert function('ccbaab') == 'b'"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "text": "'abca'"
                    },
                    "expected_output": [
                        "'b'"
                    ]
                },
                {
                    "parameters": {
                        "text": "'ccbaab'"
                    },
                    "expected_output": [
                        "'b'"
                    ]
                }
            ]
        },
        {
            "problem_id": "find_longest_substring_without_repeating_characters",
            "model": "Bard",
            "id": "22",
            "description": "This problem tests the ability to work with hash sets. The task is to implement a function that finds the longest substring without repeating characters in a given string.",
            "function_prototype": {
                "function_name": "find_longest_substring_without_repeating_characters",
                "parameters": [
                    {
                        "name": "text",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that finds the longest substring without repeating characters in a given string."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that finds the longest substring without repeating characters in a given string.\n\nTest Cases:\n- Input: 'abcabcbb'\n  Expected Output: 'abc'\n- Input: 'bbbbb'\n  Expected Output: 'b'"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_find_longest_substring_without_repeating_characters():\n  assert find_longest_substring_without_repeating_characters('abcabcbb') == 'abc'\n  assert find_longest_substring_without_repeating_characters('bbbbb') == 'b'"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_22():\n  assert function('abcabcbb') == 'abc'\n  assert function('bbbbb') == 'b'"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "text": "'abcabcbb'"
                    },
                    "expected_output": [
                        "'abc'"
                    ]
                },
                {
                    "parameters": {
                        "text": "'bbbbb'"
                    },
                    "expected_output": [
                        "'b'"
                    ]
                }
            ]
        },
        {
            "problem_id": "longest_substring_with_k_distinct_characters",
            "model": "Bard",
            "id": "23",
            "description": "This problem tests the ability to work with hash maps. The task is to implement a function that finds the longest substring with k distinct characters in a given string.",
            "function_prototype": {
                "function_name": "longest_substring_with_k_distinct_characters",
                "parameters": [
                    {
                        "name": "text",
                        "type": "str"
                    },
                    {
                        "name": "k",
                        "type": "int"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that finds the longest substring with k distinct characters in a given string."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that finds the longest substring with k distinct characters in a given string.\n\nTest Cases:\n- Input: 'abcabcbb', k = 3\n  Expected Output: 'abc'\n- Input: 'bbbbb', k = 3\n  Expected Output: ''"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_longest_substring_with_k_distinct_characters():\n  assert longest_substring_with_k_distinct_characters('abcabcbb', 3) == 'abc'\n  assert longest_substring_with_k_distinct_characters('bbbbb', 3) == ''"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_23():\n  assert function('abcabcbb', 3) == 'abc'\n  assert function('bbbbb', 3) == ''"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "text": "'abcabcbb'",
                        "k": "3"
                    },
                    "expected_output": [
                        "'abc'"
                    ]
                },
                {
                    "parameters": {
                        "text": "'bbbbb'",
                        "k": "3"
                    },
                    "expected_output": [
                        "''"
                    ]
                }
            ]
        },
        {
            "problem_id": "longest_palindromic_substring",
            "model": "Bard",
            "id": "24",
            "description": "This problem tests the ability to work with dynamic programming. The task is to implement a function that finds the longest palindromic substring in a given string.",
            "function_prototype": {
                "function_name": "longest_palindromic_substring",
                "parameters": [
                    {
                        "name": "text",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that finds the longest palindromic substring in a given string."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that finds the longest palindromic substring in a given string.\n\nTest Cases:\n- Input: 'babad'\n  Expected Output: 'bab'\n- Input: 'cbbd'\n  Expected Output: 'bb'"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_longest_palindromic_substring():\n  assert longest_palindromic_substring('babad') == 'bab'\n  assert longest_palindromic_substring('cbbd') == 'bb'"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_24():\n  assert function('babad') == 'bab'\n  assert function('cbbd') == 'bb'"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "text": "'babad'"
                    },
                    "expected_output": [
                        "'bab'"
                    ]
                },
                {
                    "parameters": {
                        "text": "'cbbd'"
                    },
                    "expected_output": [
                        "'bb'"
                    ]
                }
            ]
        },
        {
            "problem_id": "longest_common_substring",
            "model": "Bard",
            "id": "25",
            "description": "This problem tests the ability to work with dynamic programming. The task is to implement a function that finds the longest common substring between two strings.",
            "function_prototype": {
                "function_name": "longest_common_substring",
                "parameters": [
                    {
                        "name": "text1",
                        "type": "str"
                    },
                    {
                        "name": "text2",
                        "type": "str"
                    }
                ],
                "return_values": [
                    {
                        "type": "str"
                    }
                ]
            },
            "prompts": [
                {
                    "type": "prompt_only",
                    "content": "Implement a function that finds the longest common substring between two strings."
                },
                {
                    "type": "prompt_with_tests",
                    "content": "Implement a function that finds the longest common substring between two strings.\n\nTest Cases:\n- Input: 'abcde', 'bcde'\n  Expected Output: 'bcde'\n- Input: 'abcdef', 'abef'\n  Expected Output: 'abe'"
                },
                {
                    "type": "prompt_tests_only",
                    "content": "Write a Python function to pass the following tests: def test_longest_common_substring():\n  assert longest_common_substring('abcde', 'bcde') == 'bcde'\n  assert longest_common_substring('abcdef', 'abef') == 'abe'"
                },
                {
                    "type": "prompt_generic_tests",
                    "content": "Write a Python function to pass the following tests: def test_generic_25():\n  assert function('abcde', 'bcde') == 'bcde'\n  assert function('abcdef', 'abef') == 'abe'"
                }
            ],
            "test_cases": [
                {
                    "parameters": {
                        "text1": "'abcde'",
                        "text2": "'bcde'"
                    },
                    "expected_output": [
                        "'bcde'"
                    ]
                },
                {
                    "parameters": {
                        "text1": "'abcdef'",
                        "text2": "'abef'"
                    },
                    "expected_output": [
                        "'abe'"
                    ]
                }
            ]
        }
    ]
}