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_110_exchange | lua | -- In this problem, you will implement a function that takes two tables of numbers,
-- and determines whether it is possible to perform an exchange of elements
-- between them to make lst1 a table of only even numbers.
-- There is no limit on the number of exchanged elements between lst1 and lst2.
-- If it is possible ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py | reworded | 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 table
-- of the letter with the most repetition and containing the corresponding count.
-- If several letters have the same occurrence, return all of them.
-- Example:
-- >>> histogram('a b c')
-- {['a'] = 1, ['b'] = 1, ['c'] = 1}
-- >>> histo... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py | reworded | 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 table containing the result string and true/fa... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py | reworded | 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 table of strings, where each string consists of only digits, return a table.
-- 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.
-- >>> odd_count({'1234567'... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py | reworded | 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 a table of integers nums, find the minimum sum of any non-empty sub-table
-- of nums.
-- Example
-- >>> minSubArraySum({2, 3, 4, 1, 2, 4})
-- 1
-- >>> minSubArraySum({-1, -2, -3})
-- -6
local function minSubArraySum(nums)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py | reworded | 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.... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py | reworded | 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 a table 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:
-- >>> sort_array({1, 5, 2, 3, 4})
-- {1, 2, 3, 4, 5}
-- >>> sort_array({-... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_sort_array.py | reworded | 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 table 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 table.
-- Note: you may as... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py | reworded | 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 table 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py | reworded | 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.
-- >>> string_xor('010', '110')
-- '100'
local function string_xor(a, b)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_11_string_xor.py | reworded | 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 a table arr of integers and a positive integer k, return a sorted table
-- of length k with the maximum k numbers in arr.
-- Example 1:
-- >>> maximum({-3, -4, 5}, 3)
-- {-4, -3, 5}
-- Example 2:
-- >>> maximum({4, -4, 4}, 2)
-- {4, 4}
-- Example 3:
-- >>> maximum({-3, 2, 1, 2, -1, -2, 1}, 1)
-- {2}
-- Note:
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py | reworded | 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 table of integers, return the sum of all of the odd elements that are in even positions.
-- Examples
-- >>> solution({5, 8, 7, 1})
-- 12
-- >>> solution({3, 3, 3, 3, 3})
-- 9
-- >>> solution({30, 13, 24, 321})
-- 0
local function solution(lst)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py | reworded | 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 table 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:
-- >>> add_elements({111, 21, 3, 4000, 5, 6, 7, 8, 9}, 4)
-- 24
-- Constraints:
-- 1. 1 <= len(arr) <= 100
-- 2. 1 <= k <= len(arr)
local function ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py | reworded | 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 table 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py | reworded | 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 table 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
-- >>> split... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_125_split_words.py | reworded | 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 table of numbers, return whether or not they are sorted
-- in ascending order. If table has more than 1 duplicate of the same
-- number, return false. Assume no negative numbers and only integers.
-- Examples
-- >>> is_sorted({5})
-- true
-- >>> is_sorted({1, 2, 3, 4, 5})
-- true
-- >>> is_sorted({1, 3, 2, 4... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py | reworded | 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.
-- ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py | reworded | 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 a table arr of integers and you need to return
-- sum of magnitudes of integers multiplied by product of all signs
-- of each number in the table, represented by 1, -1 or 0.
-- Note: return nil for empty arr.
-- Example:
-- >>> prod_signs({1, 2, 2, -4})
-- 9
-- >>> prod_signs({0, 1})
-- 0
-- >>> prod_s... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_128_prod_signs.py | reworded | 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 ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py | reworded | 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 table of strings, return the longest one. Return the first one in case of multiple
-- strings of the same length. Return nil in case the input table is empty.
-- >>> longest({})
-- None
-- >>> longest({'a', 'b', 'c'})
-- 'a'
-- >>> longest({'a', 'bb', 'ccc'})
-- 'ccc'
local function longest(strings)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_12_longest.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py | reworded | 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:
-- >>> digits(1)
-- 1
-- >>> digits(4)
-- 0
-- >>> digits(235)
-- 15
local function digits(n)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py | reworded | 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.
-- >>> is_nested('[[]]')
-- true
-- >>> is_nested('[]]]]]]][[[[[]')
-- false
-- >... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py | reworded | 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 table of numbers.
-- You need to return the sum of squared numbers in the given table,
-- round each element in the table to the upper int(Ceiling) first.
-- Examples:
-- >>> lst({1.0, 2.0, 3.0})
-- 14
-- >>> lst({1.0, 4.0, 9.0})
-- 98
-- >>> lst({1.0, 3.0, 5.0, 7.0})
-- 84
-- >>> lst({1.4, 4.2, 0.0}... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py | reworded | 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:
-- >>> check_if_last_char_is_a_letter('apple pie')
-- false
-- >>> check_if_last_c... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py | reworded | 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 table will not contain
-- duplicate values.
-- Examples:
-- >>> can_arrange({1, 2, 4, 3, 5})
-- 3
-- >>> can_arrange({1... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py | reworded | 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 table (a, b), where 'a' is
-- the largest of negative integers, and 'b' is the smallest
-- of positive integers in a table.
-- If there is no negative or positive integers, return them as nil.
-- Examples:
-- >>> largest_smallest_integers({2, 4, 1, 3, 5, 7})
-- {None, 1}
-- >>> large... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py | reworded | 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 nil if the values are equal.
-- Note: If a real number is represented as a string, the floating point might be . or ,
-- >>> compare_one(1, 2.5)
-- 2.5
-- >>> ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_137_compare_one.py | reworded | 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
-- >>> is_equal_to_sum_even(4)
-- false
-- >>> is_equal_to_sum_even(6)
-- false
-- >>> is_equal_to_sum_even(8)
-- true
local function is_equal_to_sum_even(n)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py | reworded | 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:
-- >>> special_factorial(4)
-- 288
-- The function will receive an integer as input and should return the special
-- factorial of this integer.
local function special_factorial(n)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py | reworded | 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
-- >>> greatest_common_divisor(3, 5)
-- 1
-- >>> greatest_common_divisor(25, 15)
-- 5
local function greatest_common_divisor(a, b)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_13_greatest_common_divisor.py | reworded | 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 -
-- >>> fix_spaces(' Example')
-- 'Example'
-- >>> fix_spaces(' Example 1')
-- 'Example_1'
-- >>> fix_spaces(' Example 2')
-- '_Example_2'
-- >>> fix_... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py | reworded | 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 table of integers. For all entries in the table, 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 table whose inde... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py | reworded | 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 table 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 table.
-- For example:
-- >>> order_by_points({1, 11, -1, -11, -12})
-- {-1, -11, 1... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py | reworded | 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 a table of numbers as input and returns
-- the number of elements in the table that are greater than 10 and both
-- first and last digits of a number are odd (1, 3, 5, 7, 9).
-- For example:
-- >>> specialFilter({15, -73, 14, -15})
-- 1
-- >>> specialFilter({33, -2, -3, 45, 21, 109})
--... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py | reworded | 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 table 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 :
-- >>> get_max_trip... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py | reworded | 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 table containing all planets whose orbit... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_148_bf.py | reworded | 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 table of strings as a parameter,
-- deletes the strings that have odd lengths from it,
-- and returns the resulted table with a sorted order,
-- The table is always a table of strings and never a table of numbers,
-- and it may contain duplicates.
-- The order of the table should be a... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py | reworded | 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 table of all prefixes from shortest to longest of the input string
-- >>> all_prefixes('abc')
-- {'a', 'ab', 'abc'}
local function all_prefixes(string)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_14_all_prefixes.py | reworded | 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:
-- >>> x_or_y(7, 34, 12)
-- 34
-- >>> x_or_y(15, 8, 5)
-- 5
local function x_or_y(n, x, y)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py | reworded | 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 table of numbers, return the sum of squares of the numbers
-- in the table that are odd. Ignore numbers that are negative or not integers.
-- >>> double_the_difference({1, 3, 2, 0})
-- 10
-- >>> double_the_difference({-1, -2, 0})
-- 0
-- >>> double_the_difference({9, -2})
-- 81
-- >>> double_the_difference({... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py | reworded | 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 table 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 letter... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py | reworded | 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
-- >>> cycpattern_check('abcd', 'abd')
-- false
-- >>> cycpattern_check('hello', 'ell')
-- true
-- >>> cycpattern_check('whassup', 'psus')
-- false
-- >>> cycpattern_check('abab', 'baa')
-- true... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py | reworded | 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 table that has the number of even and odd digits respectively.
-- Example:
-- >>> even_odd_count(-12)
-- {1, 1}
-- >>> even_odd_count(123)
-- {1, 2}
local function even_odd_count(num)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py | reworded | 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:
-- >>> int_to_mini_roman(19)
-- 'xix'
-- >>> int_to_mini_roman(152)
-- 'clii'
-- >>> int_to_mini_roman(426)
-- 'cdxxvi'
local function int_to_mini_roman(number)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py | reworded | 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:
-- >>> right_angle_triangle(3, 4, 5)
-- true
-- >>> right_angle_triangle(1, 2, ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py | reworded | 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 table of strings.
-- The table 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.
-- >>> find_max({'name', 'of', 'string'})
-... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py | reworded | 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 a table of [ total number of eaten carrots after your meals,
-- the number of carrots left after your meals ]
-- if... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py | reworded | 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.
-- >>> string_sequence(0)
-- '0'
-- >>> string_sequence(5)
-- '0 1 2 3 4 5'
local function string_sequence(n)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_15_string_sequence.py | reworded | 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_160_do_algebra | lua | -- Given two tables operator, and operand. The first table has basic algebra operations, and
-- the second table is a table of integers. Use the two given tables to build the algebric
-- expression and return the evaluation of this expression.
-- The basic algebra operations:
-- Addition ( + )
-- Subtraction ( - )
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = do_algebra
lu.assertEquals(candidate({'**', '*', '+'}, {2, 3, 4, 5}), 37)
lu.assertEquals(candidate({'+', '*', '-'}, {2, 3, 4, 5}), 9)
lu.assertEquals(candidate({'//', '*'}, {7, 3, 4}), 8)
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
-- >>> solve('1234')
-- '4321'
-- >>> solve('ab')
-- 'AB'
-- >... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py | reworded | 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 nil.
-- >>> string_to_md5('Hello world')
-- '3e25960a79dbc69b674cd4ec67a72c62'
local function string_to_md5(text)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_162_string_to_md5.py | reworded | 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:
-- >>> generate_integers(2, 8)
-- {2, 4, 6, 8}
-- >>> generate_integers(8, 2)
-- {2, 4, 6, 8}
-- >>> generate_integers(10, 14)
-- {}
local function generate_integers(a, b)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py | reworded | 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"
] |
HumanEval_16_count_distinct_characters | lua | -- Given a string, find out how many distinct characters (regardless of case) does it consist of
-- >>> count_distinct_characters('xyzXYZ')
-- 3
-- >>> count_distinct_characters('Jerry')
-- 4
local function count_distinct_characters(string)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_16_count_distinct_characters.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = count_distinct_characters
lu.assertEquals(candidate(''), 0)
lu.assertEquals(candidate('abcde'), 5)
lu.assertEquals(candidate('abcdecadeCADE'), 5)
lu.assertEquals(candidate('aaaaAAAAaaaa'), 1)
lu.assertEquals(candidate('Jerry jERRY ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_17_parse_music | lua | -- Input to this function is a string representing musical notes in a special ASCII format.
-- Your task is to parse this string and return table of integers corresponding to how many beats does each
-- not last.
-- Here is a legend:
-- 'o' - whole note, lasts four beats
-- 'o|' - half note, lasts two beats
-- '.|' - ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_17_parse_music.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = parse_music
lu.assertEquals(candidate(''), {})
lu.assertEquals(candidate('o o o o'), {4, 4, 4, 4})
lu.assertEquals(candidate('.| .| .| .|'), {1, 1, 1, 1})
lu.assertEquals(candidate('o| o| .| .| o o o o'), {2, 2, 1, 1, 4, 4, 4, 4})
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_18_how_many_times | lua | -- Find how many times a given substring can be found in the original string. Count overlaping cases.
-- >>> how_many_times('', 'a')
-- 0
-- >>> how_many_times('aaa', 'a')
-- 3
-- >>> how_many_times('aaaa', 'aa')
-- 3
local function how_many_times(string, substring)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_18_how_many_times.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = how_many_times
lu.assertEquals(candidate('', 'x'), 0)
lu.assertEquals(candidate('xyxyxyx', 'x'), 4)
lu.assertEquals(candidate('cacacacac', 'cac'), 4)
lu.assertEquals(candidate('john doe', 'john'), 1)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_19_sort_numbers | lua | -- Input is a space-delimited string of numberals from 'zero' to 'nine'.
-- Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
-- Return the string with numbers sorted from smallest to largest
-- >>> sort_numbers('three one five')
-- 'one three five'
local function sor... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_19_sort_numbers.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = sort_numbers
lu.assertEquals(candidate(''), '')
lu.assertEquals(candidate('three'), 'three')
lu.assertEquals(candidate('three five nine'), 'three five nine')
lu.assertEquals(candidate('five zero four seven nine eight'), 'zero four five... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_1_separate_paren_groups | lua | -- Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
-- separate those group into separate strings and return the table of those.
-- Separate groups are balanced (each open brace is properly closed) and not nested within each other
-- Ignore any spaces in the input st... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_1_separate_paren_groups.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = separate_paren_groups
lu.assertEquals(candidate('(()()) ((())) () ((())()())'), {'(()())', '((()))', '()', '((())()())'})
lu.assertEquals(candidate('() (()) ((())) (((())))'), {'()', '(())', '((()))', '(((())))'})
lu.assertEquals(candidate... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_20_find_closest_elements | lua | -- From a supplied table of numbers (of length at least two) select and return two that are the closest to each
-- other and return them in order (smaller number, larger number).
-- >>> find_closest_elements({1.0, 2.0, 3.0, 4.0, 5.0, 2.2})
-- {2.0, 2.2}
-- >>> find_closest_elements({1.0, 2.0, 3.0, 4.0, 5.0, 2.0})
-- {... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_20_find_closest_elements.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = find_closest_elements
lu.assertEquals(candidate({1.0, 2.0, 3.9, 4.0, 5.0, 2.2}), {3.9, 4.0})
lu.assertEquals(candidate({1.0, 2.0, 5.9, 4.0, 5.0}), {5.0, 5.9})
lu.assertEquals(candidate({1.0, 2.0, 3.0, 4.0, 5.0, 2.2}), {2.0, 2.2})
lu.as... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_21_rescale_to_unit | lua | -- Given table of numbers (of at least two elements), apply a linear transform to that table,
-- such that the smallest number will become 0 and the largest will become 1
-- >>> rescale_to_unit({1.0, 2.0, 3.0, 4.0, 5.0})
-- {0.0, 0.25, 0.5, 0.75, 1.0}
local function rescale_to_unit(numbers)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_21_rescale_to_unit.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = rescale_to_unit
lu.assertEquals(candidate({2.0, 49.9}), {0.0, 1.0})
lu.assertEquals(candidate({100.0, 49.9}), {1.0, 0.0})
lu.assertEquals(candidate({1.0, 2.0, 3.0, 4.0, 5.0}), {0.0, 0.25, 0.5, 0.75, 1.0})
lu.assertEquals(candidate({2.0... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_22_filter_integers | lua | -- Filter given table of any luathon values only for integers
-- >>> filter_integers({'a', 3.14, 5})
-- {5}
-- >>> filter_integers({1, 2, 3, 'abc', {}, {}})
-- {1, 2, 3}
local function filter_integers(values)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_22_filter_integers.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = filter_integers
lu.assertEquals(candidate({}), {})
lu.assertEquals(candidate({4, {}, {}, 23.2, 9, 'adasd'}), {4, 9})
lu.assertEquals(candidate({3, 'c', 3, 3, 'a', 'b'}), {3, 3, 3})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_23_strlen | lua | -- Return length of given string
-- >>> strlen('')
-- 0
-- >>> strlen('abc')
-- 3
local function strlen(string)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_23_strlen.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = strlen
lu.assertEquals(candidate(''), 0)
lu.assertEquals(candidate('x'), 1)
lu.assertEquals(candidate('asdasnakj'), 9)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_24_largest_divisor | lua | -- For a given number n, find the largest number that divides n evenly, smaller than n
-- >>> largest_divisor(15)
-- 5
local function largest_divisor(n)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_24_largest_divisor.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = largest_divisor
lu.assertEquals(candidate(3), 1)
lu.assertEquals(candidate(7), 1)
lu.assertEquals(candidate(10), 5)
lu.assertEquals(candidate(100), 50)
lu.assertEquals(candidate(49), 7)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_25_factorize | lua | -- Return table of prime factors of given integer in the order from smallest to largest.
-- Each of the factors should be tableed number of times corresponding to how many times it appeares in factorization.
-- Input number should be equal to the product of all factors
-- >>> factorize(8)
-- {2, 2, 2}
-- >>> factorize... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_25_factorize.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = factorize
lu.assertEquals(candidate(2), {2})
lu.assertEquals(candidate(4), {2, 2})
lu.assertEquals(candidate(8), {2, 2, 2})
lu.assertEquals(candidate(57), {3, 19})
lu.assertEquals(candidate(3249), {3, 3, 19, 19})
lu.assertEqual... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_26_remove_duplicates | lua | -- From a table of integers, remove all elements that occur more than once.
-- Keep order of elements left the same as in the input.
-- >>> remove_duplicates({1, 2, 3, 2, 4})
-- {1, 3, 4}
local function remove_duplicates(numbers)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_26_remove_duplicates.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = remove_duplicates
lu.assertEquals(candidate({}), {})
lu.assertEquals(candidate({1, 2, 3, 4}), {1, 2, 3, 4})
lu.assertEquals(candidate({1, 2, 3, 2, 4, 3, 5}), {1, 4, 5})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_27_flip_case | lua | -- For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
-- >>> flip_case('Hello')
-- 'hELLO'
local function flip_case(string)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_27_flip_case.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = flip_case
lu.assertEquals(candidate(''), '')
lu.assertEquals(candidate('Hello!'), 'hELLO!')
lu.assertEquals(candidate('These violent delights have violent ends'), 'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS')
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_28_concatenate | lua | -- Concatenate table of strings into a single string
-- >>> concatenate({})
-- ''
-- >>> concatenate({'a', 'b', 'c'})
-- 'abc'
local function concatenate(strings)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_28_concatenate.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = concatenate
lu.assertEquals(candidate({}), '')
lu.assertEquals(candidate({'x', 'y', 'z'}), 'xyz')
lu.assertEquals(candidate({'x', 'y', 'z', 'w', 'k'}), 'xyzwk')
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_29_filter_by_prefix | lua | -- Filter an input table of strings only for ones that start with a given prefix.
-- >>> filter_by_prefix({}, 'a')
-- {}
-- >>> filter_by_prefix({'abc', 'bcd', 'cde', 'array'}, 'a')
-- {'abc', 'array'}
local function filter_by_prefix(strings, prefix)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_29_filter_by_prefix.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = filter_by_prefix
lu.assertEquals(candidate({}, 'john'), {})
lu.assertEquals(candidate({'xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'}, 'xxx'), {'xxx', 'xxxAAA', 'xxx'})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_2_truncate_number | lua | -- Given a positive floating point number, it can be decomposed into
-- and integer part (largest integer smaller than given number) and decimals
-- (leftover part always smaller than 1).
-- Return the decimal part of the number.
-- >>> truncate_number(3.5)
-- 0.5
local function truncate_number(number)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_2_truncate_number.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = truncate_number
lu.assertEquals(candidate(3.5), 0.5)
lu.assertEquals(candidate(1.25), 0.25)
lu.assertEquals(candidate(123.0), 0.0)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_30_get_positive | lua | -- Return only positive numbers in the table.
-- >>> get_positive({-1, 2, -4, 5, 6})
-- {2, 5, 6}
-- >>> get_positive({5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10})
-- {5, 3, 2, 3, 9, 123, 1}
local function get_positive(l)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_30_get_positive.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = get_positive
lu.assertEquals(candidate({-1, -2, 4, 5, 6}), {4, 5, 6})
lu.assertEquals(candidate({5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10}), {5, 3, 2, 3, 3, 9, 123, 1})
lu.assertEquals(candidate({-1, -2}), {})
lu.assertEquals(candidate({})... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_31_is_prime | lua | -- Return true if a given number is prime, and false otherwise.
-- >>> is_prime(6)
-- false
-- >>> is_prime(101)
-- true
-- >>> is_prime(11)
-- true
-- >>> is_prime(13441)
-- true
-- >>> is_prime(61)
-- true
-- >>> is_prime(4)
-- false
-- >>> is_prime(1)
-- false
local function is_prime(n)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_31_is_prime.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = is_prime
lu.assertEquals(candidate(6), false)
lu.assertEquals(candidate(101), true)
lu.assertEquals(candidate(11), true)
lu.assertEquals(candidate(13441), true)
lu.assertEquals(candidate(61), true)
lu.assertEquals(candidate(4),... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_33_sort_third | lua | -- This function takes a table l and returns a table l' such that
-- 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
-- to the values of the corresponding indicies of l, but sorted.
-- >>> sort_third({1, 2, 3})
-- {1, 2, 3}
-- ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_33_sort_third.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = sort_third
lu.assertEquals(candidate({5, 6, 3, 4, 8, 9, 2}), {2, 6, 3, 4, 8, 9, 5})
lu.assertEquals(candidate({5, 8, 3, 4, 6, 9, 2}), {2, 8, 3, 4, 6, 9, 5})
lu.assertEquals(candidate({5, 6, 9, 4, 8, 3, 2}), {2, 6, 9, 4, 8, 3, 5})
lu.as... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_34_unique | lua | -- Return sorted unique elements in a table
-- >>> unique({5, 3, 5, 2, 3, 3, 9, 0, 123})
-- {0, 2, 3, 5, 9, 123}
local function unique(l)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_34_unique.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = unique
lu.assertEquals(candidate({5, 3, 5, 2, 3, 3, 9, 0, 123}), {0, 2, 3, 5, 9, 123})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_35_max_element | lua | -- Return maximum element in the table.
-- >>> max_element({1, 2, 3})
-- 3
-- >>> max_element({5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10})
-- 123
local function max_element(l)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_35_max_element.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = max_element
lu.assertEquals(candidate({1, 2, 3}), 3)
lu.assertEquals(candidate({5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10}), 124)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_36_fizz_buzz | lua | -- Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
-- >>> fizz_buzz(50)
-- 0
-- >>> fizz_buzz(78)
-- 2
-- >>> fizz_buzz(79)
-- 3
local function fizz_buzz(n)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_36_fizz_buzz.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = fizz_buzz
lu.assertEquals(candidate(50), 0)
lu.assertEquals(candidate(78), 2)
lu.assertEquals(candidate(79), 3)
lu.assertEquals(candidate(100), 3)
lu.assertEquals(candidate(200), 6)
lu.assertEquals(candidate(4000), 192)
lu.... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_37_sort_even | lua | -- This function takes a table l and returns a table l' such that
-- l' is identical to l in the odd indicies, while its values at the even indicies are equal
-- to the values of the even indicies of l, but sorted.
-- >>> sort_even({1, 2, 3})
-- {1, 2, 3}
-- >>> sort_even({5, 6, 3, 4})
-- {3, 6, 5, 4}
local function so... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_37_sort_even.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = sort_even
lu.assertEquals(candidate({1, 2, 3}), {1, 2, 3})
lu.assertEquals(candidate({5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10}), {-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123})
lu.assertEquals(candidate({5, 8, -12, 4, 23, 2, 3, 11, 12, -10}), {-12,... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_39_prime_fib | lua | -- prime_fib returns n-th number that is a Fibonacci number and it's also prime.
-- >>> prime_fib(1)
-- 2
-- >>> prime_fib(2)
-- 3
-- >>> prime_fib(3)
-- 5
-- >>> prime_fib(4)
-- 13
-- >>> prime_fib(5)
-- 89
local function prime_fib(n)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_39_prime_fib.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = prime_fib
lu.assertEquals(candidate(1), 2)
lu.assertEquals(candidate(2), 3)
lu.assertEquals(candidate(3), 5)
lu.assertEquals(candidate(4), 13)
lu.assertEquals(candidate(5), 89)
lu.assertEquals(candidate(6), 233)
lu.assertEq... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_3_below_zero | lua | -- You're given a table of deposit and withdrawal operations on a bank account that starts with
-- zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
-- at that point function should return true. Otherwise it should return false.
-- >>> below_zero({1, 2, 3})
-- false
-- ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_3_below_zero.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = below_zero
lu.assertEquals(candidate({}), false)
lu.assertEquals(candidate({1, 2, -3, 1, 2, -3}), false)
lu.assertEquals(candidate({1, 2, -4, 5, 6}), true)
lu.assertEquals(candidate({1, -1, 2, -2, 5, -5, 4, -4}), false)
lu.assertEq... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_40_triples_sum_to_zero | lua | -- triples_sum_to_zero takes a table of integers as an input.
-- it returns true if there are three distinct elements in the table that
-- sum to zero, and false otherwise.
-- >>> triples_sum_to_zero({1, 3, 5, 0})
-- false
-- >>> triples_sum_to_zero({1, 3, -2, 1})
-- true
-- >>> triples_sum_to_zero({1, 2, 3, 7})
-- fal... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_40_triples_sum_to_zero.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = triples_sum_to_zero
lu.assertEquals(candidate({1, 3, 5, 0}), false)
lu.assertEquals(candidate({1, 3, 5, -1}), false)
lu.assertEquals(candidate({1, 3, -2, 1}), true)
lu.assertEquals(candidate({1, 2, 3, 7}), false)
lu.assertEquals(ca... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_41_car_race_collision | lua | -- Imagine a road that's a perfectly straight infinitely long line.
-- n cars are driving left to right; simultaneously, a different set of n cars
-- are driving right to left. The two sets of cars start out being very far from
-- each other. All cars move in the same speed. Two cars are said to collide
-- when a ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_41_car_race_collision.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = car_race_collision
lu.assertEquals(candidate(2), 4)
lu.assertEquals(candidate(3), 9)
lu.assertEquals(candidate(4), 16)
lu.assertEquals(candidate(8), 64)
lu.assertEquals(candidate(10), 100)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_42_incr_list | lua | -- Return table with elements incremented by 1.
-- >>> incr_list({1, 2, 3})
-- {2, 3, 4}
-- >>> incr_list({5, 3, 5, 2, 3, 3, 9, 0, 123})
-- {6, 4, 6, 3, 4, 4, 10, 1, 124}
local function incr_list(l)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_42_incr_list.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = incr_list
lu.assertEquals(candidate({}), {})
lu.assertEquals(candidate({3, 2, 1}), {4, 3, 2})
lu.assertEquals(candidate({5, 2, 5, 2, 3, 3, 9, 0, 123}), {6, 3, 6, 3, 4, 4, 10, 1, 124})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_43_pairs_sum_to_zero | lua | -- pairs_sum_to_zero takes a table of integers as an input.
-- it returns true if there are two distinct elements in the table that
-- sum to zero, and false otherwise.
-- >>> pairs_sum_to_zero({1, 3, 5, 0})
-- false
-- >>> pairs_sum_to_zero({1, 3, -2, 1})
-- false
-- >>> pairs_sum_to_zero({1, 2, 3, 7})
-- false
-- >>>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_43_pairs_sum_to_zero.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = pairs_sum_to_zero
lu.assertEquals(candidate({1, 3, 5, 0}), false)
lu.assertEquals(candidate({1, 3, -2, 1}), false)
lu.assertEquals(candidate({1, 2, 3, 7}), false)
lu.assertEquals(candidate({2, 4, -5, 3, 5, 7}), true)
lu.assertEqual... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_44_change_base | lua | -- Change numerical base of input number x to base.
-- return string representation after the conversion.
-- base numbers are less than 10.
-- >>> change_base(8, 3)
-- '22'
-- >>> change_base(8, 2)
-- '1000'
-- >>> change_base(7, 2)
-- '111'
local function change_base(x, base)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_44_change_base.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = change_base
lu.assertEquals(candidate(8, 3), '22')
lu.assertEquals(candidate(9, 3), '100')
lu.assertEquals(candidate(234, 2), '11101010')
lu.assertEquals(candidate(16, 2), '10000')
lu.assertEquals(candidate(8, 2), '1000')
lu.as... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_45_triangle_area | lua | -- Given length of a side and high return area for a triangle.
-- >>> triangle_area(5, 3)
-- 7.5
local function triangle_area(a, h)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_45_triangle_area.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = triangle_area
lu.assertEquals(candidate(5, 3), 7.5)
lu.assertEquals(candidate(2, 2), 2.0)
lu.assertEquals(candidate(10, 8), 40.0)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_46_fib4 | lua | -- The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-- fib4(0) -> 0
-- fib4(1) -> 0
-- fib4(2) -> 2
-- fib4(3) -> 0
-- fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
-- Please write a function to efficiently compute the n-th element of the fib4 number seque... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_46_fib4.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = fib4
lu.assertEquals(candidate(5), 4)
lu.assertEquals(candidate(8), 28)
lu.assertEquals(candidate(10), 104)
lu.assertEquals(candidate(12), 386)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_47_median | lua | -- Return median of elements in the table l.
-- >>> median({3, 1, 2, 4, 5})
-- 3
-- >>> median({-10, 4, 6, 1000, 10, 20})
-- 15.0
local function median(l)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_47_median.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = median
lu.assertEquals(candidate({3, 1, 2, 4, 5}), 3)
lu.assertEquals(candidate({-10, 4, 6, 1000, 10, 20}), 8.0)
lu.assertEquals(candidate({5}), 5)
lu.assertEquals(candidate({6, 5}), 5.5)
lu.assertEquals(candidate({8, 1, 3, 9, 9, 2... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_48_is_palindrome | lua | -- Checks if given string is a palindrome
-- >>> is_palindrome('')
-- true
-- >>> is_palindrome('aba')
-- true
-- >>> is_palindrome('aaaaa')
-- true
-- >>> is_palindrome('zbcd')
-- false
local function is_palindrome(text)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_48_is_palindrome.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = is_palindrome
lu.assertEquals(candidate(''), true)
lu.assertEquals(candidate('aba'), true)
lu.assertEquals(candidate('aaaaa'), true)
lu.assertEquals(candidate('zbcd'), false)
lu.assertEquals(candidate('xywyx'), true)
lu.assertE... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_49_modp | lua | -- Return 2^n modulo p (be aware of numerics).
-- >>> modp(3, 5)
-- 3
-- >>> modp(1101, 101)
-- 2
-- >>> modp(0, 101)
-- 1
-- >>> modp(3, 11)
-- 8
-- >>> modp(100, 101)
-- 1
local function modp(n, p)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_49_modp.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = modp
lu.assertEquals(candidate(3, 5), 3)
lu.assertEquals(candidate(1101, 101), 2)
lu.assertEquals(candidate(0, 101), 1)
lu.assertEquals(candidate(3, 11), 8)
lu.assertEquals(candidate(100, 101), 1)
lu.assertEquals(candidate(30, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_4_mean_absolute_deviation | lua | -- For a given table of input numbers, calculate Mean Absolute Deviation
-- around the mean of this dataset.
-- Mean Absolute Deviation is the average absolute difference between each
-- element and a centerpoint (mean in this case):
-- MAD = average | x - x_mean |
-- >>> mean_absolute_deviation({1.0, 2.0, 3.0, 4.0})
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_4_mean_absolute_deviation.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = mean_absolute_deviation
lu.assertEquals(candidate({1.0, 2.0}), 0.5)
lu.assertEquals(candidate({1.0, 2.0, 3.0, 4.0}), 1.0)
lu.assertEquals(candidate({1.0, 2.0, 3.0, 4.0, 5.0}), 1.2)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_51_remove_vowels | lua | -- remove_vowels is a function that takes string and returns string without vowels.
-- >>> remove_vowels('')
-- ''
-- >>> remove_vowels('abcdef')
-- 'bcdf'
-- >>> remove_vowels('aaaaa')
-- ''
-- >>> remove_vowels('aaBAA')
-- 'B'
-- >>> remove_vowels('zbcd')
-- 'zbcd'
local function remove_vowels(text)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_51_remove_vowels.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = remove_vowels
lu.assertEquals(candidate(''), '')
lu.assertEquals(candidate('abcdef\nghijklm'), 'bcdf\nghjklm')
lu.assertEquals(candidate('fedcba'), 'fdcb')
lu.assertEquals(candidate('eeeee'), '')
lu.assertEquals(candidate('acBAA'),... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_52_below_threshold | lua | -- Return true if all numbers in the table l are below threshold t.
-- >>> below_threshold({1, 2, 4, 10}, 100)
-- true
-- >>> below_threshold({1, 20, 4, 10}, 5)
-- false
local function below_threshold(l, t)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_52_below_threshold.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = below_threshold
lu.assertEquals(candidate({1, 2, 4, 10}, 100), true)
lu.assertEquals(candidate({1, 20, 4, 10}, 5), false)
lu.assertEquals(candidate({1, 20, 4, 10}, 21), true)
lu.assertEquals(candidate({1, 20, 4, 10}, 22), true)
lu.... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_53_add | lua | -- Add two numbers x and y
-- >>> add(2, 3)
-- 5
-- >>> add(5, 7)
-- 12
local function add(x, y)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_53_add.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = add
lu.assertEquals(candidate(0, 1), 1)
lu.assertEquals(candidate(1, 0), 1)
lu.assertEquals(candidate(2, 3), 5)
lu.assertEquals(candidate(5, 7), 12)
lu.assertEquals(candidate(7, 5), 12)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_54_same_chars | lua | -- Check if two words have the same characters.
-- >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
-- true
-- >>> same_chars('abcd', 'dddddddabc')
-- true
-- >>> same_chars('dddddddabc', 'abcd')
-- true
-- >>> same_chars('eabcd', 'dddddddabc')
-- false
-- >>> same_chars('abcd', 'dddddddabce')
-- false
-- >>> same_cha... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_54_same_chars.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = same_chars
lu.assertEquals(candidate('eabcdzzzz', 'dddzzzzzzzddeddabc'), true)
lu.assertEquals(candidate('abcd', 'dddddddabc'), true)
lu.assertEquals(candidate('dddddddabc', 'abcd'), true)
lu.assertEquals(candidate('eabcd', 'dddddddabc... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_55_fib | lua | -- Return n-th Fibonacci number.
-- >>> fib(10)
-- 55
-- >>> fib(1)
-- 1
-- >>> fib(8)
-- 21
local function fib(n)
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_55_fib.py | reworded | lu = require('luaunit')
function test_humaneval()
local candidate = fib
lu.assertEquals(candidate(10), 55)
lu.assertEquals(candidate(1), 1)
lu.assertEquals(candidate(8), 21)
lu.assertEquals(candidate(11), 89)
lu.assertEquals(candidate(12), 144)
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.