DeepSeek/DeepSeek-Coder
1
0
Fork 0
mirror of https://github.com/deepseek-ai/DeepSeek-Coder synced 2024-12-12 23:24:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
b7ba565956
DeepSeek-Coder/Evaluation/HumanEval/data/humaneval-cs
Dejian a4ba628dfd init project
2023-11-02 22:07:09 +08:00

159 lines
307 KiB
Plaintext
Raw Blame History

{"name": "HumanEval_23_strlen", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return length of given string\n // >>> StringLength((\"\"))\n // (0L)\n // >>> StringLength((\"abc\"))\n // (3L)\n public static long Strlen(string str) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_23_strlen.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Strlen((\"\")) == (0L));\n Debug.Assert(Strlen((\"x\")) == (1L));\n Debug.Assert(Strlen((\"asdasnakj\")) == (9L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_23_strlen"}
{"name": "HumanEval_89_encrypt", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Create a function encrypt that takes a string as an argument and\n // returns a string encrypted with the alphabet being rotated. \n // The alphabet should be rotated in a manner such that the letters \n // shift down by two multiplied to two places.\n // For example:\n // >>> Encrypt((\"hi\"))\n // (\"lm\")\n // >>> Encrypt((\"asdfghjkl\"))\n // (\"ewhjklnop\")\n // >>> Encrypt((\"gf\"))\n // (\"kj\")\n // >>> Encrypt((\"et\"))\n // (\"ix\")\n public static string Encrypt(string s) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_89_encrypt.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Encrypt((\"hi\")).Equals((\"lm\")));\n Debug.Assert(Encrypt((\"asdfghjkl\")).Equals((\"ewhjklnop\")));\n Debug.Assert(Encrypt((\"gf\")).Equals((\"kj\")));\n Debug.Assert(Encrypt((\"et\")).Equals((\"ix\")));\n Debug.Assert(Encrypt((\"faewfawefaewg\")).Equals((\"jeiajeaijeiak\")));\n Debug.Assert(Encrypt((\"hellomyfriend\")).Equals((\"lippsqcjvmirh\")));\n Debug.Assert(Encrypt((\"dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh\")).Equals((\"hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl\")));\n Debug.Assert(Encrypt((\"a\")).Equals((\"e\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_89_encrypt"}
{"name": "HumanEval_95_check_dict_case", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a dictionary, return true if all keys are strings in lower \n // case or all keys are strings in upper case, else return false.\n // The function should return false is the given dictionary is empty.\n // Examples:\n // >>> CheckDictCase((new Dictionary<string,string>(){{\"a\", \"apple\"}, {\"b\", \"banana\"}}))\n // (true)\n // >>> CheckDictCase((new Dictionary<string,string>(){{\"a\", \"apple\"}, {\"A\", \"banana\"}, {\"B\", \"banana\"}}))\n // (false)\n // >>> CheckDictCase((new Dictionary<string,string>(){{\"a\", \"apple\"}, {8L, \"banana\"}, {\"a\", \"apple\"}}))\n // (false)\n // >>> CheckDictCase((new Dictionary<string,string>(){{\"Name\", \"John\"}, {\"Age\", \"36\"}, {\"City\", \"Houston\"}}))\n // (false)\n // >>> CheckDictCase((new Dictionary<string,string>(){{\"STATE\", \"NC\"}, {\"ZIP\", \"12345\"}}))\n // (true)\n public static bool CheckDictCase(Dictionary<string,string> dict) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_95_check_dict_case.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{\"p\", \"pineapple\"}, {\"b\", \"banana\"}})) == (true));\n Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{\"p\", \"pineapple\"}, {\"A\", \"banana\"}, {\"B\", \"banana\"}})) == (false));\n Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{\"p\", \"pineapple\"}, {\"5\", \"banana\"}, {\"a\", \"apple\"}})) == (false));\n Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{\"Name\", \"John\"}, {\"Age\", \"36\"}, {\"City\", \"Houston\"}})) == (false));\n Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{\"STATE\", \"NC\"}, {\"ZIP\", \"12345\"}})) == (true));\n Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{\"fruit\", \"Orange\"}, {\"taste\", \"Sweet\"}})) == (true));\n Debug.Assert(CheckDictCase((new Dictionary<string,string>())) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_95_check_dict_case"}
{"name": "HumanEval_85_add", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a non-empty list of integers lst. add the even elements that are at odd indices..\n // Examples:\n // >>> Add((new List<long>(new long[]{(long)4L, (long)2L, (long)6L, (long)7L})))\n // (2L)\n public static long Add(List<long> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_85_add.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Add((new List<long>(new long[]{(long)4L, (long)88L}))) == (88L));\n Debug.Assert(Add((new List<long>(new long[]{(long)4L, (long)5L, (long)6L, (long)7L, (long)2L, (long)122L}))) == (122L));\n Debug.Assert(Add((new List<long>(new long[]{(long)4L, (long)0L, (long)6L, (long)7L}))) == (0L));\n Debug.Assert(Add((new List<long>(new long[]{(long)4L, (long)4L, (long)6L, (long)8L}))) == (12L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_85_add"}
{"name": "HumanEval_140_fix_spaces", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a string text, replace all spaces in it with underscores, \n // and if a string has more than 2 consecutive spaces, \n // then replace all consecutive spaces with - \n // >>> FixSpaces((\" Example\"))\n // (\"Example\")\n // >>> FixSpaces((\" Example 1\"))\n // (\"Example_1\")\n // >>> FixSpaces((\" Example 2\"))\n // (\"_Example_2\")\n // >>> FixSpaces((\" Example 3\"))\n // (\"_Example-3\")\n public static string FixSpaces(string text) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FixSpaces((\"Example\")).Equals((\"Example\")));\n Debug.Assert(FixSpaces((\"Mudasir Hanif \")).Equals((\"Mudasir_Hanif_\")));\n Debug.Assert(FixSpaces((\"Yellow Yellow Dirty Fellow\")).Equals((\"Yellow_Yellow__Dirty__Fellow\")));\n Debug.Assert(FixSpaces((\"Exa mple\")).Equals((\"Exa-mple\")));\n Debug.Assert(FixSpaces((\" Exa 1 2 2 mple\")).Equals((\"-Exa_1_2_2_mple\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_140_fix_spaces"}
{"name": "HumanEval_63_fibfib", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:\n // fibfib(0) == 0\n // fibfib(1) == 0\n // fibfib(2) == 1\n // fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).\n // Please write a function to efficiently compute the n-th element of the fibfib number sequence.\n // >>> Fibfib((1L))\n // (0L)\n // >>> Fibfib((5L))\n // (4L)\n // >>> Fibfib((8L))\n // (24L)\n public static long Fibfib(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_63_fibfib.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Fibfib((2L)) == (1L));\n Debug.Assert(Fibfib((1L)) == (0L));\n Debug.Assert(Fibfib((5L)) == (4L));\n Debug.Assert(Fibfib((8L)) == (24L));\n Debug.Assert(Fibfib((10L)) == (81L));\n Debug.Assert(Fibfib((12L)) == (274L));\n Debug.Assert(Fibfib((14L)) == (927L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_63_fibfib"}
{"name": "HumanEval_151_double_the_difference", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a list of numbers, return the sum of squares of the numbers\n // in the list that are odd. Ignore numbers that are negative or not integers.\n // >>> DoubleTheDifference((new List<float>(new long[]{(long)1L, (long)3L, (long)2L, (long)0L})))\n // (10L)\n // >>> DoubleTheDifference((new List<float>(new long[]{(long)-1L, (long)-2L, (long)0L})))\n // (0L)\n // >>> DoubleTheDifference((new List<float>(new long[]{(long)9L, (long)-2L})))\n // (81L)\n // >>> DoubleTheDifference((new List<float>(new long[]{(long)0L})))\n // (0L)\n // If the input list is empty, return 0.\n public static long DoubleTheDifference(List<float> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(DoubleTheDifference((new List<float>())) == (0L));\n Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)5.0f, (float)4.0f}))) == (25L));\n Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)0.1f, (float)0.2f, (float)0.3f}))) == (0L));\n Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)-10.0f, (float)-20.0f, (float)-30.0f}))) == (0L));\n Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)-1.0f, (float)-2.0f, (float)8.0f}))) == (0L));\n Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)0.2f, (float)3.0f, (float)5.0f}))) == (34L));\n Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)-9.0f, (float)-7.0f, (float)-5.0f, (float)-3.0f, (float)-1.0f, (float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f, (float)9.0f}))) == (165L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_151_double_the_difference"}
{"name": "HumanEval_22_filter_integers", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Filter given list of any csthon values only for integers\n // >>> FilterIntegers((new List<object>(new string[]{(string)\"a\", (string)3.14f, (string)5L})))\n // (new List<long>(new long[]{(long)5L}))\n // >>> FilterIntegers((new List<object>(new object[]{1L, 2L, 3L, \"abc\", new List<object>()})))\n // (new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))\n public static List<long> FilterIntegers(List<object> values) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_22_filter_integers.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FilterIntegers((new List<object>())).Equals((new List<long>())));\n Debug.Assert(FilterIntegers((new List<object>(new object[]{4L, new List<object>(), 23.2f, 9L, \"adasd\"}))).Equals((new List<long>(new long[]{(long)4L, (long)9L}))));\n Debug.Assert(FilterIntegers((new List<object>(new object[]{3L, \"c\", 3L, 3L, \"a\", \"b\"}))).Equals((new List<long>(new long[]{(long)3L, (long)3L, (long)3L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_22_filter_integers"}
{"name": "HumanEval_41_car_race_collision", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Imagine a road that's a perfectly straight infinitely long line.\n // n cars are driving left to right; simultaneously, a different set of n cars\n // are driving right to left. The two sets of cars start out being very far from\n // each other. All cars move in the same speed. Two cars are said to collide\n // when a car that's moving left to right hits a car that's moving right to left.\n // However, the cars are infinitely sturdy and strong; as a result, they continue moving\n // in their trajectory as if they did not collide.\n // This function outputs the number of such collisions.\n public static long CarRaceCollision(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_41_car_race_collision.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CarRaceCollision((2L)) == (4L));\n Debug.Assert(CarRaceCollision((3L)) == (9L));\n Debug.Assert(CarRaceCollision((4L)) == (16L));\n Debug.Assert(CarRaceCollision((8L)) == (64L));\n Debug.Assert(CarRaceCollision((10L)) == (100L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_41_car_race_collision"}
{"name": "HumanEval_17_parse_music", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Input to this function is a string representing musical notes in a special ASCII format.\n // Your task is to parse this string and return list of integers corresponding to how many beats does each\n // not last.\n // Here is a legend:\n // 'o' - whole note, lasts four beats\n // 'o|' - half note, lasts two beats\n // '.|' - quater note, lasts one beat\n // >>> ParseMusic((\"o o| .| o| o| .| .| .| .| o o\"))\n // (new List<long>(new long[]{(long)4L, (long)2L, (long)1L, (long)2L, (long)2L, (long)1L, (long)1L, (long)1L, (long)1L, (long)4L, (long)4L}))\n public static List<long> ParseMusic(string music_string) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_17_parse_music.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(ParseMusic((\"\")).Equals((new List<long>())));\n Debug.Assert(ParseMusic((\"o o o o\")).Equals((new List<long>(new long[]{(long)4L, (long)4L, (long)4L, (long)4L}))));\n Debug.Assert(ParseMusic((\".| .| .| .|\")).Equals((new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L}))));\n Debug.Assert(ParseMusic((\"o| o| .| .| o o o o\")).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)1L, (long)1L, (long)4L, (long)4L, (long)4L, (long)4L}))));\n Debug.Assert(ParseMusic((\"o| .| o| .| o o| o o|\")).Equals((new List<long>(new long[]{(long)2L, (long)1L, (long)2L, (long)1L, (long)4L, (long)2L, (long)4L, (long)2L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_17_parse_music"}
{"name": "HumanEval_79_decimal_to_binary", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You will be given a number in decimal form and your task is to convert it to\n // binary format. The function should return a string, with each character representing a binary\n // number. Each character in the string will be '0' or '1'.\n // There will be an extra couple of characters 'db' at the beginning and at the end of the string.\n // The extra characters are there to help with the format.\n // Examples:\n // >>> DecimalToBinary((15L))\n // (\"db1111db\")\n // >>> DecimalToBinary((32L))\n // (\"db100000db\")\n public static string DecimalToBinary(long decimalNum) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_79_decimal_to_binary.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(DecimalToBinary((0L)).Equals((\"db0db\")));\n Debug.Assert(DecimalToBinary((32L)).Equals((\"db100000db\")));\n Debug.Assert(DecimalToBinary((103L)).Equals((\"db1100111db\")));\n Debug.Assert(DecimalToBinary((15L)).Equals((\"db1111db\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_79_decimal_to_binary"}
{"name": "HumanEval_14_all_prefixes", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return list of all prefixes from shortest to longest of the input string\n // >>> AllPrefixes((\"abc\"))\n // (new List<string>(new string[]{(string)\"a\", (string)\"ab\", (string)\"abc\"}))\n public static List<string> AllPrefixes(string str) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_14_all_prefixes.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(AllPrefixes((\"\")).Equals((new List<string>())));\n Debug.Assert(AllPrefixes((\"asdfgh\")).Equals((new List<string>(new string[]{(string)\"a\", (string)\"as\", (string)\"asd\", (string)\"asdf\", (string)\"asdfg\", (string)\"asdfgh\"}))));\n Debug.Assert(AllPrefixes((\"WWW\")).Equals((new List<string>(new string[]{(string)\"W\", (string)\"WW\", (string)\"WWW\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_14_all_prefixes"}
{"name": "HumanEval_53_add", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Add two numbers x and y\n // >>> Add((2L), (3L))\n // (5L)\n // >>> Add((5L), (7L))\n // (12L)\n public static long Add(long x, long y) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_53_add.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Add((0L), (1L)) == (1L));\n Debug.Assert(Add((1L), (0L)) == (1L));\n Debug.Assert(Add((2L), (3L)) == (5L));\n Debug.Assert(Add((5L), (7L)) == (12L));\n Debug.Assert(Add((7L), (5L)) == (12L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_53_add"}
{"name": "HumanEval_159_eat", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You're a hungry rabbit, and you already have eaten a certain number of carrots,\n // but now you need to eat more carrots to complete the day's meals.\n // you should return a list of [ total number of eaten carrots after your meals,\n // the number of carrots left after your meals ]\n // if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.\n // Example:\n // >>> Eat((5L), (6L), (10L))\n // (new List<long>(new long[]{(long)11L, (long)4L}))\n // >>> Eat((4L), (8L), (9L))\n // (new List<long>(new long[]{(long)12L, (long)1L}))\n // >>> Eat((1L), (10L), (10L))\n // (new List<long>(new long[]{(long)11L, (long)0L}))\n // >>> Eat((2L), (11L), (5L))\n // (new List<long>(new long[]{(long)7L, (long)0L}))\n // Variables:\n // @number : integer\n // the number of carrots that you have eaten.\n // @need : integer\n // the number of carrots that you need to eat.\n // @remaining : integer\n // the number of remaining carrots thet exist in stock\n // Constrain:\n // * 0 <= number <= 1000\n // * 0 <= need <= 1000\n // * 0 <= remaining <= 1000\n // Have fun :)\n public static List<long> Eat(long number, long need, long remaining) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Eat((5L), (6L), (10L)).Equals((new List<long>(new long[]{(long)11L, (long)4L}))));\n Debug.Assert(Eat((4L), (8L), (9L)).Equals((new List<long>(new long[]{(long)12L, (long)1L}))));\n Debug.Assert(Eat((1L), (10L), (10L)).Equals((new List<long>(new long[]{(long)11L, (long)0L}))));\n Debug.Assert(Eat((2L), (11L), (5L)).Equals((new List<long>(new long[]{(long)7L, (long)0L}))));\n Debug.Assert(Eat((4L), (5L), (7L)).Equals((new List<long>(new long[]{(long)9L, (long)2L}))));\n Debug.Assert(Eat((4L), (5L), (1L)).Equals((new List<long>(new long[]{(long)5L, (long)0L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_159_eat"}
{"name": "HumanEval_115_max_fill", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a rectangular grid of wells. Each row represents a single well,\n // and each 1 in a row represents a single unit of water.\n // Each well has a corresponding bucket that can be used to extract water from it, \n // and all buckets have the same capacity.\n // Your task is to use the buckets to empty the wells.\n // Output the number of times you need to lower the buckets.\n // Example 1:\n // >>> MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)1L, (long)0L}), (List<long>)new List<long>(new long[]{(long)0L, (long)1L, (long)0L, (long)0L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L})})), (1L))\n // (6L)\n // Example 2:\n // >>> MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)0L, (long)1L, (long)1L, (long)1L})})), (2L))\n // (5L)\n // Example 3:\n // >>> MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)0L}), (List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)0L})})), (5L))\n // (0L)\n // Constraints:\n // * all wells have the same length\n // * 1 <= grid.length <= 10^2\n // * 1 <= grid[:,1].length <= 10^2\n // * grid[i][j] -> 0 | 1\n // * 1 <= capacity <= 10\n public static long MaxFill(List<List<long>> grid, long capacity) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)1L, (long)0L}), (List<long>)new List<long>(new long[]{(long)0L, (long)1L, (long)0L, (long)0L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L})})), (1L)) == (6L));\n Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)0L, (long)1L, (long)1L, (long)1L})})), (2L)) == (5L));\n Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)0L}), (List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)0L})})), (5L)) == (0L));\n Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L})})), (2L)) == (4L));\n Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L})})), (9L)) == (2L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_115_max_fill"}
{"name": "HumanEval_160_do_algebra", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given two lists operator, and operand. The first list has basic algebra operations, and \n // the second list is a list of integers. Use the two given lists to build the algebric \n // expression and return the evaluation of this expression.\n // The basic algebra operations:\n // Addition ( + ) \n // Subtraction ( - ) \n // Multiplication ( * ) \n // Floor division ( // ) \n // Exponentiation ( ** ) \n // Example:\n // operator['+', '*', '-']\n // list = [2, 3, 4, 5]\n // result = 2 + 3 * 4 - 5\n // => result = 9\n // Note:\n // The length of operator list is equal to the length of operand list minus one.\n // Operand is a list of of non-negative integers.\n // Operator list has at least one operator, and operand list has at least two operands.\n public static long DoAlgebra(List<string> op, List<long> operand) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(DoAlgebra((new List<string>(new string[]{(string)\"**\", (string)\"*\", (string)\"+\"})), (new List<long>(new long[]{(long)2L, (long)3L, (long)4L, (long)5L}))) == (37L));\n Debug.Assert(DoAlgebra((new List<string>(new string[]{(string)\"+\", (string)\"*\", (string)\"-\"})), (new List<long>(new long[]{(long)2L, (long)3L, (long)4L, (long)5L}))) == (9L));\n Debug.Assert(DoAlgebra((new List<string>(new string[]{(string)\"//\", (string)\"*\"})), (new List<long>(new long[]{(long)7L, (long)3L, (long)4L}))) == (8L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_160_do_algebra"}
{"name": "HumanEval_27_flip_case", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // For a given string, flip lowercase characters to uppercase and uppercase to lowercase.\n // >>> FlipCase((\"Hello\"))\n // (\"hELLO\")\n public static string FlipCase(string str) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_27_flip_case.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FlipCase((\"\")).Equals((\"\")));\n Debug.Assert(FlipCase((\"Hello!\")).Equals((\"hELLO!\")));\n Debug.Assert(FlipCase((\"These violent delights have violent ends\")).Equals((\"tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_27_flip_case"}
{"name": "HumanEval_105_by_length", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a list of integers, sort the integers that are between 1 and 9 inclusive,\n // reverse the resulting list, and then replace each digit by its corresponding name from\n // \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\".\n // For example:\n // >>> ByLength((new List<long>(new long[]{(long)2L, (long)1L, (long)1L, (long)4L, (long)5L, (long)8L, (long)2L, (long)3L})))\n // (new List<string>(new string[]{(string)\"Eight\", (string)\"Five\", (string)\"Four\", (string)\"Three\", (string)\"Two\", (string)\"Two\", (string)\"One\", (string)\"One\"}))\n // If the list is empty, return an empty list:\n // >>> ByLength((new List<long>()))\n // (new List<string>())\n // If the list has any strange number ignore it:\n // >>> ByLength((new List<long>(new long[]{(long)1L, (long)-1L, (long)55L})))\n // (new List<string>(new string[]{(string)\"One\"}))\n public static List<string> ByLength(List<long> arr) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_105_by_length.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(ByLength((new List<long>(new long[]{(long)2L, (long)1L, (long)1L, (long)4L, (long)5L, (long)8L, (long)2L, (long)3L}))).Equals((new List<string>(new string[]{(string)\"Eight\", (string)\"Five\", (string)\"Four\", (string)\"Three\", (string)\"Two\", (string)\"Two\", (string)\"One\", (string)\"One\"}))));\n Debug.Assert(ByLength((new List<long>())).Equals((new List<string>())));\n Debug.Assert(ByLength((new List<long>(new long[]{(long)1L, (long)-1L, (long)55L}))).Equals((new List<string>(new string[]{(string)\"One\"}))));\n Debug.Assert(ByLength((new List<long>(new long[]{(long)1L, (long)-1L, (long)3L, (long)2L}))).Equals((new List<string>(new string[]{(string)\"Three\", (string)\"Two\", (string)\"One\"}))));\n Debug.Assert(ByLength((new List<long>(new long[]{(long)9L, (long)4L, (long)8L}))).Equals((new List<string>(new string[]{(string)\"Nine\", (string)\"Eight\", (string)\"Four\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_105_by_length"}
{"name": "HumanEval_25_factorize", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return list of prime factors of given integer in the order from smallest to largest.\n // Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.\n // Input number should be equal to the product of all factors\n // >>> Factorize((8L))\n // (new List<long>(new long[]{(long)2L, (long)2L, (long)2L}))\n // >>> Factorize((25L))\n // (new List<long>(new long[]{(long)5L, (long)5L}))\n // >>> Factorize((70L))\n // (new List<long>(new long[]{(long)2L, (long)5L, (long)7L}))\n public static List<long> Factorize(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_25_factorize.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Factorize((2L)).Equals((new List<long>(new long[]{(long)2L}))));\n Debug.Assert(Factorize((4L)).Equals((new List<long>(new long[]{(long)2L, (long)2L}))));\n Debug.Assert(Factorize((8L)).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)2L}))));\n Debug.Assert(Factorize((57L)).Equals((new List<long>(new long[]{(long)3L, (long)19L}))));\n Debug.Assert(Factorize((3249L)).Equals((new List<long>(new long[]{(long)3L, (long)3L, (long)19L, (long)19L}))));\n Debug.Assert(Factorize((185193L)).Equals((new List<long>(new long[]{(long)3L, (long)3L, (long)3L, (long)19L, (long)19L, (long)19L}))));\n Debug.Assert(Factorize((20577L)).Equals((new List<long>(new long[]{(long)3L, (long)19L, (long)19L, (long)19L}))));\n Debug.Assert(Factorize((18L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)3L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_25_factorize"}
{"name": "HumanEval_96_count_up_to", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Implement a function that takes an non-negative integer and returns a list of the first n\n // integers that are prime numbers and less than n.\n // for example:\n // >>> CountUpTo((5L))\n // (new List<long>(new long[]{(long)2L, (long)3L}))\n // >>> CountUpTo((11L))\n // (new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L}))\n // >>> CountUpTo((0L))\n // (new List<long>())\n // >>> CountUpTo((20L))\n // (new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L, (long)19L}))\n // >>> CountUpTo((1L))\n // (new List<long>())\n // >>> CountUpTo((18L))\n // (new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L}))\n public static List<long> CountUpTo(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_96_count_up_to.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CountUpTo((5L)).Equals((new List<long>(new long[]{(long)2L, (long)3L}))));\n Debug.Assert(CountUpTo((6L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L}))));\n Debug.Assert(CountUpTo((7L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L}))));\n Debug.Assert(CountUpTo((10L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L}))));\n Debug.Assert(CountUpTo((0L)).Equals((new List<long>())));\n Debug.Assert(CountUpTo((22L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L, (long)19L}))));\n Debug.Assert(CountUpTo((1L)).Equals((new List<long>())));\n Debug.Assert(CountUpTo((18L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L}))));\n Debug.Assert(CountUpTo((47L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L, (long)19L, (long)23L, (long)29L, (long)31L, (long)37L, (long)41L, (long)43L}))));\n Debug.Assert(CountUpTo((101L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L, (long)19L, (long)23L, (long)29L, (long)31L, (long)37L, (long)41L, (long)43L, (long)47L, (long)53L, (long)59L, (long)61L, (long)67L, (long)71L, (long)73L, (long)79L, (long)83L, (long)89L, (long)97L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_96_count_up_to"}
{"name": "HumanEval_34_unique", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return sorted unique elements in a list\n // >>> Unique((new List<long>(new long[]{(long)5L, (long)3L, (long)5L, (long)2L, (long)3L, (long)3L, (long)9L, (long)0L, (long)123L})))\n // (new List<long>(new long[]{(long)0L, (long)2L, (long)3L, (long)5L, (long)9L, (long)123L}))\n public static List<long> Unique(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_34_unique.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Unique((new List<long>(new long[]{(long)5L, (long)3L, (long)5L, (long)2L, (long)3L, (long)3L, (long)9L, (long)0L, (long)123L}))).Equals((new List<long>(new long[]{(long)0L, (long)2L, (long)3L, (long)5L, (long)9L, (long)123L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_34_unique"}
{"name": "HumanEval_74_total_match", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that accepts two lists of strings and returns the list that has \n // total number of chars in the all strings of the list less than the other list.\n // if the two lists have the same number of chars, return the first list.\n // Examples\n // >>> TotalMatch((new List<string>()), (new List<string>()))\n // (new List<string>())\n // >>> TotalMatch((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"})), (new List<string>(new string[]{(string)\"hI\", (string)\"Hi\"})))\n // (new List<string>(new string[]{(string)\"hI\", (string)\"Hi\"}))\n // >>> TotalMatch((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"})), (new List<string>(new string[]{(string)\"hi\", (string)\"hi\", (string)\"admin\", (string)\"project\"})))\n // (new List<string>(new string[]{(string)\"hi\", (string)\"admin\"}))\n // >>> TotalMatch((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"})), (new List<string>(new string[]{(string)\"hI\", (string)\"hi\", (string)\"hi\"})))\n // (new List<string>(new string[]{(string)\"hI\", (string)\"hi\", (string)\"hi\"}))\n // >>> TotalMatch((new List<string>(new string[]{(string)\"4\"})), (new List<string>(new string[]{(string)\"1\", (string)\"2\", (string)\"3\", (string)\"4\", (string)\"5\"})))\n // (new List<string>(new string[]{(string)\"4\"}))\n public static List<string> TotalMatch(List<string> lst1, List<string> lst2) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_74_total_match.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(TotalMatch((new List<string>()), (new List<string>())).Equals((new List<string>())));\n Debug.Assert(TotalMatch((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"})), (new List<string>(new string[]{(string)\"hi\", (string)\"hi\"}))).Equals((new List<string>(new string[]{(string)\"hi\", (string)\"hi\"}))));\n Debug.Assert(TotalMatch((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"})), (new List<string>(new string[]{(string)\"hi\", (string)\"hi\", (string)\"admin\", (string)\"project\"}))).Equals((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"}))));\n Debug.Assert(TotalMatch((new List<string>(new string[]{(string)\"4\"})), (new List<string>(new string[]{(string)\"1\", (string)\"2\", (string)\"3\", (string)\"4\", (string)\"5\"}))).Equals((new List<string>(new string[]{(string)\"4\"}))));\n Debug.Assert(TotalMatch((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"})), (new List<string>(new string[]{(string)\"hI\", (string)\"Hi\"}))).Equals((new List<string>(new string[]{(string)\"hI\", (string)\"Hi\"}))));\n Debug.Assert(TotalMatch((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"})), (new List<string>(new string[]{(string)\"hI\", (string)\"hi\", (string)\"hi\"}))).Equals((new List<string>(new string[]{(string)\"hI\", (string)\"hi\", (string)\"hi\"}))));\n Debug.Assert(TotalMatch((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"})), (new List<string>(new string[]{(string)\"hI\", (string)\"hi\", (string)\"hii\"}))).Equals((new List<string>(new string[]{(string)\"hi\", (string)\"admin\"}))));\n Debug.Assert(TotalMatch((new List<string>()), (new List<string>(new string[]{(string)\"this\"}))).Equals((new List<string>())));\n Debug.Assert(TotalMatch((new List<string>(new string[]{(string)\"this\"})), (new List<string>())).Equals((new List<string>())));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_74_total_match"}
{"name": "HumanEval_35_max_element", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return maximum element in the list.\n // >>> MaxElement((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))\n // (3L)\n // >>> MaxElement((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)9L, (long)0L, (long)123L, (long)1L, (long)-10L})))\n // (123L)\n public static long MaxElement(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_35_max_element.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(MaxElement((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))) == (3L));\n Debug.Assert(MaxElement((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)9L, (long)0L, (long)124L, (long)1L, (long)-10L}))) == (124L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_35_max_element"}
{"name": "HumanEval_132_is_nested", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Create a function that takes a string as input which contains only square brackets.\n // The function should return true if and only if there is a valid subsequence of brackets \n // where at least one bracket in the subsequence is nested.\n // >>> IsNested((\"[[]]\"))\n // (true)\n // >>> IsNested((\"[]]]]]]][[[[[]\"))\n // (false)\n // >>> IsNested((\"[][]\"))\n // (false)\n // >>> IsNested((\"[]\"))\n // (false)\n // >>> IsNested((\"[[][]]\"))\n // (true)\n // >>> IsNested((\"[[]][[\"))\n // (true)\n public static bool IsNested(string str) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IsNested((\"[[]]\")) == (true));\n Debug.Assert(IsNested((\"[]]]]]]][[[[[]\")) == (false));\n Debug.Assert(IsNested((\"[][]\")) == (false));\n Debug.Assert(IsNested((\"[]\")) == (false));\n Debug.Assert(IsNested((\"[[[[]]]]\")) == (true));\n Debug.Assert(IsNested((\"[]]]]]]]]]]\")) == (false));\n Debug.Assert(IsNested((\"[][][[]]\")) == (true));\n Debug.Assert(IsNested((\"[[]\")) == (false));\n Debug.Assert(IsNested((\"[]]\")) == (false));\n Debug.Assert(IsNested((\"[[]][[\")) == (true));\n Debug.Assert(IsNested((\"[[][]]\")) == (true));\n Debug.Assert(IsNested((\"\")) == (false));\n Debug.Assert(IsNested((\"[[[[[[[[\")) == (false));\n Debug.Assert(IsNested((\"]]]]]]]]\")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_132_is_nested"}
{"name": "HumanEval_113_odd_count", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a list of strings, where each string consists of only digits, return a list.\n // Each element i of the output should be \"the number of odd elements in the\n // string i of the input.\" where all the i's should be replaced by the number\n // of odd digits in the i'th string of the input.\n // >>> OddCount((new List<string>(new string[]{(string)\"1234567\"})))\n // (new List<string>(new string[]{(string)\"the number of odd elements 4n the str4ng 4 of the 4nput.\"}))\n // >>> OddCount((new List<string>(new string[]{(string)\"3\", (string)\"11111111\"})))\n // (new List<string>(new string[]{(string)\"the number of odd elements 1n the str1ng 1 of the 1nput.\", (string)\"the number of odd elements 8n the str8ng 8 of the 8nput.\"}))\n public static List<string> OddCount(List<string> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(OddCount((new List<string>(new string[]{(string)\"1234567\"}))).Equals((new List<string>(new string[]{(string)\"the number of odd elements 4n the str4ng 4 of the 4nput.\"}))));\n Debug.Assert(OddCount((new List<string>(new string[]{(string)\"3\", (string)\"11111111\"}))).Equals((new List<string>(new string[]{(string)\"the number of odd elements 1n the str1ng 1 of the 1nput.\", (string)\"the number of odd elements 8n the str8ng 8 of the 8nput.\"}))));\n Debug.Assert(OddCount((new List<string>(new string[]{(string)\"271\", (string)\"137\", (string)\"314\"}))).Equals((new List<string>(new string[]{(string)\"the number of odd elements 2n the str2ng 2 of the 2nput.\", (string)\"the number of odd elements 3n the str3ng 3 of the 3nput.\", (string)\"the number of odd elements 2n the str2ng 2 of the 2nput.\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_113_odd_count"}
{"name": "HumanEval_109_move_one_ball", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // We have a list 'arr' of N integers arr[1], arr[2], ..., arr[N].The\n // numbers in the list will be randomly ordered. Your task is to determine if\n // it is possible to get a list sorted in non-decreasing order by performing \n // the following operation on the given list:\n // You are allowed to perform right shift operation any number of times.\n // One right shift operation means shifting all elements of the list by one\n // position in the right direction. The last element of the list will be moved to\n // the starting position in the list i.e. 0th index. \n // If it is possible to obtain the sorted list by performing the above operation\n // then return true else return false.\n // If the given list is empty then return true.\n // Note: The given list is guaranteed to have unique elements.\n // For Example:\n // >>> MoveOneBall((new List<long>(new long[]{(long)3L, (long)4L, (long)5L, (long)1L, (long)2L})))\n // (true)\n // Explanation: By performin 2 right shift operations, non-decreasing order can\n // be achieved for the given list.\n // >>> MoveOneBall((new List<long>(new long[]{(long)3L, (long)5L, (long)4L, (long)1L, (long)2L})))\n // (false)\n // Explanation:It is not possible to get non-decreasing order for the given\n // list by performing any number of right shift operations.\n public static bool MoveOneBall(List<long> arr) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_109_move_one_ball.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(MoveOneBall((new List<long>(new long[]{(long)3L, (long)4L, (long)5L, (long)1L, (long)2L}))) == (true));\n Debug.Assert(MoveOneBall((new List<long>(new long[]{(long)3L, (long)5L, (long)10L, (long)1L, (long)2L}))) == (true));\n Debug.Assert(MoveOneBall((new List<long>(new long[]{(long)4L, (long)3L, (long)1L, (long)2L}))) == (false));\n Debug.Assert(MoveOneBall((new List<long>(new long[]{(long)3L, (long)5L, (long)4L, (long)1L, (long)2L}))) == (false));\n Debug.Assert(MoveOneBall((new List<long>())) == (true));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_109_move_one_ball"}
{"name": "HumanEval_107_even_odd_palindrome", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a positive integer n, return a tuple that has the number of even and odd\n // integer palindromes that fall within the range(1, n), inclusive.\n // Example 1:\n // >>> EvenOddPalindrome((3L))\n // (Tuple.Create(1L, 2L))\n // Explanation:\n // Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.\n // Example 2:\n // >>> EvenOddPalindrome((12L))\n // (Tuple.Create(4L, 6L))\n // Explanation:\n // Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.\n // Note:\n // 1. 1 <= n <= 10^3\n // 2. returned tuple has the number of even and odd integer palindromes respectively.\n public static Tuple<long, long> EvenOddPalindrome(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_107_even_odd_palindrome.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(EvenOddPalindrome((123L)).Equals((Tuple.Create(8L, 13L))));\n Debug.Assert(EvenOddPalindrome((12L)).Equals((Tuple.Create(4L, 6L))));\n Debug.Assert(EvenOddPalindrome((3L)).Equals((Tuple.Create(1L, 2L))));\n Debug.Assert(EvenOddPalindrome((63L)).Equals((Tuple.Create(6L, 8L))));\n Debug.Assert(EvenOddPalindrome((25L)).Equals((Tuple.Create(5L, 6L))));\n Debug.Assert(EvenOddPalindrome((19L)).Equals((Tuple.Create(4L, 6L))));\n Debug.Assert(EvenOddPalindrome((9L)).Equals((Tuple.Create(4L, 5L))));\n Debug.Assert(EvenOddPalindrome((1L)).Equals((Tuple.Create(0L, 1L))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_107_even_odd_palindrome"}
{"name": "HumanEval_138_is_equal_to_sum_even", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers\n // Example\n // >>> IsEqualToSumEven((4L))\n // (false)\n // >>> IsEqualToSumEven((6L))\n // (false)\n // >>> IsEqualToSumEven((8L))\n // (true)\n public static bool IsEqualToSumEven(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IsEqualToSumEven((4L)) == (false));\n Debug.Assert(IsEqualToSumEven((6L)) == (false));\n Debug.Assert(IsEqualToSumEven((8L)) == (true));\n Debug.Assert(IsEqualToSumEven((10L)) == (true));\n Debug.Assert(IsEqualToSumEven((11L)) == (false));\n Debug.Assert(IsEqualToSumEven((12L)) == (true));\n Debug.Assert(IsEqualToSumEven((13L)) == (false));\n Debug.Assert(IsEqualToSumEven((16L)) == (true));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_138_is_equal_to_sum_even"}
{"name": "HumanEval_62_derivative", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // xs represent coefficients of a polynomial.\n // xs[0] + xs[1] * x + xs[2] * x^2 + ....\n // Return derivative of this polynomial in the same form.\n // >>> Derivative((new List<long>(new long[]{(long)3L, (long)1L, (long)2L, (long)4L, (long)5L})))\n // (new List<long>(new long[]{(long)1L, (long)4L, (long)12L, (long)20L}))\n // >>> Derivative((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))\n // (new List<long>(new long[]{(long)2L, (long)6L}))\n public static List<long> Derivative(List<long> xs) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_62_derivative.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Derivative((new List<long>(new long[]{(long)3L, (long)1L, (long)2L, (long)4L, (long)5L}))).Equals((new List<long>(new long[]{(long)1L, (long)4L, (long)12L, (long)20L}))));\n Debug.Assert(Derivative((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))).Equals((new List<long>(new long[]{(long)2L, (long)6L}))));\n Debug.Assert(Derivative((new List<long>(new long[]{(long)3L, (long)2L, (long)1L}))).Equals((new List<long>(new long[]{(long)2L, (long)2L}))));\n Debug.Assert(Derivative((new List<long>(new long[]{(long)3L, (long)2L, (long)1L, (long)0L, (long)4L}))).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)0L, (long)16L}))));\n Debug.Assert(Derivative((new List<long>(new long[]{(long)1L}))).Equals((new List<long>())));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_62_derivative"}
{"name": "HumanEval_126_is_sorted", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a list of numbers, return whether or not they are sorted\n // in ascending order. If list has more than 1 duplicate of the same\n // number, return false. Assume no negative numbers and only integers.\n // Examples\n // >>> IsSorted((new List<long>(new long[]{(long)5L})))\n // (true)\n // >>> IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L})))\n // (true)\n // >>> IsSorted((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)4L, (long)5L})))\n // (false)\n // >>> IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L})))\n // (true)\n // >>> IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L})))\n // (true)\n // >>> IsSorted((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)4L, (long)5L, (long)6L, (long)7L})))\n // (false)\n // >>> IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)3L, (long)3L, (long)4L})))\n // (true)\n // >>> IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)2L, (long)3L, (long)4L})))\n // (false)\n public static bool IsSorted(List<long> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)5L}))) == (true));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))) == (true));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)4L, (long)5L}))) == (false));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}))) == (true));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L}))) == (true));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)4L, (long)5L, (long)6L, (long)7L}))) == (false));\n Debug.Assert(IsSorted((new List<long>())) == (true));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L}))) == (true));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)3L, (long)2L, (long)1L}))) == (false));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)2L, (long)3L, (long)4L}))) == (false));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)3L, (long)3L, (long)4L}))) == (false));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)3L, (long)3L, (long)4L}))) == (true));\n Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))) == (true));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_126_is_sorted"}
{"name": "HumanEval_161_solve", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a string s.\n // if s[i] is a letter, reverse its case from lower to upper or vise versa, \n // otherwise keep it as it is.\n // If the string contains no letters, reverse the string.\n // The function should return the resulted string.\n // Examples\n // >>> Solve((\"1234\"))\n // (\"4321\")\n // >>> Solve((\"ab\"))\n // (\"AB\")\n // >>> Solve((\"#a@C\"))\n // (\"#A@c\")\n public static string Solve(string s) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Solve((\"AsDf\")).Equals((\"aSdF\")));\n Debug.Assert(Solve((\"1234\")).Equals((\"4321\")));\n Debug.Assert(Solve((\"ab\")).Equals((\"AB\")));\n Debug.Assert(Solve((\"#a@C\")).Equals((\"#A@c\")));\n Debug.Assert(Solve((\"#AsdfW^45\")).Equals((\"#aSDFw^45\")));\n Debug.Assert(Solve((\"#6@2\")).Equals((\"2@6#\")));\n Debug.Assert(Solve((\"#$a^D\")).Equals((\"#$A^d\")));\n Debug.Assert(Solve((\"#ccc\")).Equals((\"#CCC\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_161_solve"}
{"name": "HumanEval_130_tri", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in \n // the last couple centuries. However, what people don't know is Tribonacci sequence.\n // Tribonacci sequence is defined by the recurrence:\n // tri(1) = 3\n // tri(n) = 1 + n / 2, if n is even.\n // tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.\n // For example:\n // tri(2) = 1 + (2 / 2) = 2\n // tri(4) = 3\n // tri(3) = tri(2) + tri(1) + tri(4)\n // = 2 + 3 + 3 = 8 \n // You are given a non-negative integer number n, you have to a return a list of the \n // first n + 1 numbers of the Tribonacci sequence.\n // Examples:\n // >>> Tri((3L))\n // (new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L}))\n public static List<long> Tri(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Tri((3L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L}))));\n Debug.Assert(Tri((4L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L}))));\n Debug.Assert(Tri((5L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L}))));\n Debug.Assert(Tri((6L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L}))));\n Debug.Assert(Tri((7L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L, (long)24L}))));\n Debug.Assert(Tri((8L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L, (long)24L, (long)5L}))));\n Debug.Assert(Tri((9L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L, (long)24L, (long)5L, (long)35L}))));\n Debug.Assert(Tri((20L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L, (long)24L, (long)5L, (long)35L, (long)6L, (long)48L, (long)7L, (long)63L, (long)8L, (long)80L, (long)9L, (long)99L, (long)10L, (long)120L, (long)11L}))));\n Debug.Assert(Tri((0L)).Equals((new List<long>(new long[]{(long)1L}))));\n Debug.Assert(Tri((1L)).Equals((new List<long>(new long[]{(long)1L, (long)3L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_130_tri"}
{"name": "HumanEval_36_fizz_buzz", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.\n // >>> FizzBuzz((50L))\n // (0L)\n // >>> FizzBuzz((78L))\n // (2L)\n // >>> FizzBuzz((79L))\n // (3L)\n public static long FizzBuzz(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_36_fizz_buzz.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FizzBuzz((50L)) == (0L));\n Debug.Assert(FizzBuzz((78L)) == (2L));\n Debug.Assert(FizzBuzz((79L)) == (3L));\n Debug.Assert(FizzBuzz((100L)) == (3L));\n Debug.Assert(FizzBuzz((200L)) == (6L));\n Debug.Assert(FizzBuzz((4000L)) == (192L));\n Debug.Assert(FizzBuzz((10000L)) == (639L));\n Debug.Assert(FizzBuzz((100000L)) == (8026L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_36_fizz_buzz"}
{"name": "HumanEval_29_filter_by_prefix", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Filter an input list of strings only for ones that start with a given prefix.\n // >>> FilterByPrefix((new List<string>()), (\"a\"))\n // (new List<string>())\n // >>> FilterByPrefix((new List<string>(new string[]{(string)\"abc\", (string)\"bcd\", (string)\"cde\", (string)\"array\"})), (\"a\"))\n // (new List<string>(new string[]{(string)\"abc\", (string)\"array\"}))\n public static List<string> FilterByPrefix(List<string> strings, string prefix) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_29_filter_by_prefix.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FilterByPrefix((new List<string>()), (\"john\")).Equals((new List<string>())));\n Debug.Assert(FilterByPrefix((new List<string>(new string[]{(string)\"xxx\", (string)\"asd\", (string)\"xxy\", (string)\"john doe\", (string)\"xxxAAA\", (string)\"xxx\"})), (\"xxx\")).Equals((new List<string>(new string[]{(string)\"xxx\", (string)\"xxxAAA\", (string)\"xxx\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_29_filter_by_prefix"}
{"name": "HumanEval_84_solve", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a positive integer N, return the total sum of its digits in binary.\n // Example\n // >>> Solve((1000L))\n // (\"1\")\n // >>> Solve((150L))\n // (\"110\")\n // >>> Solve((147L))\n // (\"1100\")\n // Variables:\n // @N integer\n // Constraints: 0 \u2264 N \u2264 10000.\n // Output:\n // a string of binary number\n public static string Solve(long N) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_84_solve.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Solve((1000L)).Equals((\"1\")));\n Debug.Assert(Solve((150L)).Equals((\"110\")));\n Debug.Assert(Solve((147L)).Equals((\"1100\")));\n Debug.Assert(Solve((333L)).Equals((\"1001\")));\n Debug.Assert(Solve((963L)).Equals((\"10010\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_84_solve"}
{"name": "HumanEval_129_minPath", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a grid with N rows and N columns (N >= 2) and a positive integer k, \n // each cell of the grid contains a value. Every integer in the range [1, N * N]\n // inclusive appears exactly once on the cells of the grid.\n // You have to find the minimum path of length k in the grid. You can start\n // from any cell, and in each step you can move to any of the neighbor cells,\n // in other words, you can go to cells which share an edge with you current\n // cell.\n // Please note that a path of length k means visiting exactly k cells (not\n // necessarily distinct).\n // You CANNOT go off the grid.\n // A path A (of length k) is considered less than a path B (of length k) if\n // after making the ordered lists of the values on the cells that A and B go\n // through (let's call them lst_A and lst_B), lst_A is lexicographically less\n // than lst_B, in other words, there exist an integer index i (1 <= i <= k)\n // such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have\n // lst_A[j] = lst_B[j].\n // It is guaranteed that the answer is unique.\n // Return an ordered list of the values on the cells that the minimum path go through.\n // Examples: \n // >>> Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L}), (List<long>)new List<long>(new long[]{(long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)7L, (long)8L, (long)9L})})), (3L))\n // (new List<long>(new long[]{(long)1L, (long)2L, (long)1L}))\n // >>> Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)5L, (long)9L, (long)3L}), (List<long>)new List<long>(new long[]{(long)4L, (long)1L, (long)6L}), (List<long>)new List<long>(new long[]{(long)7L, (long)8L, (long)2L})})), (1L))\n // (new List<long>(new long[]{(long)1L}))\n public static List<long> Minpath(List<List<long>> grid, long k) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L}), (List<long>)new List<long>(new long[]{(long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)7L, (long)8L, (long)9L})})), (3L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)1L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)5L, (long)9L, (long)3L}), (List<long>)new List<long>(new long[]{(long)4L, (long)1L, (long)6L}), (List<long>)new List<long>(new long[]{(long)7L, (long)8L, (long)2L})})), (1L)).Equals((new List<long>(new long[]{(long)1L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}), (List<long>)new List<long>(new long[]{(long)5L, (long)6L, (long)7L, (long)8L}), (List<long>)new List<long>(new long[]{(long)9L, (long)10L, (long)11L, (long)12L}), (List<long>)new List<long>(new long[]{(long)13L, (long)14L, (long)15L, (long)16L})})), (4L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)1L, (long)2L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)6L, (long)4L, (long)13L, (long)10L}), (List<long>)new List<long>(new long[]{(long)5L, (long)7L, (long)12L, (long)1L}), (List<long>)new List<long>(new long[]{(long)3L, (long)16L, (long)11L, (long)15L}), (List<long>)new List<long>(new long[]{(long)8L, (long)14L, (long)9L, (long)2L})})), (7L)).Equals((new List<long>(new long[]{(long)1L, (long)10L, (long)1L, (long)10L, (long)1L, (long)10L, (long)1L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)8L, (long)14L, (long)9L, (long)2L}), (List<long>)new List<long>(new long[]{(long)6L, (long)4L, (long)13L, (long)15L}), (List<long>)new List<long>(new long[]{(long)5L, (long)7L, (long)1L, (long)12L}), (List<long>)new List<long>(new long[]{(long)3L, (long)10L, (long)11L, (long)16L})})), (5L)).Equals((new List<long>(new long[]{(long)1L, (long)7L, (long)1L, (long)7L, (long)1L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)11L, (long)8L, (long)7L, (long)2L}), (List<long>)new List<long>(new long[]{(long)5L, (long)16L, (long)14L, (long)4L}), (List<long>)new List<long>(new long[]{(long)9L, (long)3L, (long)15L, (long)6L}), (List<long>)new List<long>(new long[]{(long)12L, (long)13L, (long)10L, (long)1L})})), (9L)).Equals((new List<long>(new long[]{(long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)12L, (long)13L, (long)10L, (long)1L}), (List<long>)new List<long>(new long[]{(long)9L, (long)3L, (long)15L, (long)6L}), (List<long>)new List<long>(new long[]{(long)5L, (long)16L, (long)14L, (long)4L}), (List<long>)new List<long>(new long[]{(long)11L, (long)8L, (long)7L, (long)2L})})), (12L)).Equals((new List<long>(new long[]{(long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)2L, (long)7L, (long)4L}), (List<long>)new List<long>(new long[]{(long)3L, (long)1L, (long)5L}), (List<long>)new List<long>(new long[]{(long)6L, (long)8L, (long)9L})})), (8L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)6L, (long)1L, (long)5L}), (List<long>)new List<long>(new long[]{(long)3L, (long)8L, (long)9L}), (List<long>)new List<long>(new long[]{(long)2L, (long)7L, (long)4L})})), (8L)).Equals((new List<long>(new long[]{(long)1L, (long)5L, (long)1L, (long)5L, (long)1L, (long)5L, (long)1L, (long)5L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L}), (List<long>)new List<long>(new long[]{(long)3L, (long)4L})})), (10L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)1L, (long)2L, (long)1L, (long)2L, (long)1L, (long)2L, (long)1L, (long)2L}))));\n Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)3L}), (List<long>)new List<long>(new long[]{(long)3L, (long)2L})})), (10L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_129_minPath"}
{"name": "HumanEval_98_count_upper", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a string s, count the number of uppercase vowels in even indices.\n // For example:\n // >>> CountUpper((\"aBCdEf\"))\n // (1L)\n // >>> CountUpper((\"abcdefg\"))\n // (0L)\n // >>> CountUpper((\"dBBE\"))\n // (0L)\n public static long CountUpper(string s) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_98_count_upper.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CountUpper((\"aBCdEf\")) == (1L));\n Debug.Assert(CountUpper((\"abcdefg\")) == (0L));\n Debug.Assert(CountUpper((\"dBBE\")) == (0L));\n Debug.Assert(CountUpper((\"B\")) == (0L));\n Debug.Assert(CountUpper((\"U\")) == (1L));\n Debug.Assert(CountUpper((\"\")) == (0L));\n Debug.Assert(CountUpper((\"EEEE\")) == (2L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_98_count_upper"}
{"name": "HumanEval_120_maximum", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a list arr of integers and a positive integer k, return a sorted list \n // of length k with the maximum k numbers in arr.\n // Example 1:\n // >>> Maximum((new List<long>(new long[]{(long)-3L, (long)-4L, (long)5L})), (3L))\n // (new List<long>(new long[]{(long)-4L, (long)-3L, (long)5L}))\n // Example 2:\n // >>> Maximum((new List<long>(new long[]{(long)4L, (long)-4L, (long)4L})), (2L))\n // (new List<long>(new long[]{(long)4L, (long)4L}))\n // Example 3:\n // >>> Maximum((new List<long>(new long[]{(long)-3L, (long)2L, (long)1L, (long)2L, (long)-1L, (long)-2L, (long)1L})), (1L))\n // (new List<long>(new long[]{(long)2L}))\n // Note:\n // 1. The length of the list will be in the range of [1, 1000].\n // 2. The elements in the list will be in the range of [-1000, 1000].\n // 3. 0 <= k <= len(arr)\n public static List<long> Maximum(List<long> arr, long k) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Maximum((new List<long>(new long[]{(long)-3L, (long)-4L, (long)5L})), (3L)).Equals((new List<long>(new long[]{(long)-4L, (long)-3L, (long)5L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)4L, (long)-4L, (long)4L})), (2L)).Equals((new List<long>(new long[]{(long)4L, (long)4L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)-3L, (long)2L, (long)1L, (long)2L, (long)-1L, (long)-2L, (long)1L})), (1L)).Equals((new List<long>(new long[]{(long)2L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)123L, (long)-123L, (long)20L, (long)0L, (long)1L, (long)2L, (long)-3L})), (3L)).Equals((new List<long>(new long[]{(long)2L, (long)20L, (long)123L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)-123L, (long)20L, (long)0L, (long)1L, (long)2L, (long)-3L})), (4L)).Equals((new List<long>(new long[]{(long)0L, (long)1L, (long)2L, (long)20L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)5L, (long)15L, (long)0L, (long)3L, (long)-13L, (long)-8L, (long)0L})), (7L)).Equals((new List<long>(new long[]{(long)-13L, (long)-8L, (long)0L, (long)0L, (long)3L, (long)5L, (long)15L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)-1L, (long)0L, (long)2L, (long)5L, (long)3L, (long)-10L})), (2L)).Equals((new List<long>(new long[]{(long)3L, (long)5L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)1L, (long)0L, (long)5L, (long)-7L})), (1L)).Equals((new List<long>(new long[]{(long)5L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)4L, (long)-4L})), (2L)).Equals((new List<long>(new long[]{(long)-4L, (long)4L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)-10L, (long)10L})), (2L)).Equals((new List<long>(new long[]{(long)-10L, (long)10L}))));\n Debug.Assert(Maximum((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)-23L, (long)243L, (long)-400L, (long)0L})), (0L)).Equals((new List<long>())));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_120_maximum"}
{"name": "HumanEval_24_largest_divisor", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // For a given number n, find the largest number that divides n evenly, smaller than n\n // >>> LargestDivisor((15L))\n // (5L)\n public static long LargestDivisor(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_24_largest_divisor.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(LargestDivisor((3L)) == (1L));\n Debug.Assert(LargestDivisor((7L)) == (1L));\n Debug.Assert(LargestDivisor((10L)) == (5L));\n Debug.Assert(LargestDivisor((100L)) == (50L));\n Debug.Assert(LargestDivisor((49L)) == (7L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_24_largest_divisor"}
{"name": "HumanEval_88_sort_array", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a list of non-negative integers, return a cocs of the given list after sorting,\n // you will sort the given list in ascending order if the sum( first index value, last index value) is odd,\n // or sort it in descending order if the sum( first index value, last index value) is even.\n // Note:\n // * don't change the given list.\n // Examples:\n // >>> SortArray((new List<long>()))\n // (new List<long>())\n // >>> SortArray((new List<long>(new long[]{(long)5L})))\n // (new List<long>(new long[]{(long)5L}))\n // >>> SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)3L, (long)0L, (long)1L, (long)5L})))\n // (new List<long>(new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))\n // >>> SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)3L, (long)0L, (long)1L, (long)5L, (long)6L})))\n // (new List<long>(new long[]{(long)6L, (long)5L, (long)4L, (long)3L, (long)2L, (long)1L, (long)0L}))\n public static List<long> SortArray(List<long> array) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_88_sort_array.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SortArray((new List<long>())).Equals((new List<long>())));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)5L}))).Equals((new List<long>(new long[]{(long)5L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)3L, (long)0L, (long)1L, (long)5L}))).Equals((new List<long>(new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)3L, (long)0L, (long)1L, (long)5L, (long)6L}))).Equals((new List<long>(new long[]{(long)6L, (long)5L, (long)4L, (long)3L, (long)2L, (long)1L, (long)0L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)1L}))).Equals((new List<long>(new long[]{(long)1L, (long)2L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)15L, (long)42L, (long)87L, (long)32L, (long)11L, (long)0L}))).Equals((new List<long>(new long[]{(long)0L, (long)11L, (long)15L, (long)32L, (long)42L, (long)87L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)21L, (long)14L, (long)23L, (long)11L}))).Equals((new List<long>(new long[]{(long)23L, (long)21L, (long)14L, (long)11L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_88_sort_array"}
{"name": "HumanEval_106_f", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Implement the function f that takes n as a parameter,\n // and returns a list of size n, such that the value of the element at index i is the factorial of i if i is even\n // or the sum of numbers from 1 to i otherwise.\n // i starts from 1.\n // the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).\n // Example:\n // >>> F((5L))\n // (new List<long>(new long[]{(long)1L, (long)2L, (long)6L, (long)24L, (long)15L}))\n public static List<long> F(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_106_f.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(F((5L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)6L, (long)24L, (long)15L}))));\n Debug.Assert(F((7L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)6L, (long)24L, (long)15L, (long)720L, (long)28L}))));\n Debug.Assert(F((1L)).Equals((new List<long>(new long[]{(long)1L}))));\n Debug.Assert(F((3L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)6L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_106_f"}
{"name": "HumanEval_77_iscube", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that takes an integer a and returns true \n // if this ingeger is a cube of some integer number.\n // Note: you may assume the input is always valid.\n // Examples:\n // >>> Iscube((1L))\n // (true)\n // >>> Iscube((2L))\n // (false)\n // >>> Iscube((-1L))\n // (true)\n // >>> Iscube((64L))\n // (true)\n // >>> Iscube((0L))\n // (true)\n // >>> Iscube((180L))\n // (false)\n public static bool Iscube(long a) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_77_iscube.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Iscube((1L)) == (true));\n Debug.Assert(Iscube((2L)) == (false));\n Debug.Assert(Iscube((-1L)) == (true));\n Debug.Assert(Iscube((64L)) == (true));\n Debug.Assert(Iscube((180L)) == (false));\n Debug.Assert(Iscube((1000L)) == (true));\n Debug.Assert(Iscube((0L)) == (true));\n Debug.Assert(Iscube((1729L)) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_77_iscube"}
{"name": "HumanEval_93_encode", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that takes a message, and encodes in such a \n // way that it swaps case of all letters, replaces all vowels in \n // the message with the letter that appears 2 places ahead of that \n // vowel in the english alphabet. \n // Assume only letters. \n // Examples:\n // >>> Encode((\"test\"))\n // (\"TGST\")\n // >>> Encode((\"This is a message\"))\n // (\"tHKS KS C MGSSCGG\")\n public static string Encode(string message) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_93_encode.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Encode((\"TEST\")).Equals((\"tgst\")));\n Debug.Assert(Encode((\"Mudasir\")).Equals((\"mWDCSKR\")));\n Debug.Assert(Encode((\"YES\")).Equals((\"ygs\")));\n Debug.Assert(Encode((\"This is a message\")).Equals((\"tHKS KS C MGSSCGG\")));\n Debug.Assert(Encode((\"I DoNt KnOw WhAt tO WrItE\")).Equals((\"k dQnT kNqW wHcT Tq wRkTg\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_93_encode"}
{"name": "HumanEval_91_is_bored", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You'll be given a string of words, and your task is to count the number\n // of boredoms. A boredom is a sentence that starts with the word \"I\".\n // Sentences are delimited by '.', '?' or '!'.\n // For example:\n // >>> IsBored((\"Hello world\"))\n // (0L)\n // >>> IsBored((\"The sky is blue. The sun is shining. I love this weather\"))\n // (1L)\n public static long IsBored(string S) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_91_is_bored.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IsBored((\"Hello world\")) == (0L));\n Debug.Assert(IsBored((\"Is the sky blue?\")) == (0L));\n Debug.Assert(IsBored((\"I love It !\")) == (1L));\n Debug.Assert(IsBored((\"bIt\")) == (0L));\n Debug.Assert(IsBored((\"I feel good today. I will be productive. will kill It\")) == (2L));\n Debug.Assert(IsBored((\"You and I are going for a walk\")) == (0L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_91_is_bored"}
{"name": "HumanEval_43_pairs_sum_to_zero", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // pairs_sum_to_zero takes a list of integers as an input.\n // it returns true if there are two distinct elements in the list that\n // sum to zero, and false otherwise.\n // >>> PairsSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)0L})))\n // (false)\n // >>> PairsSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)-2L, (long)1L})))\n // (false)\n // >>> PairsSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)7L})))\n // (false)\n // >>> PairsSumToZero((new List<long>(new long[]{(long)2L, (long)4L, (long)-5L, (long)3L, (long)5L, (long)7L})))\n // (true)\n // >>> PairsSumToZero((new List<long>(new long[]{(long)1L})))\n // (false)\n public static bool PairsSumToZero(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_43_pairs_sum_to_zero.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)0L}))) == (false));\n Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)-2L, (long)1L}))) == (false));\n Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)7L}))) == (false));\n Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)2L, (long)4L, (long)-5L, (long)3L, (long)5L, (long)7L}))) == (true));\n Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)1L}))) == (false));\n Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)-3L, (long)9L, (long)-1L, (long)3L, (long)2L, (long)30L}))) == (true));\n Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)-3L, (long)9L, (long)-1L, (long)3L, (long)2L, (long)31L}))) == (true));\n Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)-3L, (long)9L, (long)-1L, (long)4L, (long)2L, (long)30L}))) == (false));\n Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)-3L, (long)9L, (long)-1L, (long)4L, (long)2L, (long)31L}))) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_43_pairs_sum_to_zero"}
{"name": "HumanEval_71_triangle_area", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given the lengths of the three sides of a triangle. Return the area of\n // the triangle rounded to 2 decimal points if the three sides form a valid triangle. \n // Otherwise return -1\n // Three sides make a valid triangle when the sum of any two sides is greater \n // than the third side.\n // Example:\n // >>> TriangleArea((3L), (4L), (5L))\n // (6.0f)\n // >>> TriangleArea((1L), (2L), (10L))\n // (float)-1L\n public static float TriangleArea(long a, long b, long c) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_71_triangle_area.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(TriangleArea((3L), (4L), (5L)) == (6.0f));\n Debug.Assert(TriangleArea((1L), (2L), (10L)) == (float)-1L);\n Debug.Assert(TriangleArea((4L), (8L), (5L)) == (8.18f));\n Debug.Assert(TriangleArea((2L), (2L), (2L)) == (1.73f));\n Debug.Assert(TriangleArea((1L), (2L), (3L)) == (float)-1L);\n Debug.Assert(TriangleArea((10L), (5L), (7L)) == (16.25f));\n Debug.Assert(TriangleArea((2L), (6L), (3L)) == (float)-1L);\n Debug.Assert(TriangleArea((1L), (1L), (1L)) == (0.43f));\n Debug.Assert(TriangleArea((2L), (2L), (10L)) == (float)-1L);\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_71_triangle_area"}
{"name": "HumanEval_148_bf", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // There are eight planets in our solar system: the closerst to the Sun \n // is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, \n // Uranus, Neptune.\n // Write a function that takes two planet names as strings planet1 and planet2. \n // The function should return a tuple containing all planets whose orbits are \n // located between the orbit of planet1 and the orbit of planet2, sorted by \n // the proximity to the sun. \n // The function should return an empty tuple if planet1 or planet2\n // are not correct planet names. \n // Examples\n // >>> Bf((\"Jupiter\"), (\"Neptune\"))\n // (new List<string>(new string[]{(string)\"Saturn\", (string)\"Uranus\"}))\n // >>> Bf((\"Earth\"), (\"Mercury\"))\n // (List<string>(\"Venus\"))\n // >>> Bf((\"Mercury\"), (\"Uranus\"))\n // (new List<string>(new string[]{(string)\"Venus\", (string)\"Earth\", (string)\"Mars\", (string)\"Jupiter\", (string)\"Saturn\"}))\n public static List<string> Bf(string planet1, string planet2) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_148_bf.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Bf((\"Jupiter\"), (\"Neptune\")).Equals((new List<string>(new string[]{(string)\"Saturn\", (string)\"Uranus\"}))));\n Debug.Assert(Bf((\"Earth\"), (\"Mercury\")).Equals((new List<string>(new string[]{(string)\"Venus\"}))));\n Debug.Assert(Bf((\"Mercury\"), (\"Uranus\")).Equals((new List<string>(new string[]{(string)\"Venus\", (string)\"Earth\", (string)\"Mars\", (string)\"Jupiter\", (string)\"Saturn\"}))));\n Debug.Assert(Bf((\"Neptune\"), (\"Venus\")).Equals((new List<string>(new string[]{(string)\"Earth\", (string)\"Mars\", (string)\"Jupiter\", (string)\"Saturn\", (string)\"Uranus\"}))));\n Debug.Assert(Bf((\"Earth\"), (\"Earth\")).Equals((new List<string>())));\n Debug.Assert(Bf((\"Mars\"), (\"Earth\")).Equals((new List<string>())));\n Debug.Assert(Bf((\"Jupiter\"), (\"Makemake\")).Equals((new List<string>())));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_148_bf"}
{"name": "HumanEval_131_digits", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a positive integer n, return the product of the odd digits.\n // Return 0 if all digits are even.\n // For example:\n // >>> Digits((1L))\n // (1L)\n // >>> Digits((4L))\n // (0L)\n // >>> Digits((235L))\n // (15L)\n public static long Digits(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Digits((5L)) == (5L));\n Debug.Assert(Digits((54L)) == (5L));\n Debug.Assert(Digits((120L)) == (1L));\n Debug.Assert(Digits((5014L)) == (5L));\n Debug.Assert(Digits((98765L)) == (315L));\n Debug.Assert(Digits((5576543L)) == (2625L));\n Debug.Assert(Digits((2468L)) == (0L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_131_digits"}
{"name": "HumanEval_101_words_string", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You will be given a string of words separated by commas or spaces. Your task is\n // to split the string into words and return a list of the words.\n // For example:\n // >>> WordsString((\"Hi, my name is John\"))\n // (new List<string>(new string[]{(string)\"Hi\", (string)\"my\", (string)\"name\", (string)\"is\", (string)\"John\"}))\n // >>> WordsString((\"One, two, three, four, five, six\"))\n // (new List<string>(new string[]{(string)\"One\", (string)\"two\", (string)\"three\", (string)\"four\", (string)\"five\", (string)\"six\"}))\n public static List<string> WordsString(string s) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_101_words_string.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(WordsString((\"Hi, my name is John\")).Equals((new List<string>(new string[]{(string)\"Hi\", (string)\"my\", (string)\"name\", (string)\"is\", (string)\"John\"}))));\n Debug.Assert(WordsString((\"One, two, three, four, five, six\")).Equals((new List<string>(new string[]{(string)\"One\", (string)\"two\", (string)\"three\", (string)\"four\", (string)\"five\", (string)\"six\"}))));\n Debug.Assert(WordsString((\"Hi, my name\")).Equals((new List<string>(new string[]{(string)\"Hi\", (string)\"my\", (string)\"name\"}))));\n Debug.Assert(WordsString((\"One,, two, three, four, five, six,\")).Equals((new List<string>(new string[]{(string)\"One\", (string)\"two\", (string)\"three\", (string)\"four\", (string)\"five\", (string)\"six\"}))));\n Debug.Assert(WordsString((\"\")).Equals((new List<string>())));\n Debug.Assert(WordsString((\"ahmed , gamal\")).Equals((new List<string>(new string[]{(string)\"ahmed\", (string)\"gamal\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_101_words_string"}
{"name": "HumanEval_18_how_many_times", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Find how many times a given substring can be found in the original string. Count overlaping cases.\n // >>> HowManyTimes((\"\"), (\"a\"))\n // (0L)\n // >>> HowManyTimes((\"aaa\"), (\"a\"))\n // (3L)\n // >>> HowManyTimes((\"aaaa\"), (\"aa\"))\n // (3L)\n public static long HowManyTimes(string str, string substring) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_18_how_many_times.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(HowManyTimes((\"\"), (\"x\")) == (0L));\n Debug.Assert(HowManyTimes((\"xyxyxyx\"), (\"x\")) == (4L));\n Debug.Assert(HowManyTimes((\"cacacacac\"), (\"cac\")) == (4L));\n Debug.Assert(HowManyTimes((\"john doe\"), (\"john\")) == (1L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_18_how_many_times"}
{"name": "HumanEval_51_remove_vowels", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // remove_vowels is a function that takes string and returns string without vowels.\n // >>> RemoveVowels((\"\"))\n // (\"\")\n // >>> RemoveVowels((\"abcdef\"))\n // (\"bcdf\")\n // >>> RemoveVowels((\"aaaaa\"))\n // (\"\")\n // >>> RemoveVowels((\"aaBAA\"))\n // (\"B\")\n // >>> RemoveVowels((\"zbcd\"))\n // (\"zbcd\")\n public static string RemoveVowels(string text) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_51_remove_vowels.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(RemoveVowels((\"\")).Equals((\"\")));\n Debug.Assert(RemoveVowels((\"abcdef\\nghijklm\")).Equals((\"bcdf\\nghjklm\")));\n Debug.Assert(RemoveVowels((\"fedcba\")).Equals((\"fdcb\")));\n Debug.Assert(RemoveVowels((\"eeeee\")).Equals((\"\")));\n Debug.Assert(RemoveVowels((\"acBAA\")).Equals((\"cB\")));\n Debug.Assert(RemoveVowels((\"EcBOO\")).Equals((\"cB\")));\n Debug.Assert(RemoveVowels((\"ybcd\")).Equals((\"ybcd\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_51_remove_vowels"}
{"name": "HumanEval_70_strange_sort_list", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given list of integers, return list in strange order.\n // Strange sorting, is when you start with the minimum value,\n // then maximum of the remaining integers, then minimum and so on.\n // Examples:\n // >>> StrangeSortList((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})))\n // (new List<long>(new long[]{(long)1L, (long)4L, (long)2L, (long)3L}))\n // >>> StrangeSortList((new List<long>(new long[]{(long)5L, (long)5L, (long)5L, (long)5L})))\n // (new List<long>(new long[]{(long)5L, (long)5L, (long)5L, (long)5L}))\n // >>> StrangeSortList((new List<long>()))\n // (new List<long>())\n public static List<long> StrangeSortList(List<long> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_70_strange_sort_list.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(StrangeSortList((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)1L, (long)4L, (long)2L, (long)3L}))));\n Debug.Assert(StrangeSortList((new List<long>(new long[]{(long)5L, (long)6L, (long)7L, (long)8L, (long)9L}))).Equals((new List<long>(new long[]{(long)5L, (long)9L, (long)6L, (long)8L, (long)7L}))));\n Debug.Assert(StrangeSortList((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))).Equals((new List<long>(new long[]{(long)1L, (long)5L, (long)2L, (long)4L, (long)3L}))));\n Debug.Assert(StrangeSortList((new List<long>(new long[]{(long)5L, (long)6L, (long)7L, (long)8L, (long)9L, (long)1L}))).Equals((new List<long>(new long[]{(long)1L, (long)9L, (long)5L, (long)8L, (long)6L, (long)7L}))));\n Debug.Assert(StrangeSortList((new List<long>(new long[]{(long)5L, (long)5L, (long)5L, (long)5L}))).Equals((new List<long>(new long[]{(long)5L, (long)5L, (long)5L, (long)5L}))));\n Debug.Assert(StrangeSortList((new List<long>())).Equals((new List<long>())));\n Debug.Assert(StrangeSortList((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L, (long)8L}))).Equals((new List<long>(new long[]{(long)1L, (long)8L, (long)2L, (long)7L, (long)3L, (long)6L, (long)4L, (long)5L}))));\n Debug.Assert(StrangeSortList((new List<long>(new long[]{(long)0L, (long)2L, (long)2L, (long)2L, (long)5L, (long)5L, (long)-5L, (long)-5L}))).Equals((new List<long>(new long[]{(long)-5L, (long)5L, (long)-5L, (long)5L, (long)0L, (long)2L, (long)2L, (long)2L}))));\n Debug.Assert(StrangeSortList((new List<long>(new long[]{(long)111111L}))).Equals((new List<long>(new long[]{(long)111111L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_70_strange_sort_list"}
{"name": "HumanEval_20_find_closest_elements", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // From a supplied list of numbers (of length at least two) select and return two that are the closest to each\n // other and return them in order (smaller number, larger number).\n // >>> FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.2f})))\n // (Tuple.Create(2.0f, 2.2f))\n // >>> FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})))\n // (Tuple.Create(2.0f, 2.0f))\n public static Tuple<float, float> FindClosestElements(List<float> numbers) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_20_find_closest_elements.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f}))).Equals((Tuple.Create(3.9f, 4.0f))));\n Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f}))).Equals((Tuple.Create(5.0f, 5.9f))));\n Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.2f}))).Equals((Tuple.Create(2.0f, 2.2f))));\n Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f}))).Equals((Tuple.Create(2.0f, 2.0f))));\n Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f}))).Equals((Tuple.Create(2.2f, 3.1f))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_20_find_closest_elements"}
{"name": "HumanEval_76_is_simple_power", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Your task is to write a function that returns true if a number x is a simple\n // power of n and false in other cases.\n // x is a simple power of n if n**int=x\n // For example:\n // >>> IsSimplePower((1L), (4L))\n // (true)\n // >>> IsSimplePower((2L), (2L))\n // (true)\n // >>> IsSimplePower((8L), (2L))\n // (true)\n // >>> IsSimplePower((3L), (2L))\n // (false)\n // >>> IsSimplePower((3L), (1L))\n // (false)\n // >>> IsSimplePower((5L), (3L))\n // (false)\n public static bool IsSimplePower(long x, long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_76_is_simple_power.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IsSimplePower((16L), (2L)) == (true));\n Debug.Assert(IsSimplePower((143214L), (16L)) == (false));\n Debug.Assert(IsSimplePower((4L), (2L)) == (true));\n Debug.Assert(IsSimplePower((9L), (3L)) == (true));\n Debug.Assert(IsSimplePower((16L), (4L)) == (true));\n Debug.Assert(IsSimplePower((24L), (2L)) == (false));\n Debug.Assert(IsSimplePower((128L), (4L)) == (false));\n Debug.Assert(IsSimplePower((12L), (6L)) == (false));\n Debug.Assert(IsSimplePower((1L), (1L)) == (true));\n Debug.Assert(IsSimplePower((1L), (12L)) == (true));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_76_is_simple_power"}
{"name": "HumanEval_39_prime_fib", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // prime_fib returns n-th number that is a Fibonacci number and it's also prime.\n // >>> PrimeFib((1L))\n // (2L)\n // >>> PrimeFib((2L))\n // (3L)\n // >>> PrimeFib((3L))\n // (5L)\n // >>> PrimeFib((4L))\n // (13L)\n // >>> PrimeFib((5L))\n // (89L)\n public static long PrimeFib(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_39_prime_fib.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(PrimeFib((1L)) == (2L));\n Debug.Assert(PrimeFib((2L)) == (3L));\n Debug.Assert(PrimeFib((3L)) == (5L));\n Debug.Assert(PrimeFib((4L)) == (13L));\n Debug.Assert(PrimeFib((5L)) == (89L));\n Debug.Assert(PrimeFib((6L)) == (233L));\n Debug.Assert(PrimeFib((7L)) == (1597L));\n Debug.Assert(PrimeFib((8L)) == (28657L));\n Debug.Assert(PrimeFib((9L)) == (514229L));\n Debug.Assert(PrimeFib((10L)) == (433494437L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_39_prime_fib"}
{"name": "HumanEval_145_order_by_points", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function which sorts the given list of integers\n // in ascending order according to the sum of their digits.\n // Note: if there are several items with similar sum of their digits,\n // order them based on their index in original list.\n // For example:\n // >>> OrderByPoints((new List<long>(new long[]{(long)1L, (long)11L, (long)-1L, (long)-11L, (long)-12L})))\n // (new List<long>(new long[]{(long)-1L, (long)-11L, (long)1L, (long)-12L, (long)11L}))\n // >>> OrderByPoints((new List<long>()))\n // (new List<long>())\n public static List<long> OrderByPoints(List<long> nums) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)1L, (long)11L, (long)-1L, (long)-11L, (long)-12L}))).Equals((new List<long>(new long[]{(long)-1L, (long)-11L, (long)1L, (long)-12L, (long)11L}))));\n Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)1234L, (long)423L, (long)463L, (long)145L, (long)2L, (long)423L, (long)423L, (long)53L, (long)6L, (long)37L, (long)3457L, (long)3L, (long)56L, (long)0L, (long)46L}))).Equals((new List<long>(new long[]{(long)0L, (long)2L, (long)3L, (long)6L, (long)53L, (long)423L, (long)423L, (long)423L, (long)1234L, (long)145L, (long)37L, (long)46L, (long)56L, (long)463L, (long)3457L}))));\n Debug.Assert(OrderByPoints((new List<long>())).Equals((new List<long>())));\n Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)1L, (long)-11L, (long)-32L, (long)43L, (long)54L, (long)-98L, (long)2L, (long)-3L}))).Equals((new List<long>(new long[]{(long)-3L, (long)-32L, (long)-98L, (long)-11L, (long)1L, (long)2L, (long)43L, (long)54L}))));\n Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L, (long)10L, (long)11L}))).Equals((new List<long>(new long[]{(long)1L, (long)10L, (long)2L, (long)11L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L}))));\n Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)0L, (long)6L, (long)6L, (long)-76L, (long)-21L, (long)23L, (long)4L}))).Equals((new List<long>(new long[]{(long)-76L, (long)-21L, (long)0L, (long)4L, (long)23L, (long)6L, (long)6L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_145_order_by_points"}
{"name": "HumanEval_0_has_close_elements", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Check if in given list of numbers, are any two numbers closer to each other than\n // given threshold.\n // >>> HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f})), (0.5f))\n // (false)\n // >>> HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.8f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})), (0.3f))\n // (true)\n public static bool HasCloseElements(List<float> numbers, float threshold) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_0_has_close_elements.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.3f)) == (true));\n Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.05f)) == (false));\n Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.95f)) == (true));\n Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.8f)) == (false));\n Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})), (0.1f)) == (true));\n Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (1.0f)) == (true));\n Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (0.5f)) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_0_has_close_elements"}
{"name": "HumanEval_10_make_palindrome", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Find the shortest palindrome that begins with a supplied string.\n // Algorithm idea is simple:\n // - Find the longest postfix of supplied string that is a palindrome.\n // - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.\n // >>> MakePalindrome((\"\"))\n // (\"\")\n // >>> MakePalindrome((\"cat\"))\n // (\"catac\")\n // >>> MakePalindrome((\"cata\"))\n // (\"catac\")\n public static string MakePalindrome(string str) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_10_make_palindrome.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(MakePalindrome((\"\")).Equals((\"\")));\n Debug.Assert(MakePalindrome((\"x\")).Equals((\"x\")));\n Debug.Assert(MakePalindrome((\"xyz\")).Equals((\"xyzyx\")));\n Debug.Assert(MakePalindrome((\"xyx\")).Equals((\"xyx\")));\n Debug.Assert(MakePalindrome((\"jerry\")).Equals((\"jerryrrej\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_10_make_palindrome"}
{"name": "HumanEval_11_string_xor", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Input are two strings a and b consisting only of 1s and 0s.\n // Perform binary XOR on these inputs and return result also as a string.\n // >>> StringXor((\"010\"), (\"110\"))\n // (\"100\")\n public static string StringXor(string a, string b) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_11_string_xor.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(StringXor((\"111000\"), (\"101010\")).Equals((\"010010\")));\n Debug.Assert(StringXor((\"1\"), (\"1\")).Equals((\"0\")));\n Debug.Assert(StringXor((\"0101\"), (\"0000\")).Equals((\"0101\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_11_string_xor"}
{"name": "HumanEval_139_special_factorial", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // The Brazilian factorial is defined as:\n // brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n // where n > 0\n // For example:\n // >>> SpecialFactorial((4L))\n // (288L)\n // The function will receive an integer as input and should return the special\n // factorial of this integer.\n public static long SpecialFactorial(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SpecialFactorial((4L)) == (288L));\n Debug.Assert(SpecialFactorial((5L)) == (34560L));\n Debug.Assert(SpecialFactorial((7L)) == (125411328000L));\n Debug.Assert(SpecialFactorial((1L)) == (1L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_139_special_factorial"}
{"name": "HumanEval_122_add_elements", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a non-empty list of integers arr and an integer k, return\n // the sum of the elements with at most two digits from the first k elements of arr.\n // Example:\n // >>> AddElements((new List<long>(new long[]{(long)111L, (long)21L, (long)3L, (long)4000L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L})), (4L))\n // (24L)\n // Constraints:\n // 1. 1 <= len(arr) <= 100\n // 2. 1 <= k <= len(arr)\n public static long AddElements(List<long> arr, long k) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(AddElements((new List<long>(new long[]{(long)1L, (long)-2L, (long)-3L, (long)41L, (long)57L, (long)76L, (long)87L, (long)88L, (long)99L})), (3L)) == (-4L));\n Debug.Assert(AddElements((new List<long>(new long[]{(long)111L, (long)121L, (long)3L, (long)4000L, (long)5L, (long)6L})), (2L)) == (0L));\n Debug.Assert(AddElements((new List<long>(new long[]{(long)11L, (long)21L, (long)3L, (long)90L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L})), (4L)) == (125L));\n Debug.Assert(AddElements((new List<long>(new long[]{(long)111L, (long)21L, (long)3L, (long)4000L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L})), (4L)) == (24L));\n Debug.Assert(AddElements((new List<long>(new long[]{(long)1L})), (1L)) == (1L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_122_add_elements"}
{"name": "HumanEval_46_fib4", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:\n // fib4(0) -> 0\n // fib4(1) -> 0\n // fib4(2) -> 2\n // fib4(3) -> 0\n // fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).\n // Please write a function to efficiently compute the n-th element of the fib4 number sequence. Do not use recursion.\n // >>> Fib4((5L))\n // (4L)\n // >>> Fib4((6L))\n // (8L)\n // >>> Fib4((7L))\n // (14L)\n public static long Fib4(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_46_fib4.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Fib4((5L)) == (4L));\n Debug.Assert(Fib4((8L)) == (28L));\n Debug.Assert(Fib4((10L)) == (104L));\n Debug.Assert(Fib4((12L)) == (386L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_46_fib4"}
{"name": "HumanEval_104_unique_digits", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a list of positive integers x. return a sorted list of all \n // elements that hasn't any even digit.\n // Note: Returned list should be sorted in increasing order.\n // For example:\n // >>> UniqueDigits((new List<long>(new long[]{(long)15L, (long)33L, (long)1422L, (long)1L})))\n // (new List<long>(new long[]{(long)1L, (long)15L, (long)33L}))\n // >>> UniqueDigits((new List<long>(new long[]{(long)152L, (long)323L, (long)1422L, (long)10L})))\n // (new List<long>())\n public static List<long> UniqueDigits(List<long> x) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_104_unique_digits.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(UniqueDigits((new List<long>(new long[]{(long)15L, (long)33L, (long)1422L, (long)1L}))).Equals((new List<long>(new long[]{(long)1L, (long)15L, (long)33L}))));\n Debug.Assert(UniqueDigits((new List<long>(new long[]{(long)152L, (long)323L, (long)1422L, (long)10L}))).Equals((new List<long>())));\n Debug.Assert(UniqueDigits((new List<long>(new long[]{(long)12345L, (long)2033L, (long)111L, (long)151L}))).Equals((new List<long>(new long[]{(long)111L, (long)151L}))));\n Debug.Assert(UniqueDigits((new List<long>(new long[]{(long)135L, (long)103L, (long)31L}))).Equals((new List<long>(new long[]{(long)31L, (long)135L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_104_unique_digits"}
{"name": "HumanEval_117_select_words", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a string s and a natural number n, you have been tasked to implement \n // a function that returns a list of all words from string s that contain exactly \n // n consonants, in order these words appear in the string s.\n // If the string s is empty then the function should return an empty list.\n // Note: you may assume the input string contains only letters and spaces.\n // Examples:\n // >>> SelectWords((\"Mary had a little lamb\"), (4L))\n // (new List<string>(new string[]{(string)\"little\"}))\n // >>> SelectWords((\"Mary had a little lamb\"), (3L))\n // (new List<string>(new string[]{(string)\"Mary\", (string)\"lamb\"}))\n // >>> SelectWords((\"simple white space\"), (2L))\n // (new List<string>())\n // >>> SelectWords((\"Hello world\"), (4L))\n // (new List<string>(new string[]{(string)\"world\"}))\n // >>> SelectWords((\"Uncle sam\"), (3L))\n // (new List<string>(new string[]{(string)\"Uncle\"}))\n public static List<string> SelectWords(string s, long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SelectWords((\"Mary had a little lamb\"), (4L)).Equals((new List<string>(new string[]{(string)\"little\"}))));\n Debug.Assert(SelectWords((\"Mary had a little lamb\"), (3L)).Equals((new List<string>(new string[]{(string)\"Mary\", (string)\"lamb\"}))));\n Debug.Assert(SelectWords((\"simple white space\"), (2L)).Equals((new List<string>())));\n Debug.Assert(SelectWords((\"Hello world\"), (4L)).Equals((new List<string>(new string[]{(string)\"world\"}))));\n Debug.Assert(SelectWords((\"Uncle sam\"), (3L)).Equals((new List<string>(new string[]{(string)\"Uncle\"}))));\n Debug.Assert(SelectWords((\"\"), (4L)).Equals((new List<string>())));\n Debug.Assert(SelectWords((\"a b c d e f\"), (1L)).Equals((new List<string>(new string[]{(string)\"b\", (string)\"c\", (string)\"d\", (string)\"f\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_117_select_words"}
{"name": "HumanEval_72_will_it_fly", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that returns true if the object q will fly, and false otherwise.\n // The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.\n // Example:\n // >>> WillItFly((new List<long>(new long[]{(long)1L, (long)2L})), (5L))\n // (false)\n // # 1+2 is less than the maximum possible weight, but it's unbalanced.\n // >>> WillItFly((new List<long>(new long[]{(long)3L, (long)2L, (long)3L})), (1L))\n // (false)\n // # it's balanced, but 3+2+3 is more than the maximum possible weight.\n // >>> WillItFly((new List<long>(new long[]{(long)3L, (long)2L, (long)3L})), (9L))\n // (true)\n // # 3+2+3 is less than the maximum possible weight, and it's balanced.\n // >>> WillItFly((new List<long>(new long[]{(long)3L})), (5L))\n // (true)\n // # 3 is less than the maximum possible weight, and it's balanced.\n public static bool WillItFly(List<long> q, long w) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_72_will_it_fly.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(WillItFly((new List<long>(new long[]{(long)3L, (long)2L, (long)3L})), (9L)) == (true));\n Debug.Assert(WillItFly((new List<long>(new long[]{(long)1L, (long)2L})), (5L)) == (false));\n Debug.Assert(WillItFly((new List<long>(new long[]{(long)3L})), (5L)) == (true));\n Debug.Assert(WillItFly((new List<long>(new long[]{(long)3L, (long)2L, (long)3L})), (1L)) == (false));\n Debug.Assert(WillItFly((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})), (6L)) == (false));\n Debug.Assert(WillItFly((new List<long>(new long[]{(long)5L})), (5L)) == (true));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_72_will_it_fly"}
{"name": "HumanEval_55_fib", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return n-th Fibonacci number.\n // >>> Fib((10L))\n // (55L)\n // >>> Fib((1L))\n // (1L)\n // >>> Fib((8L))\n // (21L)\n public static long Fib(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_55_fib.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Fib((10L)) == (55L));\n Debug.Assert(Fib((1L)) == (1L));\n Debug.Assert(Fib((8L)) == (21L));\n Debug.Assert(Fib((11L)) == (89L));\n Debug.Assert(Fib((12L)) == (144L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_55_fib"}
{"name": "HumanEval_153_Strongest_Extension", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You will be given the name of a class (a string) and a list of extensions.\n // The extensions are to be used to load additional classes to the class. The\n // strength of the extension is as follows: Let CAP be the number of the uppercase\n // letters in the extension's name, and let SM be the number of lowercase letters \n // in the extension's name, the strength is given by the fraction CAP - SM. \n // You should find the strongest extension and return a string in this \n // format: ClassName.StrongestExtensionName.\n // If there are two or more extensions with the same strength, you should\n // choose the one that comes first in the list.\n // For example, if you are given \"Slices\" as the class and a list of the\n // extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should\n // return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension \n // (its strength is -1).\n // Example:\n // >>> StrongestExtension((\"my_class\"), (new List<string>(new string[]{(string)\"AA\", (string)\"Be\", (string)\"CC\"})))\n // (\"my_class.AA\")\n public static string StrongestExtension(string class_name, List<string> extensions) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(StrongestExtension((\"Watashi\"), (new List<string>(new string[]{(string)\"tEN\", (string)\"niNE\", (string)\"eIGHt8OKe\"}))).Equals((\"Watashi.eIGHt8OKe\")));\n Debug.Assert(StrongestExtension((\"Boku123\"), (new List<string>(new string[]{(string)\"nani\", (string)\"NazeDa\", (string)\"YEs.WeCaNe\", (string)\"32145tggg\"}))).Equals((\"Boku123.YEs.WeCaNe\")));\n Debug.Assert(StrongestExtension((\"__YESIMHERE\"), (new List<string>(new string[]{(string)\"t\", (string)\"eMptY\", (string)\"nothing\", (string)\"zeR00\", (string)\"NuLl__\", (string)\"123NoooneB321\"}))).Equals((\"__YESIMHERE.NuLl__\")));\n Debug.Assert(StrongestExtension((\"K\"), (new List<string>(new string[]{(string)\"Ta\", (string)\"TAR\", (string)\"t234An\", (string)\"cosSo\"}))).Equals((\"K.TAR\")));\n Debug.Assert(StrongestExtension((\"__HAHA\"), (new List<string>(new string[]{(string)\"Tab\", (string)\"123\", (string)\"781345\", (string)\"-_-\"}))).Equals((\"__HAHA.123\")));\n Debug.Assert(StrongestExtension((\"YameRore\"), (new List<string>(new string[]{(string)\"HhAas\", (string)\"okIWILL123\", (string)\"WorkOut\", (string)\"Fails\", (string)\"-_-\"}))).Equals((\"YameRore.okIWILL123\")));\n Debug.Assert(StrongestExtension((\"finNNalLLly\"), (new List<string>(new string[]{(string)\"Die\", (string)\"NowW\", (string)\"Wow\", (string)\"WoW\"}))).Equals((\"finNNalLLly.WoW\")));\n Debug.Assert(StrongestExtension((\"_\"), (new List<string>(new string[]{(string)\"Bb\", (string)\"91245\"}))).Equals((\"_.Bb\")));\n Debug.Assert(StrongestExtension((\"Sp\"), (new List<string>(new string[]{(string)\"671235\", (string)\"Bb\"}))).Equals((\"Sp.671235\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_153_Strongest_Extension"}
{"name": "HumanEval_119_match_parens", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a list of two strings, both strings consist of open\n // parentheses '(' or close parentheses ')' only.\n // Your job is to check if it is possible to concatenate the two strings in\n // some order, that the resulting string will be good.\n // A string S is considered to be good if and only if all parentheses in S\n // are balanced. For example: the string '(())()' is good, while the string\n // '())' is not.\n // Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.\n // Examples:\n // >>> MatchParens((new List<string>(new string[]{(string)\"()(\", (string)\")\"})))\n // (\"Yes\")\n // >>> MatchParens((new List<string>(new string[]{(string)\")\", (string)\")\"})))\n // (\"No\")\n public static string MatchParens(List<string> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\"()(\", (string)\")\"}))).Equals((\"Yes\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\")\", (string)\")\"}))).Equals((\"No\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\"(()(())\", (string)\"())())\"}))).Equals((\"No\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\")())\", (string)\"(()()(\"}))).Equals((\"Yes\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\"(())))\", (string)\"(()())((\"}))).Equals((\"Yes\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\"()\", (string)\"())\"}))).Equals((\"No\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\"(()(\", (string)\"()))()\"}))).Equals((\"Yes\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\"((((\", (string)\"((())\"}))).Equals((\"No\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\")(()\", (string)\"(()(\"}))).Equals((\"No\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\")(\", (string)\")(\"}))).Equals((\"No\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\"(\", (string)\")\"}))).Equals((\"Yes\")));\n Debug.Assert(MatchParens((new List<string>(new string[]{(string)\")\", (string)\"(\"}))).Equals((\"Yes\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_119_match_parens"}
{"name": "HumanEval_90_next_smallest", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a list of integers.\n // Write a function next_smallest() that returns the 2nd smallest element of the list.\n // Return null if there is no such element.\n // >>> NextSmallest((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L})))\n // 2L\n // >>> NextSmallest((new List<long>(new long[]{(long)5L, (long)1L, (long)4L, (long)3L, (long)2L})))\n // 2L\n // >>> NextSmallest((new List<long>()))\n // null\n // >>> NextSmallest((new List<long>(new long[]{(long)1L, (long)1L})))\n // null\n public static Nullable<long> NextSmallest(List<long> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_90_next_smallest.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(NextSmallest((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))).Equals(2L));\n Debug.Assert(NextSmallest((new List<long>(new long[]{(long)5L, (long)1L, (long)4L, (long)3L, (long)2L}))).Equals(2L));\n Debug.Assert(NextSmallest((new List<long>())).Equals(null));\n Debug.Assert(NextSmallest((new List<long>(new long[]{(long)1L, (long)1L}))).Equals(null));\n Debug.Assert(NextSmallest((new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L, (long)0L}))).Equals(1L));\n Debug.Assert(NextSmallest((new List<long>(new long[]{(long)1L, (long)1L}))).Equals(null));\n Debug.Assert(NextSmallest((new List<long>(new long[]{(long)-35L, (long)34L, (long)12L, (long)-45L}))).Equals(-35L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_90_next_smallest"}
{"name": "HumanEval_92_any_int", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Create a function that takes 3 numbers.\n // Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.\n // Returns false in any other cases.\n // Examples\n // >>> AnyInt((float)5L, (float)2L, (float)7L)\n // (true)\n // >>> AnyInt((float)3L, (float)2L, (float)2L)\n // (false)\n // >>> AnyInt((float)3L, (float)-2L, (float)1L)\n // (true)\n // >>> AnyInt((3.6f), (-2.2f), (float)2L)\n // (false)\n public static bool AnyInt(float x, float y, float z) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_92_any_int.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(AnyInt((float)2L, (float)3L, (float)1L) == (true));\n Debug.Assert(AnyInt((2.5f), (float)2L, (float)3L) == (false));\n Debug.Assert(AnyInt((1.5f), (float)5L, (3.5f)) == (false));\n Debug.Assert(AnyInt((float)2L, (float)6L, (float)2L) == (false));\n Debug.Assert(AnyInt((float)4L, (float)2L, (float)2L) == (true));\n Debug.Assert(AnyInt((2.2f), (2.2f), (2.2f)) == (false));\n Debug.Assert(AnyInt((float)-4L, (float)6L, (float)2L) == (true));\n Debug.Assert(AnyInt((float)2L, (float)1L, (float)1L) == (true));\n Debug.Assert(AnyInt((float)3L, (float)4L, (float)7L) == (true));\n Debug.Assert(AnyInt((3.0f), (float)4L, (float)7L) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_92_any_int"}
{"name": "HumanEval_2_truncate_number", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a positive floating point number, it can be decomposed into\n // and integer part (largest integer smaller than given number) and decimals\n // (leftover part always smaller than 1).\n // Return the decimal part of the number.\n // >>> TruncateNumber((3.5f))\n // (0.5f)\n public static float TruncateNumber(float number) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_2_truncate_number.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(TruncateNumber((3.5f)) == (0.5f));\n Debug.Assert(TruncateNumber((1.25f)) == (0.25f));\n Debug.Assert(TruncateNumber((123.0f)) == (0.0f));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_2_truncate_number"}
{"name": "HumanEval_42_incr_list", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return list with elements incremented by 1.\n // >>> IncrList((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))\n // (new List<long>(new long[]{(long)2L, (long)3L, (long)4L}))\n // >>> IncrList((new List<long>(new long[]{(long)5L, (long)3L, (long)5L, (long)2L, (long)3L, (long)3L, (long)9L, (long)0L, (long)123L})))\n // (new List<long>(new long[]{(long)6L, (long)4L, (long)6L, (long)3L, (long)4L, (long)4L, (long)10L, (long)1L, (long)124L}))\n public static List<long> IncrList(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_42_incr_list.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IncrList((new List<long>())).Equals((new List<long>())));\n Debug.Assert(IncrList((new List<long>(new long[]{(long)3L, (long)2L, (long)1L}))).Equals((new List<long>(new long[]{(long)4L, (long)3L, (long)2L}))));\n Debug.Assert(IncrList((new List<long>(new long[]{(long)5L, (long)2L, (long)5L, (long)2L, (long)3L, (long)3L, (long)9L, (long)0L, (long)123L}))).Equals((new List<long>(new long[]{(long)6L, (long)3L, (long)6L, (long)3L, (long)4L, (long)4L, (long)10L, (long)1L, (long)124L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_42_incr_list"}
{"name": "HumanEval_150_x_or_y", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // A simple program which should return the value of x if n is \n // a prime number and should return the value of y otherwise.\n // Examples:\n // >>> XOrY((7L), (34L), (12L))\n // (34L)\n // >>> XOrY((15L), (8L), (5L))\n // (5L)\n public static long XOrY(long n, long x, long y) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(XOrY((7L), (34L), (12L)) == (34L));\n Debug.Assert(XOrY((15L), (8L), (5L)) == (5L));\n Debug.Assert(XOrY((3L), (33L), (5212L)) == (33L));\n Debug.Assert(XOrY((1259L), (3L), (52L)) == (3L));\n Debug.Assert(XOrY((7919L), (-1L), (12L)) == (-1L));\n Debug.Assert(XOrY((3609L), (1245L), (583L)) == (583L));\n Debug.Assert(XOrY((91L), (56L), (129L)) == (129L));\n Debug.Assert(XOrY((6L), (34L), (1234L)) == (1234L));\n Debug.Assert(XOrY((1L), (2L), (0L)) == (0L));\n Debug.Assert(XOrY((2L), (2L), (0L)) == (2L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_150_x_or_y"}
{"name": "HumanEval_49_modp", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return 2^n modulo p (be aware of numerics).\n // >>> Modp((3L), (5L))\n // (3L)\n // >>> Modp((1101L), (101L))\n // (2L)\n // >>> Modp((0L), (101L))\n // (1L)\n // >>> Modp((3L), (11L))\n // (8L)\n // >>> Modp((100L), (101L))\n // (1L)\n public static long Modp(long n, long p) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_49_modp.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Modp((3L), (5L)) == (3L));\n Debug.Assert(Modp((1101L), (101L)) == (2L));\n Debug.Assert(Modp((0L), (101L)) == (1L));\n Debug.Assert(Modp((3L), (11L)) == (8L));\n Debug.Assert(Modp((100L), (101L)) == (1L));\n Debug.Assert(Modp((30L), (5L)) == (4L));\n Debug.Assert(Modp((31L), (5L)) == (3L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_49_modp"}
{"name": "HumanEval_155_even_odd_count", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given an integer. return a tuple that has the number of even and odd digits respectively.\n // Example:\n // >>> EvenOddCount((-12L))\n // (Tuple.Create(1L, 1L))\n // >>> EvenOddCount((123L))\n // (Tuple.Create(1L, 2L))\n public static Tuple<long, long> EvenOddCount(long num) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(EvenOddCount((7L)).Equals((Tuple.Create(0L, 1L))));\n Debug.Assert(EvenOddCount((-78L)).Equals((Tuple.Create(1L, 1L))));\n Debug.Assert(EvenOddCount((3452L)).Equals((Tuple.Create(2L, 2L))));\n Debug.Assert(EvenOddCount((346211L)).Equals((Tuple.Create(3L, 3L))));\n Debug.Assert(EvenOddCount((-345821L)).Equals((Tuple.Create(3L, 3L))));\n Debug.Assert(EvenOddCount((-2L)).Equals((Tuple.Create(1L, 0L))));\n Debug.Assert(EvenOddCount((-45347L)).Equals((Tuple.Create(2L, 3L))));\n Debug.Assert(EvenOddCount((0L)).Equals((Tuple.Create(1L, 0L))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_155_even_odd_count"}
{"name": "HumanEval_80_is_happy", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a string s.\n // Your task is to check if the string is hapcs or not.\n // A string is hapcs if its length is at least 3 and every 3 consecutive letters are distinct\n // For example:\n // >>> IsHappy((\"a\"))\n // (false)\n // >>> IsHappy((\"aa\"))\n // (false)\n // >>> IsHappy((\"abcd\"))\n // (true)\n // >>> IsHappy((\"aabb\"))\n // (false)\n // >>> IsHappy((\"adb\"))\n // (true)\n // >>> IsHappy((\"xyy\"))\n // (false)\n public static bool IsHappy(string s) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_80_is_happy.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IsHappy((\"a\")) == (false));\n Debug.Assert(IsHappy((\"aa\")) == (false));\n Debug.Assert(IsHappy((\"abcd\")) == (true));\n Debug.Assert(IsHappy((\"aabb\")) == (false));\n Debug.Assert(IsHappy((\"adb\")) == (true));\n Debug.Assert(IsHappy((\"xyy\")) == (false));\n Debug.Assert(IsHappy((\"iopaxpoi\")) == (true));\n Debug.Assert(IsHappy((\"iopaxioi\")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_80_is_happy"}
{"name": "HumanEval_59_largest_prime_factor", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return the largest prime factor of n. Assume n > 1 and is not a prime.\n // >>> LargestPrimeFactor((13195L))\n // (29L)\n // >>> LargestPrimeFactor((2048L))\n // (2L)\n public static long LargestPrimeFactor(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_59_largest_prime_factor.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(LargestPrimeFactor((15L)) == (5L));\n Debug.Assert(LargestPrimeFactor((27L)) == (3L));\n Debug.Assert(LargestPrimeFactor((63L)) == (7L));\n Debug.Assert(LargestPrimeFactor((330L)) == (11L));\n Debug.Assert(LargestPrimeFactor((13195L)) == (29L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_59_largest_prime_factor"}
{"name": "HumanEval_66_digitSum", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Task\n // Write a function that takes a string as input and returns the sum of the upper characters only'\n // ASCII codes.\n // Examples:\n // >>> Digitsum((\"\"))\n // (0L)\n // >>> Digitsum((\"abAB\"))\n // (131L)\n // >>> Digitsum((\"abcCd\"))\n // (67L)\n // >>> Digitsum((\"helloE\"))\n // (69L)\n // >>> Digitsum((\"woArBld\"))\n // (131L)\n // >>> Digitsum((\"aAaaaXa\"))\n // (153L)\n public static long Digitsum(string s) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_66_digitSum.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Digitsum((\"\")) == (0L));\n Debug.Assert(Digitsum((\"abAB\")) == (131L));\n Debug.Assert(Digitsum((\"abcCd\")) == (67L));\n Debug.Assert(Digitsum((\"helloE\")) == (69L));\n Debug.Assert(Digitsum((\"woArBld\")) == (131L));\n Debug.Assert(Digitsum((\"aAaaaXa\")) == (153L));\n Debug.Assert(Digitsum((\" How are yOu?\")) == (151L));\n Debug.Assert(Digitsum((\"You arE Very Smart\")) == (327L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_66_digitSum"}
{"name": "HumanEval_21_rescale_to_unit", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given list of numbers (of at least two elements), apply a linear transform to that list,\n // such that the smallest number will become 0 and the largest will become 1\n // >>> RescaleToUnit((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f})))\n // (new List<float>(new float[]{(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f}))\n public static List<float> RescaleToUnit(List<float> numbers) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_21_rescale_to_unit.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)2.0f, (float)49.9f}))).Equals((new List<float>(new float[]{(float)0.0f, (float)1.0f}))));\n Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)100.0f, (float)49.9f}))).Equals((new List<float>(new float[]{(float)1.0f, (float)0.0f}))));\n Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))).Equals((new List<float>(new float[]{(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f}))));\n Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)2.0f, (float)1.0f, (float)5.0f, (float)3.0f, (float)4.0f}))).Equals((new List<float>(new float[]{(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f}))));\n Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)12.0f, (float)11.0f, (float)15.0f, (float)13.0f, (float)14.0f}))).Equals((new List<float>(new float[]{(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_21_rescale_to_unit"}
{"name": "HumanEval_121_solution", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.\n // Examples\n // >>> Solution((new List<long>(new long[]{(long)5L, (long)8L, (long)7L, (long)1L})))\n // (12L)\n // >>> Solution((new List<long>(new long[]{(long)3L, (long)3L, (long)3L, (long)3L, (long)3L})))\n // (9L)\n // >>> Solution((new List<long>(new long[]{(long)30L, (long)13L, (long)24L, (long)321L})))\n // (0L)\n public static long Solution(List<long> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Solution((new List<long>(new long[]{(long)5L, (long)8L, (long)7L, (long)1L}))) == (12L));\n Debug.Assert(Solution((new List<long>(new long[]{(long)3L, (long)3L, (long)3L, (long)3L, (long)3L}))) == (9L));\n Debug.Assert(Solution((new List<long>(new long[]{(long)30L, (long)13L, (long)24L, (long)321L}))) == (0L));\n Debug.Assert(Solution((new List<long>(new long[]{(long)5L, (long)9L}))) == (5L));\n Debug.Assert(Solution((new List<long>(new long[]{(long)2L, (long)4L, (long)8L}))) == (0L));\n Debug.Assert(Solution((new List<long>(new long[]{(long)30L, (long)13L, (long)23L, (long)32L}))) == (23L));\n Debug.Assert(Solution((new List<long>(new long[]{(long)3L, (long)13L, (long)2L, (long)9L}))) == (3L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_121_solution"}
{"name": "HumanEval_68_pluck", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // \"Given a list representing a branch of a tree that has non-negative integer nodes\n // your task is to pluck one of the nodes and return it.\n // The plucked node should be the node with the smallest even value.\n // If multiple nodes with the same smallest even value are found return the node that has smallest index.\n // The plucked node should be returned in a list, [ smalest_value, its index ],\n // If there are no even values or the given list is empty, return [].\n // Example 1:\n // >>> Pluck((new List<long>(new long[]{(long)4L, (long)2L, (long)3L})))\n // (new List<long>(new long[]{(long)2L, (long)1L}))\n // Explanation: 2 has the smallest even value, and 2 has the smallest index.\n // Example 2:\n // >>> Pluck((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))\n // (new List<long>(new long[]{(long)2L, (long)1L}))\n // Explanation: 2 has the smallest even value, and 2 has the smallest index.\n // Example 3:\n // >>> Pluck((new List<long>()))\n // (new List<long>())\n // Example 4:\n // >>> Pluck((new List<long>(new long[]{(long)5L, (long)0L, (long)3L, (long)0L, (long)4L, (long)2L})))\n // (new List<long>(new long[]{(long)0L, (long)1L}))\n // Explanation: 0 is the smallest value, but there are two zeros,\n // so we will choose the first zero, which has the smallest index.\n // Constraints:\n // * 1 <= nodes.length <= 10000\n // * 0 <= node.value\n public static List<long> Pluck(List<long> arr) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_68_pluck.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Pluck((new List<long>(new long[]{(long)4L, (long)2L, (long)3L}))).Equals((new List<long>(new long[]{(long)2L, (long)1L}))));\n Debug.Assert(Pluck((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))).Equals((new List<long>(new long[]{(long)2L, (long)1L}))));\n Debug.Assert(Pluck((new List<long>())).Equals((new List<long>())));\n Debug.Assert(Pluck((new List<long>(new long[]{(long)5L, (long)0L, (long)3L, (long)0L, (long)4L, (long)2L}))).Equals((new List<long>(new long[]{(long)0L, (long)1L}))));\n Debug.Assert(Pluck((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)0L, (long)5L, (long)3L}))).Equals((new List<long>(new long[]{(long)0L, (long)3L}))));\n Debug.Assert(Pluck((new List<long>(new long[]{(long)5L, (long)4L, (long)8L, (long)4L, (long)8L}))).Equals((new List<long>(new long[]{(long)4L, (long)1L}))));\n Debug.Assert(Pluck((new List<long>(new long[]{(long)7L, (long)6L, (long)7L, (long)1L}))).Equals((new List<long>(new long[]{(long)6L, (long)1L}))));\n Debug.Assert(Pluck((new List<long>(new long[]{(long)7L, (long)9L, (long)7L, (long)1L}))).Equals((new List<long>())));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_68_pluck"}
{"name": "HumanEval_147_get_max_triples", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a positive integer n. You have to create an integer list a of length n.\n // For each i (1 \u2264 i \u2264 n), the value of a[i] = i * i - i + 1.\n // Return the number of triples (a[i], a[j], a[k]) of a where i < j < k, \n // and a[i] + a[j] + a[k] is a multiple of 3.\n // Example :\n // >>> GetMaxTriples((5L))\n // (1L)\n // Explanation: \n // a = [1, 3, 7, 13, 21]\n // The only valid triple is (1, 7, 13).\n public static long GetMaxTriples(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(GetMaxTriples((5L)) == (1L));\n Debug.Assert(GetMaxTriples((6L)) == (4L));\n Debug.Assert(GetMaxTriples((10L)) == (36L));\n Debug.Assert(GetMaxTriples((100L)) == (53361L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_147_get_max_triples"}
{"name": "HumanEval_110_exchange", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // In this problem, you will implement a function that takes two lists of numbers,\n // and determines whether it is possible to perform an exchange of elements\n // between them to make lst1 a list of only even numbers.\n // There is no limit on the number of exchanged elements between lst1 and lst2.\n // If it is possible to exchange elements between the lst1 and lst2 to make\n // all the elements of lst1 to be even, return \"YES\".\n // Otherwise, return \"NO\".\n // For example:\n // >>> Exchange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})), (new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})))\n // (\"YES\")\n // >>> Exchange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})), (new List<long>(new long[]{(long)1L, (long)5L, (long)3L, (long)4L})))\n // (\"NO\")\n // It is assumed that the input lists will be non-empty.\n public static string Exchange(List<long> lst1, List<long> lst2) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Exchange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})), (new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))).Equals((\"YES\")));\n Debug.Assert(Exchange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})), (new List<long>(new long[]{(long)1L, (long)5L, (long)3L, (long)4L}))).Equals((\"NO\")));\n Debug.Assert(Exchange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})), (new List<long>(new long[]{(long)2L, (long)1L, (long)4L, (long)3L}))).Equals((\"YES\")));\n Debug.Assert(Exchange((new List<long>(new long[]{(long)5L, (long)7L, (long)3L})), (new List<long>(new long[]{(long)2L, (long)6L, (long)4L}))).Equals((\"YES\")));\n Debug.Assert(Exchange((new List<long>(new long[]{(long)5L, (long)7L, (long)3L})), (new List<long>(new long[]{(long)2L, (long)6L, (long)3L}))).Equals((\"NO\")));\n Debug.Assert(Exchange((new List<long>(new long[]{(long)3L, (long)2L, (long)6L, (long)1L, (long)8L, (long)9L})), (new List<long>(new long[]{(long)3L, (long)5L, (long)5L, (long)1L, (long)1L, (long)1L}))).Equals((\"NO\")));\n Debug.Assert(Exchange((new List<long>(new long[]{(long)100L, (long)200L})), (new List<long>(new long[]{(long)200L, (long)200L}))).Equals((\"YES\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_110_exchange"}
{"name": "HumanEval_47_median", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return median of elements in the list l.\n // >>> Median((new List<long>(new long[]{(long)3L, (long)1L, (long)2L, (long)4L, (long)5L})))\n // (float)3L\n // >>> Median((new List<long>(new long[]{(long)-10L, (long)4L, (long)6L, (long)1000L, (long)10L, (long)20L})))\n // (15.0f)\n public static float Median(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_47_median.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Median((new List<long>(new long[]{(long)3L, (long)1L, (long)2L, (long)4L, (long)5L}))) == (float)3L);\n Debug.Assert(Median((new List<long>(new long[]{(long)-10L, (long)4L, (long)6L, (long)1000L, (long)10L, (long)20L}))) == (8.0f));\n Debug.Assert(Median((new List<long>(new long[]{(long)5L}))) == (float)5L);\n Debug.Assert(Median((new List<long>(new long[]{(long)6L, (long)5L}))) == (5.5f));\n Debug.Assert(Median((new List<long>(new long[]{(long)8L, (long)1L, (long)3L, (long)9L, (long)9L, (long)2L, (long)7L}))) == (float)7L);\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_47_median"}
{"name": "HumanEval_82_prime_length", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that takes a string and returns true if the string\n // length is a prime number or false otherwise\n // Examples\n // >>> PrimeLength((\"Hello\"))\n // (true)\n // >>> PrimeLength((\"abcdcba\"))\n // (true)\n // >>> PrimeLength((\"kittens\"))\n // (true)\n // >>> PrimeLength((\"orange\"))\n // (false)\n public static bool PrimeLength(string str) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_82_prime_length.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(PrimeLength((\"Hello\")) == (true));\n Debug.Assert(PrimeLength((\"abcdcba\")) == (true));\n Debug.Assert(PrimeLength((\"kittens\")) == (true));\n Debug.Assert(PrimeLength((\"orange\")) == (false));\n Debug.Assert(PrimeLength((\"wow\")) == (true));\n Debug.Assert(PrimeLength((\"world\")) == (true));\n Debug.Assert(PrimeLength((\"MadaM\")) == (true));\n Debug.Assert(PrimeLength((\"Wow\")) == (true));\n Debug.Assert(PrimeLength((\"\")) == (false));\n Debug.Assert(PrimeLength((\"HI\")) == (true));\n Debug.Assert(PrimeLength((\"go\")) == (true));\n Debug.Assert(PrimeLength((\"gogo\")) == (false));\n Debug.Assert(PrimeLength((\"aaaaaaaaaaaaaaa\")) == (false));\n Debug.Assert(PrimeLength((\"Madam\")) == (true));\n Debug.Assert(PrimeLength((\"M\")) == (false));\n Debug.Assert(PrimeLength((\"0\")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_82_prime_length"}
{"name": "HumanEval_73_smallest_change", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a list arr of integers, find the minimum number of elements that\n // need to be changed to make the list palindromic. A palindromic list is a list that\n // is read the same backwards and forwards. In one change, you can change one element to any other element.\n // For example:\n // >>> SmallestChange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)5L, (long)4L, (long)7L, (long)9L, (long)6L})))\n // (4L)\n // >>> SmallestChange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)3L, (long)2L, (long)2L})))\n // (1L)\n // >>> SmallestChange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)1L})))\n // (0L)\n public static long SmallestChange(List<long> arr) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_73_smallest_change.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SmallestChange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)5L, (long)4L, (long)7L, (long)9L, (long)6L}))) == (4L));\n Debug.Assert(SmallestChange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)3L, (long)2L, (long)2L}))) == (1L));\n Debug.Assert(SmallestChange((new List<long>(new long[]{(long)1L, (long)4L, (long)2L}))) == (1L));\n Debug.Assert(SmallestChange((new List<long>(new long[]{(long)1L, (long)4L, (long)4L, (long)2L}))) == (1L));\n Debug.Assert(SmallestChange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)1L}))) == (0L));\n Debug.Assert(SmallestChange((new List<long>(new long[]{(long)3L, (long)1L, (long)1L, (long)3L}))) == (0L));\n Debug.Assert(SmallestChange((new List<long>(new long[]{(long)1L}))) == (0L));\n Debug.Assert(SmallestChange((new List<long>(new long[]{(long)0L, (long)1L}))) == (1L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_73_smallest_change"}
{"name": "HumanEval_133_sum_squares", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a list of numbers.\n // You need to return the sum of squared numbers in the given list,\n // round each element in the list to the upper int(Ceiling) first.\n // Examples:\n // >>> Lst((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f})))\n // (14L)\n // >>> Lst((new List<float>(new float[]{(float)1.0f, (float)4.0f, (float)9.0f})))\n // (98L)\n // >>> Lst((new List<float>(new float[]{(float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f})))\n // (84L)\n // >>> Lst((new List<float>(new float[]{(float)1.4f, (float)4.2f, (float)0.0f})))\n // (29L)\n // >>> Lst((new List<float>(new float[]{(float)-2.4f, (float)1.0f, (float)1.0f})))\n // (6L)\n public static long SumSquares(List<float> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f}))) == (14L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f}))) == (14L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f}))) == (84L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)1.4f, (float)4.2f, (float)0.0f}))) == (29L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)-2.4f, (float)1.0f, (float)1.0f}))) == (6L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)100.0f, (float)1.0f, (float)15.0f, (float)2.0f}))) == (10230L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)10000.0f, (float)10000.0f}))) == (200000000L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)-1.4f, (float)4.6f, (float)6.3f}))) == (75L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)-1.4f, (float)17.9f, (float)18.9f, (float)19.9f}))) == (1086L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)0.0f}))) == (0L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)-1.0f}))) == (1L));\n Debug.Assert(SumSquares((new List<float>(new float[]{(float)-1.0f, (float)1.0f, (float)0.0f}))) == (2L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_133_sum_squares"}
{"name": "HumanEval_141_file_name_check", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Create a function which takes a string representing a file's name, and returns\n // 'Yes' if the the file's name is valid, and returns 'No' otherwise.\n // A file's name is considered to be valid if and only if all the following conditions \n // are met:\n // - There should not be more than three digits ('0'-'9') in the file's name.\n // - The file's name contains exactly one dot '.'\n // - The substring before the dot should not be empty, and it starts with a letter from \n // the latin alphapet ('a'-'z' and 'A'-'Z').\n // - The substring after the dot should be one of these: ['txt', 'exe', 'dll']\n // Examples:\n // >>> FileNameCheck((\"example.txt\"))\n // (\"Yes\")\n // >>> FileNameCheck((\"1example.dll\"))\n // (\"No\")\n public static string FileNameCheck(string file_name) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FileNameCheck((\"example.txt\")).Equals((\"Yes\")));\n Debug.Assert(FileNameCheck((\"1example.dll\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"s1sdf3.asd\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"K.dll\")).Equals((\"Yes\")));\n Debug.Assert(FileNameCheck((\"MY16FILE3.exe\")).Equals((\"Yes\")));\n Debug.Assert(FileNameCheck((\"His12FILE94.exe\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"_Y.txt\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"?aREYA.exe\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"/this_is_valid.dll\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"this_is_valid.wow\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"this_is_valid.txt\")).Equals((\"Yes\")));\n Debug.Assert(FileNameCheck((\"this_is_valid.txtexe\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"#this2_i4s_5valid.ten\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"@this1_is6_valid.exe\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"this_is_12valid.6exe4.txt\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"all.exe.txt\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"I563_No.exe\")).Equals((\"Yes\")));\n Debug.Assert(FileNameCheck((\"Is3youfault.txt\")).Equals((\"Yes\")));\n Debug.Assert(FileNameCheck((\"no_one#knows.dll\")).Equals((\"Yes\")));\n Debug.Assert(FileNameCheck((\"1I563_Yes3.exe\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"I563_Yes3.txtt\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"final..txt\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"final132\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"_f4indsartal132.\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\".txt\")).Equals((\"No\")));\n Debug.Assert(FileNameCheck((\"s.\")).Equals((\"No\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_141_file_name_check"}
{"name": "HumanEval_40_triples_sum_to_zero", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // triples_sum_to_zero takes a list of integers as an input.\n // it returns true if there are three distinct elements in the list that\n // sum to zero, and false otherwise.\n // >>> TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)0L})))\n // (false)\n // >>> TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)-2L, (long)1L})))\n // (true)\n // >>> TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)7L})))\n // (false)\n // >>> TriplesSumToZero((new List<long>(new long[]{(long)2L, (long)4L, (long)-5L, (long)3L, (long)9L, (long)7L})))\n // (true)\n // >>> TriplesSumToZero((new List<long>(new long[]{(long)1L})))\n // (false)\n public static bool TriplesSumToZero(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_40_triples_sum_to_zero.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)0L}))) == (false));\n Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)-1L}))) == (false));\n Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)-2L, (long)1L}))) == (true));\n Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)7L}))) == (false));\n Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)5L, (long)7L}))) == (false));\n Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)2L, (long)4L, (long)-5L, (long)3L, (long)9L, (long)7L}))) == (true));\n Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L}))) == (false));\n Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)-100L}))) == (false));\n Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)100L, (long)3L, (long)5L, (long)-100L}))) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_40_triples_sum_to_zero"}
{"name": "HumanEval_127_intersection", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given two intervals,\n // where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).\n // The given intervals are closed which means that the interval (start, end)\n // includes both start and end.\n // For each given interval, it is assumed that its start is less or equal its end.\n // Your task is to determine whether the length of intersection of these two \n // intervals is a prime number.\n // Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)\n // which its length is 1, which not a prime number.\n // If the length of the intersection is a prime number, return \"YES\",\n // otherwise, return \"NO\".\n // If the two intervals don't intersect, return \"NO\".\n // [input/output] samples:\n // >>> Intersection((Tuple.Create(1L, 2L)), (Tuple.Create(2L, 3L)))\n // (\"NO\")\n // >>> Intersection((Tuple.Create(-1L, 1L)), (Tuple.Create(0L, 4L)))\n // (\"NO\")\n // >>> Intersection((Tuple.Create(-3L, -1L)), (Tuple.Create(-5L, 5L)))\n // (\"YES\")\n public static string Intersection(Tuple<long, long> interval1, Tuple<long, long> interval2) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Intersection((Tuple.Create(1L, 2L)), (Tuple.Create(2L, 3L))).Equals((\"NO\")));\n Debug.Assert(Intersection((Tuple.Create(-1L, 1L)), (Tuple.Create(0L, 4L))).Equals((\"NO\")));\n Debug.Assert(Intersection((Tuple.Create(-3L, -1L)), (Tuple.Create(-5L, 5L))).Equals((\"YES\")));\n Debug.Assert(Intersection((Tuple.Create(-2L, 2L)), (Tuple.Create(-4L, 0L))).Equals((\"YES\")));\n Debug.Assert(Intersection((Tuple.Create(-11L, 2L)), (Tuple.Create(-1L, -1L))).Equals((\"NO\")));\n Debug.Assert(Intersection((Tuple.Create(1L, 2L)), (Tuple.Create(3L, 5L))).Equals((\"NO\")));\n Debug.Assert(Intersection((Tuple.Create(1L, 2L)), (Tuple.Create(1L, 2L))).Equals((\"NO\")));\n Debug.Assert(Intersection((Tuple.Create(-2L, -2L)), (Tuple.Create(-3L, -2L))).Equals((\"NO\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_127_intersection"}
{"name": "HumanEval_1_separate_paren_groups", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n // separate those group into separate strings and return the list of those.\n // Separate groups are balanced (each open brace is properly closed) and not nested within each other\n // Ignore any spaces in the input string.\n // >>> SeparateParenGroups((\"( ) (( )) (( )( ))\"))\n // (new List<string>(new string[]{(string)\"()\", (string)\"(())\", (string)\"(()())\"}))\n public static List<string> SeparateParenGroups(string paren_string) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_1_separate_paren_groups.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SeparateParenGroups((\"(()()) ((())) () ((())()())\")).Equals((new List<string>(new string[]{(string)\"(()())\", (string)\"((()))\", (string)\"()\", (string)\"((())()())\"}))));\n Debug.Assert(SeparateParenGroups((\"() (()) ((())) (((())))\")).Equals((new List<string>(new string[]{(string)\"()\", (string)\"(())\", (string)\"((()))\", (string)\"(((())))\"}))));\n Debug.Assert(SeparateParenGroups((\"(()(())((())))\")).Equals((new List<string>(new string[]{(string)\"(()(())((())))\"}))));\n Debug.Assert(SeparateParenGroups((\"( ) (( )) (( )( ))\")).Equals((new List<string>(new string[]{(string)\"()\", (string)\"(())\", (string)\"(()())\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_1_separate_paren_groups"}
{"name": "HumanEval_152_compare", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // I think we all remember that feeling when the result of some long-awaited\n // event is finally known. The feelings and thoughts you have at that moment are\n // definitely worth noting down and comparing.\n // Your task is to determine if a person correctly guessed the results of a number of matches.\n // You are given two lists of scores and guesses of equal length, where each index shows a match. \n // Return a list of the same length denoting how far off each guess was. If they have guessed correctly,\n // the value is 0, and if not, the value is the absolute difference between the guess and the score.\n // example:\n // >>> Compare((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)1L})), (new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)2L, (long)-2L})))\n // (new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)3L, (long)3L}))\n // >>> Compare((new List<long>(new long[]{(long)0L, (long)5L, (long)0L, (long)0L, (long)0L, (long)4L})), (new List<long>(new long[]{(long)4L, (long)1L, (long)1L, (long)0L, (long)0L, (long)-2L})))\n // (new List<long>(new long[]{(long)4L, (long)4L, (long)1L, (long)0L, (long)0L, (long)6L}))\n public static List<long> Compare(List<long> game, List<long> guess) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Compare((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)1L})), (new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)2L, (long)-2L}))).Equals((new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)3L, (long)3L}))));\n Debug.Assert(Compare((new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L})), (new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L}))).Equals((new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L}))));\n Debug.Assert(Compare((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})), (new List<long>(new long[]{(long)-1L, (long)-2L, (long)-3L}))).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)6L}))));\n Debug.Assert(Compare((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)5L})), (new List<long>(new long[]{(long)-1L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)2L, (long)0L, (long)0L, (long)1L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_152_compare"}
{"name": "HumanEval_83_starts_one_ends", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a positive integer n, return the count of the numbers of n-digit\n // positive integers that start or end with 1.\n public static long StartsOneEnds(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_83_starts_one_ends.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(StartsOneEnds((1L)) == (1L));\n Debug.Assert(StartsOneEnds((2L)) == (18L));\n Debug.Assert(StartsOneEnds((3L)) == (180L));\n Debug.Assert(StartsOneEnds((4L)) == (1800L));\n Debug.Assert(StartsOneEnds((5L)) == (18000L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_83_starts_one_ends"}
{"name": "HumanEval_134_check_if_last_char_is_a_letter", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Create a function that returns true if the last character\n // of a given string is an alphabetical character and is not\n // a part of a word, and false otherwise.\n // Note: \"word\" is a group of characters separated by space.\n // Examples:\n // >>> CheckIfLastCharIsALetter((\"apple pie\"))\n // (false)\n // >>> CheckIfLastCharIsALetter((\"apple pi e\"))\n // (true)\n // >>> CheckIfLastCharIsALetter((\"apple pi e \"))\n // (false)\n // >>> CheckIfLastCharIsALetter((\"\"))\n // (false)\n public static bool CheckIfLastCharIsALetter(string txt) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CheckIfLastCharIsALetter((\"apple\")) == (false));\n Debug.Assert(CheckIfLastCharIsALetter((\"apple pi e\")) == (true));\n Debug.Assert(CheckIfLastCharIsALetter((\"eeeee\")) == (false));\n Debug.Assert(CheckIfLastCharIsALetter((\"A\")) == (true));\n Debug.Assert(CheckIfLastCharIsALetter((\"Pumpkin pie \")) == (false));\n Debug.Assert(CheckIfLastCharIsALetter((\"Pumpkin pie 1\")) == (false));\n Debug.Assert(CheckIfLastCharIsALetter((\"\")) == (false));\n Debug.Assert(CheckIfLastCharIsALetter((\"eeeee e \")) == (false));\n Debug.Assert(CheckIfLastCharIsALetter((\"apple pie\")) == (false));\n Debug.Assert(CheckIfLastCharIsALetter((\"apple pi e \")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_134_check_if_last_char_is_a_letter"}
{"name": "HumanEval_124_valid_date", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You have to write a function which validates a given date string and\n // returns true if the date is valid otherwise false.\n // The date is valid if all of the following rules are satisfied:\n // 1. The date string is not empty.\n // 2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.\n // 3. The months should not be less than 1 or higher than 12.\n // 4. The date should be in the format: mm-dd-yyyy\n // >>> ValidDate((\"03-11-2000\"))\n // (true)\n // >>> ValidDate((\"15-01-2012\"))\n // (false)\n // >>> ValidDate((\"04-0-2040\"))\n // (false)\n // >>> ValidDate((\"06-04-2020\"))\n // (true)\n // >>> ValidDate((\"06/04/2020\"))\n // (false)\n public static bool ValidDate(string date) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(ValidDate((\"03-11-2000\")) == (true));\n Debug.Assert(ValidDate((\"15-01-2012\")) == (false));\n Debug.Assert(ValidDate((\"04-0-2040\")) == (false));\n Debug.Assert(ValidDate((\"06-04-2020\")) == (true));\n Debug.Assert(ValidDate((\"01-01-2007\")) == (true));\n Debug.Assert(ValidDate((\"03-32-2011\")) == (false));\n Debug.Assert(ValidDate((\"\")) == (false));\n Debug.Assert(ValidDate((\"04-31-3000\")) == (false));\n Debug.Assert(ValidDate((\"06-06-2005\")) == (true));\n Debug.Assert(ValidDate((\"21-31-2000\")) == (false));\n Debug.Assert(ValidDate((\"04-12-2003\")) == (true));\n Debug.Assert(ValidDate((\"04122003\")) == (false));\n Debug.Assert(ValidDate((\"20030412\")) == (false));\n Debug.Assert(ValidDate((\"2003-04\")) == (false));\n Debug.Assert(ValidDate((\"2003-04-12\")) == (false));\n Debug.Assert(ValidDate((\"04-2003\")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_124_valid_date"}
{"name": "HumanEval_108_count_nums", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function count_nums which takes a list of integers and returns\n // the number of elements which has a sum of digits > 0.\n // If a number is negative, then its first signed digit will be negative:\n // e.g. -123 has signed digits -1, 2, and 3.\n // >>> CountNums((new List<long>()))\n // (0L)\n // >>> CountNums((new List<long>(new long[]{(long)-1L, (long)11L, (long)-11L})))\n // (1L)\n // >>> CountNums((new List<long>(new long[]{(long)1L, (long)1L, (long)2L})))\n // (3L)\n public static long CountNums(List<long> arr) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_108_count_nums.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CountNums((new List<long>())) == (0L));\n Debug.Assert(CountNums((new List<long>(new long[]{(long)-1L, (long)-2L, (long)0L}))) == (0L));\n Debug.Assert(CountNums((new List<long>(new long[]{(long)1L, (long)1L, (long)2L, (long)-2L, (long)3L, (long)4L, (long)5L}))) == (6L));\n Debug.Assert(CountNums((new List<long>(new long[]{(long)1L, (long)6L, (long)9L, (long)-6L, (long)0L, (long)1L, (long)5L}))) == (5L));\n Debug.Assert(CountNums((new List<long>(new long[]{(long)1L, (long)100L, (long)98L, (long)-7L, (long)1L, (long)-1L}))) == (4L));\n Debug.Assert(CountNums((new List<long>(new long[]{(long)12L, (long)23L, (long)34L, (long)-45L, (long)-56L, (long)0L}))) == (5L));\n Debug.Assert(CountNums((new List<long>(new long[]{(long)0L, (long)1L}))) == (1L));\n Debug.Assert(CountNums((new List<long>(new long[]{(long)1L}))) == (1L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_108_count_nums"}
{"name": "HumanEval_86_anti_shuffle", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that takes a string and returns an ordered version of it.\n // Ordered version of string, is a string where all words (separated by space)\n // are replaced by a new word where all the characters arranged in\n // ascending order based on ascii value.\n // Note: You should keep the order of words and blank spaces in the sentence.\n // For example:\n // >>> AntiShuffle((\"Hi\"))\n // (\"Hi\")\n // >>> AntiShuffle((\"hello\"))\n // (\"ehllo\")\n // >>> AntiShuffle((\"Hello World!!!\"))\n // (\"Hello !!!Wdlor\")\n public static string AntiShuffle(string s) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_86_anti_shuffle.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(AntiShuffle((\"Hi\")).Equals((\"Hi\")));\n Debug.Assert(AntiShuffle((\"hello\")).Equals((\"ehllo\")));\n Debug.Assert(AntiShuffle((\"number\")).Equals((\"bemnru\")));\n Debug.Assert(AntiShuffle((\"abcd\")).Equals((\"abcd\")));\n Debug.Assert(AntiShuffle((\"Hello World!!!\")).Equals((\"Hello !!!Wdlor\")));\n Debug.Assert(AntiShuffle((\"\")).Equals((\"\")));\n Debug.Assert(AntiShuffle((\"Hi. My name is Mister Robot. How are you?\")).Equals((\".Hi My aemn is Meirst .Rboot How aer ?ouy\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_86_anti_shuffle"}
{"name": "HumanEval_48_is_palindrome", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Checks if given string is a palindrome\n // >>> IsPalindrome((\"\"))\n // (true)\n // >>> IsPalindrome((\"aba\"))\n // (true)\n // >>> IsPalindrome((\"aaaaa\"))\n // (true)\n // >>> IsPalindrome((\"zbcd\"))\n // (false)\n public static bool IsPalindrome(string text) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_48_is_palindrome.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IsPalindrome((\"\")) == (true));\n Debug.Assert(IsPalindrome((\"aba\")) == (true));\n Debug.Assert(IsPalindrome((\"aaaaa\")) == (true));\n Debug.Assert(IsPalindrome((\"zbcd\")) == (false));\n Debug.Assert(IsPalindrome((\"xywyx\")) == (true));\n Debug.Assert(IsPalindrome((\"xywyz\")) == (false));\n Debug.Assert(IsPalindrome((\"xywzx\")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_48_is_palindrome"}
{"name": "HumanEval_118_get_closest_vowel", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a word. Your task is to find the closest vowel that stands between \n // two consonants from the right side of the word (case sensitive).\n // Vowels in the beginning and ending doesn't count. Return empty string if you didn't\n // find any vowel met the above condition. \n // You may assume that the given string contains English letter only.\n // Example:\n // >>> GetClosestVowel((\"yogurt\"))\n // (\"u\")\n // >>> GetClosestVowel((\"FULL\"))\n // (\"U\")\n // >>> GetClosestVowel((\"quick\"))\n // (\"\")\n // >>> GetClosestVowel((\"ab\"))\n // (\"\")\n public static string GetClosestVowel(string word) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(GetClosestVowel((\"yogurt\")).Equals((\"u\")));\n Debug.Assert(GetClosestVowel((\"full\")).Equals((\"u\")));\n Debug.Assert(GetClosestVowel((\"easy\")).Equals((\"\")));\n Debug.Assert(GetClosestVowel((\"eAsy\")).Equals((\"\")));\n Debug.Assert(GetClosestVowel((\"ali\")).Equals((\"\")));\n Debug.Assert(GetClosestVowel((\"bad\")).Equals((\"a\")));\n Debug.Assert(GetClosestVowel((\"most\")).Equals((\"o\")));\n Debug.Assert(GetClosestVowel((\"ab\")).Equals((\"\")));\n Debug.Assert(GetClosestVowel((\"ba\")).Equals((\"\")));\n Debug.Assert(GetClosestVowel((\"quick\")).Equals((\"\")));\n Debug.Assert(GetClosestVowel((\"anime\")).Equals((\"i\")));\n Debug.Assert(GetClosestVowel((\"Asia\")).Equals((\"\")));\n Debug.Assert(GetClosestVowel((\"Above\")).Equals((\"o\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_118_get_closest_vowel"}
{"name": "HumanEval_31_is_prime", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return true if a given number is prime, and false otherwise.\n // >>> IsPrime((6L))\n // (false)\n // >>> IsPrime((101L))\n // (true)\n // >>> IsPrime((11L))\n // (true)\n // >>> IsPrime((13441L))\n // (true)\n // >>> IsPrime((61L))\n // (true)\n // >>> IsPrime((4L))\n // (false)\n // >>> IsPrime((1L))\n // (false)\n public static bool IsPrime(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_31_is_prime.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IsPrime((6L)) == (false));\n Debug.Assert(IsPrime((101L)) == (true));\n Debug.Assert(IsPrime((11L)) == (true));\n Debug.Assert(IsPrime((13441L)) == (true));\n Debug.Assert(IsPrime((61L)) == (true));\n Debug.Assert(IsPrime((4L)) == (false));\n Debug.Assert(IsPrime((1L)) == (false));\n Debug.Assert(IsPrime((5L)) == (true));\n Debug.Assert(IsPrime((11L)) == (true));\n Debug.Assert(IsPrime((17L)) == (true));\n Debug.Assert(IsPrime((85L)) == (false));\n Debug.Assert(IsPrime((77L)) == (false));\n Debug.Assert(IsPrime((255379L)) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_31_is_prime"}
{"name": "HumanEval_144_simplify", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Your task is to implement a function that will simplify the expression\n // x * n. The function returns true if x * n evaluates to a whole number and false\n // otherwise. Both x and n, are string representation of a fraction, and have the following format,\n // <numerator>/<denominator> where both numerator and denominator are positive whole numbers.\n // You can assume that x, and n are valid fractions, and do not have zero as denominator.\n // >>> Simplify((\"1/5\"), (\"5/1\"))\n // (true)\n // >>> Simplify((\"1/6\"), (\"2/1\"))\n // (false)\n // >>> Simplify((\"7/10\"), (\"10/2\"))\n // (false)\n public static bool Simplify(string x, string n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Simplify((\"1/5\"), (\"5/1\")) == (true));\n Debug.Assert(Simplify((\"1/6\"), (\"2/1\")) == (false));\n Debug.Assert(Simplify((\"5/1\"), (\"3/1\")) == (true));\n Debug.Assert(Simplify((\"7/10\"), (\"10/2\")) == (false));\n Debug.Assert(Simplify((\"2/10\"), (\"50/10\")) == (true));\n Debug.Assert(Simplify((\"7/2\"), (\"4/2\")) == (true));\n Debug.Assert(Simplify((\"11/6\"), (\"6/1\")) == (true));\n Debug.Assert(Simplify((\"2/3\"), (\"5/2\")) == (false));\n Debug.Assert(Simplify((\"5/2\"), (\"3/5\")) == (false));\n Debug.Assert(Simplify((\"2/4\"), (\"8/4\")) == (true));\n Debug.Assert(Simplify((\"2/4\"), (\"4/2\")) == (true));\n Debug.Assert(Simplify((\"1/5\"), (\"5/1\")) == (true));\n Debug.Assert(Simplify((\"1/5\"), (\"1/5\")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_144_simplify"}
{"name": "HumanEval_78_hex_key", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You have been tasked to write a function that receives \n // a hexadecimal number as a string and counts the number of hexadecimal \n // digits that are primes (prime number, or a prime, is a natural number \n // greater than 1 that is not a product of two smaller natural numbers).\n // Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.\n // Prime numbers are 2, 3, 5, 7, 11, 13, 17,...\n // So you have to determine a number of the following digits: 2, 3, 5, 7, \n // B (=decimal 11), D (=decimal 13).\n // Note: you may assume the input is always correct or empty string, \n // and symbols A,B,C,D,E,F are always uppercase.\n // Examples:\n // >>> HexKey((\"AB\"))\n // (1L)\n // >>> HexKey((\"1077E\"))\n // (2L)\n // >>> HexKey((\"ABED1A33\"))\n // (4L)\n // >>> HexKey((\"123456789ABCDEF0\"))\n // (6L)\n // >>> HexKey((\"2020\"))\n // (2L)\n public static long HexKey(string num) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_78_hex_key.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(HexKey((\"AB\")) == (1L));\n Debug.Assert(HexKey((\"1077E\")) == (2L));\n Debug.Assert(HexKey((\"ABED1A33\")) == (4L));\n Debug.Assert(HexKey((\"2020\")) == (2L));\n Debug.Assert(HexKey((\"123456789ABCDEF0\")) == (6L));\n Debug.Assert(HexKey((\"112233445566778899AABBCCDDEEFF00\")) == (12L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_78_hex_key"}
{"name": "HumanEval_143_words_in_sentence", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a string representing a sentence,\n // the sentence contains some words separated by a space,\n // and you have to return a string that contains the words from the original sentence,\n // whose lengths are prime numbers,\n // the order of the words in the new string should be the same as the original one.\n // Example 1:\n // >>> WordsInSentence((\"This is a test\"))\n // (\"is\")\n // Example 2:\n // >>> WordsInSentence((\"lets go for swimming\"))\n // (\"go for\")\n // Constraints:\n // * 1 <= len(sentence) <= 100\n // * sentence contains only letters\n public static string WordsInSentence(string sentence) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(WordsInSentence((\"This is a test\")).Equals((\"is\")));\n Debug.Assert(WordsInSentence((\"lets go for swimming\")).Equals((\"go for\")));\n Debug.Assert(WordsInSentence((\"there is no place available here\")).Equals((\"there is no place\")));\n Debug.Assert(WordsInSentence((\"Hi I am Hussein\")).Equals((\"Hi am Hussein\")));\n Debug.Assert(WordsInSentence((\"go for it\")).Equals((\"go for it\")));\n Debug.Assert(WordsInSentence((\"here\")).Equals((\"\")));\n Debug.Assert(WordsInSentence((\"here is\")).Equals((\"is\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_143_words_in_sentence"}
{"name": "HumanEval_111_histogram", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a string representing a space separated lowercase letters, return a dictionary\n // of the letter with the most repetition and containing the corresponding count.\n // If several letters have the same occurrence, return all of them.\n // Example:\n // >>> Histogram((\"a b c\"))\n // (new Dictionary<string,long>(){{\"a\", 1L}, {\"b\", 1L}, {\"c\", 1L}})\n // >>> Histogram((\"a b b a\"))\n // (new Dictionary<string,long>(){{\"a\", 2L}, {\"b\", 2L}})\n // >>> Histogram((\"a b c a b\"))\n // (new Dictionary<string,long>(){{\"a\", 2L}, {\"b\", 2L}})\n // >>> Histogram((\"b b b b a\"))\n // (new Dictionary<string,long>(){{\"b\", 4L}})\n // >>> Histogram((\"\"))\n // (new Dictionary<string,long>())\n public static Dictionary<string,long> Histogram(string test) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Histogram((\"a b b a\")).Equals((new Dictionary<string,long>(){{\"a\", 2L}, {\"b\", 2L}})));\n Debug.Assert(Histogram((\"a b c a b\")).Equals((new Dictionary<string,long>(){{\"a\", 2L}, {\"b\", 2L}})));\n Debug.Assert(Histogram((\"a b c d g\")).Equals((new Dictionary<string,long>(){{\"a\", 1L}, {\"b\", 1L}, {\"c\", 1L}, {\"d\", 1L}, {\"g\", 1L}})));\n Debug.Assert(Histogram((\"r t g\")).Equals((new Dictionary<string,long>(){{\"r\", 1L}, {\"t\", 1L}, {\"g\", 1L}})));\n Debug.Assert(Histogram((\"b b b b a\")).Equals((new Dictionary<string,long>(){{\"b\", 4L}})));\n Debug.Assert(Histogram((\"r t g\")).Equals((new Dictionary<string,long>(){{\"r\", 1L}, {\"t\", 1L}, {\"g\", 1L}})));\n Debug.Assert(Histogram((\"\")).Equals((new Dictionary<string,long>())));\n Debug.Assert(Histogram((\"a\")).Equals((new Dictionary<string,long>(){{\"a\", 1L}})));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_111_histogram"}
{"name": "HumanEval_87_get_row", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a 2 dimensional data, as a nested lists,\n // which is similar to matrix, however, unlike matrices,\n // each row may contain a different number of columns.\n // Given lst, and integer x, find integers x in the list,\n // and return list of tuples, [(x1, y1), (x2, y2) ...] such that\n // each tuple is a coordinate - (row, columns), starting with 0.\n // Sort coordinates initially by rows in ascending order.\n // Also, sort coordinates of the row by columns in descending order.\n // Examples:\n // >>> GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)1L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)1L})})), (1L))\n // (new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(0L, 0L), (Tuple<long, long>)Tuple.Create(1L, 4L), (Tuple<long, long>)Tuple.Create(1L, 0L), (Tuple<long, long>)Tuple.Create(2L, 5L), (Tuple<long, long>)Tuple.Create(2L, 0L)}))\n // >>> GetRow((new List<List<long>>()), (1L))\n // (new List<Tuple<long, long>>())\n // >>> GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(), (List<long>)new List<long>(new long[]{(long)1L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L})})), (3L))\n // (new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(2L, 2L)}))\n public static List<Tuple<long, long>> GetRow(List<List<long>> lst, long x) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_87_get_row.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)1L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)1L})})), (1L)).Equals((new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(0L, 0L), (Tuple<long, long>)Tuple.Create(1L, 4L), (Tuple<long, long>)Tuple.Create(1L, 0L), (Tuple<long, long>)Tuple.Create(2L, 5L), (Tuple<long, long>)Tuple.Create(2L, 0L)}))));\n Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L})})), (2L)).Equals((new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(0L, 1L), (Tuple<long, long>)Tuple.Create(1L, 1L), (Tuple<long, long>)Tuple.Create(2L, 1L), (Tuple<long, long>)Tuple.Create(3L, 1L), (Tuple<long, long>)Tuple.Create(4L, 1L), (Tuple<long, long>)Tuple.Create(5L, 1L)}))));\n Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)1L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)1L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)1L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)1L})})), (1L)).Equals((new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(0L, 0L), (Tuple<long, long>)Tuple.Create(1L, 0L), (Tuple<long, long>)Tuple.Create(2L, 1L), (Tuple<long, long>)Tuple.Create(2L, 0L), (Tuple<long, long>)Tuple.Create(3L, 2L), (Tuple<long, long>)Tuple.Create(3L, 0L), (Tuple<long, long>)Tuple.Create(4L, 3L), (Tuple<long, long>)Tuple.Create(4L, 0L), (Tuple<long, long>)Tuple.Create(5L, 4L), (Tuple<long, long>)Tuple.Create(5L, 0L), (Tuple<long, long>)Tuple.Create(6L, 5L), (Tuple<long, long>)Tuple.Create(6L, 0L)}))));\n Debug.Assert(GetRow((new List<List<long>>()), (1L)).Equals((new List<Tuple<long, long>>())));\n Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L})})), (2L)).Equals((new List<Tuple<long, long>>())));\n Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(), (List<long>)new List<long>(new long[]{(long)1L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L})})), (3L)).Equals((new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(2L, 2L)}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_87_get_row"}
{"name": "HumanEval_123_get_odd_collatz", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.\n // The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined\n // as follows: start with any positive integer n. Then each term is obtained from the \n // previous term as follows: if the previous term is even, the next term is one half of \n // the previous term. If the previous term is odd, the next term is 3 times the previous\n // term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.\n // Note: \n // 1. Collatz(1) is [1].\n // 2. returned list sorted in increasing order.\n // For example:\n // get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.\n // >>> GetOddCollatz((5L))\n // (new List<long>(new long[]{(long)1L, (long)5L}))\n public static List<long> GetOddCollatz(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(GetOddCollatz((14L)).Equals((new List<long>(new long[]{(long)1L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L}))));\n Debug.Assert(GetOddCollatz((5L)).Equals((new List<long>(new long[]{(long)1L, (long)5L}))));\n Debug.Assert(GetOddCollatz((12L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)5L}))));\n Debug.Assert(GetOddCollatz((1L)).Equals((new List<long>(new long[]{(long)1L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_123_get_odd_collatz"}
{"name": "HumanEval_135_can_arrange", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Create a function which returns the largest index of an element which\n // is not greater than or equal to the element immediately preceding it. If\n // no such element exists then return -1. The given list will not contain\n // duplicate values.\n // Examples:\n // >>> CanArrange((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)3L, (long)5L})))\n // (3L)\n // >>> CanArrange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))\n // (-1L)\n public static long CanArrange(List<long> arr) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CanArrange((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)3L, (long)5L}))) == (3L));\n Debug.Assert(CanArrange((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)5L}))) == (-1L));\n Debug.Assert(CanArrange((new List<long>(new long[]{(long)1L, (long)4L, (long)2L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L, (long)10L}))) == (2L));\n Debug.Assert(CanArrange((new List<long>(new long[]{(long)4L, (long)8L, (long)5L, (long)7L, (long)3L}))) == (4L));\n Debug.Assert(CanArrange((new List<long>())) == (-1L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_135_can_arrange"}
{"name": "HumanEval_19_sort_numbers", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Input is a space-delimited string of numberals from 'zero' to 'nine'.\n // Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.\n // Return the string with numbers sorted from smallest to largest\n // >>> SortNumbers((\"three one five\"))\n // (\"one three five\")\n public static string SortNumbers(string numbers) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_19_sort_numbers.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SortNumbers((\"\")).Equals((\"\")));\n Debug.Assert(SortNumbers((\"three\")).Equals((\"three\")));\n Debug.Assert(SortNumbers((\"three five nine\")).Equals((\"three five nine\")));\n Debug.Assert(SortNumbers((\"five zero four seven nine eight\")).Equals((\"zero four five seven eight nine\")));\n Debug.Assert(SortNumbers((\"six five four three two one zero\")).Equals((\"zero one two three four five six\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_19_sort_numbers"}
{"name": "HumanEval_65_circular_shift", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Circular shift the digits of the integer x, shift the digits right by shift\n // and return the result as a string.\n // If shift > number of digits, return digits reversed.\n // >>> CircularShift((12L), (1L))\n // (\"21\")\n // >>> CircularShift((12L), (2L))\n // (\"12\")\n public static string CircularShift(long x, long shift) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_65_circular_shift.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CircularShift((100L), (2L)).Equals((\"001\")));\n Debug.Assert(CircularShift((12L), (2L)).Equals((\"12\")));\n Debug.Assert(CircularShift((97L), (8L)).Equals((\"79\")));\n Debug.Assert(CircularShift((12L), (1L)).Equals((\"21\")));\n Debug.Assert(CircularShift((11L), (101L)).Equals((\"11\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_65_circular_shift"}
{"name": "HumanEval_142_sum_squares", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // \"\n // This function will take a list of integers. For all entries in the list, the function shall square the integer entry if its index is a \n // multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not \n // change the entries in the list whose indexes are not a multiple of 3 or 4. The function shall then return the sum of all entries. \n // Examples:\n // >>> lst\n // (long)new List<long>(new long[]{(long)1L, (long)2L, (long)3L})\n // >>> lst\n // (long)new List<long>()\n // >>> lst\n // (long)new List<long>(new long[]{(long)-1L, (long)-5L, (long)2L, (long)-1L, (long)-5L})\n public static long SumSquares(List<long> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))) == (6L));\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)1L, (long)4L, (long)9L}))) == (14L));\n Debug.Assert(SumSquares((new List<long>())) == (0L));\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L, (long)1L, (long)1L, (long)1L, (long)1L, (long)1L}))) == (9L));\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L}))) == (-3L));\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)0L}))) == (0L));\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)-1L, (long)-5L, (long)2L, (long)-1L, (long)-5L}))) == (-126L));\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)-56L, (long)-99L, (long)1L, (long)0L, (long)-2L}))) == (3030L));\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)-1L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)-1L}))) == (0L));\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)-16L, (long)-9L, (long)-2L, (long)36L, (long)36L, (long)26L, (long)-20L, (long)25L, (long)-40L, (long)20L, (long)-4L, (long)12L, (long)-26L, (long)35L, (long)37L}))) == (-14196L));\n Debug.Assert(SumSquares((new List<long>(new long[]{(long)-1L, (long)-3L, (long)17L, (long)-1L, (long)-15L, (long)13L, (long)-1L, (long)14L, (long)-14L, (long)-12L, (long)-5L, (long)14L, (long)-14L, (long)6L, (long)13L, (long)11L, (long)16L, (long)16L, (long)4L, (long)10L}))) == (-1448L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_142_sum_squares"}
{"name": "HumanEval_94_skjkasdkd", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a list of integers.\n // You need to find the largest prime value and return the sum of its digits.\n // Examples:\n // >>> Skjkasdkd((new List<long>(new long[]{(long)0L, (long)3L, (long)2L, (long)1L, (long)3L, (long)5L, (long)7L, (long)4L, (long)5L, (long)5L, (long)5L, (long)2L, (long)181L, (long)32L, (long)4L, (long)32L, (long)3L, (long)2L, (long)32L, (long)324L, (long)4L, (long)3L})))\n // (10L)\n // >>> Skjkasdkd((new List<long>(new long[]{(long)1L, (long)0L, (long)1L, (long)8L, (long)2L, (long)4597L, (long)2L, (long)1L, (long)3L, (long)40L, (long)1L, (long)2L, (long)1L, (long)2L, (long)4L, (long)2L, (long)5L, (long)1L})))\n // (25L)\n // >>> Skjkasdkd((new List<long>(new long[]{(long)1L, (long)3L, (long)1L, (long)32L, (long)5107L, (long)34L, (long)83278L, (long)109L, (long)163L, (long)23L, (long)2323L, (long)32L, (long)30L, (long)1L, (long)9L, (long)3L})))\n // (13L)\n // >>> Skjkasdkd((new List<long>(new long[]{(long)0L, (long)724L, (long)32L, (long)71L, (long)99L, (long)32L, (long)6L, (long)0L, (long)5L, (long)91L, (long)83L, (long)0L, (long)5L, (long)6L})))\n // (11L)\n // >>> Skjkasdkd((new List<long>(new long[]{(long)0L, (long)81L, (long)12L, (long)3L, (long)1L, (long)21L})))\n // (3L)\n // >>> Skjkasdkd((new List<long>(new long[]{(long)0L, (long)8L, (long)1L, (long)2L, (long)1L, (long)7L})))\n // (7L)\n public static long Skjkasdkd(List<long> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_94_skjkasdkd.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)0L, (long)3L, (long)2L, (long)1L, (long)3L, (long)5L, (long)7L, (long)4L, (long)5L, (long)5L, (long)5L, (long)2L, (long)181L, (long)32L, (long)4L, (long)32L, (long)3L, (long)2L, (long)32L, (long)324L, (long)4L, (long)3L}))) == (10L));\n Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)1L, (long)0L, (long)1L, (long)8L, (long)2L, (long)4597L, (long)2L, (long)1L, (long)3L, (long)40L, (long)1L, (long)2L, (long)1L, (long)2L, (long)4L, (long)2L, (long)5L, (long)1L}))) == (25L));\n Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)1L, (long)3L, (long)1L, (long)32L, (long)5107L, (long)34L, (long)83278L, (long)109L, (long)163L, (long)23L, (long)2323L, (long)32L, (long)30L, (long)1L, (long)9L, (long)3L}))) == (13L));\n Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)0L, (long)724L, (long)32L, (long)71L, (long)99L, (long)32L, (long)6L, (long)0L, (long)5L, (long)91L, (long)83L, (long)0L, (long)5L, (long)6L}))) == (11L));\n Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)0L, (long)81L, (long)12L, (long)3L, (long)1L, (long)21L}))) == (3L));\n Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)0L, (long)8L, (long)1L, (long)2L, (long)1L, (long)7L}))) == (7L));\n Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)8191L}))) == (19L));\n Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)8191L, (long)123456L, (long)127L, (long)7L}))) == (19L));\n Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)127L, (long)97L, (long)8192L}))) == (10L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_94_skjkasdkd"}
{"name": "HumanEval_8_sum_product", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.\n // Empty sum should be equal to 0 and empty product should be equal to 1.\n // >>> SumProduct((new List<long>()))\n // (Tuple.Create(0L, 1L))\n // >>> SumProduct((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})))\n // (Tuple.Create(10L, 24L))\n public static Tuple<long, long> SumProduct(List<long> numbers) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_8_sum_product.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SumProduct((new List<long>())).Equals((Tuple.Create(0L, 1L))));\n Debug.Assert(SumProduct((new List<long>(new long[]{(long)1L, (long)1L, (long)1L}))).Equals((Tuple.Create(3L, 1L))));\n Debug.Assert(SumProduct((new List<long>(new long[]{(long)100L, (long)0L}))).Equals((Tuple.Create(100L, 0L))));\n Debug.Assert(SumProduct((new List<long>(new long[]{(long)3L, (long)5L, (long)7L}))).Equals((Tuple.Create(15L, 105L))));\n Debug.Assert(SumProduct((new List<long>(new long[]{(long)10L}))).Equals((Tuple.Create(10L, 10L))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_8_sum_product"}
{"name": "HumanEval_102_choose_num", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // This function takes two positive numbers x and y and returns the\n // biggest even integer number that is in the range [x, y] inclusive. If \n // there's no such number, then the function should return -1.\n // For example:\n // >>> ChooseNum((12L), (15L))\n // (14L)\n // >>> ChooseNum((13L), (12L))\n // (-1L)\n public static long ChooseNum(long x, long y) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_102_choose_num.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(ChooseNum((12L), (15L)) == (14L));\n Debug.Assert(ChooseNum((13L), (12L)) == (-1L));\n Debug.Assert(ChooseNum((33L), (12354L)) == (12354L));\n Debug.Assert(ChooseNum((5234L), (5233L)) == (-1L));\n Debug.Assert(ChooseNum((6L), (29L)) == (28L));\n Debug.Assert(ChooseNum((27L), (10L)) == (-1L));\n Debug.Assert(ChooseNum((7L), (7L)) == (-1L));\n Debug.Assert(ChooseNum((546L), (546L)) == (546L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_102_choose_num"}
{"name": "HumanEval_136_largest_smallest_integers", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Create a function that returns a tuple (a, b), where 'a' is\n // the largest of negative integers, and 'b' is the smallest\n // of positive integers in a list.\n // If there is no negative or positive integers, return them as null.\n // Examples:\n // >>> LargestSmallestIntegers((new List<long>(new long[]{(long)2L, (long)4L, (long)1L, (long)3L, (long)5L, (long)7L})))\n // Tuple.Create((Nullable<long>)null, 1L)\n // >>> LargestSmallestIntegers((new List<long>()))\n // Tuple.Create((Nullable<long>)null, (Nullable<long>)null)\n // >>> LargestSmallestIntegers((new List<long>(new long[]{(long)0L})))\n // Tuple.Create((Nullable<long>)null, (Nullable<long>)null)\n public static Tuple<Nullable<long>, Nullable<long>> LargestSmallestIntegers(List<long> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)2L, (long)4L, (long)1L, (long)3L, (long)5L, (long)7L}))).Equals(Tuple.Create((Nullable<long>)null, 1L)));\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)2L, (long)4L, (long)1L, (long)3L, (long)5L, (long)7L, (long)0L}))).Equals(Tuple.Create((Nullable<long>)null, 1L)));\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)4L, (long)5L, (long)6L, (long)-2L}))).Equals(Tuple.Create(-2L, 1L)));\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)4L, (long)5L, (long)3L, (long)6L, (long)2L, (long)7L, (long)-7L}))).Equals(Tuple.Create(-7L, 2L)));\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)7L, (long)3L, (long)8L, (long)4L, (long)9L, (long)2L, (long)5L, (long)-9L}))).Equals(Tuple.Create(-9L, 2L)));\n Debug.Assert(LargestSmallestIntegers((new List<long>())).Equals(Tuple.Create((Nullable<long>)null, (Nullable<long>)null)));\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)0L}))).Equals(Tuple.Create((Nullable<long>)null, (Nullable<long>)null)));\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)-1L, (long)-3L, (long)-5L, (long)-6L}))).Equals(Tuple.Create(-1L, (Nullable<long>)null)));\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)-1L, (long)-3L, (long)-5L, (long)-6L, (long)0L}))).Equals(Tuple.Create(-1L, (Nullable<long>)null)));\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)-6L, (long)-4L, (long)-4L, (long)-3L, (long)1L}))).Equals(Tuple.Create(-3L, 1L)));\n Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)-6L, (long)-4L, (long)-4L, (long)-3L, (long)-100L, (long)1L}))).Equals(Tuple.Create(-3L, 1L)));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_136_largest_smallest_integers"}
{"name": "HumanEval_16_count_distinct_characters", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a string, find out how many distinct characters (regardless of case) does it consist of\n // >>> CountDistinctCharacters((\"xyzXYZ\"))\n // (3L)\n // >>> CountDistinctCharacters((\"Jerry\"))\n // (4L)\n public static long CountDistinctCharacters(string str) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_16_count_distinct_characters.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CountDistinctCharacters((\"\")) == (0L));\n Debug.Assert(CountDistinctCharacters((\"abcde\")) == (5L));\n Debug.Assert(CountDistinctCharacters((\"abcdecadeCADE\")) == (5L));\n Debug.Assert(CountDistinctCharacters((\"aaaaAAAAaaaa\")) == (1L));\n Debug.Assert(CountDistinctCharacters((\"Jerry jERRY JeRRRY\")) == (5L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_16_count_distinct_characters"}
{"name": "HumanEval_100_make_a_pile", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a positive integer n, you have to make a pile of n levels of stones.\n // The first level has n stones.\n // The number of stones in the next level is:\n // - the next odd number if n is odd.\n // - the next even number if n is even.\n // Return the number of stones in each level in a list, where element at index\n // i represents the number of stones in the level (i+1).\n // Examples:\n // >>> MakeAPile((3L))\n // (new List<long>(new long[]{(long)3L, (long)5L, (long)7L}))\n public static List<long> MakeAPile(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_100_make_a_pile.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(MakeAPile((3L)).Equals((new List<long>(new long[]{(long)3L, (long)5L, (long)7L}))));\n Debug.Assert(MakeAPile((4L)).Equals((new List<long>(new long[]{(long)4L, (long)6L, (long)8L, (long)10L}))));\n Debug.Assert(MakeAPile((5L)).Equals((new List<long>(new long[]{(long)5L, (long)7L, (long)9L, (long)11L, (long)13L}))));\n Debug.Assert(MakeAPile((6L)).Equals((new List<long>(new long[]{(long)6L, (long)8L, (long)10L, (long)12L, (long)14L, (long)16L}))));\n Debug.Assert(MakeAPile((8L)).Equals((new List<long>(new long[]{(long)8L, (long)10L, (long)12L, (long)14L, (long)16L, (long)18L, (long)20L, (long)22L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_100_make_a_pile"}
{"name": "HumanEval_128_prod_signs", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a list arr of integers and you need to return\n // sum of magnitudes of integers multiplied by product of all signs\n // of each number in the list, represented by 1, -1 or 0.\n // Note: return null for empty arr.\n // Example:\n // >>> ProdSigns((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)-4L})))\n // 9L\n // >>> ProdSigns((new List<long>(new long[]{(long)0L, (long)1L})))\n // 0L\n // >>> ProdSigns((new List<long>()))\n // null\n public static Nullable<long> ProdSigns(List<long> arr) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_128_prod_signs.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(ProdSigns((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)-4L}))).Equals(-9L));\n Debug.Assert(ProdSigns((new List<long>(new long[]{(long)0L, (long)1L}))).Equals(0L));\n Debug.Assert(ProdSigns((new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)2L, (long)3L, (long)-1L, (long)1L}))).Equals(-10L));\n Debug.Assert(ProdSigns((new List<long>())).Equals(null));\n Debug.Assert(ProdSigns((new List<long>(new long[]{(long)2L, (long)4L, (long)1L, (long)2L, (long)-1L, (long)-1L, (long)9L}))).Equals(20L));\n Debug.Assert(ProdSigns((new List<long>(new long[]{(long)-1L, (long)1L, (long)-1L, (long)1L}))).Equals(4L));\n Debug.Assert(ProdSigns((new List<long>(new long[]{(long)-1L, (long)1L, (long)1L, (long)1L}))).Equals(-4L));\n Debug.Assert(ProdSigns((new List<long>(new long[]{(long)-1L, (long)1L, (long)1L, (long)0L}))).Equals(0L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_128_prod_signs"}
{"name": "HumanEval_114_minSubArraySum", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a list of integers nums, find the minimum sum of any non-empty sub-list\n // of nums.\n // Example\n // >>> Minsubarraysum((new List<long>(new long[]{(long)2L, (long)3L, (long)4L, (long)1L, (long)2L, (long)4L})))\n // (1L)\n // >>> Minsubarraysum((new List<long>(new long[]{(long)-1L, (long)-2L, (long)-3L})))\n // (-6L)\n public static long Minsubarraysum(List<long> nums) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)2L, (long)3L, (long)4L, (long)1L, (long)2L, (long)4L}))) == (1L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-1L, (long)-2L, (long)-3L}))) == (-6L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-1L, (long)-2L, (long)-3L, (long)2L, (long)-10L}))) == (-14L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-9999999999999999L}))) == (-9999999999999999L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)0L, (long)10L, (long)20L, (long)1000000L}))) == (0L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-1L, (long)-2L, (long)-3L, (long)10L, (long)-5L}))) == (-6L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)100L, (long)-1L, (long)-2L, (long)-3L, (long)10L, (long)-5L}))) == (-6L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)10L, (long)11L, (long)13L, (long)8L, (long)3L, (long)4L}))) == (3L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)100L, (long)-33L, (long)32L, (long)-1L, (long)0L, (long)-2L}))) == (-33L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-10L}))) == (-10L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)7L}))) == (7L));\n Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)1L, (long)-1L}))) == (-1L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_114_minSubArraySum"}
{"name": "HumanEval_15_string_sequence", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return a string containing space-delimited numbers starting from 0 upto n inclusive.\n // >>> StringSequence((0L))\n // (\"0\")\n // >>> StringSequence((5L))\n // (\"0 1 2 3 4 5\")\n public static string StringSequence(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_15_string_sequence.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(StringSequence((0L)).Equals((\"0\")));\n Debug.Assert(StringSequence((3L)).Equals((\"0 1 2 3\")));\n Debug.Assert(StringSequence((10L)).Equals((\"0 1 2 3 4 5 6 7 8 9 10\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_15_string_sequence"}
{"name": "HumanEval_154_cycpattern_check", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given 2 words. You need to return true if the second word or any of its rotations is a substring in the first word\n // >>> CycpatternCheck((\"abcd\"), (\"abd\"))\n // (false)\n // >>> CycpatternCheck((\"hello\"), (\"ell\"))\n // (true)\n // >>> CycpatternCheck((\"whassup\"), (\"psus\"))\n // (false)\n // >>> CycpatternCheck((\"abab\"), (\"baa\"))\n // (true)\n // >>> CycpatternCheck((\"efef\"), (\"eeff\"))\n // (false)\n // >>> CycpatternCheck((\"himenss\"), (\"simen\"))\n // (true)\n public static bool CycpatternCheck(string a, string b) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CycpatternCheck((\"xyzw\"), (\"xyw\")) == (false));\n Debug.Assert(CycpatternCheck((\"yello\"), (\"ell\")) == (true));\n Debug.Assert(CycpatternCheck((\"whattup\"), (\"ptut\")) == (false));\n Debug.Assert(CycpatternCheck((\"efef\"), (\"fee\")) == (true));\n Debug.Assert(CycpatternCheck((\"abab\"), (\"aabb\")) == (false));\n Debug.Assert(CycpatternCheck((\"winemtt\"), (\"tinem\")) == (true));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_154_cycpattern_check"}
{"name": "HumanEval_57_monotonic", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return true is list elements are monotonically increasing or decreasing.\n // >>> Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)20L})))\n // (true)\n // >>> Monotonic((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})))\n // (false)\n // >>> Monotonic((new List<long>(new long[]{(long)4L, (long)1L, (long)0L, (long)-10L})))\n // (true)\n public static bool Monotonic(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_57_monotonic.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)10L}))) == (true));\n Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)20L}))) == (true));\n Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L}))) == (false));\n Debug.Assert(Monotonic((new List<long>(new long[]{(long)4L, (long)1L, (long)0L, (long)-10L}))) == (true));\n Debug.Assert(Monotonic((new List<long>(new long[]{(long)4L, (long)1L, (long)1L, (long)0L}))) == (true));\n Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)5L, (long)60L}))) == (false));\n Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)60L}))) == (true));\n Debug.Assert(Monotonic((new List<long>(new long[]{(long)9L, (long)9L, (long)9L, (long)9L}))) == (true));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_57_monotonic"}
{"name": "HumanEval_12_longest", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Out of list of strings, return the longest one. Return the first one in case of multiple\n // strings of the same length. Return null in case the input list is empty.\n // >>> Longest((new List<string>()))\n // null\n // >>> Longest((new List<string>(new string[]{(string)\"a\", (string)\"b\", (string)\"c\"})))\n // (\"a\")\n // >>> Longest((new List<string>(new string[]{(string)\"a\", (string)\"bb\", (string)\"ccc\"})))\n // (\"ccc\")\n public static string Longest(List<string> strings) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_12_longest.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Longest((new List<string>())).Equals(null));\n Debug.Assert(Longest((new List<string>(new string[]{(string)\"x\", (string)\"y\", (string)\"z\"}))).Equals((\"x\")));\n Debug.Assert(Longest((new List<string>(new string[]{(string)\"x\", (string)\"yyy\", (string)\"zzzz\", (string)\"www\", (string)\"kkkk\", (string)\"abc\"}))).Equals((\"zzzz\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_12_longest"}
{"name": "HumanEval_52_below_threshold", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return true if all numbers in the list l are below threshold t.\n // >>> BelowThreshold((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)10L})), (100L))\n // (true)\n // >>> BelowThreshold((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})), (5L))\n // (false)\n public static bool BelowThreshold(List<long> l, long t) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_52_below_threshold.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)10L})), (100L)) == (true));\n Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})), (5L)) == (false));\n Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})), (21L)) == (true));\n Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})), (22L)) == (true));\n Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)8L, (long)4L, (long)10L})), (11L)) == (true));\n Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)8L, (long)4L, (long)10L})), (10L)) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_52_below_threshold"}
{"name": "HumanEval_75_is_multiply_prime", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that returns true if the given number is the multiplication of 3 prime numbers\n // and false otherwise.\n // Knowing that (a) is less then 100. \n // Example:\n // >>> IsMultiplyPrime((30L))\n // (true)\n // 30 = 2 * 3 * 5\n public static bool IsMultiplyPrime(long a) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_75_is_multiply_prime.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IsMultiplyPrime((5L)) == (false));\n Debug.Assert(IsMultiplyPrime((30L)) == (true));\n Debug.Assert(IsMultiplyPrime((8L)) == (true));\n Debug.Assert(IsMultiplyPrime((10L)) == (false));\n Debug.Assert(IsMultiplyPrime((125L)) == (true));\n Debug.Assert(IsMultiplyPrime((105L)) == (true));\n Debug.Assert(IsMultiplyPrime((126L)) == (false));\n Debug.Assert(IsMultiplyPrime((729L)) == (false));\n Debug.Assert(IsMultiplyPrime((891L)) == (false));\n Debug.Assert(IsMultiplyPrime((1001L)) == (true));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_75_is_multiply_prime"}
{"name": "HumanEval_30_get_positive", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return only positive numbers in the list.\n // >>> GetPositive((new List<long>(new long[]{(long)-1L, (long)2L, (long)-4L, (long)5L, (long)6L})))\n // (new List<long>(new long[]{(long)2L, (long)5L, (long)6L}))\n // >>> GetPositive((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)9L, (long)0L, (long)123L, (long)1L, (long)-10L})))\n // (new List<long>(new long[]{(long)5L, (long)3L, (long)2L, (long)3L, (long)9L, (long)123L, (long)1L}))\n public static List<long> GetPositive(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_30_get_positive.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(GetPositive((new List<long>(new long[]{(long)-1L, (long)-2L, (long)4L, (long)5L, (long)6L}))).Equals((new List<long>(new long[]{(long)4L, (long)5L, (long)6L}))));\n Debug.Assert(GetPositive((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)3L, (long)3L, (long)9L, (long)0L, (long)123L, (long)1L, (long)-10L}))).Equals((new List<long>(new long[]{(long)5L, (long)3L, (long)2L, (long)3L, (long)3L, (long)9L, (long)123L, (long)1L}))));\n Debug.Assert(GetPositive((new List<long>(new long[]{(long)-1L, (long)-2L}))).Equals((new List<long>())));\n Debug.Assert(GetPositive((new List<long>())).Equals((new List<long>())));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_30_get_positive"}
{"name": "HumanEval_33_sort_third", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // This function takes a list l and returns a list l' such that\n // l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal\n // to the values of the corresponding indicies of l, but sorted.\n // >>> SortThird((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))\n // (new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))\n // >>> SortThird((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)2L})))\n // (new List<long>(new long[]{(long)2L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)5L}))\n public static List<long> SortThird(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_33_sort_third.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SortThird((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)2L}))).Equals((new List<long>(new long[]{(long)2L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)5L}))));\n Debug.Assert(SortThird((new List<long>(new long[]{(long)5L, (long)8L, (long)3L, (long)4L, (long)6L, (long)9L, (long)2L}))).Equals((new List<long>(new long[]{(long)2L, (long)8L, (long)3L, (long)4L, (long)6L, (long)9L, (long)5L}))));\n Debug.Assert(SortThird((new List<long>(new long[]{(long)5L, (long)6L, (long)9L, (long)4L, (long)8L, (long)3L, (long)2L}))).Equals((new List<long>(new long[]{(long)2L, (long)6L, (long)9L, (long)4L, (long)8L, (long)3L, (long)5L}))));\n Debug.Assert(SortThird((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)2L, (long)1L}))).Equals((new List<long>(new long[]{(long)2L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)5L, (long)1L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_33_sort_third"}
{"name": "HumanEval_6_parse_nested_parens", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Input to this function is a string represented multiple groups for nested parentheses separated by spaces.\n // For each of the group, output the deepest level of nesting of parentheses.\n // E.g. (()()) has maximum two levels of nesting while ((())) has three.\n // >>> ParseNestedParens((\"(()()) ((())) () ((())()())\"))\n // (new List<long>(new long[]{(long)2L, (long)3L, (long)1L, (long)3L}))\n public static List<long> ParseNestedParens(string paren_string) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_6_parse_nested_parens.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(ParseNestedParens((\"(()()) ((())) () ((())()())\")).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)1L, (long)3L}))));\n Debug.Assert(ParseNestedParens((\"() (()) ((())) (((())))\")).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))));\n Debug.Assert(ParseNestedParens((\"(()(())((())))\")).Equals((new List<long>(new long[]{(long)4L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_6_parse_nested_parens"}
{"name": "HumanEval_45_triangle_area", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given length of a side and high return area for a triangle.\n // >>> TriangleArea((5L), (3L))\n // (7.5f)\n public static float TriangleArea(long a, long h) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_45_triangle_area.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(TriangleArea((5L), (3L)) == (7.5f));\n Debug.Assert(TriangleArea((2L), (2L)) == (2.0f));\n Debug.Assert(TriangleArea((10L), (8L)) == (40.0f));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_45_triangle_area"}
{"name": "HumanEval_97_multiply", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Complete the function that takes two integers and returns \n // the product of their unit digits.\n // Assume the input is always valid.\n // Examples:\n // >>> Multiply((148L), (412L))\n // (16L)\n // >>> Multiply((19L), (28L))\n // (72L)\n // >>> Multiply((2020L), (1851L))\n // (0L)\n // >>> Multiply((14L), (-15L))\n // (20L)\n public static long Multiply(long a, long b) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_97_multiply.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Multiply((148L), (412L)) == (16L));\n Debug.Assert(Multiply((19L), (28L)) == (72L));\n Debug.Assert(Multiply((2020L), (1851L)) == (0L));\n Debug.Assert(Multiply((14L), (-15L)) == (20L));\n Debug.Assert(Multiply((76L), (67L)) == (42L));\n Debug.Assert(Multiply((17L), (27L)) == (49L));\n Debug.Assert(Multiply((0L), (1L)) == (0L));\n Debug.Assert(Multiply((0L), (0L)) == (0L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_97_multiply"}
{"name": "HumanEval_4_mean_absolute_deviation", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // For a given list of input numbers, calculate Mean Absolute Deviation\n // around the mean of this dataset.\n // Mean Absolute Deviation is the average absolute difference between each\n // element and a centerpoint (mean in this case):\n // MAD = average | x - x_mean |\n // >>> MeanAbsoluteDeviation((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f})))\n // (1.0f)\n public static float MeanAbsoluteDeviation(List<float> numbers) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_4_mean_absolute_deviation.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(MeanAbsoluteDeviation((new List<float>(new float[]{(float)1.0f, (float)2.0f}))) == (0.5f));\n Debug.Assert(MeanAbsoluteDeviation((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f}))) == (1.0f));\n Debug.Assert(MeanAbsoluteDeviation((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))) == (1.2f));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_4_mean_absolute_deviation"}
{"name": "HumanEval_58_common", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return sorted unique common elements for two lists.\n // >>> Common((new List<long>(new long[]{(long)1L, (long)4L, (long)3L, (long)34L, (long)653L, (long)2L, (long)5L})), (new List<long>(new long[]{(long)5L, (long)7L, (long)1L, (long)5L, (long)9L, (long)653L, (long)121L})))\n // (new List<long>(new long[]{(long)1L, (long)5L, (long)653L}))\n // >>> Common((new List<long>(new long[]{(long)5L, (long)3L, (long)2L, (long)8L})), (new List<long>(new long[]{(long)3L, (long)2L})))\n // (new List<long>(new long[]{(long)2L, (long)3L}))\n public static List<long> Common(List<long> l1, List<long> l2) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_58_common.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Common((new List<long>(new long[]{(long)1L, (long)4L, (long)3L, (long)34L, (long)653L, (long)2L, (long)5L})), (new List<long>(new long[]{(long)5L, (long)7L, (long)1L, (long)5L, (long)9L, (long)653L, (long)121L}))).Equals((new List<long>(new long[]{(long)1L, (long)5L, (long)653L}))));\n Debug.Assert(Common((new List<long>(new long[]{(long)5L, (long)3L, (long)2L, (long)8L})), (new List<long>(new long[]{(long)3L, (long)2L}))).Equals((new List<long>(new long[]{(long)2L, (long)3L}))));\n Debug.Assert(Common((new List<long>(new long[]{(long)4L, (long)3L, (long)2L, (long)8L})), (new List<long>(new long[]{(long)3L, (long)2L, (long)4L}))).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)4L}))));\n Debug.Assert(Common((new List<long>(new long[]{(long)4L, (long)3L, (long)2L, (long)8L})), (new List<long>())).Equals((new List<long>())));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_58_common"}
{"name": "HumanEval_156_int_to_mini_roman", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a positive integer, obtain its roman numeral equivalent as a string,\n // and return it in lowercase.\n // Restrictions: 1 <= num <= 1000\n // Examples:\n // >>> IntToMiniRoman((19L))\n // (\"xix\")\n // >>> IntToMiniRoman((152L))\n // (\"clii\")\n // >>> IntToMiniRoman((426L))\n // (\"cdxxvi\")\n public static string IntToMiniRoman(long number) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(IntToMiniRoman((19L)).Equals((\"xix\")));\n Debug.Assert(IntToMiniRoman((152L)).Equals((\"clii\")));\n Debug.Assert(IntToMiniRoman((251L)).Equals((\"ccli\")));\n Debug.Assert(IntToMiniRoman((426L)).Equals((\"cdxxvi\")));\n Debug.Assert(IntToMiniRoman((500L)).Equals((\"d\")));\n Debug.Assert(IntToMiniRoman((1L)).Equals((\"i\")));\n Debug.Assert(IntToMiniRoman((4L)).Equals((\"iv\")));\n Debug.Assert(IntToMiniRoman((43L)).Equals((\"xliii\")));\n Debug.Assert(IntToMiniRoman((90L)).Equals((\"xc\")));\n Debug.Assert(IntToMiniRoman((94L)).Equals((\"xciv\")));\n Debug.Assert(IntToMiniRoman((532L)).Equals((\"dxxxii\")));\n Debug.Assert(IntToMiniRoman((900L)).Equals((\"cm\")));\n Debug.Assert(IntToMiniRoman((994L)).Equals((\"cmxciv\")));\n Debug.Assert(IntToMiniRoman((1000L)).Equals((\"m\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_156_int_to_mini_roman"}
{"name": "HumanEval_67_fruit_distribution", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // In this task, you will be given a string that represents a number of apples and oranges \n // that are distributed in a basket of fruit this basket contains \n // apples, oranges, and mango fruits. Given the string that represents the total number of \n // the oranges and apples and an integer that represent the total number of the fruits \n // in the basket return the number of the mango fruits in the basket.\n // for examble:\n // >>> FruitDistribution((\"5 apples and 6 oranges\"), (19L))\n // (8L)\n // >>> FruitDistribution((\"0 apples and 1 oranges\"), (3L))\n // (2L)\n // >>> FruitDistribution((\"2 apples and 3 oranges\"), (100L))\n // (95L)\n // >>> FruitDistribution((\"100 apples and 1 oranges\"), (120L))\n // (19L)\n public static long FruitDistribution(string s, long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_67_fruit_distribution.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FruitDistribution((\"5 apples and 6 oranges\"), (19L)) == (8L));\n Debug.Assert(FruitDistribution((\"5 apples and 6 oranges\"), (21L)) == (10L));\n Debug.Assert(FruitDistribution((\"0 apples and 1 oranges\"), (3L)) == (2L));\n Debug.Assert(FruitDistribution((\"1 apples and 0 oranges\"), (3L)) == (2L));\n Debug.Assert(FruitDistribution((\"2 apples and 3 oranges\"), (100L)) == (95L));\n Debug.Assert(FruitDistribution((\"2 apples and 3 oranges\"), (5L)) == (0L));\n Debug.Assert(FruitDistribution((\"1 apples and 100 oranges\"), (120L)) == (19L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_67_fruit_distribution"}
{"name": "HumanEval_112_reverse_delete", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Task\n // We are given two strings s and c, you have to deleted all the characters in s that are equal to any character in c\n // then check if the result string is palindrome.\n // A string is called palindrome if it reads the same backward as forward.\n // You should return a tuple containing the result string and true/false for the check.\n // Example\n // >>> ReverseDelete((\"abcde\"), (\"ae\"))\n // (Tuple.Create(\"bcd\", false))\n // >>> ReverseDelete((\"abcdef\"), (\"b\"))\n // (Tuple.Create(\"acdef\", false))\n // >>> ReverseDelete((\"abcdedcba\"), (\"ab\"))\n // (Tuple.Create(\"cdedc\", true))\n public static Tuple<string, bool> ReverseDelete(string s, string c) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(ReverseDelete((\"abcde\"), (\"ae\")).Equals((Tuple.Create(\"bcd\", false))));\n Debug.Assert(ReverseDelete((\"abcdef\"), (\"b\")).Equals((Tuple.Create(\"acdef\", false))));\n Debug.Assert(ReverseDelete((\"abcdedcba\"), (\"ab\")).Equals((Tuple.Create(\"cdedc\", true))));\n Debug.Assert(ReverseDelete((\"dwik\"), (\"w\")).Equals((Tuple.Create(\"dik\", false))));\n Debug.Assert(ReverseDelete((\"a\"), (\"a\")).Equals((Tuple.Create(\"\", true))));\n Debug.Assert(ReverseDelete((\"abcdedcba\"), (\"\")).Equals((Tuple.Create(\"abcdedcba\", true))));\n Debug.Assert(ReverseDelete((\"abcdedcba\"), (\"v\")).Equals((Tuple.Create(\"abcdedcba\", true))));\n Debug.Assert(ReverseDelete((\"vabba\"), (\"v\")).Equals((Tuple.Create(\"abba\", true))));\n Debug.Assert(ReverseDelete((\"mamma\"), (\"mia\")).Equals((Tuple.Create(\"\", true))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_112_reverse_delete"}
{"name": "HumanEval_13_greatest_common_divisor", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Return a greatest common divisor of two integers a and b\n // >>> GreatestCommonDivisor((3L), (5L))\n // (1L)\n // >>> GreatestCommonDivisor((25L), (15L))\n // (5L)\n public static long GreatestCommonDivisor(long a, long b) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_13_greatest_common_divisor.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(GreatestCommonDivisor((3L), (7L)) == (1L));\n Debug.Assert(GreatestCommonDivisor((10L), (15L)) == (5L));\n Debug.Assert(GreatestCommonDivisor((49L), (14L)) == (7L));\n Debug.Assert(GreatestCommonDivisor((144L), (60L)) == (12L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_13_greatest_common_divisor"}
{"name": "HumanEval_116_sort_array", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // In this Kata, you have to sort a list of non-negative integers according to\n // number of ones in their binary representation in ascending order.\n // For similar number of ones, sort based on decimal value.\n // It must be implemented like this:\n // >>> SortArray((new List<long>(new long[]{(long)1L, (long)5L, (long)2L, (long)3L, (long)4L})))\n // (new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))\n // >>> SortArray((new List<long>(new long[]{(long)-2L, (long)-3L, (long)-4L, (long)-5L, (long)-6L})))\n // (new List<long>(new long[]{(long)-6L, (long)-5L, (long)-4L, (long)-3L, (long)-2L}))\n // >>> SortArray((new List<long>(new long[]{(long)1L, (long)0L, (long)2L, (long)3L, (long)4L})))\n // (new List<long>(new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L}))\n public static List<long> SortArray(List<long> arr) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_sort_array.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SortArray((new List<long>(new long[]{(long)1L, (long)5L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)3L, (long)5L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)-2L, (long)-3L, (long)-4L, (long)-5L, (long)-6L}))).Equals((new List<long>(new long[]{(long)-4L, (long)-2L, (long)-6L, (long)-5L, (long)-3L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)1L, (long)0L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)0L, (long)1L, (long)2L, (long)4L, (long)3L}))));\n Debug.Assert(SortArray((new List<long>())).Equals((new List<long>())));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)5L, (long)77L, (long)4L, (long)5L, (long)3L, (long)5L, (long)7L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)4L, (long)4L, (long)3L, (long)3L, (long)5L, (long)5L, (long)5L, (long)7L, (long)77L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)3L, (long)6L, (long)44L, (long)12L, (long)32L, (long)5L}))).Equals((new List<long>(new long[]{(long)32L, (long)3L, (long)5L, (long)6L, (long)12L, (long)44L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)8L, (long)16L, (long)32L}))).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)8L, (long)16L, (long)32L}))));\n Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)8L, (long)16L, (long)32L}))).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)8L, (long)16L, (long)32L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_116_sort_array"}
{"name": "HumanEval_28_concatenate", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Concatenate list of strings into a single string\n // >>> Concatenate((new List<string>()))\n // (\"\")\n // >>> Concatenate((new List<string>(new string[]{(string)\"a\", (string)\"b\", (string)\"c\"})))\n // (\"abc\")\n public static string Concatenate(List<string> strings) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_28_concatenate.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Concatenate((new List<string>())).Equals((\"\")));\n Debug.Assert(Concatenate((new List<string>(new string[]{(string)\"x\", (string)\"y\", (string)\"z\"}))).Equals((\"xyz\")));\n Debug.Assert(Concatenate((new List<string>(new string[]{(string)\"x\", (string)\"y\", (string)\"z\", (string)\"w\", (string)\"k\"}))).Equals((\"xyzwk\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_28_concatenate"}
{"name": "HumanEval_149_sorted_list_sum", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that accepts a list of strings as a parameter,\n // deletes the strings that have odd lengths from it,\n // and returns the resulted list with a sorted order,\n // The list is always a list of strings and never a list of numbers,\n // and it may contain duplicates.\n // The order of the list should be ascending by length of each word, and you\n // should return the list sorted by that rule.\n // If two words have the same length, sort the list alphabetically.\n // The function should return a list of strings in sorted order.\n // You may assume that all words will have the same length.\n // For example:\n // >>> ListSort((new List<string>(new string[]{(string)\"aa\", (string)\"a\", (string)\"aaa\"})))\n // (new List<string>(new string[]{(string)\"aa\"}))\n // >>> ListSort((new List<string>(new string[]{(string)\"ab\", (string)\"a\", (string)\"aaa\", (string)\"cd\"})))\n // (new List<string>(new string[]{(string)\"ab\", (string)\"cd\"}))\n public static List<string> SortedListSum(List<string> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SortedListSum((new List<string>(new string[]{(string)\"aa\", (string)\"a\", (string)\"aaa\"}))).Equals((new List<string>(new string[]{(string)\"aa\"}))));\n Debug.Assert(SortedListSum((new List<string>(new string[]{(string)\"school\", (string)\"AI\", (string)\"asdf\", (string)\"b\"}))).Equals((new List<string>(new string[]{(string)\"AI\", (string)\"asdf\", (string)\"school\"}))));\n Debug.Assert(SortedListSum((new List<string>(new string[]{(string)\"d\", (string)\"b\", (string)\"c\", (string)\"a\"}))).Equals((new List<string>())));\n Debug.Assert(SortedListSum((new List<string>(new string[]{(string)\"d\", (string)\"dcba\", (string)\"abcd\", (string)\"a\"}))).Equals((new List<string>(new string[]{(string)\"abcd\", (string)\"dcba\"}))));\n Debug.Assert(SortedListSum((new List<string>(new string[]{(string)\"AI\", (string)\"ai\", (string)\"au\"}))).Equals((new List<string>(new string[]{(string)\"AI\", (string)\"ai\", (string)\"au\"}))));\n Debug.Assert(SortedListSum((new List<string>(new string[]{(string)\"a\", (string)\"b\", (string)\"b\", (string)\"c\", (string)\"c\", (string)\"a\"}))).Equals((new List<string>())));\n Debug.Assert(SortedListSum((new List<string>(new string[]{(string)\"aaaa\", (string)\"bbbb\", (string)\"dd\", (string)\"cc\"}))).Equals((new List<string>(new string[]{(string)\"cc\", (string)\"dd\", (string)\"aaaa\", (string)\"bbbb\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_149_sorted_list_sum"}
{"name": "HumanEval_7_filter_by_substring", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Filter an input list of strings only for ones that contain given substring\n // >>> FilterBySubstring((new List<string>()), (\"a\"))\n // (new List<string>())\n // >>> FilterBySubstring((new List<string>(new string[]{(string)\"abc\", (string)\"bacd\", (string)\"cde\", (string)\"array\"})), (\"a\"))\n // (new List<string>(new string[]{(string)\"abc\", (string)\"bacd\", (string)\"array\"}))\n public static List<string> FilterBySubstring(List<string> strings, string substring) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_7_filter_by_substring.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FilterBySubstring((new List<string>()), (\"john\")).Equals((new List<string>())));\n Debug.Assert(FilterBySubstring((new List<string>(new string[]{(string)\"xxx\", (string)\"asd\", (string)\"xxy\", (string)\"john doe\", (string)\"xxxAAA\", (string)\"xxx\"})), (\"xxx\")).Equals((new List<string>(new string[]{(string)\"xxx\", (string)\"xxxAAA\", (string)\"xxx\"}))));\n Debug.Assert(FilterBySubstring((new List<string>(new string[]{(string)\"xxx\", (string)\"asd\", (string)\"aaaxxy\", (string)\"john doe\", (string)\"xxxAAA\", (string)\"xxx\"})), (\"xx\")).Equals((new List<string>(new string[]{(string)\"xxx\", (string)\"aaaxxy\", (string)\"xxxAAA\", (string)\"xxx\"}))));\n Debug.Assert(FilterBySubstring((new List<string>(new string[]{(string)\"grunt\", (string)\"trumpet\", (string)\"prune\", (string)\"gruesome\"})), (\"run\")).Equals((new List<string>(new string[]{(string)\"grunt\", (string)\"prune\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_7_filter_by_substring"}
{"name": "HumanEval_99_closest_integer", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Create a function that takes a value (string) representing a number\n // and returns the closest integer to it. If the number is equidistant\n // from two integers, round it away from zero.\n // Examples\n // >>> ClosestInteger((\"10\"))\n // (10L)\n // >>> ClosestInteger((\"15.3\"))\n // (15L)\n // Note:\n // Rounding away from zero means that if the given number is equidistant\n // from two integers, the one you should return is the one that is the\n // farthest from zero. For example closest_integer(\"14.5\") should\n // return 15 and closest_integer(\"-14.5\") should return -15.\n public static long ClosestInteger(string value) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_99_closest_integer.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(ClosestInteger((\"10\")) == (10L));\n Debug.Assert(ClosestInteger((\"14.5\")) == (15L));\n Debug.Assert(ClosestInteger((\"-15.5\")) == (-16L));\n Debug.Assert(ClosestInteger((\"15.3\")) == (15L));\n Debug.Assert(ClosestInteger((\"0\")) == (0L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_99_closest_integer"}
{"name": "HumanEval_64_vowels_count", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function vowels_count which takes a string representing\n // a word as input and returns the number of vowels in the string.\n // Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a\n // vowel, but only when it is at the end of the given word.\n // Example:\n // >>> VowelsCount((\"abcde\"))\n // (2L)\n // >>> VowelsCount((\"ACEDY\"))\n // (3L)\n public static long VowelsCount(string s) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_64_vowels_count.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(VowelsCount((\"abcde\")) == (2L));\n Debug.Assert(VowelsCount((\"Alone\")) == (3L));\n Debug.Assert(VowelsCount((\"key\")) == (2L));\n Debug.Assert(VowelsCount((\"bye\")) == (1L));\n Debug.Assert(VowelsCount((\"keY\")) == (2L));\n Debug.Assert(VowelsCount((\"bYe\")) == (1L));\n Debug.Assert(VowelsCount((\"ACEDY\")) == (3L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_64_vowels_count"}
{"name": "HumanEval_158_find_max", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that accepts a list of strings.\n // The list contains different words. Return the word with maximum number\n // of unique characters. If multiple strings have maximum number of unique\n // characters, return the one which comes first in lexicographical order.\n // >>> FindMax((new List<string>(new string[]{(string)\"name\", (string)\"of\", (string)\"string\"})))\n // (\"string\")\n // >>> FindMax((new List<string>(new string[]{(string)\"name\", (string)\"enam\", (string)\"game\"})))\n // (\"enam\")\n // >>> FindMax((new List<string>(new string[]{(string)\"aaaaaaa\", (string)\"bb\", (string)\"cc\"})))\n // (\"aaaaaaa\")\n public static string FindMax(List<string> words) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"name\", (string)\"of\", (string)\"string\"}))).Equals((\"string\")));\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"name\", (string)\"enam\", (string)\"game\"}))).Equals((\"enam\")));\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"aaaaaaa\", (string)\"bb\", (string)\"cc\"}))).Equals((\"aaaaaaa\")));\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"abc\", (string)\"cba\"}))).Equals((\"abc\")));\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"play\", (string)\"this\", (string)\"game\", (string)\"of\", (string)\"footbott\"}))).Equals((\"footbott\")));\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"we\", (string)\"are\", (string)\"gonna\", (string)\"rock\"}))).Equals((\"gonna\")));\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"we\", (string)\"are\", (string)\"a\", (string)\"mad\", (string)\"nation\"}))).Equals((\"nation\")));\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"this\", (string)\"is\", (string)\"a\", (string)\"prrk\"}))).Equals((\"this\")));\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"b\"}))).Equals((\"b\")));\n Debug.Assert(FindMax((new List<string>(new string[]{(string)\"play\", (string)\"play\", (string)\"play\"}))).Equals((\"play\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_158_find_max"}
{"name": "HumanEval_162_string_to_md5", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given a string 'text', return its md5 hash equivalent string.\n // If 'text' is an empty string, return null.\n // >>> StringToMd5((\"Hello world\"))\n // (\"3e25960a79dbc69b674cd4ec67a72c62\")\n public static string StringToMd5(string text) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_162_string_to_md5.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(StringToMd5((\"Hello world\")).Equals((\"3e25960a79dbc69b674cd4ec67a72c62\")));\n Debug.Assert(StringToMd5((\"\")).Equals(null));\n Debug.Assert(StringToMd5((\"A B C\")).Equals((\"0ef78513b0cb8cef12743f5aeb35f888\")));\n Debug.Assert(StringToMd5((\"password\")).Equals((\"5f4dcc3b5aa765d61d8327deb882cf99\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_162_string_to_md5"}
{"name": "HumanEval_44_change_base", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Change numerical base of input number x to base.\n // return string representation after the conversion.\n // base numbers are less than 10.\n // >>> ChangeBase((8L), (3L))\n // (\"22\")\n // >>> ChangeBase((8L), (2L))\n // (\"1000\")\n // >>> ChangeBase((7L), (2L))\n // (\"111\")\n public static string ChangeBase(long x, long numBase) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_44_change_base.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(ChangeBase((8L), (3L)).Equals((\"22\")));\n Debug.Assert(ChangeBase((9L), (3L)).Equals((\"100\")));\n Debug.Assert(ChangeBase((234L), (2L)).Equals((\"11101010\")));\n Debug.Assert(ChangeBase((16L), (2L)).Equals((\"10000\")));\n Debug.Assert(ChangeBase((8L), (2L)).Equals((\"1000\")));\n Debug.Assert(ChangeBase((7L), (2L)).Equals((\"111\")));\n Debug.Assert(ChangeBase((2L), (3L)).Equals((\"2\")));\n Debug.Assert(ChangeBase((3L), (4L)).Equals((\"3\")));\n Debug.Assert(ChangeBase((4L), (5L)).Equals((\"4\")));\n Debug.Assert(ChangeBase((5L), (6L)).Equals((\"5\")));\n Debug.Assert(ChangeBase((6L), (7L)).Equals((\"6\")));\n Debug.Assert(ChangeBase((7L), (8L)).Equals((\"7\")));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_44_change_base"}
{"name": "HumanEval_157_right_angle_triangle", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given the lengths of the three sides of a triangle. Return true if the three\n // sides form a right-angled triangle, false otherwise.\n // A right-angled triangle is a triangle in which one angle is right angle or \n // 90 degree.\n // Example:\n // >>> RightAngleTriangle((3L), (4L), (5L))\n // (true)\n // >>> RightAngleTriangle((1L), (2L), (3L))\n // (false)\n public static bool RightAngleTriangle(long a, long b, long c) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(RightAngleTriangle((3L), (4L), (5L)) == (true));\n Debug.Assert(RightAngleTriangle((1L), (2L), (3L)) == (false));\n Debug.Assert(RightAngleTriangle((10L), (6L), (8L)) == (true));\n Debug.Assert(RightAngleTriangle((2L), (2L), (2L)) == (false));\n Debug.Assert(RightAngleTriangle((7L), (24L), (25L)) == (true));\n Debug.Assert(RightAngleTriangle((10L), (5L), (7L)) == (false));\n Debug.Assert(RightAngleTriangle((5L), (12L), (13L)) == (true));\n Debug.Assert(RightAngleTriangle((15L), (8L), (17L)) == (true));\n Debug.Assert(RightAngleTriangle((48L), (55L), (73L)) == (true));\n Debug.Assert(RightAngleTriangle((1L), (1L), (1L)) == (false));\n Debug.Assert(RightAngleTriangle((2L), (2L), (10L)) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_157_right_angle_triangle"}
{"name": "HumanEval_81_numerical_letter_grade", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // It is the last week of the semester and the teacher has to give the grades\n // to students. The teacher has been making her own algorithm for grading.\n // The only problem is, she has lost the code she used for grading.\n // She has given you a list of GPAs for some students and you have to write \n // a function that can output a list of letter grades using the following table:\n // GPA | Letter grade\n // 4.0 A+\n // > 3.7 A \n // > 3.3 A- \n // > 3.0 B+\n // > 2.7 B \n // > 2.3 B-\n // > 2.0 C+\n // > 1.7 C\n // > 1.3 C-\n // > 1.0 D+ \n // > 0.7 D \n // > 0.0 D-\n // 0.0 E\n // Example:\n // >>> GradeEquation((new List<float>(new float[]{(float)4.0f, (float)3L, (float)1.7f, (float)2L, (float)3.5f})))\n // (new List<string>(new string[]{(string)\"A+\", (string)\"B\", (string)\"C-\", (string)\"C\", (string)\"A-\"}))\n public static List<string> NumericalLetterGrade(List<float> grades) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_81_numerical_letter_grade.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)4.0f, (float)3L, (float)1.7f, (float)2L, (float)3.5f}))).Equals((new List<string>(new string[]{(string)\"A+\", (string)\"B\", (string)\"C-\", (string)\"C\", (string)\"A-\"}))));\n Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)1.2f}))).Equals((new List<string>(new string[]{(string)\"D+\"}))));\n Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)0.5f}))).Equals((new List<string>(new string[]{(string)\"D-\"}))));\n Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)0.0f}))).Equals((new List<string>(new string[]{(string)\"E\"}))));\n Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)1.0f, (float)0.3f, (float)1.5f, (float)2.8f, (float)3.3f}))).Equals((new List<string>(new string[]{(string)\"D\", (string)\"D-\", (string)\"C-\", (string)\"B\", (string)\"B+\"}))));\n Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)0.0f, (float)0.7f}))).Equals((new List<string>(new string[]{(string)\"E\", (string)\"D-\"}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_81_numerical_letter_grade"}
{"name": "HumanEval_5_intersperse", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Insert a number 'delimeter' between every two consecutive elements of input list `numbers'\n // >>> Intersperse((new List<long>()), (4L))\n // (new List<long>())\n // >>> Intersperse((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})), (4L))\n // (new List<long>(new long[]{(long)1L, (long)4L, (long)2L, (long)4L, (long)3L}))\n public static List<long> Intersperse(List<long> numbers, long delimeter) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_5_intersperse.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Intersperse((new List<long>()), (7L)).Equals((new List<long>())));\n Debug.Assert(Intersperse((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)2L})), (8L)).Equals((new List<long>(new long[]{(long)5L, (long)8L, (long)6L, (long)8L, (long)3L, (long)8L, (long)2L}))));\n Debug.Assert(Intersperse((new List<long>(new long[]{(long)2L, (long)2L, (long)2L})), (2L)).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)2L, (long)2L, (long)2L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_5_intersperse"}
{"name": "HumanEval_146_specialFilter", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Write a function that takes a list of numbers as input and returns \n // the number of elements in the list that are greater than 10 and both \n // first and last digits of a number are odd (1, 3, 5, 7, 9).\n // For example:\n // >>> Specialfilter((new List<long>(new long[]{(long)15L, (long)-73L, (long)14L, (long)-15L})))\n // (1L)\n // >>> Specialfilter((new List<long>(new long[]{(long)33L, (long)-2L, (long)-3L, (long)45L, (long)21L, (long)109L})))\n // (2L)\n public static long Specialfilter(List<long> nums) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Specialfilter((new List<long>(new long[]{(long)5L, (long)-2L, (long)1L, (long)-5L}))) == (0L));\n Debug.Assert(Specialfilter((new List<long>(new long[]{(long)15L, (long)-73L, (long)14L, (long)-15L}))) == (1L));\n Debug.Assert(Specialfilter((new List<long>(new long[]{(long)33L, (long)-2L, (long)-3L, (long)45L, (long)21L, (long)109L}))) == (2L));\n Debug.Assert(Specialfilter((new List<long>(new long[]{(long)43L, (long)-12L, (long)93L, (long)125L, (long)121L, (long)109L}))) == (4L));\n Debug.Assert(Specialfilter((new List<long>(new long[]{(long)71L, (long)-2L, (long)-33L, (long)75L, (long)21L, (long)19L}))) == (3L));\n Debug.Assert(Specialfilter((new List<long>(new long[]{(long)1L}))) == (0L));\n Debug.Assert(Specialfilter((new List<long>())) == (0L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_146_specialFilter"}
{"name": "HumanEval_60_sum_to_n", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // sum_to_n is a function that sums numbers from 1 to n.\n // >>> SumToN((30L))\n // (465L)\n // >>> SumToN((100L))\n // (5050L)\n // >>> SumToN((5L))\n // (15L)\n // >>> SumToN((10L))\n // (55L)\n // >>> SumToN((1L))\n // (1L)\n public static long SumToN(long n) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_60_sum_to_n.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SumToN((1L)) == (1L));\n Debug.Assert(SumToN((6L)) == (21L));\n Debug.Assert(SumToN((11L)) == (66L));\n Debug.Assert(SumToN((30L)) == (465L));\n Debug.Assert(SumToN((100L)) == (5050L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_60_sum_to_n"}
{"name": "HumanEval_26_remove_duplicates", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // From a list of integers, remove all elements that occur more than once.\n // Keep order of elements left the same as in the input.\n // >>> RemoveDuplicates((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)4L})))\n // (new List<long>(new long[]{(long)1L, (long)3L, (long)4L}))\n public static List<long> RemoveDuplicates(List<long> numbers) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_26_remove_duplicates.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(RemoveDuplicates((new List<long>())).Equals((new List<long>())));\n Debug.Assert(RemoveDuplicates((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))));\n Debug.Assert(RemoveDuplicates((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)4L, (long)3L, (long)5L}))).Equals((new List<long>(new long[]{(long)1L, (long)4L, (long)5L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_26_remove_duplicates"}
{"name": "HumanEval_163_generate_integers", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Given two positive integers a and b, return the even digits between a\n // and b, in ascending order.\n // For example:\n // >>> GenerateIntegers((2L), (8L))\n // (new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))\n // >>> GenerateIntegers((8L), (2L))\n // (new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))\n // >>> GenerateIntegers((10L), (14L))\n // (new List<long>())\n public static List<long> GenerateIntegers(long a, long b) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(GenerateIntegers((2L), (10L)).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))));\n Debug.Assert(GenerateIntegers((10L), (2L)).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))));\n Debug.Assert(GenerateIntegers((132L), (2L)).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))));\n Debug.Assert(GenerateIntegers((17L), (89L)).Equals((new List<long>())));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_163_generate_integers"}
{"name": "HumanEval_9_rolling_max", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // From a given list of integers, generate a list of rolling maximum element found until given moment\n // in the sequence.\n // >>> RollingMax((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)3L, (long)4L, (long)2L})))\n // (new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)3L, (long)3L, (long)4L, (long)4L}))\n public static List<long> RollingMax(List<long> numbers) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_9_rolling_max.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(RollingMax((new List<long>())).Equals((new List<long>())));\n Debug.Assert(RollingMax((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))));\n Debug.Assert(RollingMax((new List<long>(new long[]{(long)4L, (long)3L, (long)2L, (long)1L}))).Equals((new List<long>(new long[]{(long)4L, (long)4L, (long)4L, (long)4L}))));\n Debug.Assert(RollingMax((new List<long>(new long[]{(long)3L, (long)2L, (long)3L, (long)100L, (long)3L}))).Equals((new List<long>(new long[]{(long)3L, (long)3L, (long)3L, (long)100L, (long)100L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_9_rolling_max"}
{"name": "HumanEval_3_below_zero", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You're given a list of deposit and withdrawal operations on a bank account that starts with\n // zero balance. Your task is to detect if at any point the balance of account fallls below zero, and\n // at that point function should return true. Otherwise it should return false.\n // >>> BelowZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))\n // (false)\n // >>> BelowZero((new List<long>(new long[]{(long)1L, (long)2L, (long)-4L, (long)5L})))\n // (true)\n public static bool BelowZero(List<long> operations) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_3_below_zero.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(BelowZero((new List<long>())) == (false));\n Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)2L, (long)-3L, (long)1L, (long)2L, (long)-3L}))) == (false));\n Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)2L, (long)-4L, (long)5L, (long)6L}))) == (true));\n Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)-1L, (long)2L, (long)-2L, (long)5L, (long)-5L, (long)4L, (long)-4L}))) == (false));\n Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)-1L, (long)2L, (long)-2L, (long)5L, (long)-5L, (long)4L, (long)-5L}))) == (true));\n Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)-2L, (long)2L, (long)-2L, (long)5L, (long)-5L, (long)4L, (long)-4L}))) == (true));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_3_below_zero"}
{"name": "HumanEval_69_search", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // You are given a non-empty list of positive integers. Return the greatest integer that is greater than \n // zero, and has a frequency greater than or equal to the value of the integer itself. \n // The frequency of an integer is the number of times it appears in the list.\n // If no such a value exist, return -1.\n // Examples:\n // >>> Search((new List<long>(new long[]{(long)4L, (long)1L, (long)2L, (long)2L, (long)3L, (long)1L})))\n // (2L)\n // >>> Search((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)3L, (long)3L, (long)3L, (long)4L, (long)4L, (long)4L})))\n // (3L)\n // >>> Search((new List<long>(new long[]{(long)5L, (long)5L, (long)4L, (long)4L, (long)4L})))\n // (-1L)\n public static long Search(List<long> lst) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_69_search.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(Search((new List<long>(new long[]{(long)5L, (long)5L, (long)5L, (long)5L, (long)1L}))) == (1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)4L, (long)1L, (long)4L, (long)1L, (long)4L, (long)4L}))) == (4L));\n Debug.Assert(Search((new List<long>(new long[]{(long)3L, (long)3L}))) == (-1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)8L, (long)8L, (long)8L, (long)8L, (long)8L, (long)8L, (long)8L, (long)8L}))) == (8L));\n Debug.Assert(Search((new List<long>(new long[]{(long)2L, (long)3L, (long)3L, (long)2L, (long)2L}))) == (2L));\n Debug.Assert(Search((new List<long>(new long[]{(long)2L, (long)7L, (long)8L, (long)8L, (long)4L, (long)8L, (long)7L, (long)3L, (long)9L, (long)6L, (long)5L, (long)10L, (long)4L, (long)3L, (long)6L, (long)7L, (long)1L, (long)7L, (long)4L, (long)10L, (long)8L, (long)1L}))) == (1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)3L, (long)2L, (long)8L, (long)2L}))) == (2L));\n Debug.Assert(Search((new List<long>(new long[]{(long)6L, (long)7L, (long)1L, (long)8L, (long)8L, (long)10L, (long)5L, (long)8L, (long)5L, (long)3L, (long)10L}))) == (1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)8L, (long)8L, (long)3L, (long)6L, (long)5L, (long)6L, (long)4L}))) == (-1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)6L, (long)9L, (long)6L, (long)7L, (long)1L, (long)4L, (long)7L, (long)1L, (long)8L, (long)8L, (long)9L, (long)8L, (long)10L, (long)10L, (long)8L, (long)4L, (long)10L, (long)4L, (long)10L, (long)1L, (long)2L, (long)9L, (long)5L, (long)7L, (long)9L}))) == (1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)1L, (long)9L, (long)10L, (long)1L, (long)3L}))) == (1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)6L, (long)9L, (long)7L, (long)5L, (long)8L, (long)7L, (long)5L, (long)3L, (long)7L, (long)5L, (long)10L, (long)10L, (long)3L, (long)6L, (long)10L, (long)2L, (long)8L, (long)6L, (long)5L, (long)4L, (long)9L, (long)5L, (long)3L, (long)10L}))) == (5L));\n Debug.Assert(Search((new List<long>(new long[]{(long)1L}))) == (1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)8L, (long)8L, (long)10L, (long)6L, (long)4L, (long)3L, (long)5L, (long)8L, (long)2L, (long)4L, (long)2L, (long)8L, (long)4L, (long)6L, (long)10L, (long)4L, (long)2L, (long)1L, (long)10L, (long)2L, (long)1L, (long)1L, (long)5L}))) == (4L));\n Debug.Assert(Search((new List<long>(new long[]{(long)2L, (long)10L, (long)4L, (long)8L, (long)2L, (long)10L, (long)5L, (long)1L, (long)2L, (long)9L, (long)5L, (long)5L, (long)6L, (long)3L, (long)8L, (long)6L, (long)4L, (long)10L}))) == (2L));\n Debug.Assert(Search((new List<long>(new long[]{(long)1L, (long)6L, (long)10L, (long)1L, (long)6L, (long)9L, (long)10L, (long)8L, (long)6L, (long)8L, (long)7L, (long)3L}))) == (1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)9L, (long)2L, (long)4L, (long)1L, (long)5L, (long)1L, (long)5L, (long)2L, (long)5L, (long)7L, (long)7L, (long)7L, (long)3L, (long)10L, (long)1L, (long)5L, (long)4L, (long)2L, (long)8L, (long)4L, (long)1L, (long)9L, (long)10L, (long)7L, (long)10L, (long)2L, (long)8L, (long)10L, (long)9L, (long)4L}))) == (4L));\n Debug.Assert(Search((new List<long>(new long[]{(long)2L, (long)6L, (long)4L, (long)2L, (long)8L, (long)7L, (long)5L, (long)6L, (long)4L, (long)10L, (long)4L, (long)6L, (long)3L, (long)7L, (long)8L, (long)8L, (long)3L, (long)1L, (long)4L, (long)2L, (long)2L, (long)10L, (long)7L}))) == (4L));\n Debug.Assert(Search((new List<long>(new long[]{(long)9L, (long)8L, (long)6L, (long)10L, (long)2L, (long)6L, (long)10L, (long)2L, (long)7L, (long)8L, (long)10L, (long)3L, (long)8L, (long)2L, (long)6L, (long)2L, (long)3L, (long)1L}))) == (2L));\n Debug.Assert(Search((new List<long>(new long[]{(long)5L, (long)5L, (long)3L, (long)9L, (long)5L, (long)6L, (long)3L, (long)2L, (long)8L, (long)5L, (long)6L, (long)10L, (long)10L, (long)6L, (long)8L, (long)4L, (long)10L, (long)7L, (long)7L, (long)10L, (long)8L}))) == (-1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)10L}))) == (-1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)9L, (long)7L, (long)7L, (long)2L, (long)4L, (long)7L, (long)2L, (long)10L, (long)9L, (long)7L, (long)5L, (long)7L, (long)2L}))) == (2L));\n Debug.Assert(Search((new List<long>(new long[]{(long)5L, (long)4L, (long)10L, (long)2L, (long)1L, (long)1L, (long)10L, (long)3L, (long)6L, (long)1L, (long)8L}))) == (1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)7L, (long)9L, (long)9L, (long)9L, (long)3L, (long)4L, (long)1L, (long)5L, (long)9L, (long)1L, (long)2L, (long)1L, (long)1L, (long)10L, (long)7L, (long)5L, (long)6L, (long)7L, (long)6L, (long)7L, (long)7L, (long)6L}))) == (1L));\n Debug.Assert(Search((new List<long>(new long[]{(long)3L, (long)10L, (long)10L, (long)9L, (long)2L}))) == (-1L));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_69_search"}
{"name": "HumanEval_61_correct_bracketing", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // brackets is a string of \"(\" and \")\".\n // return true if every opening bracket has a corresponding closing bracket.\n // >>> CorrectBracketing((\"(\"))\n // (false)\n // >>> CorrectBracketing((\"()\"))\n // (true)\n // >>> CorrectBracketing((\"(()())\"))\n // (true)\n // >>> CorrectBracketing((\")(()\"))\n // (false)\n public static bool CorrectBracketing(string brackets) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_61_correct_bracketing.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CorrectBracketing((\"()\")) == (true));\n Debug.Assert(CorrectBracketing((\"(()())\")) == (true));\n Debug.Assert(CorrectBracketing((\"()()(()())()\")) == (true));\n Debug.Assert(CorrectBracketing((\"()()((()()())())(()()(()))\")) == (true));\n Debug.Assert(CorrectBracketing((\"((()())))\")) == (false));\n Debug.Assert(CorrectBracketing((\")(()\")) == (false));\n Debug.Assert(CorrectBracketing((\"(\")) == (false));\n Debug.Assert(CorrectBracketing((\"((((\")) == (false));\n Debug.Assert(CorrectBracketing((\")\")) == (false));\n Debug.Assert(CorrectBracketing((\"(()\")) == (false));\n Debug.Assert(CorrectBracketing((\"()()(()())())(()\")) == (false));\n Debug.Assert(CorrectBracketing((\"()()(()())()))()\")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_61_correct_bracketing"}
{"name": "HumanEval_37_sort_even", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // This function takes a list l and returns a list l' such that\n // l' is identical to l in the odd indicies, while its values at the even indicies are equal\n // to the values of the even indicies of l, but sorted.\n // >>> SortEven((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))\n // (new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))\n // >>> SortEven((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)4L})))\n // (new List<long>(new long[]{(long)3L, (long)6L, (long)5L, (long)4L}))\n public static List<long> SortEven(List<long> l) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_37_sort_even.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SortEven((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))));\n Debug.Assert(SortEven((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)9L, (long)0L, (long)123L, (long)1L, (long)-10L}))).Equals((new List<long>(new long[]{(long)-10L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)5L, (long)0L, (long)9L, (long)1L, (long)123L}))));\n Debug.Assert(SortEven((new List<long>(new long[]{(long)5L, (long)8L, (long)-12L, (long)4L, (long)23L, (long)2L, (long)3L, (long)11L, (long)12L, (long)-10L}))).Equals((new List<long>(new long[]{(long)-12L, (long)8L, (long)3L, (long)4L, (long)5L, (long)2L, (long)12L, (long)11L, (long)23L, (long)-10L}))));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_37_sort_even"}
{"name": "HumanEval_54_same_chars", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // Check if two words have the same characters.\n // >>> SameChars((\"eabcdzzzz\"), (\"dddzzzzzzzddeddabc\"))\n // (true)\n // >>> SameChars((\"abcd\"), (\"dddddddabc\"))\n // (true)\n // >>> SameChars((\"dddddddabc\"), (\"abcd\"))\n // (true)\n // >>> SameChars((\"eabcd\"), (\"dddddddabc\"))\n // (false)\n // >>> SameChars((\"abcd\"), (\"dddddddabce\"))\n // (false)\n // >>> SameChars((\"eabcdzzzz\"), (\"dddzzzzzzzddddabc\"))\n // (false)\n public static bool SameChars(string s0, string s1) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_54_same_chars.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(SameChars((\"eabcdzzzz\"), (\"dddzzzzzzzddeddabc\")) == (true));\n Debug.Assert(SameChars((\"abcd\"), (\"dddddddabc\")) == (true));\n Debug.Assert(SameChars((\"dddddddabc\"), (\"abcd\")) == (true));\n Debug.Assert(SameChars((\"eabcd\"), (\"dddddddabc\")) == (false));\n Debug.Assert(SameChars((\"abcd\"), (\"dddddddabcf\")) == (false));\n Debug.Assert(SameChars((\"eabcdzzzz\"), (\"dddzzzzzzzddddabc\")) == (false));\n Debug.Assert(SameChars((\"aabb\"), (\"aaccc\")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_54_same_chars"}
{"name": "HumanEval_56_correct_bracketing", "language": "cs", "prompt": "using System;\nusing System.Numerics;\nusing System.Diagnostics;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Text;\nusing System.Security.Cryptography;\nclass Problem {\n // brackets is a string of \"<\" and \">\".\n // return true if every opening bracket has a corresponding closing bracket.\n // >>> CorrectBracketing((\"<\"))\n // (false)\n // >>> CorrectBracketing((\"<>\"))\n // (true)\n // >>> CorrectBracketing((\"<<><>>\"))\n // (true)\n // >>> CorrectBracketing((\"><<>\"))\n // (false)\n public static bool CorrectBracketing(string brackets) {\n", "doctests": "transform", "original": "/home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_56_correct_bracketing.py", "prompt_terminology": "reworded", "tests": " }\n public static void Main(string[] args) {\n Debug.Assert(CorrectBracketing((\"<>\")) == (true));\n Debug.Assert(CorrectBracketing((\"<<><>>\")) == (true));\n Debug.Assert(CorrectBracketing((\"<><><<><>><>\")) == (true));\n Debug.Assert(CorrectBracketing((\"<><><<<><><>><>><<><><<>>>\")) == (true));\n Debug.Assert(CorrectBracketing((\"<<<><>>>>\")) == (false));\n Debug.Assert(CorrectBracketing((\"><<>\")) == (false));\n Debug.Assert(CorrectBracketing((\"<\")) == (false));\n Debug.Assert(CorrectBracketing((\"<<<<\")) == (false));\n Debug.Assert(CorrectBracketing((\">\")) == (false));\n Debug.Assert(CorrectBracketing((\"<<>\")) == (false));\n Debug.Assert(CorrectBracketing((\"<><><<><>><>><<>\")) == (false));\n Debug.Assert(CorrectBracketing((\"<><><<><>><>>><>\")) == (false));\n }\n\n}\n", "stop_tokens": ["\n }\n"], "task_id": "HumanEval_56_correct_bracketing"}
Reference in New Issue View Git Blame Copy Permalink