|
[ |
|
{ |
|
"name": "HumanEval_24_largest_divisor", |
|
"language": "r", |
|
"prompt": "# For a given number n, find the largest number that divides n evenly, smaller than n\n# >>> largest_divisor(15)\n# 5\nlargest_divisor <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_24_largest_divisor.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- largest_divisor\n if(!identical(candidate(3), 1)){quit('no', 1)}\n if(!identical(candidate(7), 1)){quit('no', 1)}\n if(!identical(candidate(10), 5)){quit('no', 1)}\n if(!identical(candidate(100), 50)){quit('no', 1)}\n if(!identical(candidate(49), 7)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_47_median", |
|
"language": "r", |
|
"prompt": "# Return median of elements in the list l.\n# >>> median([3, 1, 2, 4, 5])\n# 3\n# >>> median([-10, 4, 6, 1000, 10, 20])\n# 15.0\nmedian <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_47_median.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- median\n if(!identical(candidate(c(3, 1, 2, 4, 5)), 3)){quit('no', 1)}\n if(!identical(candidate(c(-10, 4, 6, 1000, 10, 20)), 8.0)){quit('no', 1)}\n if(!identical(candidate(c(5)), 5)){quit('no', 1)}\n if(!identical(candidate(c(6, 5)), 5.5)){quit('no', 1)}\n if(!identical(candidate(c(8, 1, 3, 9, 9, 2, 7)), 7)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_160_do_algebra", |
|
"language": "r", |
|
"prompt": "# 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# array = [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.\ndo_algebra <- function(operator, operand) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_160_do_algebra.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- do_algebra\n if(!identical(candidate(c('**', '*', '+'), c(2, 3, 4, 5)), 37)){quit('no', 1)}\n if(!identical(candidate(c('+', '*', '-'), c(2, 3, 4, 5)), 9)){quit('no', 1)}\n if(!identical(candidate(c('//', '*'), c(7, 3, 4)), 8)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_35_max_element", |
|
"language": "r", |
|
"prompt": "# Return maximum element in the list.\n# >>> max_element([1, 2, 3])\n# 3\n# >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n# 123\nmax_element <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_35_max_element.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- max_element\n if(!identical(candidate(c(1, 2, 3)), 3)){quit('no', 1)}\n if(!identical(candidate(c(5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10)), 124)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_135_can_arrange", |
|
"language": "r", |
|
"prompt": "# 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 array will not contain\n# duplicate values.\n# Examples:\n# can_arrange([1,2,4,3,5]) = 3\n# can_arrange([1,2,3]) = -1\ncan_arrange <- function(arr) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_135_can_arrange.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- can_arrange\n if(!identical(candidate(c(1, 2, 4, 3, 5)), 3)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 4, 5)), -1)){quit('no', 1)}\n if(!identical(candidate(c(1, 4, 2, 5, 6, 7, 8, 9, 10)), 2)){quit('no', 1)}\n if(!identical(candidate(c(4, 8, 5, 7, 3)), 4)){quit('no', 1)}\n if(!identical(candidate(c()), -1)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_41_car_race_collision", |
|
"language": "r", |
|
"prompt": "# 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.\ncar_race_collision <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_41_car_race_collision.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- car_race_collision\n if(!identical(candidate(2), 4)){quit('no', 1)}\n if(!identical(candidate(3), 9)){quit('no', 1)}\n if(!identical(candidate(4), 16)){quit('no', 1)}\n if(!identical(candidate(8), 64)){quit('no', 1)}\n if(!identical(candidate(10), 100)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_134_check_if_last_char_is_a_letter", |
|
"language": "r", |
|
"prompt": "# 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# check_if_last_char_is_a_letter(\"apple pie\") \u279e False\n# check_if_last_char_is_a_letter(\"apple pi e\") \u279e True\n# check_if_last_char_is_a_letter(\"apple pi e \") \u279e False\n# check_if_last_char_is_a_letter(\"\") \u279e False\ncheck_if_last_char_is_a_letter <- function(txt) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_134_check_if_last_char_is_a_letter.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- check_if_last_char_is_a_letter\n if(!identical(candidate('apple'), FALSE)){quit('no', 1)}\n if(!identical(candidate('apple pi e'), TRUE)){quit('no', 1)}\n if(!identical(candidate('eeeee'), FALSE)){quit('no', 1)}\n if(!identical(candidate('A'), TRUE)){quit('no', 1)}\n if(!identical(candidate('Pumpkin pie '), FALSE)){quit('no', 1)}\n if(!identical(candidate('Pumpkin pie 1'), FALSE)){quit('no', 1)}\n if(!identical(candidate(''), FALSE)){quit('no', 1)}\n if(!identical(candidate('eeeee e '), FALSE)){quit('no', 1)}\n if(!identical(candidate('apple pie'), FALSE)){quit('no', 1)}\n if(!identical(candidate('apple pi e '), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_31_is_prime", |
|
"language": "r", |
|
"prompt": "# Return true if a given number is prime, and false otherwise.\n# >>> is_prime(6)\n# False\n# >>> is_prime(101)\n# True\n# >>> is_prime(11)\n# True\n# >>> is_prime(13441)\n# True\n# >>> is_prime(61)\n# True\n# >>> is_prime(4)\n# False\n# >>> is_prime(1)\n# False\nis_prime <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_31_is_prime.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- is_prime\n if(!identical(candidate(6), FALSE)){quit('no', 1)}\n if(!identical(candidate(101), TRUE)){quit('no', 1)}\n if(!identical(candidate(11), TRUE)){quit('no', 1)}\n if(!identical(candidate(13441), TRUE)){quit('no', 1)}\n if(!identical(candidate(61), TRUE)){quit('no', 1)}\n if(!identical(candidate(4), FALSE)){quit('no', 1)}\n if(!identical(candidate(1), FALSE)){quit('no', 1)}\n if(!identical(candidate(5), TRUE)){quit('no', 1)}\n if(!identical(candidate(11), TRUE)){quit('no', 1)}\n if(!identical(candidate(17), TRUE)){quit('no', 1)}\n if(!identical(candidate(85), FALSE)){quit('no', 1)}\n if(!identical(candidate(77), FALSE)){quit('no', 1)}\n if(!identical(candidate(255379), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_104_unique_digits", |
|
"language": "r", |
|
"prompt": "# 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# >>> unique_digits([15, 33, 1422, 1])\n# [1, 15, 33]\n# >>> unique_digits([152, 323, 1422, 10])\n# []\nunique_digits <- function(x) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_104_unique_digits.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- unique_digits\n if(!identical(candidate(c(15, 33, 1422, 1)), list(1, 15, 33))){quit('no', 1)}\n if(!identical(candidate(c(152, 323, 1422, 10)), list())){quit('no', 1)}\n if(!identical(candidate(c(12345, 2033, 111, 151)), list(111, 151))){quit('no', 1)}\n if(!identical(candidate(c(135, 103, 31)), list(31, 135))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_11_string_xor", |
|
"language": "r", |
|
"prompt": "# 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# >>> string_xor('010', '110')\n# '100'\nstring_xor <- function(a, b) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_11_string_xor.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- string_xor\n if(!identical(candidate('111000', '101010'), '010010')){quit('no', 1)}\n if(!identical(candidate('1', '1'), '0')){quit('no', 1)}\n if(!identical(candidate('0101', '0000'), '0101')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_60_sum_to_n", |
|
"language": "r", |
|
"prompt": "# sum_to_n is a function that sums numbers from 1 to n.\n# >>> sum_to_n(30)\n# 465\n# >>> sum_to_n(100)\n# 5050\n# >>> sum_to_n(5)\n# 15\n# >>> sum_to_n(10)\n# 55\n# >>> sum_to_n(1)\n# 1\nsum_to_n <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_60_sum_to_n.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sum_to_n\n if(!identical(candidate(1), 1)){quit('no', 1)}\n if(!identical(candidate(6), 21)){quit('no', 1)}\n if(!identical(candidate(11), 66)){quit('no', 1)}\n if(!identical(candidate(30), 465)){quit('no', 1)}\n if(!identical(candidate(100), 5050)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_151_double_the_difference", |
|
"language": "r", |
|
"prompt": "# 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# double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10\n# double_the_difference([-1, -2, 0]) == 0\n# double_the_difference([9, -2]) == 81\n# double_the_difference([0]) == 0 \n# If the input list is empty, return 0.\ndouble_the_difference <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_151_double_the_difference.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- double_the_difference\n if(!identical(candidate(c()), 0)){quit('no', 1)}\n if(!identical(candidate(c(5.0, 4.0)), 25)){quit('no', 1)}\n if(!identical(candidate(c(0.1, 0.2, 0.3)), 0)){quit('no', 1)}\n if(!identical(candidate(c(-10.0, -20.0, -30.0)), 0)){quit('no', 1)}\n if(!identical(candidate(c(-1.0, -2.0, 8.0)), 0)){quit('no', 1)}\n if(!identical(candidate(c(0.2, 3.0, 5.0)), 34)){quit('no', 1)}\n if(!identical(candidate(c(-9.0, -7.0, -5.0, -3.0, -1.0, 1.0, 3.0, 5.0, 7.0, 9.0)), 165)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_23_strlen", |
|
"language": "r", |
|
"prompt": "# Return length of given string\n# >>> strlen('')\n# 0\n# >>> strlen('abc')\n# 3\nstrlen <- function(string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_23_strlen.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- strlen\n if(!identical(candidate(''), 0)){quit('no', 1)}\n if(!identical(candidate('x'), 1)){quit('no', 1)}\n if(!identical(candidate('asdasnakj'), 9)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_91_is_bored", |
|
"language": "r", |
|
"prompt": "# 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# >>> is_bored(\"Hello world\")\n# 0\n# >>> is_bored(\"The sky is blue. The sun is shining. I love this weather\")\n# 1\nis_bored <- function(S) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_91_is_bored.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- is_bored\n if(!identical(candidate('Hello world'), 0)){quit('no', 1)}\n if(!identical(candidate('Is the sky blue?'), 0)){quit('no', 1)}\n if(!identical(candidate('I love It !'), 1)){quit('no', 1)}\n if(!identical(candidate('bIt'), 0)){quit('no', 1)}\n if(!identical(candidate('I feel good today. I will be productive. will kill It'), 2)){quit('no', 1)}\n if(!identical(candidate('You and I are going for a walk'), 0)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_64_vowels_count", |
|
"language": "r", |
|
"prompt": "# 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# >>> vowels_count(\"abcde\")\n# 2\n# >>> vowels_count(\"ACEDY\")\n# 3\nvowels_count <- function(s) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_64_vowels_count.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- vowels_count\n if(!identical(candidate('abcde'), 2)){quit('no', 1)}\n if(!identical(candidate('Alone'), 3)){quit('no', 1)}\n if(!identical(candidate('key'), 2)){quit('no', 1)}\n if(!identical(candidate('bye'), 1)){quit('no', 1)}\n if(!identical(candidate('keY'), 2)){quit('no', 1)}\n if(!identical(candidate('bYe'), 1)){quit('no', 1)}\n if(!identical(candidate('ACEDY'), 3)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_55_fib", |
|
"language": "r", |
|
"prompt": "# Return n-th Fibonacci number.\n# >>> fib(10)\n# 55\n# >>> fib(1)\n# 1\n# >>> fib(8)\n# 21\nfib <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_55_fib.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- fib\n if(!identical(candidate(10), 55)){quit('no', 1)}\n if(!identical(candidate(1), 1)){quit('no', 1)}\n if(!identical(candidate(8), 21)){quit('no', 1)}\n if(!identical(candidate(11), 89)){quit('no', 1)}\n if(!identical(candidate(12), 144)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_144_simplify", |
|
"language": "r", |
|
"prompt": "# 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\") = True\n# simplify(\"1/6\", \"2/1\") = False\n# simplify(\"7/10\", \"10/2\") = False\nsimplify <- function(x, n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_144_simplify.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- simplify\n if(!identical(candidate('1/5', '5/1'), TRUE)){quit('no', 1)}\n if(!identical(candidate('1/6', '2/1'), FALSE)){quit('no', 1)}\n if(!identical(candidate('5/1', '3/1'), TRUE)){quit('no', 1)}\n if(!identical(candidate('7/10', '10/2'), FALSE)){quit('no', 1)}\n if(!identical(candidate('2/10', '50/10'), TRUE)){quit('no', 1)}\n if(!identical(candidate('7/2', '4/2'), TRUE)){quit('no', 1)}\n if(!identical(candidate('11/6', '6/1'), TRUE)){quit('no', 1)}\n if(!identical(candidate('2/3', '5/2'), FALSE)){quit('no', 1)}\n if(!identical(candidate('5/2', '3/5'), FALSE)){quit('no', 1)}\n if(!identical(candidate('2/4', '8/4'), TRUE)){quit('no', 1)}\n if(!identical(candidate('2/4', '4/2'), TRUE)){quit('no', 1)}\n if(!identical(candidate('1/5', '5/1'), TRUE)){quit('no', 1)}\n if(!identical(candidate('1/5', '1/5'), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_98_count_upper", |
|
"language": "r", |
|
"prompt": "# Given a string s, count the number of uppercase vowels in even indices.\n# For example:\n# count_upper('aBCdEf') returns 1\n# count_upper('abcdefg') returns 0\n# count_upper('dBBE') returns 0\ncount_upper <- function(s) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_98_count_upper.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- count_upper\n if(!identical(candidate('aBCdEf'), 1)){quit('no', 1)}\n if(!identical(candidate('abcdefg'), 0)){quit('no', 1)}\n if(!identical(candidate('dBBE'), 0)){quit('no', 1)}\n if(!identical(candidate('B'), 0)){quit('no', 1)}\n if(!identical(candidate('U'), 1)){quit('no', 1)}\n if(!identical(candidate(''), 0)){quit('no', 1)}\n if(!identical(candidate('EEEE'), 2)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_115_max_fill", |
|
"language": "r", |
|
"prompt": "# 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# Input: \n# grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]\n# bucket_capacity : 1\n# Output: 6\n# Example 2:\n# Input: \n# grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]\n# bucket_capacity : 2\n# Output: 5\n# Example 3:\n# Input: \n# grid : [[0,0,0], [0,0,0]]\n# bucket_capacity : 5\n# Output: 0\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\nmax_fill <- function(grid, capacity) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_115_max_fill.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- max_fill\n if(!identical(candidate(list(list(0, 0, 1, 0), list(0, 1, 0, 0), list(1, 1, 1, 1)), 1), 6)){quit('no', 1)}\n if(!identical(candidate(list(list(0, 0, 1, 1), list(0, 0, 0, 0), list(1, 1, 1, 1), list(0, 1, 1, 1)), 2), 5)){quit('no', 1)}\n if(!identical(candidate(list(list(0, 0, 0), list(0, 0, 0)), 5), 0)){quit('no', 1)}\n if(!identical(candidate(list(list(1, 1, 1, 1), list(1, 1, 1, 1)), 2), 4)){quit('no', 1)}\n if(!identical(candidate(list(list(1, 1, 1, 1), list(1, 1, 1, 1)), 9), 2)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_120_maximum", |
|
"language": "r", |
|
"prompt": "# Given an array 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# Input: arr = [-3, -4, 5], k = 3\n# Output: [-4, -3, 5]\n# Example 2:\n# Input: arr = [4, -4, 4], k = 2\n# Output: [4, 4]\n# Example 3:\n# Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1\n# Output: [2]\n# Note:\n# 1. The length of the array will be in the range of [1, 1000].\n# 2. The elements in the array will be in the range of [-1000, 1000].\n# 3. 0 <= k <= len(arr)\nmaximum <- function(arr, k) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_120_maximum.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- maximum\n if(!identical(candidate(c(-3, -4, 5), 3), list(-4, -3, 5))){quit('no', 1)}\n if(!identical(candidate(c(4, -4, 4), 2), list(4, 4))){quit('no', 1)}\n if(!identical(candidate(c(-3, 2, 1, 2, -1, -2, 1), 1), list(2))){quit('no', 1)}\n if(!identical(candidate(c(123, -123, 20, 0, 1, 2, -3), 3), list(2, 20, 123))){quit('no', 1)}\n if(!identical(candidate(c(-123, 20, 0, 1, 2, -3), 4), list(0, 1, 2, 20))){quit('no', 1)}\n if(!identical(candidate(c(5, 15, 0, 3, -13, -8, 0), 7), list(-13, -8, 0, 0, 3, 5, 15))){quit('no', 1)}\n if(!identical(candidate(c(-1, 0, 2, 5, 3, -10), 2), list(3, 5))){quit('no', 1)}\n if(!identical(candidate(c(1, 0, 5, -7), 1), list(5))){quit('no', 1)}\n if(!identical(candidate(c(4, -4), 2), list(-4, 4))){quit('no', 1)}\n if(!identical(candidate(c(-10, 10), 2), list(-10, 10))){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, -23, 243, -400, 0), 0), list())){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_93_encode", |
|
"language": "r", |
|
"prompt": "# 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'\nencode <- function(message) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_93_encode.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- encode\n if(!identical(candidate('TEST'), 'tgst')){quit('no', 1)}\n if(!identical(candidate('Mudasir'), 'mWDCSKR')){quit('no', 1)}\n if(!identical(candidate('YES'), 'ygs')){quit('no', 1)}\n if(!identical(candidate('This is a message'), 'tHKS KS C MGSSCGG')){quit('no', 1)}\n if(!identical(candidate('I DoNt KnOw WhAt tO WrItE'), 'k dQnT kNqW wHcT Tq wRkTg')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_51_remove_vowels", |
|
"language": "r", |
|
"prompt": "# remove_vowels is a function that takes string and returns string without vowels.\n# >>> remove_vowels('')\n# ''\n# >>> remove_vowels('abcdef')\n# 'bcdf'\n# >>> remove_vowels('aaaaa')\n# ''\n# >>> remove_vowels('aaBAA')\n# 'B'\n# >>> remove_vowels('zbcd')\n# 'zbcd'\nremove_vowels <- function(text) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_51_remove_vowels.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- remove_vowels\n if(!identical(candidate(''), '')){quit('no', 1)}\n if(!identical(candidate('abcdef\\nghijklm'), 'bcdf\\nghjklm')){quit('no', 1)}\n if(!identical(candidate('fedcba'), 'fdcb')){quit('no', 1)}\n if(!identical(candidate('eeeee'), '')){quit('no', 1)}\n if(!identical(candidate('acBAA'), 'cB')){quit('no', 1)}\n if(!identical(candidate('EcBOO'), 'cB')){quit('no', 1)}\n if(!identical(candidate('ybcd'), 'ybcd')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_30_get_positive", |
|
"language": "r", |
|
"prompt": "# Return only positive numbers in the list.\n# >>> get_positive([-1, 2, -4, 5, 6])\n# [2, 5, 6]\n# >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n# [5, 3, 2, 3, 9, 123, 1]\nget_positive <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_30_get_positive.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- get_positive\n if(!identical(candidate(c(-1, -2, 4, 5, 6)), list(4, 5, 6))){quit('no', 1)}\n if(!identical(candidate(c(5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10)), list(5, 3, 2, 3, 3, 9, 123, 1))){quit('no', 1)}\n if(!identical(candidate(c(-1, -2)), list())){quit('no', 1)}\n if(!identical(candidate(c()), list())){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_15_string_sequence", |
|
"language": "r", |
|
"prompt": "# Return a string containing space-delimited numbers starting from 0 upto n inclusive.\n# >>> string_sequence(0)\n# '0'\n# >>> string_sequence(5)\n# '0 1 2 3 4 5'\nstring_sequence <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_15_string_sequence.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- string_sequence\n if(!identical(candidate(0), '0')){quit('no', 1)}\n if(!identical(candidate(3), '0 1 2 3')){quit('no', 1)}\n if(!identical(candidate(10), '0 1 2 3 4 5 6 7 8 9 10')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_100_make_a_pile", |
|
"language": "r", |
|
"prompt": "# 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# >>> make_a_pile(3)\n# [3, 5, 7]\nmake_a_pile <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_100_make_a_pile.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- make_a_pile\n if(!identical(candidate(3), list(3, 5, 7))){quit('no', 1)}\n if(!identical(candidate(4), list(4, 6, 8, 10))){quit('no', 1)}\n if(!identical(candidate(5), list(5, 7, 9, 11, 13))){quit('no', 1)}\n if(!identical(candidate(6), list(6, 8, 10, 12, 14, 16))){quit('no', 1)}\n if(!identical(candidate(8), list(8, 10, 12, 14, 16, 18, 20, 22))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_112_reverse_delete", |
|
"language": "r", |
|
"prompt": "# 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# For s = \"abcde\", c = \"ae\", the result should be ('bcd',False)\n# For s = \"abcdef\", c = \"b\" the result should be ('acdef',False)\n# For s = \"abcdedcba\", c = \"ab\", the result should be ('cdedc',True)\nreverse_delete <- function(s, c) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_112_reverse_delete.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- reverse_delete\n if(!identical(candidate('abcde', 'ae'), list('bcd', FALSE))){quit('no', 1)}\n if(!identical(candidate('abcdef', 'b'), list('acdef', FALSE))){quit('no', 1)}\n if(!identical(candidate('abcdedcba', 'ab'), list('cdedc', TRUE))){quit('no', 1)}\n if(!identical(candidate('dwik', 'w'), list('dik', FALSE))){quit('no', 1)}\n if(!identical(candidate('a', 'a'), list('', TRUE))){quit('no', 1)}\n if(!identical(candidate('abcdedcba', ''), list('abcdedcba', TRUE))){quit('no', 1)}\n if(!identical(candidate('abcdedcba', 'v'), list('abcdedcba', TRUE))){quit('no', 1)}\n if(!identical(candidate('vabba', 'v'), list('abba', TRUE))){quit('no', 1)}\n if(!identical(candidate('mamma', 'mia'), list('', TRUE))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_27_flip_case", |
|
"language": "r", |
|
"prompt": "# For a given string, flip lowercase characters to uppercase and uppercase to lowercase.\n# >>> flip_case('Hello')\n# 'hELLO'\nflip_case <- function(string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_27_flip_case.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- flip_case\n if(!identical(candidate(''), '')){quit('no', 1)}\n if(!identical(candidate('Hello!'), 'hELLO!')){quit('no', 1)}\n if(!identical(candidate('These violent delights have violent ends'), 'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_161_solve", |
|
"language": "r", |
|
"prompt": "# 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\") = \"4321\"\n# solve(\"ab\") = \"AB\"\n# solve(\"#a@C\") = \"#A@c\"\nsolve <- function(s) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_161_solve.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- solve\n if(!identical(candidate('AsDf'), 'aSdF')){quit('no', 1)}\n if(!identical(candidate('1234'), '4321')){quit('no', 1)}\n if(!identical(candidate('ab'), 'AB')){quit('no', 1)}\n if(!identical(candidate('#a@C'), '#A@c')){quit('no', 1)}\n if(!identical(candidate('#AsdfW^45'), '#aSDFw^45')){quit('no', 1)}\n if(!identical(candidate('#6@2'), '2@6#')){quit('no', 1)}\n if(!identical(candidate('#$a^D'), '#$A^d')){quit('no', 1)}\n if(!identical(candidate('#ccc'), '#CCC')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_29_filter_by_prefix", |
|
"language": "r", |
|
"prompt": "# Filter an input list of strings only for ones that start with a given prefix.\n# >>> filter_by_prefix([], 'a')\n# []\n# >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')\n# ['abc', 'array']\nfilter_by_prefix <- function(strings, prefix) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_29_filter_by_prefix.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- filter_by_prefix\n if(!identical(candidate(c(), 'john'), list())){quit('no', 1)}\n if(!identical(candidate(c('xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'), 'xxx'), list('xxx', 'xxxAAA', 'xxx'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_102_choose_num", |
|
"language": "r", |
|
"prompt": "# 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# choose_num(12, 15) = 14\n# choose_num(13, 12) = -1\nchoose_num <- function(x, y) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_102_choose_num.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- choose_num\n if(!identical(candidate(12, 15), 14)){quit('no', 1)}\n if(!identical(candidate(13, 12), -1)){quit('no', 1)}\n if(!identical(candidate(33, 12354), 12354)){quit('no', 1)}\n if(!identical(candidate(5234, 5233), -1)){quit('no', 1)}\n if(!identical(candidate(6, 29), 28)){quit('no', 1)}\n if(!identical(candidate(27, 10), -1)){quit('no', 1)}\n if(!identical(candidate(7, 7), -1)){quit('no', 1)}\n if(!identical(candidate(546, 546), 546)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_143_words_in_sentence", |
|
"language": "r", |
|
"prompt": "# 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# Input: sentence = \"This is a test\"\n# Output: \"is\"\n# Example 2:\n# Input: sentence = \"lets go for swimming\"\n# Output: \"go for\"\n# Constraints:\n# * 1 <= len(sentence) <= 100\n# * sentence contains only letters\nwords_in_sentence <- function(sentence) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_143_words_in_sentence.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- words_in_sentence\n if(!identical(candidate('This is a test'), 'is')){quit('no', 1)}\n if(!identical(candidate('lets go for swimming'), 'go for')){quit('no', 1)}\n if(!identical(candidate('there is no place available here'), 'there is no place')){quit('no', 1)}\n if(!identical(candidate('Hi I am Hussein'), 'Hi am Hussein')){quit('no', 1)}\n if(!identical(candidate('go for it'), 'go for it')){quit('no', 1)}\n if(!identical(candidate('here'), '')){quit('no', 1)}\n if(!identical(candidate('here is'), 'is')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_5_intersperse", |
|
"language": "r", |
|
"prompt": "# Insert a number 'delimeter' between every two consecutive elements of input list `numbers'\n# >>> intersperse([], 4)\n# []\n# >>> intersperse([1, 2, 3], 4)\n# [1, 4, 2, 4, 3]\nintersperse <- function(numbers, delimeter) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_5_intersperse.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- intersperse\n if(!identical(candidate(c(), 7), list())){quit('no', 1)}\n if(!identical(candidate(c(5, 6, 3, 2), 8), list(5, 8, 6, 8, 3, 8, 2))){quit('no', 1)}\n if(!identical(candidate(c(2, 2, 2), 2), list(2, 2, 2, 2, 2))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_76_is_simple_power", |
|
"language": "r", |
|
"prompt": "# 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# is_simple_power(1, 4) => true\n# is_simple_power(2, 2) => true\n# is_simple_power(8, 2) => true\n# is_simple_power(3, 2) => false\n# is_simple_power(3, 1) => false\n# is_simple_power(5, 3) => false\nis_simple_power <- function(x, n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_76_is_simple_power.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- is_simple_power\n if(!identical(candidate(16, 2), TRUE)){quit('no', 1)}\n if(!identical(candidate(143214, 16), FALSE)){quit('no', 1)}\n if(!identical(candidate(4, 2), TRUE)){quit('no', 1)}\n if(!identical(candidate(9, 3), TRUE)){quit('no', 1)}\n if(!identical(candidate(16, 4), TRUE)){quit('no', 1)}\n if(!identical(candidate(24, 2), FALSE)){quit('no', 1)}\n if(!identical(candidate(128, 4), FALSE)){quit('no', 1)}\n if(!identical(candidate(12, 6), FALSE)){quit('no', 1)}\n if(!identical(candidate(1, 1), TRUE)){quit('no', 1)}\n if(!identical(candidate(1, 12), TRUE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_75_is_multiply_prime", |
|
"language": "r", |
|
"prompt": "# 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# is_multiply_prime(30) == True\n# 30 = 2 * 3 * 5\nis_multiply_prime <- function(a) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_75_is_multiply_prime.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- is_multiply_prime\n if(!identical(candidate(5), FALSE)){quit('no', 1)}\n if(!identical(candidate(30), TRUE)){quit('no', 1)}\n if(!identical(candidate(8), TRUE)){quit('no', 1)}\n if(!identical(candidate(10), FALSE)){quit('no', 1)}\n if(!identical(candidate(125), TRUE)){quit('no', 1)}\n if(!identical(candidate(105), TRUE)){quit('no', 1)}\n if(!identical(candidate(126), FALSE)){quit('no', 1)}\n if(!identical(candidate(729), FALSE)){quit('no', 1)}\n if(!identical(candidate(891), FALSE)){quit('no', 1)}\n if(!identical(candidate(1001), TRUE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_157_right_angle_triangle", |
|
"language": "r", |
|
"prompt": "# 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# right_angle_triangle(3, 4, 5) == True\n# right_angle_triangle(1, 2, 3) == False\nright_angle_triangle <- function(a, b, c) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_157_right_angle_triangle.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- right_angle_triangle\n if(!identical(candidate(3, 4, 5), TRUE)){quit('no', 1)}\n if(!identical(candidate(1, 2, 3), FALSE)){quit('no', 1)}\n if(!identical(candidate(10, 6, 8), TRUE)){quit('no', 1)}\n if(!identical(candidate(2, 2, 2), FALSE)){quit('no', 1)}\n if(!identical(candidate(7, 24, 25), TRUE)){quit('no', 1)}\n if(!identical(candidate(10, 5, 7), FALSE)){quit('no', 1)}\n if(!identical(candidate(5, 12, 13), TRUE)){quit('no', 1)}\n if(!identical(candidate(15, 8, 17), TRUE)){quit('no', 1)}\n if(!identical(candidate(48, 55, 73), TRUE)){quit('no', 1)}\n if(!identical(candidate(1, 1, 1), FALSE)){quit('no', 1)}\n if(!identical(candidate(2, 2, 10), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_92_any_int", |
|
"language": "r", |
|
"prompt": "# 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# any_int(5, 2, 7) \u279e True\n# any_int(3, 2, 2) \u279e False\n# any_int(3, -2, 1) \u279e True\n# any_int(3.6, -2.2, 2) \u279e False\nany_int <- function(x, y, z) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_92_any_int.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- any_int\n if(!identical(candidate(2, 3, 1), TRUE)){quit('no', 1)}\n if(!identical(candidate(2.5, 2, 3), FALSE)){quit('no', 1)}\n if(!identical(candidate(1.5, 5, 3.5), FALSE)){quit('no', 1)}\n if(!identical(candidate(2, 6, 2), FALSE)){quit('no', 1)}\n if(!identical(candidate(4, 2, 2), TRUE)){quit('no', 1)}\n if(!identical(candidate(2.2, 2.2, 2.2), FALSE)){quit('no', 1)}\n if(!identical(candidate(-4, 6, 2), TRUE)){quit('no', 1)}\n if(!identical(candidate(2, 1, 1), TRUE)){quit('no', 1)}\n if(!identical(candidate(3, 4, 7), TRUE)){quit('no', 1)}\n if(!identical(candidate(3.0, 4, 7), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_33_sort_third", |
|
"language": "r", |
|
"prompt": "# 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# >>> sort_third([1, 2, 3])\n# [1, 2, 3]\n# >>> sort_third([5, 6, 3, 4, 8, 9, 2])\n# [2, 6, 3, 4, 8, 9, 5]\nsort_third <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_33_sort_third.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sort_third\n if(!identical(candidate(c(5, 6, 3, 4, 8, 9, 2)), list(2, 6, 3, 4, 8, 9, 5))){quit('no', 1)}\n if(!identical(candidate(c(5, 8, 3, 4, 6, 9, 2)), list(2, 8, 3, 4, 6, 9, 5))){quit('no', 1)}\n if(!identical(candidate(c(5, 6, 9, 4, 8, 3, 2)), list(2, 6, 9, 4, 8, 3, 5))){quit('no', 1)}\n if(!identical(candidate(c(5, 6, 3, 4, 8, 9, 2, 1)), list(2, 6, 3, 4, 8, 9, 5, 1))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_53_add", |
|
"language": "r", |
|
"prompt": "# Add two numbers x and y\n# >>> add(2, 3)\n# 5\n# >>> add(5, 7)\n# 12\nadd <- function(x, y) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_53_add.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- add\n if(!identical(candidate(0, 1), 1)){quit('no', 1)}\n if(!identical(candidate(1, 0), 1)){quit('no', 1)}\n if(!identical(candidate(2, 3), 5)){quit('no', 1)}\n if(!identical(candidate(5, 7), 12)){quit('no', 1)}\n if(!identical(candidate(7, 5), 12)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_69_search", |
|
"language": "r", |
|
"prompt": "# 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([4, 1, 2, 2, 3, 1]) == 2\n# search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3\n# search([5, 5, 4, 4, 4]) == -1\nsearch <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_69_search.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- search\n if(!identical(candidate(c(5, 5, 5, 5, 1)), 1)){quit('no', 1)}\n if(!identical(candidate(c(4, 1, 4, 1, 4, 4)), 4)){quit('no', 1)}\n if(!identical(candidate(c(3, 3)), -1)){quit('no', 1)}\n if(!identical(candidate(c(8, 8, 8, 8, 8, 8, 8, 8)), 8)){quit('no', 1)}\n if(!identical(candidate(c(2, 3, 3, 2, 2)), 2)){quit('no', 1)}\n if(!identical(candidate(c(2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3, 6, 7, 1, 7, 4, 10, 8, 1)), 1)){quit('no', 1)}\n if(!identical(candidate(c(3, 2, 8, 2)), 2)){quit('no', 1)}\n if(!identical(candidate(c(6, 7, 1, 8, 8, 10, 5, 8, 5, 3, 10)), 1)){quit('no', 1)}\n if(!identical(candidate(c(8, 8, 3, 6, 5, 6, 4)), -1)){quit('no', 1)}\n if(!identical(candidate(c(6, 9, 6, 7, 1, 4, 7, 1, 8, 8, 9, 8, 10, 10, 8, 4, 10, 4, 10, 1, 2, 9, 5, 7, 9)), 1)){quit('no', 1)}\n if(!identical(candidate(c(1, 9, 10, 1, 3)), 1)){quit('no', 1)}\n if(!identical(candidate(c(6, 9, 7, 5, 8, 7, 5, 3, 7, 5, 10, 10, 3, 6, 10, 2, 8, 6, 5, 4, 9, 5, 3, 10)), 5)){quit('no', 1)}\n if(!identical(candidate(c(1)), 1)){quit('no', 1)}\n if(!identical(candidate(c(8, 8, 10, 6, 4, 3, 5, 8, 2, 4, 2, 8, 4, 6, 10, 4, 2, 1, 10, 2, 1, 1, 5)), 4)){quit('no', 1)}\n if(!identical(candidate(c(2, 10, 4, 8, 2, 10, 5, 1, 2, 9, 5, 5, 6, 3, 8, 6, 4, 10)), 2)){quit('no', 1)}\n if(!identical(candidate(c(1, 6, 10, 1, 6, 9, 10, 8, 6, 8, 7, 3)), 1)){quit('no', 1)}\n if(!identical(candidate(c(9, 2, 4, 1, 5, 1, 5, 2, 5, 7, 7, 7, 3, 10, 1, 5, 4, 2, 8, 4, 1, 9, 10, 7, 10, 2, 8, 10, 9, 4)), 4)){quit('no', 1)}\n if(!identical(candidate(c(2, 6, 4, 2, 8, 7, 5, 6, 4, 10, 4, 6, 3, 7, 8, 8, 3, 1, 4, 2, 2, 10, 7)), 4)){quit('no', 1)}\n if(!identical(candidate(c(9, 8, 6, 10, 2, 6, 10, 2, 7, 8, 10, 3, 8, 2, 6, 2, 3, 1)), 2)){quit('no', 1)}\n if(!identical(candidate(c(5, 5, 3, 9, 5, 6, 3, 2, 8, 5, 6, 10, 10, 6, 8, 4, 10, 7, 7, 10, 8)), -1)){quit('no', 1)}\n if(!identical(candidate(c(10)), -1)){quit('no', 1)}\n if(!identical(candidate(c(9, 7, 7, 2, 4, 7, 2, 10, 9, 7, 5, 7, 2)), 2)){quit('no', 1)}\n if(!identical(candidate(c(5, 4, 10, 2, 1, 1, 10, 3, 6, 1, 8)), 1)){quit('no', 1)}\n if(!identical(candidate(c(7, 9, 9, 9, 3, 4, 1, 5, 9, 1, 2, 1, 1, 10, 7, 5, 6, 7, 6, 7, 7, 6)), 1)){quit('no', 1)}\n if(!identical(candidate(c(3, 10, 10, 9, 2)), -1)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_82_prime_length", |
|
"language": "r", |
|
"prompt": "# 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# prime_length('Hello') == True\n# prime_length('abcdcba') == True\n# prime_length('kittens') == True\n# prime_length('orange') == False\nprime_length <- function(string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_82_prime_length.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- prime_length\n if(!identical(candidate('Hello'), TRUE)){quit('no', 1)}\n if(!identical(candidate('abcdcba'), TRUE)){quit('no', 1)}\n if(!identical(candidate('kittens'), TRUE)){quit('no', 1)}\n if(!identical(candidate('orange'), FALSE)){quit('no', 1)}\n if(!identical(candidate('wow'), TRUE)){quit('no', 1)}\n if(!identical(candidate('world'), TRUE)){quit('no', 1)}\n if(!identical(candidate('MadaM'), TRUE)){quit('no', 1)}\n if(!identical(candidate('Wow'), TRUE)){quit('no', 1)}\n if(!identical(candidate(''), FALSE)){quit('no', 1)}\n if(!identical(candidate('HI'), TRUE)){quit('no', 1)}\n if(!identical(candidate('go'), TRUE)){quit('no', 1)}\n if(!identical(candidate('gogo'), FALSE)){quit('no', 1)}\n if(!identical(candidate('aaaaaaaaaaaaaaa'), FALSE)){quit('no', 1)}\n if(!identical(candidate('Madam'), TRUE)){quit('no', 1)}\n if(!identical(candidate('M'), FALSE)){quit('no', 1)}\n if(!identical(candidate('0'), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_58_common", |
|
"language": "r", |
|
"prompt": "# Return sorted unique common elements for two lists.\n# >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n# [1, 5, 653]\n# >>> common([5, 3, 2, 8], [3, 2])\n# [2, 3]\ncommon <- function(l1, l2) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_58_common.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- common\n if(!identical(candidate(c(1, 4, 3, 34, 653, 2, 5), c(5, 7, 1, 5, 9, 653, 121)), list(1, 5, 653))){quit('no', 1)}\n if(!identical(candidate(c(5, 3, 2, 8), c(3, 2)), list(2, 3))){quit('no', 1)}\n if(!identical(candidate(c(4, 3, 2, 8), c(3, 2, 4)), list(2, 3, 4))){quit('no', 1)}\n if(!identical(candidate(c(4, 3, 2, 8), c()), list())){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_139_special_factorial", |
|
"language": "r", |
|
"prompt": "# The Brazilian factorial is defined as:\n# brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n# where n > 0\n# For example:\n# >>> special_factorial(4)\n# 288\n# The function will receive an integer as input and should return the special\n# factorial of this integer.\nspecial_factorial <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_139_special_factorial.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- special_factorial\n if(!identical(candidate(4), 288)){quit('no', 1)}\n if(!identical(candidate(5), 34560)){quit('no', 1)}\n if(!identical(candidate(7), 125411328000)){quit('no', 1)}\n if(!identical(candidate(1), 1)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_110_exchange", |
|
"language": "r", |
|
"prompt": "# 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([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n# exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n# It is assumed that the input lists will be non-empty.\nexchange <- function(lst1, lst2) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_110_exchange.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- exchange\n if(!identical(candidate(c(1, 2, 3, 4), c(1, 2, 3, 4)), 'YES')){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4), c(1, 5, 3, 4)), 'NO')){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4), c(2, 1, 4, 3)), 'YES')){quit('no', 1)}\n if(!identical(candidate(c(5, 7, 3), c(2, 6, 4)), 'YES')){quit('no', 1)}\n if(!identical(candidate(c(5, 7, 3), c(2, 6, 3)), 'NO')){quit('no', 1)}\n if(!identical(candidate(c(3, 2, 6, 1, 8, 9), c(3, 5, 5, 1, 1, 1)), 'NO')){quit('no', 1)}\n if(!identical(candidate(c(100, 200), c(200, 200)), 'YES')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_122_add_elements", |
|
"language": "r", |
|
"prompt": "# Given a non-empty array 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# Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4\n# Output: 24 # sum of 21 + 3\n# Constraints:\n# 1. 1 <= len(arr) <= 100\n# 2. 1 <= k <= len(arr)\nadd_elements <- function(arr, k) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_122_add_elements.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- add_elements\n if(!identical(candidate(c(1, -2, -3, 41, 57, 76, 87, 88, 99), 3), -4)){quit('no', 1)}\n if(!identical(candidate(c(111, 121, 3, 4000, 5, 6), 2), 0)){quit('no', 1)}\n if(!identical(candidate(c(11, 21, 3, 90, 5, 6, 7, 8, 9), 4), 125)){quit('no', 1)}\n if(!identical(candidate(c(111, 21, 3, 4000, 5, 6, 7, 8, 9), 4), 24)){quit('no', 1)}\n if(!identical(candidate(c(1), 1), 1)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_150_x_or_y", |
|
"language": "r", |
|
"prompt": "# 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# for x_or_y(7, 34, 12) == 34\n# for x_or_y(15, 8, 5) == 5\nx_or_y <- function(n, x, y) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_150_x_or_y.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- x_or_y\n if(!identical(candidate(7, 34, 12), 34)){quit('no', 1)}\n if(!identical(candidate(15, 8, 5), 5)){quit('no', 1)}\n if(!identical(candidate(3, 33, 5212), 33)){quit('no', 1)}\n if(!identical(candidate(1259, 3, 52), 3)){quit('no', 1)}\n if(!identical(candidate(7919, -1, 12), -1)){quit('no', 1)}\n if(!identical(candidate(3609, 1245, 583), 583)){quit('no', 1)}\n if(!identical(candidate(91, 56, 129), 129)){quit('no', 1)}\n if(!identical(candidate(6, 34, 1234), 1234)){quit('no', 1)}\n if(!identical(candidate(1, 2, 0), 0)){quit('no', 1)}\n if(!identical(candidate(2, 2, 0), 2)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_45_triangle_area", |
|
"language": "r", |
|
"prompt": "# Given length of a side and high return area for a triangle.\n# >>> triangle_area(5, 3)\n# 7.5\ntriangle_area <- function(a, h) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_45_triangle_area.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- triangle_area\n if(!identical(candidate(5, 3), 7.5)){quit('no', 1)}\n if(!identical(candidate(2, 2), 2.0)){quit('no', 1)}\n if(!identical(candidate(10, 8), 40.0)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_130_tri", |
|
"language": "r", |
|
"prompt": "# 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(3) = [1, 3, 2, 8]\ntri <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_130_tri.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- tri\n if(!identical(candidate(3), list(1, 3, 2, 8))){quit('no', 1)}\n if(!identical(candidate(4), list(1, 3, 2, 8, 3))){quit('no', 1)}\n if(!identical(candidate(5), list(1, 3, 2, 8, 3, 15))){quit('no', 1)}\n if(!identical(candidate(6), list(1, 3, 2, 8, 3, 15, 4))){quit('no', 1)}\n if(!identical(candidate(7), list(1, 3, 2, 8, 3, 15, 4, 24))){quit('no', 1)}\n if(!identical(candidate(8), list(1, 3, 2, 8, 3, 15, 4, 24, 5))){quit('no', 1)}\n if(!identical(candidate(9), list(1, 3, 2, 8, 3, 15, 4, 24, 5, 35))){quit('no', 1)}\n if(!identical(candidate(20), list(1, 3, 2, 8, 3, 15, 4, 24, 5, 35, 6, 48, 7, 63, 8, 80, 9, 99, 10, 120, 11))){quit('no', 1)}\n if(!identical(candidate(0), list(1))){quit('no', 1)}\n if(!identical(candidate(1), list(1, 3))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_119_match_parens", |
|
"language": "r", |
|
"prompt": "# 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# match_parens(['()(', ')']) == 'Yes'\n# match_parens([')', ')']) == 'No'\nmatch_parens <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_119_match_parens.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- match_parens\n if(!identical(candidate(c('()(', ')')), 'Yes')){quit('no', 1)}\n if(!identical(candidate(c(')', ')')), 'No')){quit('no', 1)}\n if(!identical(candidate(c('(()(())', '())())')), 'No')){quit('no', 1)}\n if(!identical(candidate(c(')())', '(()()(')), 'Yes')){quit('no', 1)}\n if(!identical(candidate(c('(())))', '(()())((')), 'Yes')){quit('no', 1)}\n if(!identical(candidate(c('()', '())')), 'No')){quit('no', 1)}\n if(!identical(candidate(c('(()(', '()))()')), 'Yes')){quit('no', 1)}\n if(!identical(candidate(c('((((', '((())')), 'No')){quit('no', 1)}\n if(!identical(candidate(c(')(()', '(()(')), 'No')){quit('no', 1)}\n if(!identical(candidate(c(')(', ')(')), 'No')){quit('no', 1)}\n if(!identical(candidate(c('(', ')')), 'Yes')){quit('no', 1)}\n if(!identical(candidate(c(')', '(')), 'Yes')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_26_remove_duplicates", |
|
"language": "r", |
|
"prompt": "# 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# >>> remove_duplicates([1, 2, 3, 2, 4])\n# [1, 3, 4]\nremove_duplicates <- function(numbers) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_26_remove_duplicates.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- remove_duplicates\n if(!identical(candidate(c()), list())){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4)), list(1, 2, 3, 4))){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 2, 4, 3, 5)), list(1, 4, 5))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_13_greatest_common_divisor", |
|
"language": "r", |
|
"prompt": "# Return a greatest common divisor of two integers a and b\n# >>> greatest_common_divisor(3, 5)\n# 1\n# >>> greatest_common_divisor(25, 15)\n# 5\ngreatest_common_divisor <- function(a, b) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_13_greatest_common_divisor.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- greatest_common_divisor\n if(!identical(candidate(3, 7), 1)){quit('no', 1)}\n if(!identical(candidate(10, 15), 5)){quit('no', 1)}\n if(!identical(candidate(49, 14), 7)){quit('no', 1)}\n if(!identical(candidate(144, 60), 12)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_48_is_palindrome", |
|
"language": "r", |
|
"prompt": "# Checks if given string is a palindrome\n# >>> is_palindrome('')\n# True\n# >>> is_palindrome('aba')\n# True\n# >>> is_palindrome('aaaaa')\n# True\n# >>> is_palindrome('zbcd')\n# False\nis_palindrome <- function(text) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_48_is_palindrome.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- is_palindrome\n if(!identical(candidate(''), TRUE)){quit('no', 1)}\n if(!identical(candidate('aba'), TRUE)){quit('no', 1)}\n if(!identical(candidate('aaaaa'), TRUE)){quit('no', 1)}\n if(!identical(candidate('zbcd'), FALSE)){quit('no', 1)}\n if(!identical(candidate('xywyx'), TRUE)){quit('no', 1)}\n if(!identical(candidate('xywyz'), FALSE)){quit('no', 1)}\n if(!identical(candidate('xywzx'), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_62_derivative", |
|
"language": "r", |
|
"prompt": "# 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([3, 1, 2, 4, 5])\n# [1, 4, 12, 20]\n# >>> derivative([1, 2, 3])\n# [2, 6]\nderivative <- function(xs) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_62_derivative.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- derivative\n if(!identical(candidate(c(3, 1, 2, 4, 5)), list(1, 4, 12, 20))){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3)), list(2, 6))){quit('no', 1)}\n if(!identical(candidate(c(3, 2, 1)), list(2, 2))){quit('no', 1)}\n if(!identical(candidate(c(3, 2, 1, 0, 4)), list(2, 2, 0, 16))){quit('no', 1)}\n if(!identical(candidate(c(1)), list())){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_67_fruit_distribution", |
|
"language": "r", |
|
"prompt": "# 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# fruit_distribution(\"5 apples and 6 oranges\", 19) ->19 - 5 - 6 = 8\n# fruit_distribution(\"0 apples and 1 oranges\",3) -> 3 - 0 - 1 = 2\n# fruit_distribution(\"2 apples and 3 oranges\", 100) -> 100 - 2 - 3 = 95\n# fruit_distribution(\"100 apples and 1 oranges\",120) -> 120 - 100 - 1 = 19\nfruit_distribution <- function(s, n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_67_fruit_distribution.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- fruit_distribution\n if(!identical(candidate('5 apples and 6 oranges', 19), 8)){quit('no', 1)}\n if(!identical(candidate('5 apples and 6 oranges', 21), 10)){quit('no', 1)}\n if(!identical(candidate('0 apples and 1 oranges', 3), 2)){quit('no', 1)}\n if(!identical(candidate('1 apples and 0 oranges', 3), 2)){quit('no', 1)}\n if(!identical(candidate('2 apples and 3 oranges', 100), 95)){quit('no', 1)}\n if(!identical(candidate('2 apples and 3 oranges', 5), 0)){quit('no', 1)}\n if(!identical(candidate('1 apples and 100 oranges', 120), 19)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_77_iscube", |
|
"language": "r", |
|
"prompt": "# 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(1) ==> True\n# iscube(2) ==> False\n# iscube(-1) ==> True\n# iscube(64) ==> True\n# iscube(0) ==> True\n# iscube(180) ==> False\niscube <- function(a) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_77_iscube.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- iscube\n if(!identical(candidate(1), TRUE)){quit('no', 1)}\n if(!identical(candidate(2), FALSE)){quit('no', 1)}\n if(!identical(candidate(-1), TRUE)){quit('no', 1)}\n if(!identical(candidate(64), TRUE)){quit('no', 1)}\n if(!identical(candidate(180), FALSE)){quit('no', 1)}\n if(!identical(candidate(1000), TRUE)){quit('no', 1)}\n if(!identical(candidate(0), TRUE)){quit('no', 1)}\n if(!identical(candidate(1729), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_116_sort_array", |
|
"language": "r", |
|
"prompt": "# In this Kata, you have to sort an array 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# >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]\n# >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]\n# >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]\nsort_array <- function(arr) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_116_sort_array.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sort_array\n if(!identical(candidate(c(1, 5, 2, 3, 4)), list(1, 2, 4, 3, 5))){quit('no', 1)}\n if(!identical(candidate(c(-2, -3, -4, -5, -6)), list(-4, -2, -6, -5, -3))){quit('no', 1)}\n if(!identical(candidate(c(1, 0, 2, 3, 4)), list(0, 1, 2, 4, 3))){quit('no', 1)}\n if(!identical(candidate(c()), list())){quit('no', 1)}\n if(!identical(candidate(c(2, 5, 77, 4, 5, 3, 5, 7, 2, 3, 4)), list(2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77))){quit('no', 1)}\n if(!identical(candidate(c(3, 6, 44, 12, 32, 5)), list(32, 3, 5, 6, 12, 44))){quit('no', 1)}\n if(!identical(candidate(c(2, 4, 8, 16, 32)), list(2, 4, 8, 16, 32))){quit('no', 1)}\n if(!identical(candidate(c(2, 4, 8, 16, 32)), list(2, 4, 8, 16, 32))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_113_odd_count", |
|
"language": "r", |
|
"prompt": "# 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# >>> odd_count(['1234567'])\n# [\"the number of odd elements 4n the str4ng 4 of the 4nput.\"]\n# >>> odd_count(['3',\"11111111\"])\n# [\"the number of odd elements 1n the str1ng 1 of the 1nput.\",\n# \"the number of odd elements 8n the str8ng 8 of the 8nput.\"]\nodd_count <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_113_odd_count.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- odd_count\n if(!identical(candidate(c('1234567')), list('the number of odd elements 4n the str4ng 4 of the 4nput.'))){quit('no', 1)}\n if(!identical(candidate(c('3', '11111111')), list('the number of odd elements 1n the str1ng 1 of the 1nput.', 'the number of odd elements 8n the str8ng 8 of the 8nput.'))){quit('no', 1)}\n if(!identical(candidate(c('271', '137', '314')), list('the number of odd elements 2n the str2ng 2 of the 2nput.', 'the number of odd elements 3n the str3ng 3 of the 3nput.', 'the number of odd elements 2n the str2ng 2 of the 2nput.'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_61_correct_bracketing", |
|
"language": "r", |
|
"prompt": "# brackets is a string of \"(\" and \")\".\n# return True if every opening bracket has a corresponding closing bracket.\n# >>> correct_bracketing(\"(\")\n# False\n# >>> correct_bracketing(\"()\")\n# True\n# >>> correct_bracketing(\"(()())\")\n# True\n# >>> correct_bracketing(\")(()\")\n# False\ncorrect_bracketing <- function(brackets) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_61_correct_bracketing.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- correct_bracketing\n if(!identical(candidate('()'), TRUE)){quit('no', 1)}\n if(!identical(candidate('(()())'), TRUE)){quit('no', 1)}\n if(!identical(candidate('()()(()())()'), TRUE)){quit('no', 1)}\n if(!identical(candidate('()()((()()())())(()()(()))'), TRUE)){quit('no', 1)}\n if(!identical(candidate('((()())))'), FALSE)){quit('no', 1)}\n if(!identical(candidate(')(()'), FALSE)){quit('no', 1)}\n if(!identical(candidate('('), FALSE)){quit('no', 1)}\n if(!identical(candidate('(((('), FALSE)){quit('no', 1)}\n if(!identical(candidate(')'), FALSE)){quit('no', 1)}\n if(!identical(candidate('(()'), FALSE)){quit('no', 1)}\n if(!identical(candidate('()()(()())())(()'), FALSE)){quit('no', 1)}\n if(!identical(candidate('()()(()())()))()'), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_66_digitSum", |
|
"language": "r", |
|
"prompt": "# 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(\"\") => 0\n# digitSum(\"abAB\") => 131\n# digitSum(\"abcCd\") => 67\n# digitSum(\"helloE\") => 69\n# digitSum(\"woArBld\") => 131\n# digitSum(\"aAaaaXa\") => 153\ndigitSum <- function(s) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_66_digitSum.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- digitSum\n if(!identical(candidate(''), 0)){quit('no', 1)}\n if(!identical(candidate('abAB'), 131)){quit('no', 1)}\n if(!identical(candidate('abcCd'), 67)){quit('no', 1)}\n if(!identical(candidate('helloE'), 69)){quit('no', 1)}\n if(!identical(candidate('woArBld'), 131)){quit('no', 1)}\n if(!identical(candidate('aAaaaXa'), 153)){quit('no', 1)}\n if(!identical(candidate(' How are yOu?'), 151)){quit('no', 1)}\n if(!identical(candidate('You arE Very Smart'), 327)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_149_sorted_list_sum", |
|
"language": "r", |
|
"prompt": "# 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 an array 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# assert list_sort([\"aa\", \"a\", \"aaa\"]) => [\"aa\"]\n# assert list_sort([\"ab\", \"a\", \"aaa\", \"cd\"]) => [\"ab\", \"cd\"]\nsorted_list_sum <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_149_sorted_list_sum.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sorted_list_sum\n if(!identical(candidate(c('aa', 'a', 'aaa')), list('aa'))){quit('no', 1)}\n if(!identical(candidate(c('school', 'AI', 'asdf', 'b')), list('AI', 'asdf', 'school'))){quit('no', 1)}\n if(!identical(candidate(c('d', 'b', 'c', 'a')), list())){quit('no', 1)}\n if(!identical(candidate(c('d', 'dcba', 'abcd', 'a')), list('abcd', 'dcba'))){quit('no', 1)}\n if(!identical(candidate(c('AI', 'ai', 'au')), list('AI', 'ai', 'au'))){quit('no', 1)}\n if(!identical(candidate(c('a', 'b', 'b', 'c', 'c', 'a')), list())){quit('no', 1)}\n if(!identical(candidate(c('aaaa', 'bbbb', 'dd', 'cc')), list('cc', 'dd', 'aaaa', 'bbbb'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_128_prod_signs", |
|
"language": "r", |
|
"prompt": "# You are given an array 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 array, represented by 1, -1 or 0.\n# Note: return None for empty arr.\n# Example:\n# >>> prod_signs([1, 2, 2, -4]) == -9\n# >>> prod_signs([0, 1]) == 0\n# >>> prod_signs([]) == None\nprod_signs <- function(arr) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_128_prod_signs.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- prod_signs\n if(!identical(candidate(c(1, 2, 2, -4)), -9)){quit('no', 1)}\n if(!identical(candidate(c(0, 1)), 0)){quit('no', 1)}\n if(!identical(candidate(c(1, 1, 1, 2, 3, -1, 1)), -10)){quit('no', 1)}\n if(!identical(candidate(c()), NULL)){quit('no', 1)}\n if(!identical(candidate(c(2, 4, 1, 2, -1, -1, 9)), 20)){quit('no', 1)}\n if(!identical(candidate(c(-1, 1, -1, 1)), 4)){quit('no', 1)}\n if(!identical(candidate(c(-1, 1, 1, 1)), -4)){quit('no', 1)}\n if(!identical(candidate(c(-1, 1, 1, 0)), 0)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_42_incr_list", |
|
"language": "r", |
|
"prompt": "# Return list with elements incremented by 1.\n# >>> incr_list([1, 2, 3])\n# [2, 3, 4]\n# >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])\n# [6, 4, 6, 3, 4, 4, 10, 1, 124]\nincr_list <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_42_incr_list.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- incr_list\n if(!identical(candidate(c()), list())){quit('no', 1)}\n if(!identical(candidate(c(3, 2, 1)), list(4, 3, 2))){quit('no', 1)}\n if(!identical(candidate(c(5, 2, 5, 2, 3, 3, 9, 0, 123)), list(6, 3, 6, 3, 4, 4, 10, 1, 124))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_9_rolling_max", |
|
"language": "r", |
|
"prompt": "# From a given list of integers, generate a list of rolling maximum element found until given moment\n# in the sequence.\n# >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n# [1, 2, 3, 3, 3, 4, 4]\nrolling_max <- function(numbers) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_9_rolling_max.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- rolling_max\n if(!identical(candidate(c()), list())){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4)), list(1, 2, 3, 4))){quit('no', 1)}\n if(!identical(candidate(c(4, 3, 2, 1)), list(4, 4, 4, 4))){quit('no', 1)}\n if(!identical(candidate(c(3, 2, 3, 100, 3)), list(3, 3, 3, 100, 100))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_1_separate_paren_groups", |
|
"language": "r", |
|
"prompt": "# 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# >>> separate_paren_groups('( ) (( )) (( )( ))')\n# ['()', '(())', '(()())']\nseparate_paren_groups <- function(paren_string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_1_separate_paren_groups.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- separate_paren_groups\n if(!identical(candidate('(()()) ((())) () ((())()())'), list('(()())', '((()))', '()', '((())()())'))){quit('no', 1)}\n if(!identical(candidate('() (()) ((())) (((())))'), list('()', '(())', '((()))', '(((())))'))){quit('no', 1)}\n if(!identical(candidate('(()(())((())))'), list('(()(())((())))'))){quit('no', 1)}\n if(!identical(candidate('( ) (( )) (( )( ))'), list('()', '(())', '(()())'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_101_words_string", |
|
"language": "r", |
|
"prompt": "# 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 an array of the words.\n# For example:\n# words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n# words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\nwords_string <- function(s) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_101_words_string.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- words_string\n if(!identical(candidate('Hi, my name is John'), list('Hi', 'my', 'name', 'is', 'John'))){quit('no', 1)}\n if(!identical(candidate('One, two, three, four, five, six'), list('One', 'two', 'three', 'four', 'five', 'six'))){quit('no', 1)}\n if(!identical(candidate('Hi, my name'), list('Hi', 'my', 'name'))){quit('no', 1)}\n if(!identical(candidate('One,, two, three, four, five, six,'), list('One', 'two', 'three', 'four', 'five', 'six'))){quit('no', 1)}\n if(!identical(candidate(''), list())){quit('no', 1)}\n if(!identical(candidate('ahmed , gamal'), list('ahmed', 'gamal'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_137_compare_one", |
|
"language": "r", |
|
"prompt": "# Create a function that takes integers, floats, or strings representing\n# real numbers, and returns the larger variable in its given variable type.\n# Return None if the values are equal.\n# Note: If a real number is represented as a string, the floating point might be . or ,\n# compare_one(1, 2.5) \u279e 2.5\n# compare_one(1, \"2,3\") \u279e \"2,3\"\n# compare_one(\"5,1\", \"6\") \u279e \"6\"\n# compare_one(\"1\", 1) \u279e None\ncompare_one <- function(a, b) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_137_compare_one.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- compare_one\n if(!identical(candidate(1, 2), 2)){quit('no', 1)}\n if(!identical(candidate(1, 2.5), 2.5)){quit('no', 1)}\n if(!identical(candidate(2, 3), 3)){quit('no', 1)}\n if(!identical(candidate(5, 6), 6)){quit('no', 1)}\n if(!identical(candidate(1, '2,3'), '2,3')){quit('no', 1)}\n if(!identical(candidate('5,1', '6'), '6')){quit('no', 1)}\n if(!identical(candidate('1', '2'), '2')){quit('no', 1)}\n if(!identical(candidate('1', 1), NULL)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_22_filter_integers", |
|
"language": "r", |
|
"prompt": "# Filter given list of any python values only for integers\n# >>> filter_integers(['a', 3.14, 5])\n# [5]\n# >>> filter_integers([1, 2, 3, 'abc', {}, []])\n# [1, 2, 3]\nfilter_integers <- function(values) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_22_filter_integers.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- filter_integers\n if(!identical(candidate(list()), list())){quit('no', 1)}\n if(!identical(candidate(list(4, list(), list(), 23.2, 9, 'adasd')), list(4, 9))){quit('no', 1)}\n if(!identical(candidate(list(3, 'c', 3, 3, 'a', 'b')), list(3, 3, 3))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_37_sort_even", |
|
"language": "r", |
|
"prompt": "# 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# >>> sort_even([1, 2, 3])\n# [1, 2, 3]\n# >>> sort_even([5, 6, 3, 4])\n# [3, 6, 5, 4]\nsort_even <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_37_sort_even.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sort_even\n if(!identical(candidate(c(1, 2, 3)), list(1, 2, 3))){quit('no', 1)}\n if(!identical(candidate(c(5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10)), list(-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123))){quit('no', 1)}\n if(!identical(candidate(c(5, 8, -12, 4, 23, 2, 3, 11, 12, -10)), list(-12, 8, 3, 4, 5, 2, 12, 11, 23, -10))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_152_compare", |
|
"language": "r", |
|
"prompt": "# 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 arrays of scores and guesses of equal length, where each index shows a match. \n# Return an array 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([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]\n# compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]\ncompare <- function(game, guess) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_152_compare.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- compare\n if(!identical(candidate(c(1, 2, 3, 4, 5, 1), c(1, 2, 3, 4, 2, -2)), list(0, 0, 0, 0, 3, 3))){quit('no', 1)}\n if(!identical(candidate(c(0, 0, 0, 0, 0, 0), c(0, 0, 0, 0, 0, 0)), list(0, 0, 0, 0, 0, 0))){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3), c(-1, -2, -3)), list(2, 4, 6))){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 5), c(-1, 2, 3, 4)), list(2, 0, 0, 1))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_107_even_odd_palindrome", |
|
"language": "r", |
|
"prompt": "# 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# Input: 3\n# Output: (1, 2)\n# Explanation:\n# Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.\n# Example 2:\n# Input: 12\n# Output: (4, 6)\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.\neven_odd_palindrome <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_107_even_odd_palindrome.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- even_odd_palindrome\n if(!identical(candidate(123), list(8, 13))){quit('no', 1)}\n if(!identical(candidate(12), list(4, 6))){quit('no', 1)}\n if(!identical(candidate(3), list(1, 2))){quit('no', 1)}\n if(!identical(candidate(63), list(6, 8))){quit('no', 1)}\n if(!identical(candidate(25), list(5, 6))){quit('no', 1)}\n if(!identical(candidate(19), list(4, 6))){quit('no', 1)}\n if(!identical(candidate(9), list(4, 5))){quit('no', 1)}\n if(!identical(candidate(1), list(0, 1))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_46_fib4", |
|
"language": "r", |
|
"prompt": "# 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(5)\n# 4\n# >>> fib4(6)\n# 8\n# >>> fib4(7)\n# 14\nfib4 <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_46_fib4.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- fib4\n if(!identical(candidate(5), 4)){quit('no', 1)}\n if(!identical(candidate(8), 28)){quit('no', 1)}\n if(!identical(candidate(10), 104)){quit('no', 1)}\n if(!identical(candidate(12), 386)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_163_generate_integers", |
|
"language": "r", |
|
"prompt": "# Given two positive integers a and b, return the even digits between a\n# and b, in ascending order.\n# For example:\n# generate_integers(2, 8) => [2, 4, 6, 8]\n# generate_integers(8, 2) => [2, 4, 6, 8]\n# generate_integers(10, 14) => []\ngenerate_integers <- function(a, b) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_163_generate_integers.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- generate_integers\n if(!identical(candidate(2, 10), list(2, 4, 6, 8))){quit('no', 1)}\n if(!identical(candidate(10, 2), list(2, 4, 6, 8))){quit('no', 1)}\n if(!identical(candidate(132, 2), list(2, 4, 6, 8))){quit('no', 1)}\n if(!identical(candidate(17, 89), list())){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_4_mean_absolute_deviation", |
|
"language": "r", |
|
"prompt": "# 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# >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])\n# 1.0\nmean_absolute_deviation <- function(numbers) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_4_mean_absolute_deviation.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- mean_absolute_deviation\n if(!identical(candidate(c(1.0, 2.0)), 0.5)){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 3.0, 4.0)), 1.0)){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 3.0, 4.0, 5.0)), 1.2)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_89_encrypt", |
|
"language": "r", |
|
"prompt": "# 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') returns 'lm'\n# encrypt('asdfghjkl') returns 'ewhjklnop'\n# encrypt('gf') returns 'kj'\n# encrypt('et') returns 'ix'\nencrypt <- function(s) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_89_encrypt.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- encrypt\n if(!identical(candidate('hi'), 'lm')){quit('no', 1)}\n if(!identical(candidate('asdfghjkl'), 'ewhjklnop')){quit('no', 1)}\n if(!identical(candidate('gf'), 'kj')){quit('no', 1)}\n if(!identical(candidate('et'), 'ix')){quit('no', 1)}\n if(!identical(candidate('faewfawefaewg'), 'jeiajeaijeiak')){quit('no', 1)}\n if(!identical(candidate('hellomyfriend'), 'lippsqcjvmirh')){quit('no', 1)}\n if(!identical(candidate('dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh'), 'hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl')){quit('no', 1)}\n if(!identical(candidate('a'), 'e')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_123_get_odd_collatz", |
|
"language": "r", |
|
"prompt": "# 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.\nget_odd_collatz <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_123_get_odd_collatz.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- get_odd_collatz\n if(!identical(candidate(14), list(1, 5, 7, 11, 13, 17))){quit('no', 1)}\n if(!identical(candidate(5), list(1, 5))){quit('no', 1)}\n if(!identical(candidate(12), list(1, 3, 5))){quit('no', 1)}\n if(!identical(candidate(1), list(1))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_18_how_many_times", |
|
"language": "r", |
|
"prompt": "# Find how many times a given substring can be found in the original string. Count overlaping cases.\n# >>> how_many_times('', 'a')\n# 0\n# >>> how_many_times('aaa', 'a')\n# 3\n# >>> how_many_times('aaaa', 'aa')\n# 3\nhow_many_times <- function(string, substring) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_18_how_many_times.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- how_many_times\n if(!identical(candidate('', 'x'), 0)){quit('no', 1)}\n if(!identical(candidate('xyxyxyx', 'x'), 4)){quit('no', 1)}\n if(!identical(candidate('cacacacac', 'cac'), 4)){quit('no', 1)}\n if(!identical(candidate('john doe', 'john'), 1)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_109_move_one_ball", |
|
"language": "r", |
|
"prompt": "# We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The\n# numbers in the array will be randomly ordered. Your task is to determine if\n# it is possible to get an array sorted in non-decreasing order by performing \n# the following operation on the given array:\n# You are allowed to perform right shift operation any number of times.\n# One right shift operation means shifting all elements of the array by one\n# position in the right direction. The last element of the array will be moved to\n# the starting position in the array i.e. 0th index. \n# If it is possible to obtain the sorted array by performing the above operation\n# then return True else return False.\n# If the given array is empty then return True.\n# Note: The given list is guaranteed to have unique elements.\n# For Example:\n# move_one_ball([3, 4, 5, 1, 2])==>True\n# Explanation: By performin 2 right shift operations, non-decreasing order can\n# be achieved for the given array.\n# move_one_ball([3, 5, 4, 1, 2])==>False\n# Explanation:It is not possible to get non-decreasing order for the given\n# array by performing any number of right shift operations.\nmove_one_ball <- function(arr) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_109_move_one_ball.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- move_one_ball\n if(!identical(candidate(c(3, 4, 5, 1, 2)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(3, 5, 10, 1, 2)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(4, 3, 1, 2)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(3, 5, 4, 1, 2)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c()), TRUE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_145_order_by_points", |
|
"language": "r", |
|
"prompt": "# 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# >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]\n# >>> order_by_points([]) == []\norder_by_points <- function(nums) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_145_order_by_points.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- order_by_points\n if(!identical(candidate(c(1, 11, -1, -11, -12)), list(-1, -11, 1, -12, 11))){quit('no', 1)}\n if(!identical(candidate(c(1234, 423, 463, 145, 2, 423, 423, 53, 6, 37, 3457, 3, 56, 0, 46)), list(0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457))){quit('no', 1)}\n if(!identical(candidate(c()), list())){quit('no', 1)}\n if(!identical(candidate(c(1, -11, -32, 43, 54, -98, 2, -3)), list(-3, -32, -98, -11, 1, 2, 43, 54))){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)), list(1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9))){quit('no', 1)}\n if(!identical(candidate(c(0, 6, 6, -76, -21, 23, 4)), list(-76, -21, 0, 4, 23, 6, 6))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_25_factorize", |
|
"language": "r", |
|
"prompt": "# 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(8)\n# [2, 2, 2]\n# >>> factorize(25)\n# [5, 5]\n# >>> factorize(70)\n# [2, 5, 7]\nfactorize <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_25_factorize.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- factorize\n if(!identical(candidate(2), list(2))){quit('no', 1)}\n if(!identical(candidate(4), list(2, 2))){quit('no', 1)}\n if(!identical(candidate(8), list(2, 2, 2))){quit('no', 1)}\n if(!identical(candidate(57), list(3, 19))){quit('no', 1)}\n if(!identical(candidate(3249), list(3, 3, 19, 19))){quit('no', 1)}\n if(!identical(candidate(185193), list(3, 3, 3, 19, 19, 19))){quit('no', 1)}\n if(!identical(candidate(20577), list(3, 19, 19, 19))){quit('no', 1)}\n if(!identical(candidate(18), list(2, 3, 3))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_52_below_threshold", |
|
"language": "r", |
|
"prompt": "# Return True if all numbers in the list l are below threshold t.\n# >>> below_threshold([1, 2, 4, 10], 100)\n# True\n# >>> below_threshold([1, 20, 4, 10], 5)\n# False\nbelow_threshold <- function(l, t) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_52_below_threshold.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- below_threshold\n if(!identical(candidate(c(1, 2, 4, 10), 100), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 20, 4, 10), 5), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 20, 4, 10), 21), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 20, 4, 10), 22), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 8, 4, 10), 11), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 8, 4, 10), 10), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_103_rounded_avg", |
|
"language": "r", |
|
"prompt": "# You are given two positive integers n and m, and your task is to compute the\n# average of the integers from n through m (including n and m). \n# Round the answer to the nearest integer and convert that to binary.\n# If n is greater than m, return -1.\n# Example:\n# rounded_avg(1, 5) => \"0b11\"\n# rounded_avg(7, 5) => -1\n# rounded_avg(10, 20) => \"0b1111\"\n# rounded_avg(20, 33) => \"0b11010\"\nrounded_avg <- function(n, m) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_103_rounded_avg.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- rounded_avg\n if(!identical(candidate(1, 5), '0b11')){quit('no', 1)}\n if(!identical(candidate(7, 13), '0b1010')){quit('no', 1)}\n if(!identical(candidate(964, 977), '0b1111001010')){quit('no', 1)}\n if(!identical(candidate(996, 997), '0b1111100100')){quit('no', 1)}\n if(!identical(candidate(560, 851), '0b1011000010')){quit('no', 1)}\n if(!identical(candidate(185, 546), '0b101101110')){quit('no', 1)}\n if(!identical(candidate(362, 496), '0b110101101')){quit('no', 1)}\n if(!identical(candidate(350, 902), '0b1001110010')){quit('no', 1)}\n if(!identical(candidate(197, 233), '0b11010111')){quit('no', 1)}\n if(!identical(candidate(7, 5), -1)){quit('no', 1)}\n if(!identical(candidate(5, 1), -1)){quit('no', 1)}\n if(!identical(candidate(5, 5), '0b101')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_6_parse_nested_parens", |
|
"language": "r", |
|
"prompt": "# 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# >>> parse_nested_parens('(()()) ((())) () ((())()())')\n# [2, 3, 1, 3]\nparse_nested_parens <- function(paren_string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_6_parse_nested_parens.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- parse_nested_parens\n if(!identical(candidate('(()()) ((())) () ((())()())'), list(2, 3, 1, 3))){quit('no', 1)}\n if(!identical(candidate('() (()) ((())) (((())))'), list(1, 2, 3, 4))){quit('no', 1)}\n if(!identical(candidate('(()(())((())))'), list(4))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_121_solution", |
|
"language": "r", |
|
"prompt": "# 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([5, 8, 7, 1]) ==> 12\n# solution([3, 3, 3, 3, 3]) ==> 9\n# solution([30, 13, 24, 321]) ==>0\nsolution <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_121_solution.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- solution\n if(!identical(candidate(c(5, 8, 7, 1)), 12)){quit('no', 1)}\n if(!identical(candidate(c(3, 3, 3, 3, 3)), 9)){quit('no', 1)}\n if(!identical(candidate(c(30, 13, 24, 321)), 0)){quit('no', 1)}\n if(!identical(candidate(c(5, 9)), 5)){quit('no', 1)}\n if(!identical(candidate(c(2, 4, 8)), 0)){quit('no', 1)}\n if(!identical(candidate(c(30, 13, 23, 32)), 23)){quit('no', 1)}\n if(!identical(candidate(c(3, 13, 2, 9)), 3)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_147_get_max_triples", |
|
"language": "r", |
|
"prompt": "# You are given a positive integer n. You have to create an integer array 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# Input: n = 5\n# Output: 1\n# Explanation: \n# a = [1, 3, 7, 13, 21]\n# The only valid triple is (1, 7, 13).\nget_max_triples <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_147_get_max_triples.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- get_max_triples\n if(!identical(candidate(5), 1)){quit('no', 1)}\n if(!identical(candidate(6), 4)){quit('no', 1)}\n if(!identical(candidate(10), 36)){quit('no', 1)}\n if(!identical(candidate(100), 53361)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_148_bf", |
|
"language": "r", |
|
"prompt": "# 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\") ==> (\"Saturn\", \"Uranus\")\n# bf(\"Earth\", \"Mercury\") ==> (\"Venus\")\n# bf(\"Mercury\", \"Uranus\") ==> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")\nbf <- function(planet1, planet2) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_148_bf.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- bf\n if(!identical(candidate('Jupiter', 'Neptune'), list('Saturn', 'Uranus'))){quit('no', 1)}\n if(!identical(candidate('Earth', 'Mercury'), list('Venus'))){quit('no', 1)}\n if(!identical(candidate('Mercury', 'Uranus'), list('Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn'))){quit('no', 1)}\n if(!identical(candidate('Neptune', 'Venus'), list('Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus'))){quit('no', 1)}\n if(!identical(candidate('Earth', 'Earth'), list())){quit('no', 1)}\n if(!identical(candidate('Mars', 'Earth'), list())){quit('no', 1)}\n if(!identical(candidate('Jupiter', 'Makemake'), list())){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_90_next_smallest", |
|
"language": "r", |
|
"prompt": "# You are given a list of integers.\n# Write a function next_smallest() that returns the 2nd smallest element of the list.\n# Return None if there is no such element.\n# next_smallest([1, 2, 3, 4, 5]) == 2\n# next_smallest([5, 1, 4, 3, 2]) == 2\n# next_smallest([]) == None\n# next_smallest([1, 1]) == None\nnext_smallest <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_90_next_smallest.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- next_smallest\n if(!identical(candidate(c(1, 2, 3, 4, 5)), 2)){quit('no', 1)}\n if(!identical(candidate(c(5, 1, 4, 3, 2)), 2)){quit('no', 1)}\n if(!identical(candidate(c()), NULL)){quit('no', 1)}\n if(!identical(candidate(c(1, 1)), NULL)){quit('no', 1)}\n if(!identical(candidate(c(1, 1, 1, 1, 0)), 1)){quit('no', 1)}\n if(!identical(candidate(c(1, 1)), NULL)){quit('no', 1)}\n if(!identical(candidate(c(-35, 34, 12, -45)), -35)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_19_sort_numbers", |
|
"language": "r", |
|
"prompt": "# 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# >>> sort_numbers('three one five')\n# 'one three five'\nsort_numbers <- function(numbers) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_19_sort_numbers.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sort_numbers\n if(!identical(candidate(''), '')){quit('no', 1)}\n if(!identical(candidate('three'), 'three')){quit('no', 1)}\n if(!identical(candidate('three five nine'), 'three five nine')){quit('no', 1)}\n if(!identical(candidate('five zero four seven nine eight'), 'zero four five seven eight nine')){quit('no', 1)}\n if(!identical(candidate('six five four three two one zero'), 'zero one two three four five six')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_154_cycpattern_check", |
|
"language": "r", |
|
"prompt": "# 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# cycpattern_check(\"abcd\",\"abd\") => False\n# cycpattern_check(\"hello\",\"ell\") => True\n# cycpattern_check(\"whassup\",\"psus\") => False\n# cycpattern_check(\"abab\",\"baa\") => True\n# cycpattern_check(\"efef\",\"eeff\") => False\n# cycpattern_check(\"himenss\",\"simen\") => True\ncycpattern_check <- function(a, b) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_154_cycpattern_check.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- cycpattern_check\n if(!identical(candidate('xyzw', 'xyw'), FALSE)){quit('no', 1)}\n if(!identical(candidate('yello', 'ell'), TRUE)){quit('no', 1)}\n if(!identical(candidate('whattup', 'ptut'), FALSE)){quit('no', 1)}\n if(!identical(candidate('efef', 'fee'), TRUE)){quit('no', 1)}\n if(!identical(candidate('abab', 'aabb'), FALSE)){quit('no', 1)}\n if(!identical(candidate('winemtt', 'tinem'), TRUE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_79_decimal_to_binary", |
|
"language": "r", |
|
"prompt": "# 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# decimal_to_binary(15) # returns \"db1111db\"\n# decimal_to_binary(32) # returns \"db100000db\"\ndecimal_to_binary <- function(decimal) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_79_decimal_to_binary.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- decimal_to_binary\n if(!identical(candidate(0), 'db0db')){quit('no', 1)}\n if(!identical(candidate(32), 'db100000db')){quit('no', 1)}\n if(!identical(candidate(103), 'db1100111db')){quit('no', 1)}\n if(!identical(candidate(15), 'db1111db')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_7_filter_by_substring", |
|
"language": "r", |
|
"prompt": "# Filter an input list of strings only for ones that contain given substring\n# >>> filter_by_substring([], 'a')\n# []\n# >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')\n# ['abc', 'bacd', 'array']\nfilter_by_substring <- function(strings, substring) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_7_filter_by_substring.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- filter_by_substring\n if(!identical(candidate(c(), 'john'), list())){quit('no', 1)}\n if(!identical(candidate(c('xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'), 'xxx'), list('xxx', 'xxxAAA', 'xxx'))){quit('no', 1)}\n if(!identical(candidate(c('xxx', 'asd', 'aaaxxy', 'john doe', 'xxxAAA', 'xxx'), 'xx'), list('xxx', 'aaaxxy', 'xxxAAA', 'xxx'))){quit('no', 1)}\n if(!identical(candidate(c('grunt', 'trumpet', 'prune', 'gruesome'), 'run'), list('grunt', 'prune'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_155_even_odd_count", |
|
"language": "r", |
|
"prompt": "# Given an integer. return a tuple that has the number of even and odd digits respectively.\n# Example:\n# even_odd_count(-12) ==> (1, 1)\n# even_odd_count(123) ==> (1, 2)\neven_odd_count <- function(num) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_155_even_odd_count.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- even_odd_count\n if(!identical(candidate(7), list(0, 1))){quit('no', 1)}\n if(!identical(candidate(-78), list(1, 1))){quit('no', 1)}\n if(!identical(candidate(3452), list(2, 2))){quit('no', 1)}\n if(!identical(candidate(346211), list(3, 3))){quit('no', 1)}\n if(!identical(candidate(-345821), list(3, 3))){quit('no', 1)}\n if(!identical(candidate(-2), list(1, 0))){quit('no', 1)}\n if(!identical(candidate(-45347), list(2, 3))){quit('no', 1)}\n if(!identical(candidate(0), list(1, 0))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_158_find_max", |
|
"language": "r", |
|
"prompt": "# 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# find_max([\"name\", \"of\", \"string\"]) == \"string\"\n# find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n# find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"\"aaaaaaa\"\nfind_max <- function(words) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_158_find_max.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- find_max\n if(!identical(candidate(c('name', 'of', 'string')), 'string')){quit('no', 1)}\n if(!identical(candidate(c('name', 'enam', 'game')), 'enam')){quit('no', 1)}\n if(!identical(candidate(c('aaaaaaa', 'bb', 'cc')), 'aaaaaaa')){quit('no', 1)}\n if(!identical(candidate(c('abc', 'cba')), 'abc')){quit('no', 1)}\n if(!identical(candidate(c('play', 'this', 'game', 'of', 'footbott')), 'footbott')){quit('no', 1)}\n if(!identical(candidate(c('we', 'are', 'gonna', 'rock')), 'gonna')){quit('no', 1)}\n if(!identical(candidate(c('we', 'are', 'a', 'mad', 'nation')), 'nation')){quit('no', 1)}\n if(!identical(candidate(c('this', 'is', 'a', 'prrk')), 'this')){quit('no', 1)}\n if(!identical(candidate(c('b')), 'b')){quit('no', 1)}\n if(!identical(candidate(c('play', 'play', 'play')), 'play')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_83_starts_one_ends", |
|
"language": "r", |
|
"prompt": "# Given a positive integer n, return the count of the numbers of n-digit\n# positive integers that start or end with 1.\nstarts_one_ends <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_83_starts_one_ends.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- starts_one_ends\n if(!identical(candidate(1), 1)){quit('no', 1)}\n if(!identical(candidate(2), 18)){quit('no', 1)}\n if(!identical(candidate(3), 180)){quit('no', 1)}\n if(!identical(candidate(4), 1800)){quit('no', 1)}\n if(!identical(candidate(5), 18000)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_136_largest_smallest_integers", |
|
"language": "r", |
|
"prompt": "# 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 None.\n# Examples:\n# largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)\n# largest_smallest_integers([]) == (None, None)\n# largest_smallest_integers([0]) == (None, None)\nlargest_smallest_integers <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_136_largest_smallest_integers.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- largest_smallest_integers\n if(!identical(candidate(c(2, 4, 1, 3, 5, 7)), list(NULL, 1))){quit('no', 1)}\n if(!identical(candidate(c(2, 4, 1, 3, 5, 7, 0)), list(NULL, 1))){quit('no', 1)}\n if(!identical(candidate(c(1, 3, 2, 4, 5, 6, -2)), list(-2, 1))){quit('no', 1)}\n if(!identical(candidate(c(4, 5, 3, 6, 2, 7, -7)), list(-7, 2))){quit('no', 1)}\n if(!identical(candidate(c(7, 3, 8, 4, 9, 2, 5, -9)), list(-9, 2))){quit('no', 1)}\n if(!identical(candidate(c()), list(NULL, NULL))){quit('no', 1)}\n if(!identical(candidate(c(0)), list(NULL, NULL))){quit('no', 1)}\n if(!identical(candidate(c(-1, -3, -5, -6)), list(-1, NULL))){quit('no', 1)}\n if(!identical(candidate(c(-1, -3, -5, -6, 0)), list(-1, NULL))){quit('no', 1)}\n if(!identical(candidate(c(-6, -4, -4, -3, 1)), list(-3, 1))){quit('no', 1)}\n if(!identical(candidate(c(-6, -4, -4, -3, -100, 1)), list(-3, 1))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_68_pluck", |
|
"language": "r", |
|
"prompt": "# \"Given an array 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 array is empty, return [].\n# Example 1:\n# Input: [4,2,3]\n# Output: [2, 1]\n# Explanation: 2 has the smallest even value, and 2 has the smallest index.\n# Example 2:\n# Input: [1,2,3]\n# Output: [2, 1]\n# Explanation: 2 has the smallest even value, and 2 has the smallest index. \n# Example 3:\n# Input: []\n# Output: []\n# Example 4:\n# Input: [5, 0, 3, 0, 4, 2]\n# Output: [0, 1]\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\npluck <- function(arr) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_68_pluck.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- pluck\n if(!identical(candidate(c(4, 2, 3)), list(2, 1))){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3)), list(2, 1))){quit('no', 1)}\n if(!identical(candidate(c()), list())){quit('no', 1)}\n if(!identical(candidate(c(5, 0, 3, 0, 4, 2)), list(0, 1))){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 0, 5, 3)), list(0, 3))){quit('no', 1)}\n if(!identical(candidate(c(5, 4, 8, 4, 8)), list(4, 1))){quit('no', 1)}\n if(!identical(candidate(c(7, 6, 7, 1)), list(6, 1))){quit('no', 1)}\n if(!identical(candidate(c(7, 9, 7, 1)), list())){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_108_count_nums", |
|
"language": "r", |
|
"prompt": "# Write a function count_nums which takes an array 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# >>> count_nums([]) == 0\n# >>> count_nums([-1, 11, -11]) == 1\n# >>> count_nums([1, 1, 2]) == 3\ncount_nums <- function(arr) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_108_count_nums.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- count_nums\n if(!identical(candidate(c()), 0)){quit('no', 1)}\n if(!identical(candidate(c(-1, -2, 0)), 0)){quit('no', 1)}\n if(!identical(candidate(c(1, 1, 2, -2, 3, 4, 5)), 6)){quit('no', 1)}\n if(!identical(candidate(c(1, 6, 9, -6, 0, 1, 5)), 5)){quit('no', 1)}\n if(!identical(candidate(c(1, 100, 98, -7, 1, -1)), 4)){quit('no', 1)}\n if(!identical(candidate(c(12, 23, 34, -45, -56, 0)), 5)){quit('no', 1)}\n if(!identical(candidate(c(0, 1)), 1)){quit('no', 1)}\n if(!identical(candidate(c(1)), 1)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_129_minPath", |
|
"language": "r", |
|
"prompt": "# 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# Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3\n# Output: [1, 2, 1]\n# Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1\n# Output: [1]\nminPath <- function(grid, k) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_129_minPath.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- minPath\n if(!identical(candidate(list(list(1, 2, 3), list(4, 5, 6), list(7, 8, 9)), 3), list(1, 2, 1))){quit('no', 1)}\n if(!identical(candidate(list(list(5, 9, 3), list(4, 1, 6), list(7, 8, 2)), 1), list(1))){quit('no', 1)}\n if(!identical(candidate(list(list(1, 2, 3, 4), list(5, 6, 7, 8), list(9, 10, 11, 12), list(13, 14, 15, 16)), 4), list(1, 2, 1, 2))){quit('no', 1)}\n if(!identical(candidate(list(list(6, 4, 13, 10), list(5, 7, 12, 1), list(3, 16, 11, 15), list(8, 14, 9, 2)), 7), list(1, 10, 1, 10, 1, 10, 1))){quit('no', 1)}\n if(!identical(candidate(list(list(8, 14, 9, 2), list(6, 4, 13, 15), list(5, 7, 1, 12), list(3, 10, 11, 16)), 5), list(1, 7, 1, 7, 1))){quit('no', 1)}\n if(!identical(candidate(list(list(11, 8, 7, 2), list(5, 16, 14, 4), list(9, 3, 15, 6), list(12, 13, 10, 1)), 9), list(1, 6, 1, 6, 1, 6, 1, 6, 1))){quit('no', 1)}\n if(!identical(candidate(list(list(12, 13, 10, 1), list(9, 3, 15, 6), list(5, 16, 14, 4), list(11, 8, 7, 2)), 12), list(1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6))){quit('no', 1)}\n if(!identical(candidate(list(list(2, 7, 4), list(3, 1, 5), list(6, 8, 9)), 8), list(1, 3, 1, 3, 1, 3, 1, 3))){quit('no', 1)}\n if(!identical(candidate(list(list(6, 1, 5), list(3, 8, 9), list(2, 7, 4)), 8), list(1, 5, 1, 5, 1, 5, 1, 5))){quit('no', 1)}\n if(!identical(candidate(list(list(1, 2), list(3, 4)), 10), list(1, 2, 1, 2, 1, 2, 1, 2, 1, 2))){quit('no', 1)}\n if(!identical(candidate(list(list(1, 3), list(3, 2)), 10), list(1, 3, 1, 3, 1, 3, 1, 3, 1, 3))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_70_strange_sort_list", |
|
"language": "r", |
|
"prompt": "# 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# strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]\n# strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]\n# strange_sort_list([]) == []\nstrange_sort_list <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_70_strange_sort_list.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- strange_sort_list\n if(!identical(candidate(c(1, 2, 3, 4)), list(1, 4, 2, 3))){quit('no', 1)}\n if(!identical(candidate(c(5, 6, 7, 8, 9)), list(5, 9, 6, 8, 7))){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4, 5)), list(1, 5, 2, 4, 3))){quit('no', 1)}\n if(!identical(candidate(c(5, 6, 7, 8, 9, 1)), list(1, 9, 5, 8, 6, 7))){quit('no', 1)}\n if(!identical(candidate(c(5, 5, 5, 5)), list(5, 5, 5, 5))){quit('no', 1)}\n if(!identical(candidate(c()), list())){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4, 5, 6, 7, 8)), list(1, 8, 2, 7, 3, 6, 4, 5))){quit('no', 1)}\n if(!identical(candidate(c(0, 2, 2, 2, 5, 5, -5, -5)), list(-5, 5, -5, 5, 0, 2, 2, 2))){quit('no', 1)}\n if(!identical(candidate(c(111111)), list(111111))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_162_string_to_md5", |
|
"language": "r", |
|
"prompt": "# Given a string 'text', return its md5 hash equivalent string.\n# If 'text' is an empty string, return None.\n# >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'\nstring_to_md5 <- function(text) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_162_string_to_md5.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- string_to_md5\n if(!identical(candidate('Hello world'), '3e25960a79dbc69b674cd4ec67a72c62')){quit('no', 1)}\n if(!identical(candidate(''), NULL)){quit('no', 1)}\n if(!identical(candidate('A B C'), '0ef78513b0cb8cef12743f5aeb35f888')){quit('no', 1)}\n if(!identical(candidate('password'), '5f4dcc3b5aa765d61d8327deb882cf99')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_118_get_closest_vowel", |
|
"language": "r", |
|
"prompt": "# 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# get_closest_vowel(\"yogurt\") ==> \"u\"\n# get_closest_vowel(\"FULL\") ==> \"U\"\n# get_closest_vowel(\"quick\") ==> \"\"\n# get_closest_vowel(\"ab\") ==> \"\"\nget_closest_vowel <- function(word) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_118_get_closest_vowel.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- get_closest_vowel\n if(!identical(candidate('yogurt'), 'u')){quit('no', 1)}\n if(!identical(candidate('full'), 'u')){quit('no', 1)}\n if(!identical(candidate('easy'), '')){quit('no', 1)}\n if(!identical(candidate('eAsy'), '')){quit('no', 1)}\n if(!identical(candidate('ali'), '')){quit('no', 1)}\n if(!identical(candidate('bad'), 'a')){quit('no', 1)}\n if(!identical(candidate('most'), 'o')){quit('no', 1)}\n if(!identical(candidate('ab'), '')){quit('no', 1)}\n if(!identical(candidate('ba'), '')){quit('no', 1)}\n if(!identical(candidate('quick'), '')){quit('no', 1)}\n if(!identical(candidate('anime'), 'i')){quit('no', 1)}\n if(!identical(candidate('Asia'), '')){quit('no', 1)}\n if(!identical(candidate('Above'), 'o')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_44_change_base", |
|
"language": "r", |
|
"prompt": "# Change numerical base of input number x to base.\n# return string representation after the conversion.\n# base numbers are less than 10.\n# >>> change_base(8, 3)\n# '22'\n# >>> change_base(8, 2)\n# '1000'\n# >>> change_base(7, 2)\n# '111'\nchange_base <- function(x, base) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_44_change_base.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- change_base\n if(!identical(candidate(8, 3), '22')){quit('no', 1)}\n if(!identical(candidate(9, 3), '100')){quit('no', 1)}\n if(!identical(candidate(234, 2), '11101010')){quit('no', 1)}\n if(!identical(candidate(16, 2), '10000')){quit('no', 1)}\n if(!identical(candidate(8, 2), '1000')){quit('no', 1)}\n if(!identical(candidate(7, 2), '111')){quit('no', 1)}\n if(!identical(candidate(2, 3), '2')){quit('no', 1)}\n if(!identical(candidate(3, 4), '3')){quit('no', 1)}\n if(!identical(candidate(4, 5), '4')){quit('no', 1)}\n if(!identical(candidate(5, 6), '5')){quit('no', 1)}\n if(!identical(candidate(6, 7), '6')){quit('no', 1)}\n if(!identical(candidate(7, 8), '7')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_0_has_close_elements", |
|
"language": "r", |
|
"prompt": "# Check if in given list of numbers, are any two numbers closer to each other than\n# given threshold.\n# >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n# False\n# >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n# True\nhas_close_elements <- function(numbers, threshold) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_0_has_close_elements.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- has_close_elements\n if(!identical(candidate(c(1.0, 2.0, 3.9, 4.0, 5.0, 2.2), 0.3), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 3.9, 4.0, 5.0, 2.2), 0.05), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 5.9, 4.0, 5.0), 0.95), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 5.9, 4.0, 5.0), 0.8), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 3.0, 4.0, 5.0, 2.0), 0.1), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1.1, 2.2, 3.1, 4.1, 5.1), 1.0), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1.1, 2.2, 3.1, 4.1, 5.1), 0.5), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_132_is_nested", |
|
"language": "r", |
|
"prompt": "# 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# is_nested('[[]]') \u279e True\n# is_nested('[]]]]]]][[[[[]') \u279e False\n# is_nested('[][]') \u279e False\n# is_nested('[]') \u279e False\n# is_nested('[[][]]') \u279e True\n# is_nested('[[]][[') \u279e True\nis_nested <- function(string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_132_is_nested.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- is_nested\n if(!identical(candidate('[[]]'), TRUE)){quit('no', 1)}\n if(!identical(candidate('[]]]]]]][[[[[]'), FALSE)){quit('no', 1)}\n if(!identical(candidate('[][]'), FALSE)){quit('no', 1)}\n if(!identical(candidate('[]'), FALSE)){quit('no', 1)}\n if(!identical(candidate('[[[[]]]]'), TRUE)){quit('no', 1)}\n if(!identical(candidate('[]]]]]]]]]]'), FALSE)){quit('no', 1)}\n if(!identical(candidate('[][][[]]'), TRUE)){quit('no', 1)}\n if(!identical(candidate('[[]'), FALSE)){quit('no', 1)}\n if(!identical(candidate('[]]'), FALSE)){quit('no', 1)}\n if(!identical(candidate('[[]][['), TRUE)){quit('no', 1)}\n if(!identical(candidate('[[][]]'), TRUE)){quit('no', 1)}\n if(!identical(candidate(''), FALSE)){quit('no', 1)}\n if(!identical(candidate('[[[[[[[['), FALSE)){quit('no', 1)}\n if(!identical(candidate(']]]]]]]]'), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_28_concatenate", |
|
"language": "r", |
|
"prompt": "# Concatenate list of strings into a single string\n# >>> concatenate([])\n# ''\n# >>> concatenate(['a', 'b', 'c'])\n# 'abc'\nconcatenate <- function(strings) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_28_concatenate.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- concatenate\n if(!identical(candidate(c()), '')){quit('no', 1)}\n if(!identical(candidate(c('x', 'y', 'z')), 'xyz')){quit('no', 1)}\n if(!identical(candidate(c('x', 'y', 'z', 'w', 'k')), 'xyzwk')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_39_prime_fib", |
|
"language": "r", |
|
"prompt": "# prime_fib returns n-th number that is a Fibonacci number and it's also prime.\n# >>> prime_fib(1)\n# 2\n# >>> prime_fib(2)\n# 3\n# >>> prime_fib(3)\n# 5\n# >>> prime_fib(4)\n# 13\n# >>> prime_fib(5)\n# 89\nprime_fib <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_39_prime_fib.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- prime_fib\n if(!identical(candidate(1), 2)){quit('no', 1)}\n if(!identical(candidate(2), 3)){quit('no', 1)}\n if(!identical(candidate(3), 5)){quit('no', 1)}\n if(!identical(candidate(4), 13)){quit('no', 1)}\n if(!identical(candidate(5), 89)){quit('no', 1)}\n if(!identical(candidate(6), 233)){quit('no', 1)}\n if(!identical(candidate(7), 1597)){quit('no', 1)}\n if(!identical(candidate(8), 28657)){quit('no', 1)}\n if(!identical(candidate(9), 514229)){quit('no', 1)}\n if(!identical(candidate(10), 433494437)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_20_find_closest_elements", |
|
"language": "r", |
|
"prompt": "# 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# >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n# (2.0, 2.2)\n# >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n# (2.0, 2.0)\nfind_closest_elements <- function(numbers) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_20_find_closest_elements.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- find_closest_elements\n if(!identical(candidate(c(1.0, 2.0, 3.9, 4.0, 5.0, 2.2)), list(3.9, 4.0))){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 5.9, 4.0, 5.0)), list(5.0, 5.9))){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 3.0, 4.0, 5.0, 2.2)), list(2.0, 2.2))){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 3.0, 4.0, 5.0, 2.0)), list(2.0, 2.0))){quit('no', 1)}\n if(!identical(candidate(c(1.1, 2.2, 3.1, 4.1, 5.1)), list(2.2, 3.1))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_78_hex_key", |
|
"language": "r", |
|
"prompt": "# 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# For num = \"AB\" the output should be 1.\n# For num = \"1077E\" the output should be 2.\n# For num = \"ABED1A33\" the output should be 4.\n# For num = \"123456789ABCDEF0\" the output should be 6.\n# For num = \"2020\" the output should be 2.\nhex_key <- function(num) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_78_hex_key.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- hex_key\n if(!identical(candidate('AB'), 1)){quit('no', 1)}\n if(!identical(candidate('1077E'), 2)){quit('no', 1)}\n if(!identical(candidate('ABED1A33'), 4)){quit('no', 1)}\n if(!identical(candidate('2020'), 2)){quit('no', 1)}\n if(!identical(candidate('123456789ABCDEF0'), 6)){quit('no', 1)}\n if(!identical(candidate('112233445566778899AABBCCDDEEFF00'), 12)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_97_multiply", |
|
"language": "r", |
|
"prompt": "# 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(148, 412) should return 16.\n# multiply(19, 28) should return 72.\n# multiply(2020, 1851) should return 0.\n# multiply(14,-15) should return 20.\nmultiply <- function(a, b) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_97_multiply.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- multiply\n if(!identical(candidate(148, 412), 16)){quit('no', 1)}\n if(!identical(candidate(19, 28), 72)){quit('no', 1)}\n if(!identical(candidate(2020, 1851), 0)){quit('no', 1)}\n if(!identical(candidate(14, -15), 20)){quit('no', 1)}\n if(!identical(candidate(76, 67), 42)){quit('no', 1)}\n if(!identical(candidate(17, 27), 49)){quit('no', 1)}\n if(!identical(candidate(0, 1), 0)){quit('no', 1)}\n if(!identical(candidate(0, 0), 0)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_21_rescale_to_unit", |
|
"language": "r", |
|
"prompt": "# 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# >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])\n# [0.0, 0.25, 0.5, 0.75, 1.0]\nrescale_to_unit <- function(numbers) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_21_rescale_to_unit.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- rescale_to_unit\n if(!identical(candidate(c(2.0, 49.9)), list(0.0, 1.0))){quit('no', 1)}\n if(!identical(candidate(c(100.0, 49.9)), list(1.0, 0.0))){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 3.0, 4.0, 5.0)), list(0.0, 0.25, 0.5, 0.75, 1.0))){quit('no', 1)}\n if(!identical(candidate(c(2.0, 1.0, 5.0, 3.0, 4.0)), list(0.25, 0.0, 1.0, 0.5, 0.75))){quit('no', 1)}\n if(!identical(candidate(c(12.0, 11.0, 15.0, 13.0, 14.0)), list(0.25, 0.0, 1.0, 0.5, 0.75))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_131_digits", |
|
"language": "r", |
|
"prompt": "# 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(1) == 1\n# digits(4) == 0\n# digits(235) == 15\ndigits <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_131_digits.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- digits\n if(!identical(candidate(5), 5)){quit('no', 1)}\n if(!identical(candidate(54), 5)){quit('no', 1)}\n if(!identical(candidate(120), 1)){quit('no', 1)}\n if(!identical(candidate(5014), 5)){quit('no', 1)}\n if(!identical(candidate(98765), 315)){quit('no', 1)}\n if(!identical(candidate(5576543), 2625)){quit('no', 1)}\n if(!identical(candidate(2468), 0)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_153_Strongest_Extension", |
|
"language": "r", |
|
"prompt": "# 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# for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'\nStrongest_Extension <- function(class_name, extensions) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_153_Strongest_Extension.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- Strongest_Extension\n if(!identical(candidate('Watashi', c('tEN', 'niNE', 'eIGHt8OKe')), 'Watashi.eIGHt8OKe')){quit('no', 1)}\n if(!identical(candidate('Boku123', c('nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg')), 'Boku123.YEs.WeCaNe')){quit('no', 1)}\n if(!identical(candidate('__YESIMHERE', c('t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321')), '__YESIMHERE.NuLl__')){quit('no', 1)}\n if(!identical(candidate('K', c('Ta', 'TAR', 't234An', 'cosSo')), 'K.TAR')){quit('no', 1)}\n if(!identical(candidate('__HAHA', c('Tab', '123', '781345', '-_-')), '__HAHA.123')){quit('no', 1)}\n if(!identical(candidate('YameRore', c('HhAas', 'okIWILL123', 'WorkOut', 'Fails', '-_-')), 'YameRore.okIWILL123')){quit('no', 1)}\n if(!identical(candidate('finNNalLLly', c('Die', 'NowW', 'Wow', 'WoW')), 'finNNalLLly.WoW')){quit('no', 1)}\n if(!identical(candidate('_', c('Bb', '91245')), '_.Bb')){quit('no', 1)}\n if(!identical(candidate('Sp', c('671235', 'Bb')), 'Sp.671235')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_111_histogram", |
|
"language": "r", |
|
"prompt": "# 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') == {'a': 1, 'b': 1, 'c': 1}\n# histogram('a b b a') == {'a': 2, 'b': 2}\n# histogram('a b c a b') == {'a': 2, 'b': 2}\n# histogram('b b b b a') == {'b': 4}\n# histogram('') == {}\nhistogram <- function(test) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_111_histogram.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- histogram\n if(!identical(candidate('a b b a'), list('a' = 2, 'b' = 2))){quit('no', 1)}\n if(!identical(candidate('a b c a b'), list('a' = 2, 'b' = 2))){quit('no', 1)}\n if(!identical(candidate('a b c d g'), list('a' = 1, 'b' = 1, 'c' = 1, 'd' = 1, 'g' = 1))){quit('no', 1)}\n if(!identical(candidate('r t g'), list('r' = 1, 't' = 1, 'g' = 1))){quit('no', 1)}\n if(!identical(candidate('b b b b a'), list('b' = 4))){quit('no', 1)}\n if(!identical(candidate('r t g'), list('r' = 1, 't' = 1, 'g' = 1))){quit('no', 1)}\n if(!identical(candidate(''), list())){quit('no', 1)}\n if(!identical(candidate('a'), list('a' = 1))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_43_pairs_sum_to_zero", |
|
"language": "r", |
|
"prompt": "# 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# >>> pairs_sum_to_zero([1, 3, 5, 0])\n# False\n# >>> pairs_sum_to_zero([1, 3, -2, 1])\n# False\n# >>> pairs_sum_to_zero([1, 2, 3, 7])\n# False\n# >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])\n# True\n# >>> pairs_sum_to_zero([1])\n# False\npairs_sum_to_zero <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_43_pairs_sum_to_zero.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- pairs_sum_to_zero\n if(!identical(candidate(c(1, 3, 5, 0)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 3, -2, 1)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 7)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(2, 4, -5, 3, 5, 7)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(-3, 9, -1, 3, 2, 30)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(-3, 9, -1, 3, 2, 31)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(-3, 9, -1, 4, 2, 30)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(-3, 9, -1, 4, 2, 31)), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_74_total_match", |
|
"language": "r", |
|
"prompt": "# 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# total_match([], []) \u279e []\n# total_match(['hi', 'admin'], ['hI', 'Hi']) \u279e ['hI', 'Hi']\n# total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) \u279e ['hi', 'admin']\n# total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) \u279e ['hI', 'hi', 'hi']\n# total_match(['4'], ['1', '2', '3', '4', '5']) \u279e ['4']\ntotal_match <- function(lst1, lst2) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_74_total_match.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- total_match\n if(!identical(candidate(c(), c()), list())){quit('no', 1)}\n if(!identical(candidate(c('hi', 'admin'), c('hi', 'hi')), list('hi', 'hi'))){quit('no', 1)}\n if(!identical(candidate(c('hi', 'admin'), c('hi', 'hi', 'admin', 'project')), list('hi', 'admin'))){quit('no', 1)}\n if(!identical(candidate(c('4'), c('1', '2', '3', '4', '5')), list('4'))){quit('no', 1)}\n if(!identical(candidate(c('hi', 'admin'), c('hI', 'Hi')), list('hI', 'Hi'))){quit('no', 1)}\n if(!identical(candidate(c('hi', 'admin'), c('hI', 'hi', 'hi')), list('hI', 'hi', 'hi'))){quit('no', 1)}\n if(!identical(candidate(c('hi', 'admin'), c('hI', 'hi', 'hii')), list('hi', 'admin'))){quit('no', 1)}\n if(!identical(candidate(c(), c('this')), list())){quit('no', 1)}\n if(!identical(candidate(c('this'), c()), list())){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_65_circular_shift", |
|
"language": "r", |
|
"prompt": "# 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# >>> circular_shift(12, 1)\n# \"21\"\n# >>> circular_shift(12, 2)\n# \"12\"\ncircular_shift <- function(x, shift) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_65_circular_shift.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- circular_shift\n if(!identical(candidate(100, 2), '001')){quit('no', 1)}\n if(!identical(candidate(12, 2), '12')){quit('no', 1)}\n if(!identical(candidate(97, 8), '79')){quit('no', 1)}\n if(!identical(candidate(12, 1), '21')){quit('no', 1)}\n if(!identical(candidate(11, 101), '11')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_57_monotonic", |
|
"language": "r", |
|
"prompt": "# Return True is list elements are monotonically increasing or decreasing.\n# >>> monotonic([1, 2, 4, 20])\n# True\n# >>> monotonic([1, 20, 4, 10])\n# False\n# >>> monotonic([4, 1, 0, -10])\n# True\nmonotonic <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_57_monotonic.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- monotonic\n if(!identical(candidate(c(1, 2, 4, 10)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 4, 20)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 20, 4, 10)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(4, 1, 0, -10)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(4, 1, 1, 0)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 2, 5, 60)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4, 5, 60)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(9, 9, 9, 9)), TRUE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_138_is_equal_to_sum_even", |
|
"language": "r", |
|
"prompt": "# Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers\n# Example\n# is_equal_to_sum_even(4) == False\n# is_equal_to_sum_even(6) == False\n# is_equal_to_sum_even(8) == True\nis_equal_to_sum_even <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_138_is_equal_to_sum_even.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- is_equal_to_sum_even\n if(!identical(candidate(4), FALSE)){quit('no', 1)}\n if(!identical(candidate(6), FALSE)){quit('no', 1)}\n if(!identical(candidate(8), TRUE)){quit('no', 1)}\n if(!identical(candidate(10), TRUE)){quit('no', 1)}\n if(!identical(candidate(11), FALSE)){quit('no', 1)}\n if(!identical(candidate(12), TRUE)){quit('no', 1)}\n if(!identical(candidate(13), FALSE)){quit('no', 1)}\n if(!identical(candidate(16), TRUE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_17_parse_music", |
|
"language": "r", |
|
"prompt": "# 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# >>> parse_music('o o| .| o| o| .| .| .| .| o o')\n# [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]\nparse_music <- function(music_string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_17_parse_music.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- parse_music\n if(!identical(candidate(''), list())){quit('no', 1)}\n if(!identical(candidate('o o o o'), list(4, 4, 4, 4))){quit('no', 1)}\n if(!identical(candidate('.| .| .| .|'), list(1, 1, 1, 1))){quit('no', 1)}\n if(!identical(candidate('o| o| .| .| o o o o'), list(2, 2, 1, 1, 4, 4, 4, 4))){quit('no', 1)}\n if(!identical(candidate('o| .| o| .| o o| o o|'), list(2, 1, 2, 1, 4, 2, 4, 2))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_142_sum_squares", |
|
"language": "r", |
|
"prompt": "# \"\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# For lst = [1,2,3] the output should be 6\n# For lst = [] the output should be 0\n# For lst = [-1,-5,2,-1,-5] the output should be -126\nsum_squares <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_142_sum_squares.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sum_squares\n if(!identical(candidate(c(1, 2, 3)), 6)){quit('no', 1)}\n if(!identical(candidate(c(1, 4, 9)), 14)){quit('no', 1)}\n if(!identical(candidate(c()), 0)){quit('no', 1)}\n if(!identical(candidate(c(1, 1, 1, 1, 1, 1, 1, 1, 1)), 9)){quit('no', 1)}\n if(!identical(candidate(c(-1, -1, -1, -1, -1, -1, -1, -1, -1)), -3)){quit('no', 1)}\n if(!identical(candidate(c(0)), 0)){quit('no', 1)}\n if(!identical(candidate(c(-1, -5, 2, -1, -5)), -126)){quit('no', 1)}\n if(!identical(candidate(c(-56, -99, 1, 0, -2)), 3030)){quit('no', 1)}\n if(!identical(candidate(c(-1, 0, 0, 0, 0, 0, 0, 0, -1)), 0)){quit('no', 1)}\n if(!identical(candidate(c(-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37)), -14196)){quit('no', 1)}\n if(!identical(candidate(c(-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10)), -1448)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_40_triples_sum_to_zero", |
|
"language": "r", |
|
"prompt": "# 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# >>> triples_sum_to_zero([1, 3, 5, 0])\n# False\n# >>> triples_sum_to_zero([1, 3, -2, 1])\n# True\n# >>> triples_sum_to_zero([1, 2, 3, 7])\n# False\n# >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])\n# True\n# >>> triples_sum_to_zero([1])\n# False\ntriples_sum_to_zero <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_40_triples_sum_to_zero.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- triples_sum_to_zero\n if(!identical(candidate(c(1, 3, 5, 0)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 3, 5, -1)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 3, -2, 1)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 7)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 5, 7)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(2, 4, -5, 3, 9, 7)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 3, 5, -100)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(100, 3, 5, -100)), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_56_correct_bracketing", |
|
"language": "r", |
|
"prompt": "# brackets is a string of \"<\" and \">\".\n# return True if every opening bracket has a corresponding closing bracket.\n# >>> correct_bracketing(\"<\")\n# False\n# >>> correct_bracketing(\"<>\")\n# True\n# >>> correct_bracketing(\"<<><>>\")\n# True\n# >>> correct_bracketing(\"><<>\")\n# False\ncorrect_bracketing <- function(brackets) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_56_correct_bracketing.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- correct_bracketing\n if(!identical(candidate('<>'), TRUE)){quit('no', 1)}\n if(!identical(candidate('<<><>>'), TRUE)){quit('no', 1)}\n if(!identical(candidate('<><><<><>><>'), TRUE)){quit('no', 1)}\n if(!identical(candidate('<><><<<><><>><>><<><><<>>>'), TRUE)){quit('no', 1)}\n if(!identical(candidate('<<<><>>>>'), FALSE)){quit('no', 1)}\n if(!identical(candidate('><<>'), FALSE)){quit('no', 1)}\n if(!identical(candidate('<'), FALSE)){quit('no', 1)}\n if(!identical(candidate('<<<<'), FALSE)){quit('no', 1)}\n if(!identical(candidate('>'), FALSE)){quit('no', 1)}\n if(!identical(candidate('<<>'), FALSE)){quit('no', 1)}\n if(!identical(candidate('<><><<><>><>><<>'), FALSE)){quit('no', 1)}\n if(!identical(candidate('<><><<><>><>>><>'), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_146_specialFilter", |
|
"language": "r", |
|
"prompt": "# Write a function that takes an array of numbers as input and returns \n# the number of elements in the array 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([15, -73, 14, -15]) => 1 \n# specialFilter([33, -2, -3, 45, 21, 109]) => 2\nspecialFilter <- function(nums) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_146_specialFilter.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- specialFilter\n if(!identical(candidate(c(5, -2, 1, -5)), 0)){quit('no', 1)}\n if(!identical(candidate(c(15, -73, 14, -15)), 1)){quit('no', 1)}\n if(!identical(candidate(c(33, -2, -3, 45, 21, 109)), 2)){quit('no', 1)}\n if(!identical(candidate(c(43, -12, 93, 125, 121, 109)), 4)){quit('no', 1)}\n if(!identical(candidate(c(71, -2, -33, 75, 21, 19)), 3)){quit('no', 1)}\n if(!identical(candidate(c(1)), 0)){quit('no', 1)}\n if(!identical(candidate(c()), 0)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_95_check_dict_case", |
|
"language": "r", |
|
"prompt": "# 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# check_dict_case({\"a\":\"apple\", \"b\":\"banana\"}) should return True.\n# check_dict_case({\"a\":\"apple\", \"A\":\"banana\", \"B\":\"banana\"}) should return False.\n# check_dict_case({\"a\":\"apple\", \"8\":\"banana\", \"a\":\"apple\"}) should return False.\n# check_dict_case({\"Name\":\"John\", \"Age\":\"36\", \"City\":\"Houston\"}) should return False.\n# check_dict_case({\"STATE\":\"NC\", \"ZIP\":\"12345\" }) should return True.\ncheck_dict_case <- function(dict) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_95_check_dict_case.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- check_dict_case\n if(!identical(candidate(list('p' = 'pineapple', 'b' = 'banana')), TRUE)){quit('no', 1)}\n if(!identical(candidate(list('p' = 'pineapple', 'A' = 'banana', 'B' = 'banana')), FALSE)){quit('no', 1)}\n if(!identical(candidate(list('p' = 'pineapple', '5' = 'banana', 'a' = 'apple')), FALSE)){quit('no', 1)}\n if(!identical(candidate(list('Name' = 'John', 'Age' = '36', 'City' = 'Houston')), FALSE)){quit('no', 1)}\n if(!identical(candidate(list('STATE' = 'NC', 'ZIP' = '12345')), TRUE)){quit('no', 1)}\n if(!identical(candidate(list('fruit' = 'Orange', 'taste' = 'Sweet')), TRUE)){quit('no', 1)}\n if(!identical(candidate(list()), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_125_split_words", |
|
"language": "r", |
|
"prompt": "# Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you\n# should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the\n# alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25\n# Examples\n# split_words(\"Hello world!\") \u279e [\"Hello\", \"world!\"]\n# split_words(\"Hello,world!\") \u279e [\"Hello\", \"world!\"]\n# split_words(\"abcdef\") == 3\nsplit_words <- function(txt) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_125_split_words.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- split_words\n if(!identical(candidate('Hello world!'), list('Hello', 'world!'))){quit('no', 1)}\n if(!identical(candidate('Hello,world!'), list('Hello', 'world!'))){quit('no', 1)}\n if(!identical(candidate('Hello world,!'), list('Hello', 'world,!'))){quit('no', 1)}\n if(!identical(candidate('Hello,Hello,world !'), list('Hello,Hello,world', '!'))){quit('no', 1)}\n if(!identical(candidate('abcdef'), 3)){quit('no', 1)}\n if(!identical(candidate('aaabb'), 2)){quit('no', 1)}\n if(!identical(candidate('aaaBb'), 1)){quit('no', 1)}\n if(!identical(candidate(''), 0)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_63_fibfib", |
|
"language": "r", |
|
"prompt": "# 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(1)\n# 0\n# >>> fibfib(5)\n# 4\n# >>> fibfib(8)\n# 24\nfibfib <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_63_fibfib.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- fibfib\n if(!identical(candidate(2), 1)){quit('no', 1)}\n if(!identical(candidate(1), 0)){quit('no', 1)}\n if(!identical(candidate(5), 4)){quit('no', 1)}\n if(!identical(candidate(8), 24)){quit('no', 1)}\n if(!identical(candidate(10), 81)){quit('no', 1)}\n if(!identical(candidate(12), 274)){quit('no', 1)}\n if(!identical(candidate(14), 927)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_133_sum_squares", |
|
"language": "r", |
|
"prompt": "# 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# For lst = [1,2,3] the output should be 14\n# For lst = [1,4,9] the output should be 98\n# For lst = [1,3,5,7] the output should be 84\n# For lst = [1.4,4.2,0] the output should be 29\n# For lst = [-2.4,1,1] the output should be 6\nsum_squares <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_133_sum_squares.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sum_squares\n if(!identical(candidate(c(1.0, 2.0, 3.0)), 14)){quit('no', 1)}\n if(!identical(candidate(c(1.0, 2.0, 3.0)), 14)){quit('no', 1)}\n if(!identical(candidate(c(1.0, 3.0, 5.0, 7.0)), 84)){quit('no', 1)}\n if(!identical(candidate(c(1.4, 4.2, 0.0)), 29)){quit('no', 1)}\n if(!identical(candidate(c(-2.4, 1.0, 1.0)), 6)){quit('no', 1)}\n if(!identical(candidate(c(100.0, 1.0, 15.0, 2.0)), 10230)){quit('no', 1)}\n if(!identical(candidate(c(10000.0, 10000.0)), 200000000)){quit('no', 1)}\n if(!identical(candidate(c(-1.4, 4.6, 6.3)), 75)){quit('no', 1)}\n if(!identical(candidate(c(-1.4, 17.9, 18.9, 19.9)), 1086)){quit('no', 1)}\n if(!identical(candidate(c(0.0)), 0)){quit('no', 1)}\n if(!identical(candidate(c(-1.0)), 1)){quit('no', 1)}\n if(!identical(candidate(c(-1.0, 1.0, 0.0)), 2)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_85_add", |
|
"language": "r", |
|
"prompt": "# Given a non-empty list of integers lst. add the even elements that are at odd indices..\n# Examples:\n# add([4, 2, 6, 7]) ==> 2\nadd <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_85_add.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- add\n if(!identical(candidate(c(4, 88)), 88)){quit('no', 1)}\n if(!identical(candidate(c(4, 5, 6, 7, 2, 122)), 122)){quit('no', 1)}\n if(!identical(candidate(c(4, 0, 6, 7)), 0)){quit('no', 1)}\n if(!identical(candidate(c(4, 4, 6, 8)), 12)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_34_unique", |
|
"language": "r", |
|
"prompt": "# Return sorted unique elements in a list\n# >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])\n# [0, 2, 3, 5, 9, 123]\nunique <- function(l) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_34_unique.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- unique\n if(!identical(candidate(c(5, 3, 5, 2, 3, 3, 9, 0, 123)), list(0, 2, 3, 5, 9, 123))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_140_fix_spaces", |
|
"language": "r", |
|
"prompt": "# 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# fix_spaces(\"Example\") == \"Example\"\n# fix_spaces(\"Example 1\") == \"Example_1\"\n# fix_spaces(\" Example 2\") == \"_Example_2\"\n# fix_spaces(\" Example 3\") == \"_Example-3\"\nfix_spaces <- function(text) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_140_fix_spaces.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- fix_spaces\n if(!identical(candidate('Example'), 'Example')){quit('no', 1)}\n if(!identical(candidate('Mudasir Hanif '), 'Mudasir_Hanif_')){quit('no', 1)}\n if(!identical(candidate('Yellow Yellow Dirty Fellow'), 'Yellow_Yellow__Dirty__Fellow')){quit('no', 1)}\n if(!identical(candidate('Exa mple'), 'Exa-mple')){quit('no', 1)}\n if(!identical(candidate(' Exa 1 2 2 mple'), '-Exa_1_2_2_mple')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_49_modp", |
|
"language": "r", |
|
"prompt": "# Return 2^n modulo p (be aware of numerics).\n# >>> modp(3, 5)\n# 3\n# >>> modp(1101, 101)\n# 2\n# >>> modp(0, 101)\n# 1\n# >>> modp(3, 11)\n# 8\n# >>> modp(100, 101)\n# 1\nmodp <- function(n, p) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_49_modp.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- modp\n if(!identical(candidate(3, 5), 3)){quit('no', 1)}\n if(!identical(candidate(1101, 101), 2)){quit('no', 1)}\n if(!identical(candidate(0, 101), 1)){quit('no', 1)}\n if(!identical(candidate(3, 11), 8)){quit('no', 1)}\n if(!identical(candidate(100, 101), 1)){quit('no', 1)}\n if(!identical(candidate(30, 5), 4)){quit('no', 1)}\n if(!identical(candidate(31, 5), 3)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_124_valid_date", |
|
"language": "r", |
|
"prompt": "# 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# for example: \n# valid_date('03-11-2000') => True\n# valid_date('15-01-2012') => False\n# valid_date('04-0-2040') => False\n# valid_date('06-04-2020') => True\n# valid_date('06/04/2020') => False\nvalid_date <- function(date) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_124_valid_date.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- valid_date\n if(!identical(candidate('03-11-2000'), TRUE)){quit('no', 1)}\n if(!identical(candidate('15-01-2012'), FALSE)){quit('no', 1)}\n if(!identical(candidate('04-0-2040'), FALSE)){quit('no', 1)}\n if(!identical(candidate('06-04-2020'), TRUE)){quit('no', 1)}\n if(!identical(candidate('01-01-2007'), TRUE)){quit('no', 1)}\n if(!identical(candidate('03-32-2011'), FALSE)){quit('no', 1)}\n if(!identical(candidate(''), FALSE)){quit('no', 1)}\n if(!identical(candidate('04-31-3000'), FALSE)){quit('no', 1)}\n if(!identical(candidate('06-06-2005'), TRUE)){quit('no', 1)}\n if(!identical(candidate('21-31-2000'), FALSE)){quit('no', 1)}\n if(!identical(candidate('04-12-2003'), TRUE)){quit('no', 1)}\n if(!identical(candidate('04122003'), FALSE)){quit('no', 1)}\n if(!identical(candidate('20030412'), FALSE)){quit('no', 1)}\n if(!identical(candidate('2003-04'), FALSE)){quit('no', 1)}\n if(!identical(candidate('2003-04-12'), FALSE)){quit('no', 1)}\n if(!identical(candidate('04-2003'), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_86_anti_shuffle", |
|
"language": "r", |
|
"prompt": "# 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# anti_shuffle('Hi') returns 'Hi'\n# anti_shuffle('hello') returns 'ehllo'\n# anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'\nanti_shuffle <- function(s) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_86_anti_shuffle.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- anti_shuffle\n if(!identical(candidate('Hi'), 'Hi')){quit('no', 1)}\n if(!identical(candidate('hello'), 'ehllo')){quit('no', 1)}\n if(!identical(candidate('number'), 'bemnru')){quit('no', 1)}\n if(!identical(candidate('abcd'), 'abcd')){quit('no', 1)}\n if(!identical(candidate('Hello World!!!'), 'Hello !!!Wdlor')){quit('no', 1)}\n if(!identical(candidate(''), '')){quit('no', 1)}\n if(!identical(candidate('Hi. My name is Mister Robot. How are you?'), '.Hi My aemn is Meirst .Rboot How aer ?ouy')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_126_is_sorted", |
|
"language": "r", |
|
"prompt": "# 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# is_sorted([5]) \u279e True\n# is_sorted([1, 2, 3, 4, 5]) \u279e True\n# is_sorted([1, 3, 2, 4, 5]) \u279e False\n# is_sorted([1, 2, 3, 4, 5, 6]) \u279e True\n# is_sorted([1, 2, 3, 4, 5, 6, 7]) \u279e True\n# is_sorted([1, 3, 2, 4, 5, 6, 7]) \u279e False\n# is_sorted([1, 2, 2, 3, 3, 4]) \u279e True\n# is_sorted([1, 2, 2, 2, 3, 4]) \u279e False\nis_sorted <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_126_is_sorted.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- is_sorted\n if(!identical(candidate(c(5)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4, 5)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 3, 2, 4, 5)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4, 5, 6)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4, 5, 6, 7)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 3, 2, 4, 5, 6, 7)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c()), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(3, 2, 1)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 2, 2, 3, 4)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 3, 3, 4)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 2, 3, 3, 4)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4)), TRUE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_80_is_happy", |
|
"language": "r", |
|
"prompt": "# You are given a string s.\n# Your task is to check if the string is happy or not.\n# A string is happy if its length is at least 3 and every 3 consecutive letters are distinct\n# For example:\n# is_happy(a) => False\n# is_happy(aa) => False\n# is_happy(abcd) => True\n# is_happy(aabb) => False\n# is_happy(adb) => True\n# is_happy(xyy) => False\nis_happy <- function(s) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_80_is_happy.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- is_happy\n if(!identical(candidate('a'), FALSE)){quit('no', 1)}\n if(!identical(candidate('aa'), FALSE)){quit('no', 1)}\n if(!identical(candidate('abcd'), TRUE)){quit('no', 1)}\n if(!identical(candidate('aabb'), FALSE)){quit('no', 1)}\n if(!identical(candidate('adb'), TRUE)){quit('no', 1)}\n if(!identical(candidate('xyy'), FALSE)){quit('no', 1)}\n if(!identical(candidate('iopaxpoi'), TRUE)){quit('no', 1)}\n if(!identical(candidate('iopaxioi'), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_72_will_it_fly", |
|
"language": "r", |
|
"prompt": "# 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# will_it_fly([1, 2], 5) \u279e False \n# # 1+2 is less than the maximum possible weight, but it's unbalanced.\n# will_it_fly([3, 2, 3], 1) \u279e False\n# # it's balanced, but 3+2+3 is more than the maximum possible weight.\n# will_it_fly([3, 2, 3], 9) \u279e True\n# # 3+2+3 is less than the maximum possible weight, and it's balanced.\n# will_it_fly([3], 5) \u279e True\n# # 3 is less than the maximum possible weight, and it's balanced.\nwill_it_fly <- function(q, w) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_72_will_it_fly.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- will_it_fly\n if(!identical(candidate(c(3, 2, 3), 9), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2), 5), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(3), 5), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(3, 2, 3), 1), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3), 6), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(5), 5), TRUE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_88_sort_array", |
|
"language": "r", |
|
"prompt": "# Given an array of non-negative integers, return a copy of the given array after sorting,\n# you will sort the given array 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 array.\n# Examples:\n# * sort_array([]) => []\n# * sort_array([5]) => [5]\n# * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]\n# * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]\nsort_array <- function(array) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_88_sort_array.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sort_array\n if(!identical(candidate(c()), list())){quit('no', 1)}\n if(!identical(candidate(c(5)), list(5))){quit('no', 1)}\n if(!identical(candidate(c(2, 4, 3, 0, 1, 5)), list(0, 1, 2, 3, 4, 5))){quit('no', 1)}\n if(!identical(candidate(c(2, 4, 3, 0, 1, 5, 6)), list(6, 5, 4, 3, 2, 1, 0))){quit('no', 1)}\n if(!identical(candidate(c(2, 1)), list(1, 2))){quit('no', 1)}\n if(!identical(candidate(c(15, 42, 87, 32, 11, 0)), list(0, 11, 15, 32, 42, 87))){quit('no', 1)}\n if(!identical(candidate(c(21, 14, 23, 11)), list(23, 21, 14, 11))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_96_count_up_to", |
|
"language": "r", |
|
"prompt": "# Implement a function that takes an non-negative integer and returns an array of the first n\n# integers that are prime numbers and less than n.\n# for example:\n# count_up_to(5) => [2,3]\n# count_up_to(11) => [2,3,5,7]\n# count_up_to(0) => []\n# count_up_to(20) => [2,3,5,7,11,13,17,19]\n# count_up_to(1) => []\n# count_up_to(18) => [2,3,5,7,11,13,17]\ncount_up_to <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_96_count_up_to.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- count_up_to\n if(!identical(candidate(5), list(2, 3))){quit('no', 1)}\n if(!identical(candidate(6), list(2, 3, 5))){quit('no', 1)}\n if(!identical(candidate(7), list(2, 3, 5))){quit('no', 1)}\n if(!identical(candidate(10), list(2, 3, 5, 7))){quit('no', 1)}\n if(!identical(candidate(0), list())){quit('no', 1)}\n if(!identical(candidate(22), list(2, 3, 5, 7, 11, 13, 17, 19))){quit('no', 1)}\n if(!identical(candidate(1), list())){quit('no', 1)}\n if(!identical(candidate(18), list(2, 3, 5, 7, 11, 13, 17))){quit('no', 1)}\n if(!identical(candidate(47), list(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43))){quit('no', 1)}\n if(!identical(candidate(101), list(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_12_longest", |
|
"language": "r", |
|
"prompt": "# Out of list of strings, return the longest one. Return the first one in case of multiple\n# strings of the same length. Return None in case the input list is empty.\n# >>> longest([])\n# >>> longest(['a', 'b', 'c'])\n# 'a'\n# >>> longest(['a', 'bb', 'ccc'])\n# 'ccc'\nlongest <- function(strings) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_12_longest.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- longest\n if(!identical(candidate(c()), NULL)){quit('no', 1)}\n if(!identical(candidate(c('x', 'y', 'z')), 'x')){quit('no', 1)}\n if(!identical(candidate(c('x', 'yyy', 'zzzz', 'www', 'kkkk', 'abc')), 'zzzz')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_105_by_length", |
|
"language": "r", |
|
"prompt": "# Given an array of integers, sort the integers that are between 1 and 9 inclusive,\n# reverse the resulting array, and then replace each digit by its corresponding name from\n# \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\".\n# For example:\n# arr = [2, 1, 1, 4, 5, 8, 2, 3] \n# -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] \n# -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]\n# return [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n# If the array is empty, return an empty array:\n# arr = []\n# return []\n# If the array has any strange number ignore it:\n# arr = [1, -1 , 55] \n# -> sort arr -> [-1, 1, 55]\n# -> reverse arr -> [55, 1, -1]\n# return = ['One']\nby_length <- function(arr) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_105_by_length.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- by_length\n if(!identical(candidate(c(2, 1, 1, 4, 5, 8, 2, 3)), list('Eight', 'Five', 'Four', 'Three', 'Two', 'Two', 'One', 'One'))){quit('no', 1)}\n if(!identical(candidate(c()), list())){quit('no', 1)}\n if(!identical(candidate(c(1, -1, 55)), list('One'))){quit('no', 1)}\n if(!identical(candidate(c(1, -1, 3, 2)), list('Three', 'Two', 'One'))){quit('no', 1)}\n if(!identical(candidate(c(9, 4, 8)), list('Nine', 'Eight', 'Four'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_106_f", |
|
"language": "r", |
|
"prompt": "# 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(5) == [1, 2, 6, 24, 15]\nf <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_106_f.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- f\n if(!identical(candidate(5), list(1, 2, 6, 24, 15))){quit('no', 1)}\n if(!identical(candidate(7), list(1, 2, 6, 24, 15, 720, 28))){quit('no', 1)}\n if(!identical(candidate(1), list(1))){quit('no', 1)}\n if(!identical(candidate(3), list(1, 2, 6))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_36_fizz_buzz", |
|
"language": "r", |
|
"prompt": "# Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.\n# >>> fizz_buzz(50)\n# 0\n# >>> fizz_buzz(78)\n# 2\n# >>> fizz_buzz(79)\n# 3\nfizz_buzz <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_36_fizz_buzz.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- fizz_buzz\n if(!identical(candidate(50), 0)){quit('no', 1)}\n if(!identical(candidate(78), 2)){quit('no', 1)}\n if(!identical(candidate(79), 3)){quit('no', 1)}\n if(!identical(candidate(100), 3)){quit('no', 1)}\n if(!identical(candidate(200), 6)){quit('no', 1)}\n if(!identical(candidate(4000), 192)){quit('no', 1)}\n if(!identical(candidate(10000), 639)){quit('no', 1)}\n if(!identical(candidate(100000), 8026)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_2_truncate_number", |
|
"language": "r", |
|
"prompt": "# 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# >>> truncate_number(3.5)\n# 0.5\ntruncate_number <- function(number) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_2_truncate_number.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- truncate_number\n if(!identical(candidate(3.5), 0.5)){quit('no', 1)}\n if(!identical(candidate(1.25), 0.25)){quit('no', 1)}\n if(!identical(candidate(123.0), 0.0)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_8_sum_product", |
|
"language": "r", |
|
"prompt": "# 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# >>> sum_product([])\n# (0, 1)\n# >>> sum_product([1, 2, 3, 4])\n# (10, 24)\nsum_product <- function(numbers) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_8_sum_product.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- sum_product\n if(!identical(candidate(c()), list(0, 1))){quit('no', 1)}\n if(!identical(candidate(c(1, 1, 1)), list(3, 1))){quit('no', 1)}\n if(!identical(candidate(c(100, 0)), list(100, 0))){quit('no', 1)}\n if(!identical(candidate(c(3, 5, 7)), list(15, 105))){quit('no', 1)}\n if(!identical(candidate(c(10)), list(10, 10))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_87_get_row", |
|
"language": "r", |
|
"prompt": "# 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# get_row([\n# [1,2,3,4,5,6],\n# [1,2,3,4,1,6],\n# [1,2,3,4,5,1]\n# ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]\n# get_row([], 1) == []\n# get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]\nget_row <- function(lst, x) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_87_get_row.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- get_row\n if(!identical(candidate(list(list(1, 2, 3, 4, 5, 6), list(1, 2, 3, 4, 1, 6), list(1, 2, 3, 4, 5, 1)), 1), list(list(0, 0), list(1, 4), list(1, 0), list(2, 5), list(2, 0)))){quit('no', 1)}\n if(!identical(candidate(list(list(1, 2, 3, 4, 5, 6), list(1, 2, 3, 4, 5, 6), list(1, 2, 3, 4, 5, 6), list(1, 2, 3, 4, 5, 6), list(1, 2, 3, 4, 5, 6), list(1, 2, 3, 4, 5, 6)), 2), list(list(0, 1), list(1, 1), list(2, 1), list(3, 1), list(4, 1), list(5, 1)))){quit('no', 1)}\n if(!identical(candidate(list(list(1, 2, 3, 4, 5, 6), list(1, 2, 3, 4, 5, 6), list(1, 1, 3, 4, 5, 6), list(1, 2, 1, 4, 5, 6), list(1, 2, 3, 1, 5, 6), list(1, 2, 3, 4, 1, 6), list(1, 2, 3, 4, 5, 1)), 1), list(list(0, 0), list(1, 0), list(2, 1), list(2, 0), list(3, 2), list(3, 0), list(4, 3), list(4, 0), list(5, 4), list(5, 0), list(6, 5), list(6, 0)))){quit('no', 1)}\n if(!identical(candidate(list(), 1), list())){quit('no', 1)}\n if(!identical(candidate(list(list(1)), 2), list())){quit('no', 1)}\n if(!identical(candidate(list(list(), list(1), list(1, 2, 3)), 3), list(list(2, 2)))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_159_eat", |
|
"language": "r", |
|
"prompt": "# 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 an array 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(5, 6, 10) -> [11, 4]\n# * eat(4, 8, 9) -> [12, 1]\n# * eat(1, 10, 10) -> [11, 0]\n# * eat(2, 11, 5) -> [7, 0]\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 :)\neat <- function(number, need, remaining) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_159_eat.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- eat\n if(!identical(candidate(5, 6, 10), list(11, 4))){quit('no', 1)}\n if(!identical(candidate(4, 8, 9), list(12, 1))){quit('no', 1)}\n if(!identical(candidate(1, 10, 10), list(11, 0))){quit('no', 1)}\n if(!identical(candidate(2, 11, 5), list(7, 0))){quit('no', 1)}\n if(!identical(candidate(4, 5, 7), list(9, 2))){quit('no', 1)}\n if(!identical(candidate(4, 5, 1), list(5, 0))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_84_solve", |
|
"language": "r", |
|
"prompt": "# Given a positive integer N, return the total sum of its digits in binary.\n# Example\n# For N = 1000, the sum of digits will be 1 the output should be \"1\".\n# For N = 150, the sum of digits will be 6 the output should be \"110\".\n# For N = 147, the sum of digits will be 12 the output should be \"1100\".\n# Variables:\n# @N integer\n# Constraints: 0 \u2264 N \u2264 10000.\n# Output:\n# a string of binary number\nsolve <- function(N) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_84_solve.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- solve\n if(!identical(candidate(1000), '1')){quit('no', 1)}\n if(!identical(candidate(150), '110')){quit('no', 1)}\n if(!identical(candidate(147), '1100')){quit('no', 1)}\n if(!identical(candidate(333), '1001')){quit('no', 1)}\n if(!identical(candidate(963), '10010')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_94_skjkasdkd", |
|
"language": "r", |
|
"prompt": "# 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# For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10\n# For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25\n# For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13\n# For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11\n# For lst = [0,81,12,3,1,21] the output should be 3\n# For lst = [0,8,1,2,1,7] the output should be 7\nskjkasdkd <- function(lst) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_94_skjkasdkd.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- skjkasdkd\n if(!identical(candidate(c(0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3)), 10)){quit('no', 1)}\n if(!identical(candidate(c(1, 0, 1, 8, 2, 4597, 2, 1, 3, 40, 1, 2, 1, 2, 4, 2, 5, 1)), 25)){quit('no', 1)}\n if(!identical(candidate(c(1, 3, 1, 32, 5107, 34, 83278, 109, 163, 23, 2323, 32, 30, 1, 9, 3)), 13)){quit('no', 1)}\n if(!identical(candidate(c(0, 724, 32, 71, 99, 32, 6, 0, 5, 91, 83, 0, 5, 6)), 11)){quit('no', 1)}\n if(!identical(candidate(c(0, 81, 12, 3, 1, 21)), 3)){quit('no', 1)}\n if(!identical(candidate(c(0, 8, 1, 2, 1, 7)), 7)){quit('no', 1)}\n if(!identical(candidate(c(8191)), 19)){quit('no', 1)}\n if(!identical(candidate(c(8191, 123456, 127, 7)), 19)){quit('no', 1)}\n if(!identical(candidate(c(127, 97, 8192)), 10)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_73_smallest_change", |
|
"language": "r", |
|
"prompt": "# Given an array arr of integers, find the minimum number of elements that\n# need to be changed to make the array palindromic. A palindromic array is an array 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# smallest_change([1,2,3,5,4,7,9,6]) == 4\n# smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1\n# smallest_change([1, 2, 3, 2, 1]) == 0\nsmallest_change <- function(arr) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_73_smallest_change.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- smallest_change\n if(!identical(candidate(c(1, 2, 3, 5, 4, 7, 9, 6)), 4)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 4, 3, 2, 2)), 1)){quit('no', 1)}\n if(!identical(candidate(c(1, 4, 2)), 1)){quit('no', 1)}\n if(!identical(candidate(c(1, 4, 4, 2)), 1)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, 3, 2, 1)), 0)){quit('no', 1)}\n if(!identical(candidate(c(3, 1, 1, 3)), 0)){quit('no', 1)}\n if(!identical(candidate(c(1)), 0)){quit('no', 1)}\n if(!identical(candidate(c(0, 1)), 1)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_81_numerical_letter_grade", |
|
"language": "r", |
|
"prompt": "# 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# grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']\nnumerical_letter_grade <- function(grades) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_81_numerical_letter_grade.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- numerical_letter_grade\n if(!identical(candidate(c(4.0, 3, 1.7, 2, 3.5)), list('A+', 'B', 'C-', 'C', 'A-'))){quit('no', 1)}\n if(!identical(candidate(c(1.2)), list('D+'))){quit('no', 1)}\n if(!identical(candidate(c(0.5)), list('D-'))){quit('no', 1)}\n if(!identical(candidate(c(0.0)), list('E'))){quit('no', 1)}\n if(!identical(candidate(c(1.0, 0.3, 1.5, 2.8, 3.3)), list('D', 'D-', 'C-', 'B', 'B+'))){quit('no', 1)}\n if(!identical(candidate(c(0.0, 0.7)), list('E', 'D-'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_71_triangle_area", |
|
"language": "r", |
|
"prompt": "# 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# triangle_area(3, 4, 5) == 6.00\n# triangle_area(1, 2, 10) == -1\ntriangle_area <- function(a, b, c) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_71_triangle_area.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- triangle_area\n if(!identical(candidate(3, 4, 5), 6.0)){quit('no', 1)}\n if(!identical(candidate(1, 2, 10), -1)){quit('no', 1)}\n if(!identical(candidate(4, 8, 5), 8.18)){quit('no', 1)}\n if(!identical(candidate(2, 2, 2), 1.73)){quit('no', 1)}\n if(!identical(candidate(1, 2, 3), -1)){quit('no', 1)}\n if(!identical(candidate(10, 5, 7), 16.25)){quit('no', 1)}\n if(!identical(candidate(2, 6, 3), -1)){quit('no', 1)}\n if(!identical(candidate(1, 1, 1), 0.43)){quit('no', 1)}\n if(!identical(candidate(2, 2, 10), -1)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_54_same_chars", |
|
"language": "r", |
|
"prompt": "# Check if two words have the same characters.\n# >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')\n# True\n# >>> same_chars('abcd', 'dddddddabc')\n# True\n# >>> same_chars('dddddddabc', 'abcd')\n# True\n# >>> same_chars('eabcd', 'dddddddabc')\n# False\n# >>> same_chars('abcd', 'dddddddabce')\n# False\n# >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')\n# False\nsame_chars <- function(s0, s1) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_54_same_chars.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- same_chars\n if(!identical(candidate('eabcdzzzz', 'dddzzzzzzzddeddabc'), TRUE)){quit('no', 1)}\n if(!identical(candidate('abcd', 'dddddddabc'), TRUE)){quit('no', 1)}\n if(!identical(candidate('dddddddabc', 'abcd'), TRUE)){quit('no', 1)}\n if(!identical(candidate('eabcd', 'dddddddabc'), FALSE)){quit('no', 1)}\n if(!identical(candidate('abcd', 'dddddddabcf'), FALSE)){quit('no', 1)}\n if(!identical(candidate('eabcdzzzz', 'dddzzzzzzzddddabc'), FALSE)){quit('no', 1)}\n if(!identical(candidate('aabb', 'aaccc'), FALSE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_114_minSubArraySum", |
|
"language": "r", |
|
"prompt": "# Given an array of integers nums, find the minimum sum of any non-empty sub-array\n# of nums.\n# Example\n# minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n# minSubArraySum([-1, -2, -3]) == -6\nminSubArraySum <- function(nums) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_114_minSubArraySum.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- minSubArraySum\n if(!identical(candidate(c(2, 3, 4, 1, 2, 4)), 1)){quit('no', 1)}\n if(!identical(candidate(c(-1, -2, -3)), -6)){quit('no', 1)}\n if(!identical(candidate(c(-1, -2, -3, 2, -10)), -14)){quit('no', 1)}\n if(!identical(candidate(c(-9999999999999999)), -9999999999999999)){quit('no', 1)}\n if(!identical(candidate(c(0, 10, 20, 1000000)), 0)){quit('no', 1)}\n if(!identical(candidate(c(-1, -2, -3, 10, -5)), -6)){quit('no', 1)}\n if(!identical(candidate(c(100, -1, -2, -3, 10, -5)), -6)){quit('no', 1)}\n if(!identical(candidate(c(10, 11, 13, 8, 3, 4)), 3)){quit('no', 1)}\n if(!identical(candidate(c(100, -33, 32, -1, 0, -2)), -33)){quit('no', 1)}\n if(!identical(candidate(c(-10)), -10)){quit('no', 1)}\n if(!identical(candidate(c(7)), 7)){quit('no', 1)}\n if(!identical(candidate(c(1, -1)), -1)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_117_select_words", |
|
"language": "r", |
|
"prompt": "# 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# select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n# select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n# select_words(\"simple white space\", 2) ==> []\n# select_words(\"Hello world\", 4) ==> [\"world\"]\n# select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\nselect_words <- function(s, n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_117_select_words.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- select_words\n if(!identical(candidate('Mary had a little lamb', 4), list('little'))){quit('no', 1)}\n if(!identical(candidate('Mary had a little lamb', 3), list('Mary', 'lamb'))){quit('no', 1)}\n if(!identical(candidate('simple white space', 2), list())){quit('no', 1)}\n if(!identical(candidate('Hello world', 4), list('world'))){quit('no', 1)}\n if(!identical(candidate('Uncle sam', 3), list('Uncle'))){quit('no', 1)}\n if(!identical(candidate('', 4), list())){quit('no', 1)}\n if(!identical(candidate('a b c d e f', 1), list('b', 'c', 'd', 'f'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_14_all_prefixes", |
|
"language": "r", |
|
"prompt": "# Return list of all prefixes from shortest to longest of the input string\n# >>> all_prefixes('abc')\n# ['a', 'ab', 'abc']\nall_prefixes <- function(string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_14_all_prefixes.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- all_prefixes\n if(!identical(candidate(''), list())){quit('no', 1)}\n if(!identical(candidate('asdfgh'), list('a', 'as', 'asd', 'asdf', 'asdfg', 'asdfgh'))){quit('no', 1)}\n if(!identical(candidate('WWW'), list('W', 'WW', 'WWW'))){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_99_closest_integer", |
|
"language": "r", |
|
"prompt": "# 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# >>> closest_integer(\"10\")\n# 10\n# >>> closest_integer(\"15.3\")\n# 15\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.\nclosest_integer <- function(value) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_99_closest_integer.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- closest_integer\n if(!identical(candidate('10'), 10)){quit('no', 1)}\n if(!identical(candidate('14.5'), 15)){quit('no', 1)}\n if(!identical(candidate('-15.5'), -16)){quit('no', 1)}\n if(!identical(candidate('15.3'), 15)){quit('no', 1)}\n if(!identical(candidate('0'), 0)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_141_file_name_check", |
|
"language": "r", |
|
"prompt": "# 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# file_name_check(\"example.txt\") # => 'Yes'\n# file_name_check(\"1example.dll\") # => 'No' (the name should start with a latin alphapet letter)\nfile_name_check <- function(file_name) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_141_file_name_check.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- file_name_check\n if(!identical(candidate('example.txt'), 'Yes')){quit('no', 1)}\n if(!identical(candidate('1example.dll'), 'No')){quit('no', 1)}\n if(!identical(candidate('s1sdf3.asd'), 'No')){quit('no', 1)}\n if(!identical(candidate('K.dll'), 'Yes')){quit('no', 1)}\n if(!identical(candidate('MY16FILE3.exe'), 'Yes')){quit('no', 1)}\n if(!identical(candidate('His12FILE94.exe'), 'No')){quit('no', 1)}\n if(!identical(candidate('_Y.txt'), 'No')){quit('no', 1)}\n if(!identical(candidate('?aREYA.exe'), 'No')){quit('no', 1)}\n if(!identical(candidate('/this_is_valid.dll'), 'No')){quit('no', 1)}\n if(!identical(candidate('this_is_valid.wow'), 'No')){quit('no', 1)}\n if(!identical(candidate('this_is_valid.txt'), 'Yes')){quit('no', 1)}\n if(!identical(candidate('this_is_valid.txtexe'), 'No')){quit('no', 1)}\n if(!identical(candidate('#this2_i4s_5valid.ten'), 'No')){quit('no', 1)}\n if(!identical(candidate('@this1_is6_valid.exe'), 'No')){quit('no', 1)}\n if(!identical(candidate('this_is_12valid.6exe4.txt'), 'No')){quit('no', 1)}\n if(!identical(candidate('all.exe.txt'), 'No')){quit('no', 1)}\n if(!identical(candidate('I563_No.exe'), 'Yes')){quit('no', 1)}\n if(!identical(candidate('Is3youfault.txt'), 'Yes')){quit('no', 1)}\n if(!identical(candidate('no_one#knows.dll'), 'Yes')){quit('no', 1)}\n if(!identical(candidate('1I563_Yes3.exe'), 'No')){quit('no', 1)}\n if(!identical(candidate('I563_Yes3.txtt'), 'No')){quit('no', 1)}\n if(!identical(candidate('final..txt'), 'No')){quit('no', 1)}\n if(!identical(candidate('final132'), 'No')){quit('no', 1)}\n if(!identical(candidate('_f4indsartal132.'), 'No')){quit('no', 1)}\n if(!identical(candidate('.txt'), 'No')){quit('no', 1)}\n if(!identical(candidate('s.'), 'No')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_127_intersection", |
|
"language": "r", |
|
"prompt": "# 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((1, 2), (2, 3)) ==> \"NO\"\n# intersection((-1, 1), (0, 4)) ==> \"NO\"\n# intersection((-3, -1), (-5, 5)) ==> \"YES\"\nintersection <- function(interval1, interval2) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_127_intersection.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- intersection\n if(!identical(candidate(list(1, 2), list(2, 3)), 'NO')){quit('no', 1)}\n if(!identical(candidate(list(-1, 1), list(0, 4)), 'NO')){quit('no', 1)}\n if(!identical(candidate(list(-3, -1), list(-5, 5)), 'YES')){quit('no', 1)}\n if(!identical(candidate(list(-2, 2), list(-4, 0)), 'YES')){quit('no', 1)}\n if(!identical(candidate(list(-11, 2), list(-1, -1)), 'NO')){quit('no', 1)}\n if(!identical(candidate(list(1, 2), list(3, 5)), 'NO')){quit('no', 1)}\n if(!identical(candidate(list(1, 2), list(1, 2)), 'NO')){quit('no', 1)}\n if(!identical(candidate(list(-2, -2), list(-3, -2)), 'NO')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_59_largest_prime_factor", |
|
"language": "r", |
|
"prompt": "# Return the largest prime factor of n. Assume n > 1 and is not a prime.\n# >>> largest_prime_factor(13195)\n# 29\n# >>> largest_prime_factor(2048)\n# 2\nlargest_prime_factor <- function(n) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_59_largest_prime_factor.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- largest_prime_factor\n if(!identical(candidate(15), 5)){quit('no', 1)}\n if(!identical(candidate(27), 3)){quit('no', 1)}\n if(!identical(candidate(63), 7)){quit('no', 1)}\n if(!identical(candidate(330), 11)){quit('no', 1)}\n if(!identical(candidate(13195), 29)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_16_count_distinct_characters", |
|
"language": "r", |
|
"prompt": "# Given a string, find out how many distinct characters (regardless of case) does it consist of\n# >>> count_distinct_characters('xyzXYZ')\n# 3\n# >>> count_distinct_characters('Jerry')\n# 4\ncount_distinct_characters <- function(string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_16_count_distinct_characters.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- count_distinct_characters\n if(!identical(candidate(''), 0)){quit('no', 1)}\n if(!identical(candidate('abcde'), 5)){quit('no', 1)}\n if(!identical(candidate('abcdecadeCADE'), 5)){quit('no', 1)}\n if(!identical(candidate('aaaaAAAAaaaa'), 1)){quit('no', 1)}\n if(!identical(candidate('Jerry jERRY JeRRRY'), 5)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_3_below_zero", |
|
"language": "r", |
|
"prompt": "# 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# >>> below_zero([1, 2, 3])\n# False\n# >>> below_zero([1, 2, -4, 5])\n# True\nbelow_zero <- function(operations) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_3_below_zero.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- below_zero\n if(!identical(candidate(c()), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, -3, 1, 2, -3)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, 2, -4, 5, 6)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, -1, 2, -2, 5, -5, 4, -4)), FALSE)){quit('no', 1)}\n if(!identical(candidate(c(1, -1, 2, -2, 5, -5, 4, -5)), TRUE)){quit('no', 1)}\n if(!identical(candidate(c(1, -2, 2, -2, 5, -5, 4, -4)), TRUE)){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_10_make_palindrome", |
|
"language": "r", |
|
"prompt": "# 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# >>> make_palindrome('')\n# ''\n# >>> make_palindrome('cat')\n# 'catac'\n# >>> make_palindrome('cata')\n# 'catac'\nmake_palindrome <- function(string) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_10_make_palindrome.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- make_palindrome\n if(!identical(candidate(''), '')){quit('no', 1)}\n if(!identical(candidate('x'), 'x')){quit('no', 1)}\n if(!identical(candidate('xyz'), 'xyzyx')){quit('no', 1)}\n if(!identical(candidate('xyx'), 'xyx')){quit('no', 1)}\n if(!identical(candidate('jerry'), 'jerryrrej')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
}, |
|
{ |
|
"name": "HumanEval_156_int_to_mini_roman", |
|
"language": "r", |
|
"prompt": "# 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# >>> int_to_mini_roman(19) == 'xix'\n# >>> int_to_mini_roman(152) == 'clii'\n# >>> int_to_mini_roman(426) == 'cdxxvi'\nint_to_mini_roman <- function(number) {", |
|
"doctests": "keep", |
|
"original": "/home/arjun/repos/MultiPL-E/datasets/../datasets/originals/HumanEval_156_int_to_mini_roman.py", |
|
"prompt_terminology": "verbatim", |
|
"tests": "test_humaneval <- function() {\ncandidate <- int_to_mini_roman\n if(!identical(candidate(19), 'xix')){quit('no', 1)}\n if(!identical(candidate(152), 'clii')){quit('no', 1)}\n if(!identical(candidate(251), 'ccli')){quit('no', 1)}\n if(!identical(candidate(426), 'cdxxvi')){quit('no', 1)}\n if(!identical(candidate(500), 'd')){quit('no', 1)}\n if(!identical(candidate(1), 'i')){quit('no', 1)}\n if(!identical(candidate(4), 'iv')){quit('no', 1)}\n if(!identical(candidate(43), 'xliii')){quit('no', 1)}\n if(!identical(candidate(90), 'xc')){quit('no', 1)}\n if(!identical(candidate(94), 'xciv')){quit('no', 1)}\n if(!identical(candidate(532), 'dxxxii')){quit('no', 1)}\n if(!identical(candidate(900), 'cm')){quit('no', 1)}\n if(!identical(candidate(994), 'cmxciv')){quit('no', 1)}\n if(!identical(candidate(1000), 'm')){quit('no', 1)}\n}\ntest_humaneval()", |
|
"stop_tokens": [ |
|
"\n#", |
|
"\n```" |
|
] |
|
} |
|
] |
