name stringclasses 161
values | language stringclasses 22
values | prompt stringlengths 40 2.27k | doctests stringclasses 3
values | original stringclasses 956
values | prompt_terminology stringclasses 2
values | tests stringlengths 125 5.35k | stop_tokens listlengths 1 7 |
|---|---|---|---|---|---|---|---|
HumanEval_73_smallest_change | lua | -- Given an array arr of integers, find the minimum number of elements that
-- need to be changed to make the array palindromic. A palindromic array is an array that
-- is read the same backwards and forwards. In one change, you can change one element to any other element.
-- For example:
-- smallest_change([1,2,3,5,4,... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_73_smallest_change.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = smallest_change
lu.assertEquals(candidate({1, 2, 3, 5, 4, 7, 9, 6}), 4)
lu.assertEquals(candidate({1, 2, 3, 4, 3, 2, 2}), 1)
lu.assertEquals(candidate({1, 4, 2}), 1)
lu.assertEquals(candidate({1, 4, 4, 2}), 1)
lu.assertEquals(candi... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_74_total_match | lua | -- Write a function that accepts two lists of strings and returns the list that has
-- total number of chars in the all strings of the list less than the other list.
-- if the two lists have the same number of chars, return the first list.
-- Examples
-- total_match([], []) ➞ []
-- total_match(['hi', 'admin'], ['hI', ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_74_total_match.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = total_match
lu.assertEquals(candidate({}, {}), {})
lu.assertEquals(candidate({'hi', 'admin'}, {'hi', 'hi'}), {'hi', 'hi'})
lu.assertEquals(candidate({'hi', 'admin'}, {'hi', 'hi', 'admin', 'project'}), {'hi', 'admin'})
lu.assertEquals(c... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_75_is_multiply_prime | lua | -- Write a function that returns true if the given number is the multiplication of 3 prime numbers
-- and false otherwise.
-- Knowing that (a) is less then 100.
-- Example:
-- is_multiply_prime(30) == True
-- 30 = 2 * 3 * 5
local function is_multiply_prime(a)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_75_is_multiply_prime.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = is_multiply_prime
lu.assertEquals(candidate(5), false)
lu.assertEquals(candidate(30), true)
lu.assertEquals(candidate(8), true)
lu.assertEquals(candidate(10), false)
lu.assertEquals(candidate(125), true)
lu.assertEquals(candida... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_76_is_simple_power | lua | -- Your task is to write a function that returns true if a number x is a simple
-- power of n and false in other cases.
-- x is a simple power of n if n**int=x
-- For example:
-- is_simple_power(1, 4) => true
-- is_simple_power(2, 2) => true
-- is_simple_power(8, 2) => true
-- is_simple_power(3, 2) => false
-- is_simpl... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_76_is_simple_power.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = is_simple_power
lu.assertEquals(candidate(16, 2), true)
lu.assertEquals(candidate(143214, 16), false)
lu.assertEquals(candidate(4, 2), true)
lu.assertEquals(candidate(9, 3), true)
lu.assertEquals(candidate(16, 4), true)
lu.asse... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_77_iscube | lua | -- Write a function that takes an integer a and returns True
-- if this ingeger is a cube of some integer number.
-- Note: you may assume the input is always valid.
-- Examples:
-- iscube(1) ==> True
-- iscube(2) ==> False
-- iscube(-1) ==> True
-- iscube(64) ==> True
-- iscube(0) ==> True
-- iscube(180) ==> False
loc... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_77_iscube.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = iscube
lu.assertEquals(candidate(1), true)
lu.assertEquals(candidate(2), false)
lu.assertEquals(candidate(-1), true)
lu.assertEquals(candidate(64), true)
lu.assertEquals(candidate(180), false)
lu.assertEquals(candidate(1000), t... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_78_hex_key | lua | -- You have been tasked to write a function that receives
-- a hexadecimal number as a string and counts the number of hexadecimal
-- digits that are primes (prime number, or a prime, is a natural number
-- greater than 1 that is not a product of two smaller natural numbers).
-- Hexadecimal digits are 0, 1, 2, 3, 4,... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_78_hex_key.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = hex_key
lu.assertEquals(candidate('AB'), 1)
lu.assertEquals(candidate('1077E'), 2)
lu.assertEquals(candidate('ABED1A33'), 4)
lu.assertEquals(candidate('2020'), 2)
lu.assertEquals(candidate('123456789ABCDEF0'), 6)
lu.assertEqual... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_79_decimal_to_binary | lua | -- You will be given a number in decimal form and your task is to convert it to
-- binary format. The function should return a string, with each character representing a binary
-- number. Each character in the string will be '0' or '1'.
-- There will be an extra couple of characters 'db' at the beginning and at the end... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_79_decimal_to_binary.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = decimal_to_binary
lu.assertEquals(candidate(0), 'db0db')
lu.assertEquals(candidate(32), 'db100000db')
lu.assertEquals(candidate(103), 'db1100111db')
lu.assertEquals(candidate(15), 'db1111db')
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_7_filter_by_substring | lua | -- Filter an input list of strings only for ones that contain given substring
-- >>> filter_by_substring([], 'a')
-- []
-- >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
-- ['abc', 'bacd', 'array']
local function filter_by_substring(strings, substring)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_7_filter_by_substring.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = filter_by_substring
lu.assertEquals(candidate({}, 'john'), {})
lu.assertEquals(candidate({'xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'}, 'xxx'), {'xxx', 'xxxAAA', 'xxx'})
lu.assertEquals(candidate({'xxx', 'asd', 'aaaxxy', 'john doe', '... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_80_is_happy | lua | -- You are given a string s.
-- Your task is to check if the string is happy or not.
-- A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
-- For example:
-- is_happy(a) => False
-- is_happy(aa) => False
-- is_happy(abcd) => True
-- is_happy(aabb) => False
-- is_happy(adb) => Tru... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_80_is_happy.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = is_happy
lu.assertEquals(candidate('a'), false)
lu.assertEquals(candidate('aa'), false)
lu.assertEquals(candidate('abcd'), true)
lu.assertEquals(candidate('aabb'), false)
lu.assertEquals(candidate('adb'), true)
lu.assertEquals(... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_81_numerical_letter_grade | lua | -- It is the last week of the semester and the teacher has to give the grades
-- to students. The teacher has been making her own algorithm for grading.
-- The only problem is, she has lost the code she used for grading.
-- She has given you a list of GPAs for some students and you have to write
-- a function that can... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_81_numerical_letter_grade.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = numerical_letter_grade
lu.assertEquals(candidate({4.0, 3, 1.7, 2, 3.5}), {'A+', 'B', 'C-', 'C', 'A-'})
lu.assertEquals(candidate({1.2}), {'D+'})
lu.assertEquals(candidate({0.5}), {'D-'})
lu.assertEquals(candidate({0.0}), {'E'})
lu.... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_82_prime_length | lua | -- Write a function that takes a string and returns True if the string
-- length is a prime number or False otherwise
-- Examples
-- prime_length('Hello') == True
-- prime_length('abcdcba') == True
-- prime_length('kittens') == True
-- prime_length('orange') == False
local function prime_length(string)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_82_prime_length.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = prime_length
lu.assertEquals(candidate('Hello'), true)
lu.assertEquals(candidate('abcdcba'), true)
lu.assertEquals(candidate('kittens'), true)
lu.assertEquals(candidate('orange'), false)
lu.assertEquals(candidate('wow'), true)
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_83_starts_one_ends | lua | -- Given a positive integer n, return the count of the numbers of n-digit
-- positive integers that start or end with 1.
local function starts_one_ends(n)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_83_starts_one_ends.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = starts_one_ends
lu.assertEquals(candidate(1), 1)
lu.assertEquals(candidate(2), 18)
lu.assertEquals(candidate(3), 180)
lu.assertEquals(candidate(4), 1800)
lu.assertEquals(candidate(5), 18000)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_84_solve | lua | -- Given a positive integer N, return the total sum of its digits in binary.
-- Example
-- For N = 1000, the sum of digits will be 1 the output should be "1".
-- For N = 150, the sum of digits will be 6 the output should be "110".
-- For N = 147, the sum of digits will be 12 the output should be "1100".
-- ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_84_solve.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = solve
lu.assertEquals(candidate(1000), '1')
lu.assertEquals(candidate(150), '110')
lu.assertEquals(candidate(147), '1100')
lu.assertEquals(candidate(333), '1001')
lu.assertEquals(candidate(963), '10010')
end
os.exit(lu.LuaUnit.run... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_85_add | lua | -- Given a non-empty list of integers lst. add the even elements that are at odd indices..
-- Examples:
-- add([4, 2, 6, 7]) ==> 2
local function add(lst)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_85_add.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = add
lu.assertEquals(candidate({4, 88}), 88)
lu.assertEquals(candidate({4, 5, 6, 7, 2, 122}), 122)
lu.assertEquals(candidate({4, 0, 6, 7}), 0)
lu.assertEquals(candidate({4, 4, 6, 8}), 12)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_86_anti_shuffle | lua | -- Write a function that takes a string and returns an ordered version of it.
-- Ordered version of string, is a string where all words (separated by space)
-- are replaced by a new word where all the characters arranged in
-- ascending order based on ascii value.
-- Note: You should keep the order of words and blank s... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_86_anti_shuffle.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = anti_shuffle
lu.assertEquals(candidate('Hi'), 'Hi')
lu.assertEquals(candidate('hello'), 'ehllo')
lu.assertEquals(candidate('number'), 'bemnru')
lu.assertEquals(candidate('abcd'), 'abcd')
lu.assertEquals(candidate('Hello World!!!'),... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_87_get_row | lua | -- You are given a 2 dimensional data, as a nested lists,
-- which is similar to matrix, however, unlike matrices,
-- each row may contain a different number of columns.
-- Given lst, and integer x, find integers x in the list,
-- and return list of tuples, [(x1, y1), (x2, y2) ...] such that
-- each tuple is a coordina... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_87_get_row.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = get_row
lu.assertEquals(candidate({{1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 1, 6}, {1, 2, 3, 4, 5, 1}}, 1), {{0, 0}, {1, 4}, {1, 0}, {2, 5}, {2, 0}})
lu.assertEquals(candidate({{1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 5... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_88_sort_array | lua | -- Given an array of non-negative integers, return a copy of the given array after sorting,
-- you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
-- or sort it in descending order if the sum( first index value, last index value) is even.
-- Note:
-- * don't change ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_88_sort_array.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = sort_array
lu.assertEquals(candidate({}), {})
lu.assertEquals(candidate({5}), {5})
lu.assertEquals(candidate({2, 4, 3, 0, 1, 5}), {0, 1, 2, 3, 4, 5})
lu.assertEquals(candidate({2, 4, 3, 0, 1, 5, 6}), {6, 5, 4, 3, 2, 1, 0})
lu.asser... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_89_encrypt | lua | -- Create a function encrypt that takes a string as an argument and
-- returns a string encrypted with the alphabet being rotated.
-- The alphabet should be rotated in a manner such that the letters
-- shift down by two multiplied to two places.
-- For example:
-- encrypt('hi') returns 'lm'
-- encrypt('asdfghjkl') re... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_89_encrypt.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = encrypt
lu.assertEquals(candidate('hi'), 'lm')
lu.assertEquals(candidate('asdfghjkl'), 'ewhjklnop')
lu.assertEquals(candidate('gf'), 'kj')
lu.assertEquals(candidate('et'), 'ix')
lu.assertEquals(candidate('faewfawefaewg'), 'jeiajeai... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_8_sum_product | lua | -- For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
-- Empty sum should be equal to 0 and empty product should be equal to 1.
-- >>> sum_product([])
-- (0, 1)
-- >>> sum_product([1, 2, 3, 4])
-- (10, 24)
local function sum_product(numbers)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_8_sum_product.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = sum_product
lu.assertEquals(candidate({}), {0, 1})
lu.assertEquals(candidate({1, 1, 1}), {3, 1})
lu.assertEquals(candidate({100, 0}), {100, 0})
lu.assertEquals(candidate({3, 5, 7}), {15, 105})
lu.assertEquals(candidate({10}), {10, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_90_next_smallest | lua | -- You are given a list of integers.
-- Write a function next_smallest() that returns the 2nd smallest element of the list.
-- Return None if there is no such element.
-- next_smallest([1, 2, 3, 4, 5]) == 2
-- next_smallest([5, 1, 4, 3, 2]) == 2
-- next_smallest([]) == None
-- next_smallest([1, 1]) == None
local functi... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_90_next_smallest.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = next_smallest
lu.assertEquals(candidate({1, 2, 3, 4, 5}), 2)
lu.assertEquals(candidate({5, 1, 4, 3, 2}), 2)
lu.assertEquals(candidate({}), None)
lu.assertEquals(candidate({1, 1}), None)
lu.assertEquals(candidate({1, 1, 1, 1, 0}), 1... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_91_is_bored | lua | -- You'll be given a string of words, and your task is to count the number
-- of boredoms. A boredom is a sentence that starts with the word "I".
-- Sentences are delimited by '.', '?' or '!'.
-- For example:
-- >>> is_bored("Hello world")
-- 0
-- >>> is_bored("The sky is blue. The sun is shining. I love this weather")... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_91_is_bored.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = is_bored
lu.assertEquals(candidate('Hello world'), 0)
lu.assertEquals(candidate('Is the sky blue?'), 0)
lu.assertEquals(candidate('I love It !'), 1)
lu.assertEquals(candidate('bIt'), 0)
lu.assertEquals(candidate('I feel good today.... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_92_any_int | lua | -- Create a function that takes 3 numbers.
-- Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
-- Returns false in any other cases.
-- Examples
-- any_int(5, 2, 7) ➞ True
-- any_int(3, 2, 2) ➞ False
-- any_int(3, -2, 1) ➞ True
-- any_int(3.6, -2.2, 2) ➞ False
local ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_92_any_int.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = any_int
lu.assertEquals(candidate(2, 3, 1), true)
lu.assertEquals(candidate(2.5, 2, 3), false)
lu.assertEquals(candidate(1.5, 5, 3.5), false)
lu.assertEquals(candidate(2, 6, 2), false)
lu.assertEquals(candidate(4, 2, 2), true)
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_93_encode | lua | -- Write a function that takes a message, and encodes in such a
-- way that it swaps case of all letters, replaces all vowels in
-- the message with the letter that appears 2 places ahead of that
-- vowel in the english alphabet.
-- Assume only letters.
-- Examples:
-- >>> encode('test')
-- 'TGST'
-- >>> encode('T... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_93_encode.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = encode
lu.assertEquals(candidate('TEST'), 'tgst')
lu.assertEquals(candidate('Mudasir'), 'mWDCSKR')
lu.assertEquals(candidate('YES'), 'ygs')
lu.assertEquals(candidate('This is a message'), 'tHKS KS C MGSSCGG')
lu.assertEquals(candid... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_94_skjkasdkd | lua | -- You are given a list of integers.
-- You need to find the largest prime value and return the sum of its digits.
-- Examples:
-- 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
-- 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
-- For lst = [1,3,1,32,... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_94_skjkasdkd.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = skjkasdkd
lu.assertEquals(candidate({0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3}), 10)
lu.assertEquals(candidate({1, 0, 1, 8, 2, 4597, 2, 1, 3, 40, 1, 2, 1, 2, 4, 2, 5, 1}), 25)
lu.assertEquals(candidate({1, 3,... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_95_check_dict_case | lua | -- Given a dictionary, return True if all keys are strings in lower
-- case or all keys are strings in upper case, else return False.
-- The function should return False is the given dictionary is empty.
-- Examples:
-- check_dict_case({"a":"apple", "b":"banana"}) should return True.
-- check_dict_case({"a":"apple", "... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_95_check_dict_case.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = check_dict_case
lu.assertEquals(candidate({['p'] = 'pineapple', ['b'] = 'banana'}), true)
lu.assertEquals(candidate({['p'] = 'pineapple', ['A'] = 'banana', ['B'] = 'banana'}), false)
lu.assertEquals(candidate({['p'] = 'pineapple', ['5'] = ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_96_count_up_to | lua | -- Implement a function that takes an non-negative integer and returns an array of the first n
-- integers that are prime numbers and less than n.
-- for example:
-- count_up_to(5) => [2,3]
-- count_up_to(11) => [2,3,5,7]
-- count_up_to(0) => []
-- count_up_to(20) => [2,3,5,7,11,13,17,19]
-- count_up_to(1) => []
-- cou... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_96_count_up_to.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = count_up_to
lu.assertEquals(candidate(5), {2, 3})
lu.assertEquals(candidate(6), {2, 3, 5})
lu.assertEquals(candidate(7), {2, 3, 5})
lu.assertEquals(candidate(10), {2, 3, 5, 7})
lu.assertEquals(candidate(0), {})
lu.assertEquals(... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_97_multiply | lua | -- Complete the function that takes two integers and returns
-- the product of their unit digits.
-- Assume the input is always valid.
-- Examples:
-- multiply(148, 412) should return 16.
-- multiply(19, 28) should return 72.
-- multiply(2020, 1851) should return 0.
-- multiply(14,-15) should return 20.
local function... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_97_multiply.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = multiply
lu.assertEquals(candidate(148, 412), 16)
lu.assertEquals(candidate(19, 28), 72)
lu.assertEquals(candidate(2020, 1851), 0)
lu.assertEquals(candidate(14, -15), 20)
lu.assertEquals(candidate(76, 67), 42)
lu.assertEquals(c... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_98_count_upper | lua | -- Given a string s, count the number of uppercase vowels in even indices.
-- For example:
-- count_upper('aBCdEf') returns 1
-- count_upper('abcdefg') returns 0
-- count_upper('dBBE') returns 0
local function count_upper(s)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_98_count_upper.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = count_upper
lu.assertEquals(candidate('aBCdEf'), 1)
lu.assertEquals(candidate('abcdefg'), 0)
lu.assertEquals(candidate('dBBE'), 0)
lu.assertEquals(candidate('B'), 0)
lu.assertEquals(candidate('U'), 1)
lu.assertEquals(candidate(... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_99_closest_integer | lua | -- Create a function that takes a value (string) representing a number
-- and returns the closest integer to it. If the number is equidistant
-- from two integers, round it away from zero.
-- Examples
-- >>> closest_integer("10")
-- 10
-- >>> closest_integer("15.3")
-- 15
-- Note:
-- Rounding away from zero means that ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_99_closest_integer.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = closest_integer
lu.assertEquals(candidate('10'), 10)
lu.assertEquals(candidate('14.5'), 15)
lu.assertEquals(candidate('-15.5'), -16)
lu.assertEquals(candidate('15.3'), 15)
lu.assertEquals(candidate('0'), 0)
end
os.exit(lu.LuaUnit.... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_9_rolling_max | lua | -- From a given list of integers, generate a list of rolling maximum element found until given moment
-- in the sequence.
-- >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
-- [1, 2, 3, 3, 3, 4, 4]
local function rolling_max(numbers)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_9_rolling_max.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = rolling_max
lu.assertEquals(candidate({}), {})
lu.assertEquals(candidate({1, 2, 3, 4}), {1, 2, 3, 4})
lu.assertEquals(candidate({4, 3, 2, 1}), {4, 4, 4, 4})
lu.assertEquals(candidate({3, 2, 3, 100, 3}), {3, 3, 3, 100, 100})
end
os.exi... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_0_has_close_elements | lua | -- Check if in given list of numbers, are any two numbers closer to each other than
-- given threshold.
local function has_close_elements(numbers, threshold)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_0_has_close_elements.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = has_close_elements
lu.assertEquals(candidate({1.0, 2.0, 3.9, 4.0, 5.0, 2.2}, 0.3), true)
lu.assertEquals(candidate({1.0, 2.0, 3.9, 4.0, 5.0, 2.2}, 0.05), false)
lu.assertEquals(candidate({1.0, 2.0, 5.9, 4.0, 5.0}, 0.95), true)
lu.asser... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_100_make_a_pile | lua | -- Given a positive integer n, you have to make a pile of n levels of stones.
-- The first level has n stones.
-- The number of stones in the next level is:
-- - the next odd number if n is odd.
-- - the next even number if n is even.
-- Return the number of stones in each level in a list, where element at inde... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_100_make_a_pile.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = make_a_pile
lu.assertEquals(candidate(3), {3, 5, 7})
lu.assertEquals(candidate(4), {4, 6, 8, 10})
lu.assertEquals(candidate(5), {5, 7, 9, 11, 13})
lu.assertEquals(candidate(6), {6, 8, 10, 12, 14, 16})
lu.assertEquals(candidate(8), ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_101_words_string | lua | -- You will be given a string of words separated by commas or spaces. Your task is
-- to split the string into words and return an array of the words.
-- For example:
local function words_string(s)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_101_words_string.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = words_string
lu.assertEquals(candidate('Hi, my name is John'), {'Hi', 'my', 'name', 'is', 'John'})
lu.assertEquals(candidate('One, two, three, four, five, six'), {'One', 'two', 'three', 'four', 'five', 'six'})
lu.assertEquals(candidate('Hi... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_102_choose_num | lua | -- This function takes two positive numbers x and y and returns the
-- biggest even integer number that is in the range [x, y] inclusive. If
-- there's no such number, then the function should return -1.
-- For example:
local function choose_num(x, y)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_102_choose_num.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = choose_num
lu.assertEquals(candidate(12, 15), 14)
lu.assertEquals(candidate(13, 12), -1)
lu.assertEquals(candidate(33, 12354), 12354)
lu.assertEquals(candidate(5234, 5233), -1)
lu.assertEquals(candidate(6, 29), 28)
lu.assertEqu... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_103_rounded_avg | lua | -- You are given two positive integers n and m, and your task is to compute the
-- average of the integers from n through m (including n and m).
-- Round the answer to the nearest integer and convert that to binary.
-- If n is greater than m, return -1.
-- Example:
local function rounded_avg(n, m)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_103_rounded_avg.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = rounded_avg
lu.assertEquals(candidate(1, 5), '0b11')
lu.assertEquals(candidate(7, 13), '0b1010')
lu.assertEquals(candidate(964, 977), '0b1111001010')
lu.assertEquals(candidate(996, 997), '0b1111100100')
lu.assertEquals(candidate(56... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_104_unique_digits | lua | -- Given a list of positive integers x. return a sorted list of all
-- elements that hasn't any even digit.
-- Note: Returned list should be sorted in increasing order.
-- For example:
local function unique_digits(x)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_104_unique_digits.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = unique_digits
lu.assertEquals(candidate({15, 33, 1422, 1}), {1, 15, 33})
lu.assertEquals(candidate({152, 323, 1422, 10}), {})
lu.assertEquals(candidate({12345, 2033, 111, 151}), {111, 151})
lu.assertEquals(candidate({135, 103, 31}), {3... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_105_by_length | lua | -- Given an array of integers, sort the integers that are between 1 and 9 inclusive,
-- reverse the resulting array, and then replace each digit by its corresponding name from
-- "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
-- For example:
-- If the array is empty, return an empty array:
--... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_105_by_length.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = by_length
lu.assertEquals(candidate({2, 1, 1, 4, 5, 8, 2, 3}), {'Eight', 'Five', 'Four', 'Three', 'Two', 'Two', 'One', 'One'})
lu.assertEquals(candidate({}), {})
lu.assertEquals(candidate({1, -1, 55}), {'One'})
lu.assertEquals(candidat... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_106_f | lua | -- Implement the function f that takes n as a parameter,
-- 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
-- or the sum of numbers from 1 to i otherwise.
-- i starts from 1.
-- the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_106_f.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = f
lu.assertEquals(candidate(5), {1, 2, 6, 24, 15})
lu.assertEquals(candidate(7), {1, 2, 6, 24, 15, 720, 28})
lu.assertEquals(candidate(1), {1})
lu.assertEquals(candidate(3), {1, 2, 6})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_107_even_odd_palindrome | lua | -- Given a positive integer n, return a tuple that has the number of even and odd
-- integer palindromes that fall within the range(1, n), inclusive.
-- Example 1:
-- Explanation:
-- Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
-- Example 2:
-- Explanation:
-- In... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_107_even_odd_palindrome.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = even_odd_palindrome
lu.assertEquals(candidate(123), {8, 13})
lu.assertEquals(candidate(12), {4, 6})
lu.assertEquals(candidate(3), {1, 2})
lu.assertEquals(candidate(63), {6, 8})
lu.assertEquals(candidate(25), {5, 6})
lu.assertEq... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_108_count_nums | lua | -- Write a function count_nums which takes an array of integers and returns
-- the number of elements which has a sum of digits > 0.
-- If a number is negative, then its first signed digit will be negative:
-- e.g. -123 has signed digits -1, 2, and 3.
local function count_nums(arr)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_108_count_nums.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = count_nums
lu.assertEquals(candidate({}), 0)
lu.assertEquals(candidate({-1, -2, 0}), 0)
lu.assertEquals(candidate({1, 1, 2, -2, 3, 4, 5}), 6)
lu.assertEquals(candidate({1, 6, 9, -6, 0, 1, 5}), 5)
lu.assertEquals(candidate({1, 100, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_109_move_one_ball | lua | -- We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
-- numbers in the array will be randomly ordered. Your task is to determine if
-- it is possible to get an array sorted in non-decreasing order by performing
-- the following operation on the given array:
-- You are allowed to perform right sh... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_109_move_one_ball.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = move_one_ball
lu.assertEquals(candidate({3, 4, 5, 1, 2}), true)
lu.assertEquals(candidate({3, 5, 10, 1, 2}), true)
lu.assertEquals(candidate({4, 3, 1, 2}), false)
lu.assertEquals(candidate({3, 5, 4, 1, 2}), false)
lu.assertEquals(c... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_10_make_palindrome | lua | -- Find the shortest palindrome that begins with a supplied string.
-- Algorithm idea is simple:
-- - Find the longest postfix of supplied string that is a palindrome.
-- - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
local function make_palindrome(string)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_10_make_palindrome.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = make_palindrome
lu.assertEquals(candidate(''), '')
lu.assertEquals(candidate('x'), 'x')
lu.assertEquals(candidate('xyz'), 'xyzyx')
lu.assertEquals(candidate('xyx'), 'xyx')
lu.assertEquals(candidate('jerry'), 'jerryrrej')
end
os.ex... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_110_exchange | lua | -- In this problem, you will implement a function that takes two lists of numbers,
-- and determines whether it is possible to perform an exchange of elements
-- between them to make lst1 a list of only even numbers.
-- There is no limit on the number of exchanged elements between lst1 and lst2.
-- If it is possible to... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = exchange
lu.assertEquals(candidate({1, 2, 3, 4}, {1, 2, 3, 4}), 'YES')
lu.assertEquals(candidate({1, 2, 3, 4}, {1, 5, 3, 4}), 'NO')
lu.assertEquals(candidate({1, 2, 3, 4}, {2, 1, 4, 3}), 'YES')
lu.assertEquals(candidate({5, 7, 3}, {2, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_111_histogram | lua | -- Given a string representing a space separated lowercase letters, return a dictionary
-- of the letter with the most repetition and containing the corresponding count.
-- If several letters have the same occurrence, return all of them.
-- Example:
local function histogram(test)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = histogram
lu.assertEquals(candidate('a b b a'), {['a'] = 2, ['b'] = 2})
lu.assertEquals(candidate('a b c a b'), {['a'] = 2, ['b'] = 2})
lu.assertEquals(candidate('a b c d g'), {['a'] = 1, ['b'] = 1, ['c'] = 1, ['d'] = 1, ['g'] = 1})
lu... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_112_reverse_delete | lua | -- Task
-- 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
-- then check if the result string is palindrome.
-- A string is called palindrome if it reads the same backward as forward.
-- You should return a tuple containing the result string and True/Fa... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = reverse_delete
lu.assertEquals(candidate('abcde', 'ae'), {'bcd', false})
lu.assertEquals(candidate('abcdef', 'b'), {'acdef', false})
lu.assertEquals(candidate('abcdedcba', 'ab'), {'cdedc', true})
lu.assertEquals(candidate('dwik', 'w'),... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_113_odd_count | lua | -- Given a list of strings, where each string consists of only digits, return a list.
-- Each element i of the output should be "the number of odd elements in the
-- string i of the input." where all the i's should be replaced by the number
-- of odd digits in the i'th string of the input.
local function odd_count(lst)... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = odd_count
lu.assertEquals(candidate({'1234567'}), {'the number of odd elements 4n the str4ng 4 of the 4nput.'})
lu.assertEquals(candidate({'3', '11111111'}), {'the number of odd elements 1n the str1ng 1 of the 1nput.', 'the number of odd eleme... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_114_minSubArraySum | lua | -- Given an array of integers nums, find the minimum sum of any non-empty sub-array
-- of nums.
-- Example
local function minSubArraySum(nums)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = minSubArraySum
lu.assertEquals(candidate({2, 3, 4, 1, 2, 4}), 1)
lu.assertEquals(candidate({-1, -2, -3}), -6)
lu.assertEquals(candidate({-1, -2, -3, 2, -10}), -14)
lu.assertEquals(candidate({-9999999999999999}), -9999999999999999)
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_115_max_fill | lua | -- You are given a rectangular grid of wells. Each row represents a single well,
-- and each 1 in a row represents a single unit of water.
-- Each well has a corresponding bucket that can be used to extract water from it,
-- and all buckets have the same capacity.
-- Your task is to use the buckets to empty the wells.... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = max_fill
lu.assertEquals(candidate({{0, 0, 1, 0}, {0, 1, 0, 0}, {1, 1, 1, 1}}, 1), 6)
lu.assertEquals(candidate({{0, 0, 1, 1}, {0, 0, 0, 0}, {1, 1, 1, 1}, {0, 1, 1, 1}}, 2), 5)
lu.assertEquals(candidate({{0, 0, 0}, {0, 0, 0}}, 5), 0)
l... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_116_sort_array | lua | -- In this Kata, you have to sort an array of non-negative integers according to
-- number of ones in their binary representation in ascending order.
-- For similar number of ones, sort based on decimal value.
-- It must be implemented like this:
local function sort_array(arr)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_sort_array.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = sort_array
lu.assertEquals(candidate({1, 5, 2, 3, 4}), {1, 2, 4, 3, 5})
lu.assertEquals(candidate({-2, -3, -4, -5, -6}), {-4, -2, -6, -5, -3})
lu.assertEquals(candidate({1, 0, 2, 3, 4}), {0, 1, 2, 4, 3})
lu.assertEquals(candidate({}), ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_117_select_words | lua | -- Given a string s and a natural number n, you have been tasked to implement
-- a function that returns a list of all words from string s that contain exactly
-- n consonants, in order these words appear in the string s.
-- If the string s is empty then the function should return an empty list.
-- Note: you may assu... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = select_words
lu.assertEquals(candidate('Mary had a little lamb', 4), {'little'})
lu.assertEquals(candidate('Mary had a little lamb', 3), {'Mary', 'lamb'})
lu.assertEquals(candidate('simple white space', 2), {})
lu.assertEquals(candidat... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_118_get_closest_vowel | lua | -- You are given a word. Your task is to find the closest vowel that stands between
-- two consonants from the right side of the word (case sensitive).
-- Vowels in the beginning and ending doesn't count. Return empty string if you didn't
-- find any vowel met the above condition.
-- You may assume that the given str... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = get_closest_vowel
lu.assertEquals(candidate('yogurt'), 'u')
lu.assertEquals(candidate('full'), 'u')
lu.assertEquals(candidate('easy'), '')
lu.assertEquals(candidate('eAsy'), '')
lu.assertEquals(candidate('ali'), '')
lu.assertEq... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_119_match_parens | lua | -- You are given a list of two strings, both strings consist of open
-- parentheses '(' or close parentheses ')' only.
-- Your job is to check if it is possible to concatenate the two strings in
-- some order, that the resulting string will be good.
-- A string S is considered to be good if and only if all parentheses ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = match_parens
lu.assertEquals(candidate({'()(', ')'}), 'Yes')
lu.assertEquals(candidate({')', ')'}), 'No')
lu.assertEquals(candidate({'(()(())', '())())'}), 'No')
lu.assertEquals(candidate({')())', '(()()('}), 'Yes')
lu.assertEquals... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_11_string_xor | lua | -- Input are two strings a and b consisting only of 1s and 0s.
-- Perform binary XOR on these inputs and return result also as a string.
local function string_xor(a, b)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_11_string_xor.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = string_xor
lu.assertEquals(candidate('111000', '101010'), '010010')
lu.assertEquals(candidate('1', '1'), '0')
lu.assertEquals(candidate('0101', '0000'), '0101')
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_120_maximum | lua | -- Given an array arr of integers and a positive integer k, return a sorted list
-- of length k with the maximum k numbers in arr.
-- Example 1:
-- Example 2:
-- Example 3:
-- Note:
-- 1. The length of the array will be in the range of [1, 1000].
-- 2. The elements in the array will be in the range of [-1000, ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = maximum
lu.assertEquals(candidate({-3, -4, 5}, 3), {-4, -3, 5})
lu.assertEquals(candidate({4, -4, 4}, 2), {4, 4})
lu.assertEquals(candidate({-3, 2, 1, 2, -1, -2, 1}, 1), {2})
lu.assertEquals(candidate({123, -123, 20, 0, 1, 2, -3}, 3), ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_121_solution | lua | -- Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
-- Examples
local function solution(lst)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = solution
lu.assertEquals(candidate({5, 8, 7, 1}), 12)
lu.assertEquals(candidate({3, 3, 3, 3, 3}), 9)
lu.assertEquals(candidate({30, 13, 24, 321}), 0)
lu.assertEquals(candidate({5, 9}), 5)
lu.assertEquals(candidate({2, 4, 8}), 0)
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_122_add_elements | lua | -- Given a non-empty array of integers arr and an integer k, return
-- the sum of the elements with at most two digits from the first k elements of arr.
-- Example:
-- Constraints:
-- 1. 1 <= len(arr) <= 100
-- 2. 1 <= k <= len(arr)
local function add_elements(arr, k)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = add_elements
lu.assertEquals(candidate({1, -2, -3, 41, 57, 76, 87, 88, 99}, 3), -4)
lu.assertEquals(candidate({111, 121, 3, 4000, 5, 6}, 2), 0)
lu.assertEquals(candidate({11, 21, 3, 90, 5, 6, 7, 8, 9}, 4), 125)
lu.assertEquals(candidat... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_123_get_odd_collatz | lua | -- Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.
-- The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
-- as follows: start with any positive integer n. Then each term is obtained from the
-- previous term as follows: if the previous ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = get_odd_collatz
lu.assertEquals(candidate(14), {1, 5, 7, 11, 13, 17})
lu.assertEquals(candidate(5), {1, 5})
lu.assertEquals(candidate(12), {1, 3, 5})
lu.assertEquals(candidate(1), {1})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_124_valid_date | lua | -- You have to write a function which validates a given date string and
-- returns True if the date is valid otherwise False.
-- The date is valid if all of the following rules are satisfied:
-- 1. The date string is not empty.
-- 2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,1... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = valid_date
lu.assertEquals(candidate('03-11-2000'), true)
lu.assertEquals(candidate('15-01-2012'), false)
lu.assertEquals(candidate('04-0-2040'), false)
lu.assertEquals(candidate('06-04-2020'), true)
lu.assertEquals(candidate('01-0... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_125_split_words | lua | -- Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
-- should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
-- alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
-- Examples
local functio... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_125_split_words.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = split_words
lu.assertEquals(candidate('Hello world!'), {'Hello', 'world!'})
lu.assertEquals(candidate('Hello,world!'), {'Hello', 'world!'})
lu.assertEquals(candidate('Hello world,!'), {'Hello', 'world,!'})
lu.assertEquals(candidate('He... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_126_is_sorted | lua | -- Given a list of numbers, return whether or not they are sorted
-- in ascending order. If list has more than 1 duplicate of the same
-- number, return False. Assume no negative numbers and only integers.
-- Examples
local function is_sorted(lst)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = is_sorted
lu.assertEquals(candidate({5}), true)
lu.assertEquals(candidate({1, 2, 3, 4, 5}), true)
lu.assertEquals(candidate({1, 3, 2, 4, 5}), false)
lu.assertEquals(candidate({1, 2, 3, 4, 5, 6}), true)
lu.assertEquals(candidate({1,... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_127_intersection | lua | -- You are given two intervals,
-- where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
-- The given intervals are closed which means that the interval (start, end)
-- includes both start and end.
-- For each given interval, it is assumed that its start is less or equal its end.
-- ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = intersection
lu.assertEquals(candidate({1, 2}, {2, 3}), 'NO')
lu.assertEquals(candidate({-1, 1}, {0, 4}), 'NO')
lu.assertEquals(candidate({-3, -1}, {-5, 5}), 'YES')
lu.assertEquals(candidate({-2, 2}, {-4, 0}), 'YES')
lu.assertEqual... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_128_prod_signs | lua | -- You are given an array arr of integers and you need to return
-- sum of magnitudes of integers multiplied by product of all signs
-- of each number in the array, represented by 1, -1 or 0.
-- Note: return None for empty arr.
-- Example:
local function prod_signs(arr)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_128_prod_signs.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = prod_signs
lu.assertEquals(candidate({1, 2, 2, -4}), -9)
lu.assertEquals(candidate({0, 1}), 0)
lu.assertEquals(candidate({1, 1, 1, 2, 3, -1, 1}), -10)
lu.assertEquals(candidate({}), None)
lu.assertEquals(candidate({2, 4, 1, 2, -1, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_129_minPath | lua | -- Given a grid with N rows and N columns (N >= 2) and a positive integer k,
-- each cell of the grid contains a value. Every integer in the range [1, N * N]
-- inclusive appears exactly once on the cells of the grid.
-- You have to find the minimum path of length k in the grid. You can start
-- from any cell, and in ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = minPath
lu.assertEquals(candidate({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, 3), {1, 2, 1})
lu.assertEquals(candidate({{5, 9, 3}, {4, 1, 6}, {7, 8, 2}}, 1), {1})
lu.assertEquals(candidate({{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_12_longest | lua | -- Out of list of strings, return the longest one. Return the first one in case of multiple
-- strings of the same length. Return None in case the input list is empty.
local function longest(strings)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_12_longest.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = longest
lu.assertEquals(candidate({}), None)
lu.assertEquals(candidate({'x', 'y', 'z'}), 'x')
lu.assertEquals(candidate({'x', 'yyy', 'zzzz', 'www', 'kkkk', 'abc'}), 'zzzz')
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_130_tri | lua | -- Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in
-- the last couple centuries. However, what people don't know is Tribonacci sequence.
-- Tribonacci sequence is defined by the recurrence:
-- tri(1) = 3
-- tri(n) = 1 + n / 2, if n is even.
-- tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = tri
lu.assertEquals(candidate(3), {1, 3, 2, 8})
lu.assertEquals(candidate(4), {1, 3, 2, 8, 3})
lu.assertEquals(candidate(5), {1, 3, 2, 8, 3, 15})
lu.assertEquals(candidate(6), {1, 3, 2, 8, 3, 15, 4})
lu.assertEquals(candidate(7), {... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_131_digits | lua | -- Given a positive integer n, return the product of the odd digits.
-- Return 0 if all digits are even.
-- For example:
local function digits(n)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = digits
lu.assertEquals(candidate(5), 5)
lu.assertEquals(candidate(54), 5)
lu.assertEquals(candidate(120), 1)
lu.assertEquals(candidate(5014), 5)
lu.assertEquals(candidate(98765), 315)
lu.assertEquals(candidate(5576543), 2625)
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_132_is_nested | lua | -- Create a function that takes a string as input which contains only square brackets.
-- The function should return True if and only if there is a valid subsequence of brackets
-- where at least one bracket in the subsequence is nested.
local function is_nested(string)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = is_nested
lu.assertEquals(candidate('[[]]'), true)
lu.assertEquals(candidate('[]]]]]]][[[[[]'), false)
lu.assertEquals(candidate('[][]'), false)
lu.assertEquals(candidate('[]'), false)
lu.assertEquals(candidate('[[[[]]]]'), true)
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_133_sum_squares | lua | -- You are given a list of numbers.
-- You need to return the sum of squared numbers in the given list,
-- round each element in the list to the upper int(Ceiling) first.
-- Examples:
local function sum_squares(lst)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = sum_squares
lu.assertEquals(candidate({1.0, 2.0, 3.0}), 14)
lu.assertEquals(candidate({1.0, 2.0, 3.0}), 14)
lu.assertEquals(candidate({1.0, 3.0, 5.0, 7.0}), 84)
lu.assertEquals(candidate({1.4, 4.2, 0.0}), 29)
lu.assertEquals(candid... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_134_check_if_last_char_is_a_letter | lua | -- Create a function that returns True if the last character
-- of a given string is an alphabetical character and is not
-- a part of a word, and False otherwise.
-- Note: "word" is a group of characters separated by space.
-- Examples:
local function check_if_last_char_is_a_letter(txt)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = check_if_last_char_is_a_letter
lu.assertEquals(candidate('apple'), false)
lu.assertEquals(candidate('apple pi e'), true)
lu.assertEquals(candidate('eeeee'), false)
lu.assertEquals(candidate('A'), true)
lu.assertEquals(candidate('Pu... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_135_can_arrange | lua | -- Create a function which returns the largest index of an element which
-- is not greater than or equal to the element immediately preceding it. If
-- no such element exists then return -1. The given array will not contain
-- duplicate values.
-- Examples:
local function can_arrange(arr)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = can_arrange
lu.assertEquals(candidate({1, 2, 4, 3, 5}), 3)
lu.assertEquals(candidate({1, 2, 4, 5}), -1)
lu.assertEquals(candidate({1, 4, 2, 5, 6, 7, 8, 9, 10}), 2)
lu.assertEquals(candidate({4, 8, 5, 7, 3}), 4)
lu.assertEquals(cand... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_136_largest_smallest_integers | lua | -- Create a function that returns a tuple (a, b), where 'a' is
-- the largest of negative integers, and 'b' is the smallest
-- of positive integers in a list.
-- If there is no negative or positive integers, return them as None.
-- Examples:
local function largest_smallest_integers(lst)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = largest_smallest_integers
lu.assertEquals(candidate({2, 4, 1, 3, 5, 7}), {None, 1})
lu.assertEquals(candidate({2, 4, 1, 3, 5, 7, 0}), {None, 1})
lu.assertEquals(candidate({1, 3, 2, 4, 5, 6, -2}), {-2, 1})
lu.assertEquals(candidate({4, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_137_compare_one | lua | -- Create a function that takes integers, floats, or strings representing
-- real numbers, and returns the larger variable in its given variable type.
-- Return None if the values are equal.
-- Note: If a real number is represented as a string, the floating point might be . or ,
local function compare_one(a, b)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_137_compare_one.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = compare_one
lu.assertEquals(candidate(1, 2), 2)
lu.assertEquals(candidate(1, 2.5), 2.5)
lu.assertEquals(candidate(2, 3), 3)
lu.assertEquals(candidate(5, 6), 6)
lu.assertEquals(candidate(1, '2,3'), '2,3')
lu.assertEquals(candida... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_138_is_equal_to_sum_even | lua | -- Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
-- Example
local function is_equal_to_sum_even(n)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = is_equal_to_sum_even
lu.assertEquals(candidate(4), false)
lu.assertEquals(candidate(6), false)
lu.assertEquals(candidate(8), true)
lu.assertEquals(candidate(10), true)
lu.assertEquals(candidate(11), false)
lu.assertEquals(candi... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_139_special_factorial | lua | -- The Brazilian factorial is defined as:
-- brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
-- where n > 0
-- For example:
-- The function will receive an integer as input and should return the special
-- factorial of this integer.
local function special_factorial(n)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = special_factorial
lu.assertEquals(candidate(4), 288)
lu.assertEquals(candidate(5), 34560)
lu.assertEquals(candidate(7), 125411328000)
lu.assertEquals(candidate(1), 1)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_13_greatest_common_divisor | lua | -- Return a greatest common divisor of two integers a and b
local function greatest_common_divisor(a, b)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_13_greatest_common_divisor.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = greatest_common_divisor
lu.assertEquals(candidate(3, 7), 1)
lu.assertEquals(candidate(10, 15), 5)
lu.assertEquals(candidate(49, 14), 7)
lu.assertEquals(candidate(144, 60), 12)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_140_fix_spaces | lua | -- Given a string text, replace all spaces in it with underscores,
-- and if a string has more than 2 consecutive spaces,
-- then replace all consecutive spaces with -
local function fix_spaces(text)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = fix_spaces
lu.assertEquals(candidate('Example'), 'Example')
lu.assertEquals(candidate('Mudasir Hanif '), 'Mudasir_Hanif_')
lu.assertEquals(candidate('Yellow Yellow Dirty Fellow'), 'Yellow_Yellow__Dirty__Fellow')
lu.assertEquals(candi... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_141_file_name_check | lua | -- Create a function which takes a string representing a file's name, and returns
-- 'Yes' if the the file's name is valid, and returns 'No' otherwise.
-- A file's name is considered to be valid if and only if all the following conditions
-- are met:
-- - There should not be more than three digits ('0'-'9') in the fil... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = file_name_check
lu.assertEquals(candidate('example.txt'), 'Yes')
lu.assertEquals(candidate('1example.dll'), 'No')
lu.assertEquals(candidate('s1sdf3.asd'), 'No')
lu.assertEquals(candidate('K.dll'), 'Yes')
lu.assertEquals(candidate('... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_142_sum_squares | lua | -- "
-- 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
-- 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
-- change the entries in the list whose indexes... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = sum_squares
lu.assertEquals(candidate({1, 2, 3}), 6)
lu.assertEquals(candidate({1, 4, 9}), 14)
lu.assertEquals(candidate({}), 0)
lu.assertEquals(candidate({1, 1, 1, 1, 1, 1, 1, 1, 1}), 9)
lu.assertEquals(candidate({-1, -1, -1, -1, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_143_words_in_sentence | lua | -- You are given a string representing a sentence,
-- the sentence contains some words separated by a space,
-- and you have to return a string that contains the words from the original sentence,
-- whose lengths are prime numbers,
-- the order of the words in the new string should be the same as the original one.
-- E... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = words_in_sentence
lu.assertEquals(candidate('This is a test'), 'is')
lu.assertEquals(candidate('lets go for swimming'), 'go for')
lu.assertEquals(candidate('there is no place available here'), 'there is no place')
lu.assertEquals(candi... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_144_simplify | lua | -- Your task is to implement a function that will simplify the expression
-- x * n. The function returns True if x * n evaluates to a whole number and False
-- otherwise. Both x and n, are string representation of a fraction, and have the following format,
-- <numerator>/<denominator> where both numerator and denominat... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = simplify
lu.assertEquals(candidate('1/5', '5/1'), true)
lu.assertEquals(candidate('1/6', '2/1'), false)
lu.assertEquals(candidate('5/1', '3/1'), true)
lu.assertEquals(candidate('7/10', '10/2'), false)
lu.assertEquals(candidate('2/1... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_145_order_by_points | lua | -- Write a function which sorts the given list of integers
-- in ascending order according to the sum of their digits.
-- Note: if there are several items with similar sum of their digits,
-- order them based on their index in original list.
-- For example:
local function order_by_points(nums)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = order_by_points
lu.assertEquals(candidate({1, 11, -1, -11, -12}), {-1, -11, 1, -12, 11})
lu.assertEquals(candidate({1234, 423, 463, 145, 2, 423, 423, 53, 6, 37, 3457, 3, 56, 0, 46}), {0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_146_specialFilter | lua | -- Write a function that takes an array of numbers as input and returns
-- the number of elements in the array that are greater than 10 and both
-- first and last digits of a number are odd (1, 3, 5, 7, 9).
-- For example:
local function specialFilter(nums)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = specialFilter
lu.assertEquals(candidate({5, -2, 1, -5}), 0)
lu.assertEquals(candidate({15, -73, 14, -15}), 1)
lu.assertEquals(candidate({33, -2, -3, 45, 21, 109}), 2)
lu.assertEquals(candidate({43, -12, 93, 125, 121, 109}), 4)
lu.a... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_147_get_max_triples | lua | -- You are given a positive integer n. You have to create an integer array a of length n.
-- For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
-- Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
-- and a[i] + a[j] + a[k] is a multiple of 3.
-- Example :
-- Explanation:
--... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = get_max_triples
lu.assertEquals(candidate(5), 1)
lu.assertEquals(candidate(6), 4)
lu.assertEquals(candidate(10), 36)
lu.assertEquals(candidate(100), 53361)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_148_bf | lua | -- There are eight planets in our solar system: the closerst to the Sun
-- is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
-- Uranus, Neptune.
-- Write a function that takes two planet names as strings planet1 and planet2.
-- The function should return a tuple containing all planets whose orbit... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_148_bf.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = bf
lu.assertEquals(candidate('Jupiter', 'Neptune'), {'Saturn', 'Uranus'})
lu.assertEquals(candidate('Earth', 'Mercury'), {'Venus'})
lu.assertEquals(candidate('Mercury', 'Uranus'), {'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn'})
lu.ass... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_149_sorted_list_sum | lua | -- Write a function that accepts a list of strings as a parameter,
-- deletes the strings that have odd lengths from it,
-- and returns the resulted list with a sorted order,
-- The list is always a list of strings and never an array of numbers,
-- and it may contain duplicates.
-- The order of the list should be ascen... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = sorted_list_sum
lu.assertEquals(candidate({'aa', 'a', 'aaa'}), {'aa'})
lu.assertEquals(candidate({'school', 'AI', 'asdf', 'b'}), {'AI', 'asdf', 'school'})
lu.assertEquals(candidate({'d', 'b', 'c', 'a'}), {})
lu.assertEquals(candidate({... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_14_all_prefixes | lua | -- Return list of all prefixes from shortest to longest of the input string
local function all_prefixes(string)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_14_all_prefixes.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = all_prefixes
lu.assertEquals(candidate(''), {})
lu.assertEquals(candidate('asdfgh'), {'a', 'as', 'asd', 'asdf', 'asdfg', 'asdfgh'})
lu.assertEquals(candidate('WWW'), {'W', 'WW', 'WWW'})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_150_x_or_y | lua | -- A simple program which should return the value of x if n is
-- a prime number and should return the value of y otherwise.
-- Examples:
local function x_or_y(n, x, y)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = x_or_y
lu.assertEquals(candidate(7, 34, 12), 34)
lu.assertEquals(candidate(15, 8, 5), 5)
lu.assertEquals(candidate(3, 33, 5212), 33)
lu.assertEquals(candidate(1259, 3, 52), 3)
lu.assertEquals(candidate(7919, -1, 12), -1)
lu.ass... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_151_double_the_difference | lua | -- Given a list of numbers, return the sum of squares of the numbers
-- in the list that are odd. Ignore numbers that are negative or not integers.
-- If the input list is empty, return 0.
local function double_the_difference(lst)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = double_the_difference
lu.assertEquals(candidate({}), 0)
lu.assertEquals(candidate({5.0, 4.0}), 25)
lu.assertEquals(candidate({0.1, 0.2, 0.3}), 0)
lu.assertEquals(candidate({-10.0, -20.0, -30.0}), 0)
lu.assertEquals(candidate({-1.0,... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_152_compare | lua | -- I think we all remember that feeling when the result of some long-awaited
-- event is finally known. The feelings and thoughts you have at that moment are
-- definitely worth noting down and comparing.
-- Your task is to determine if a person correctly guessed the results of a number of matches.
-- You are given two... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = compare
lu.assertEquals(candidate({1, 2, 3, 4, 5, 1}, {1, 2, 3, 4, 2, -2}), {0, 0, 0, 0, 3, 3})
lu.assertEquals(candidate({0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}), {0, 0, 0, 0, 0, 0})
lu.assertEquals(candidate({1, 2, 3}, {-1, -2, -3}), {2, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_153_Strongest_Extension | lua | -- You will be given the name of a class (a string) and a list of extensions.
-- The extensions are to be used to load additional classes to the class. The
-- strength of the extension is as follows: Let CAP be the number of the uppercase
-- letters in the extension's name, and let SM be the number of lowercase letters... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = Strongest_Extension
lu.assertEquals(candidate('Watashi', {'tEN', 'niNE', 'eIGHt8OKe'}), 'Watashi.eIGHt8OKe')
lu.assertEquals(candidate('Boku123', {'nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg'}), 'Boku123.YEs.WeCaNe')
lu.assertEquals(candida... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_154_cycpattern_check | lua | -- 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
local function cycpattern_check(a, b)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = cycpattern_check
lu.assertEquals(candidate('xyzw', 'xyw'), false)
lu.assertEquals(candidate('yello', 'ell'), true)
lu.assertEquals(candidate('whattup', 'ptut'), false)
lu.assertEquals(candidate('efef', 'fee'), true)
lu.assertEquals... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_155_even_odd_count | lua | -- Given an integer. return a tuple that has the number of even and odd digits respectively.
-- Example:
local function even_odd_count(num)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = even_odd_count
lu.assertEquals(candidate(7), {0, 1})
lu.assertEquals(candidate(-78), {1, 1})
lu.assertEquals(candidate(3452), {2, 2})
lu.assertEquals(candidate(346211), {3, 3})
lu.assertEquals(candidate(-345821), {3, 3})
lu.ass... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_156_int_to_mini_roman | lua | -- Given a positive integer, obtain its roman numeral equivalent as a string,
-- and return it in lowercase.
-- Restrictions: 1 <= num <= 1000
-- Examples:
local function int_to_mini_roman(number)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = int_to_mini_roman
lu.assertEquals(candidate(19), 'xix')
lu.assertEquals(candidate(152), 'clii')
lu.assertEquals(candidate(251), 'ccli')
lu.assertEquals(candidate(426), 'cdxxvi')
lu.assertEquals(candidate(500), 'd')
lu.assertEqu... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_157_right_angle_triangle | lua | -- Given the lengths of the three sides of a triangle. Return True if the three
-- sides form a right-angled triangle, False otherwise.
-- A right-angled triangle is a triangle in which one angle is right angle or
-- 90 degree.
-- Example:
local function right_angle_triangle(a, b, c)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = right_angle_triangle
lu.assertEquals(candidate(3, 4, 5), true)
lu.assertEquals(candidate(1, 2, 3), false)
lu.assertEquals(candidate(10, 6, 8), true)
lu.assertEquals(candidate(2, 2, 2), false)
lu.assertEquals(candidate(7, 24, 25), t... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_158_find_max | lua | -- Write a function that accepts a list of strings.
-- The list contains different words. Return the word with maximum number
-- of unique characters. If multiple strings have maximum number of unique
-- characters, return the one which comes first in lexicographical order.
local function find_max(words)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = find_max
lu.assertEquals(candidate({'name', 'of', 'string'}), 'string')
lu.assertEquals(candidate({'name', 'enam', 'game'}), 'enam')
lu.assertEquals(candidate({'aaaaaaa', 'bb', 'cc'}), 'aaaaaaa')
lu.assertEquals(candidate({'abc', 'cba'... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_159_eat | lua | -- You're a hungry rabbit, and you already have eaten a certain number of carrots,
-- but now you need to eat more carrots to complete the day's meals.
-- you should return an array of [ total number of eaten carrots after your meals,
-- the number of carrots left after your meals ]
-- i... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = eat
lu.assertEquals(candidate(5, 6, 10), {11, 4})
lu.assertEquals(candidate(4, 8, 9), {12, 1})
lu.assertEquals(candidate(1, 10, 10), {11, 0})
lu.assertEquals(candidate(2, 11, 5), {7, 0})
lu.assertEquals(candidate(4, 5, 7), {9, 2})
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_15_string_sequence | lua | -- Return a string containing space-delimited numbers starting from 0 upto n inclusive.
local function string_sequence(n)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_15_string_sequence.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = string_sequence
lu.assertEquals(candidate(0), '0')
lu.assertEquals(candidate(3), '0 1 2 3')
lu.assertEquals(candidate(10), '0 1 2 3 4 5 6 7 8 9 10')
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_161_solve | lua | -- You are given a string s.
-- if s[i] is a letter, reverse its case from lower to upper or vise versa,
-- otherwise keep it as it is.
-- If the string contains no letters, reverse the string.
-- The function should return the resulted string.
-- Examples
local function solve(s)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = solve
lu.assertEquals(candidate('AsDf'), 'aSdF')
lu.assertEquals(candidate('1234'), '4321')
lu.assertEquals(candidate('ab'), 'AB')
lu.assertEquals(candidate('#a@C'), '#A@c')
lu.assertEquals(candidate('#AsdfW^45'), '#aSDFw^45')
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_162_string_to_md5 | lua | -- Given a string 'text', return its md5 hash equivalent string.
-- If 'text' is an empty string, return None.
local function string_to_md5(text)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_162_string_to_md5.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = string_to_md5
lu.assertEquals(candidate('Hello world'), '3e25960a79dbc69b674cd4ec67a72c62')
lu.assertEquals(candidate(''), None)
lu.assertEquals(candidate('A B C'), '0ef78513b0cb8cef12743f5aeb35f888')
lu.assertEquals(candidate('passwor... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_163_generate_integers | lua | -- Given two positive integers a and b, return the even digits between a
-- and b, in ascending order.
-- For example:
local function generate_integers(a, b)
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = generate_integers
lu.assertEquals(candidate(2, 10), {2, 4, 6, 8})
lu.assertEquals(candidate(10, 2), {2, 4, 6, 8})
lu.assertEquals(candidate(132, 2), {2, 4, 6, 8})
lu.assertEquals(candidate(17, 89), {})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.