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_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:
-- >>> prod_signs([1, 2, 2, -4]) == -9
-- >>> prod_signs([0, 1]) == 0
-- >>> pro... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.
-- >>> longest([])
-- >>> longest(['a', 'b', 'c'])
-- 'a'
-- >>> longest(['a', 'bb', 'ccc'])
-- 'ccc'
local function longest(strings)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- digits(1) == 1
-- digits(4) == 0
-- digits(235) == 15
local function digits(n)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.
-- is_nested('[[]]') ➞ True
-- is_nested('[]]]]]]][[[[[]') ➞ False
-- is_nested('... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- For lst = [1,2,3] the output should be 14
-- For lst = [1,4,9] the output should be 98
-- For lst = [1,3,5,7] the output should be 84... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- check_if_last_char_is_a_letter("apple pie") ➞ False
-- check_if_last_char_is_a_... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- can_arrange([1,2,4,3,5]) = 3
-- can_arrange([1,2,3]) = -1
l... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
-- largest_small... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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 ,
-- compare_one(1, 2.5) ➞ 2.5
-- compare_... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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
-- 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- >>> 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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
-- >>> greatest_common_divisor(3, 5)
-- 1
-- >>> greatest_common_divisor(25, 15)
-- 5
local function greatest_common_divisor(a, b)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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 -
-- fix_spaces("Example") == "Example"
-- fix_spaces("Example 1") == "Example_1"
-- fix_spaces(" Example 2") == "_Example_2"
-- fix_spaces(" Example ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- specialFilter([15, -73, 14, -15]) => 1
-- specialFilter([33, -2, -3, 45, 21, 109]) => 2
loc... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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 :
-- Input: n = 5
-- Outp... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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
-- >>> all_prefixes('abc')
-- ['a', 'ab', 'abc']
local function all_prefixes(string)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- for x_or_y(7, 34, 12) == 34
-- for x_or_y(15, 8, 5) == 5
local function x_or_y(n, x, y)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.
-- double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
-- double_the_difference([-1, -2, 0]) == 0
-- double_the_difference([9, -2]) == 81
-- double_the_difference([0]... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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
-- cycpattern_check("abcd","abd") => False
-- cycpattern_check("hello","ell") => True
-- cycpattern_check("whassup","psus") => False
-- cycpattern_check("abab","baa") => True
-- cycpattern_check... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- even_odd_count(-12) ==> (1, 1)
-- even_odd_count(123) ==> (1, 2)
local function even_odd_count(num)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- >>> 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- right_angle_triangle(3, 4, 5) == True
-- right_angle_triangle(1, 2, 3) == Fa... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.
-- find_max(["name", "of", "string"]) == "str... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.
-- >>> string_sequence(0)
-- '0'
-- >>> string_sequence(5)
-- '0 1 2 3 4 5'
local function string_sequence(n)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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_160_do_algebra | lua | -- Given two lists operator, and operand. The first list has basic algebra operations, and
-- the second list is a list of integers. Use the two given lists to build the algebric
-- expression and return the evaluation of this expression.
-- The basic algebra operations:
-- Addition ( + )
-- Subtraction ( - )
-- Mu... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_160_do_algebra.py | verbatim | 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"
-- solve("#a@C... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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.
-- >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
local function string_to_md5(text)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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:
-- 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/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"
] |
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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_16_count_distinct_characters.py | verbatim | 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 list 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
-- '.|' - q... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_17_parse_music.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_18_how_many_times.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_19_sort_numbers.py | verbatim | 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 list of those.
-- Separate groups are balanced (each open brace is properly closed) and not nested within each other
-- Ignore any spaces in the input str... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_1_separate_paren_groups.py | verbatim | 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 list 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])
-- (2... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_20_find_closest_elements.py | verbatim | 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 list of numbers (of at least two elements), apply a linear transform to that list,
-- 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_21_rescale_to_unit.py | verbatim | 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 list of any python 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_22_filter_integers.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_23_strlen.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_24_largest_divisor.py | verbatim | 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 list of prime factors of given integer in the order from smallest to largest.
-- Each of the factors should be listed 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(2... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_25_factorize.py | verbatim | 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 list 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_26_remove_duplicates.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_27_flip_case.py | verbatim | 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 list of strings into a single string
-- >>> concatenate([])
-- ''
-- >>> concatenate(['a', 'b', 'c'])
-- 'abc'
local function concatenate(strings)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_28_concatenate.py | verbatim | 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 list 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_29_filter_by_prefix.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_2_truncate_number.py | verbatim | 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 list.
-- >>> 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_30_get_positive.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_31_is_prime.py | verbatim | 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 list l and returns a list 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]
-- >>... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_33_sort_third.py | verbatim | 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 list
-- >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
-- [0, 2, 3, 5, 9, 123]
local function unique(l)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_34_unique.py | verbatim | 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 list.
-- >>> 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_35_max_element.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_36_fizz_buzz.py | verbatim | 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 list l and returns a list 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 sort... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_37_sort_even.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_39_prime_fib.py | verbatim | 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 list 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
-- >... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_3_below_zero.py | verbatim | 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 list of integers as an input.
-- it returns True if there are three distinct elements in the list 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])
-- False... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_40_triples_sum_to_zero.py | verbatim | 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_41_car_race_collision.py | verbatim | 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 list 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_42_incr_list.py | verbatim | 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 list of integers as an input.
-- it returns True if there are two distinct elements in the list 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
-- >>> p... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_43_pairs_sum_to_zero.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_44_change_base.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_45_triangle_area.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_46_fib4.py | verbatim | 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 list l.
-- >>> median([3, 1, 2, 4, 5])
-- 3
-- >>> median([-10, 4, 6, 1000, 10, 20])
-- 15.0
local function median(l)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_47_median.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_48_is_palindrome.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_49_modp.py | verbatim | 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 list 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])
-... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_4_mean_absolute_deviation.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_51_remove_vowels.py | verbatim | 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 list 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_52_below_threshold.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_53_add.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_54_same_chars.py | verbatim | 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)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_55_fib.py | verbatim | 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"
] |
HumanEval_56_correct_bracketing | lua | -- brackets is a string of "<" and ">".
-- return True if every opening bracket has a corresponding closing bracket.
-- >>> correct_bracketing("<")
-- False
-- >>> correct_bracketing("<>")
-- True
-- >>> correct_bracketing("<<><>>")
-- True
-- >>> correct_bracketing("><<>")
-- False
local function correct_bracketing(b... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_56_correct_bracketing.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = correct_bracketing
lu.assertEquals(candidate('<>'), true)
lu.assertEquals(candidate('<<><>>'), true)
lu.assertEquals(candidate('<><><<><>><>'), true)
lu.assertEquals(candidate('<><><<<><><>><>><<><><<>>>'), true)
lu.assertEquals(ca... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_57_monotonic | lua | -- Return True is list elements are monotonically increasing or decreasing.
-- >>> monotonic([1, 2, 4, 20])
-- True
-- >>> monotonic([1, 20, 4, 10])
-- False
-- >>> monotonic([4, 1, 0, -10])
-- True
local function monotonic(l)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_57_monotonic.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = monotonic
lu.assertEquals(candidate({1, 2, 4, 10}), true)
lu.assertEquals(candidate({1, 2, 4, 20}), true)
lu.assertEquals(candidate({1, 20, 4, 10}), false)
lu.assertEquals(candidate({4, 1, 0, -10}), true)
lu.assertEquals(candidate(... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_58_common | lua | -- Return sorted unique common elements for two lists.
-- >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
-- [1, 5, 653]
-- >>> common([5, 3, 2, 8], [3, 2])
-- [2, 3]
local function common(l1, l2)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_58_common.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = common
lu.assertEquals(candidate({1, 4, 3, 34, 653, 2, 5}, {5, 7, 1, 5, 9, 653, 121}), {1, 5, 653})
lu.assertEquals(candidate({5, 3, 2, 8}, {3, 2}), {2, 3})
lu.assertEquals(candidate({4, 3, 2, 8}, {3, 2, 4}), {2, 3, 4})
lu.assertEquals... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_59_largest_prime_factor | lua | -- Return the largest prime factor of n. Assume n > 1 and is not a prime.
-- >>> largest_prime_factor(13195)
-- 29
-- >>> largest_prime_factor(2048)
-- 2
local function largest_prime_factor(n)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_59_largest_prime_factor.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = largest_prime_factor
lu.assertEquals(candidate(15), 5)
lu.assertEquals(candidate(27), 3)
lu.assertEquals(candidate(63), 7)
lu.assertEquals(candidate(330), 11)
lu.assertEquals(candidate(13195), 29)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_5_intersperse | lua | -- Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
-- >>> intersperse([], 4)
-- []
-- >>> intersperse([1, 2, 3], 4)
-- [1, 4, 2, 4, 3]
local function intersperse(numbers, delimeter)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_5_intersperse.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = intersperse
lu.assertEquals(candidate({}, 7), {})
lu.assertEquals(candidate({5, 6, 3, 2}, 8), {5, 8, 6, 8, 3, 8, 2})
lu.assertEquals(candidate({2, 2, 2}, 2), {2, 2, 2, 2, 2})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_60_sum_to_n | lua | -- sum_to_n is a function that sums numbers from 1 to n.
-- >>> sum_to_n(30)
-- 465
-- >>> sum_to_n(100)
-- 5050
-- >>> sum_to_n(5)
-- 15
-- >>> sum_to_n(10)
-- 55
-- >>> sum_to_n(1)
-- 1
local function sum_to_n(n)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_60_sum_to_n.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = sum_to_n
lu.assertEquals(candidate(1), 1)
lu.assertEquals(candidate(6), 21)
lu.assertEquals(candidate(11), 66)
lu.assertEquals(candidate(30), 465)
lu.assertEquals(candidate(100), 5050)
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_61_correct_bracketing | lua | -- brackets is a string of "(" and ")".
-- return True if every opening bracket has a corresponding closing bracket.
-- >>> correct_bracketing("(")
-- False
-- >>> correct_bracketing("()")
-- True
-- >>> correct_bracketing("(()())")
-- True
-- >>> correct_bracketing(")(()")
-- False
local function correct_bracketing(b... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_61_correct_bracketing.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = correct_bracketing
lu.assertEquals(candidate('()'), true)
lu.assertEquals(candidate('(()())'), true)
lu.assertEquals(candidate('()()(()())()'), true)
lu.assertEquals(candidate('()()((()()())())(()()(()))'), true)
lu.assertEquals(ca... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_62_derivative | lua | -- xs represent coefficients of a polynomial.
-- xs[0] + xs[1] * x + xs[2] * x^2 + ....
-- Return derivative of this polynomial in the same form.
-- >>> derivative([3, 1, 2, 4, 5])
-- [1, 4, 12, 20]
-- >>> derivative([1, 2, 3])
-- [2, 6]
local function derivative(xs)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_62_derivative.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = derivative
lu.assertEquals(candidate({3, 1, 2, 4, 5}), {1, 4, 12, 20})
lu.assertEquals(candidate({1, 2, 3}), {2, 6})
lu.assertEquals(candidate({3, 2, 1}), {2, 2})
lu.assertEquals(candidate({3, 2, 1, 0, 4}), {2, 2, 0, 16})
lu.assert... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_63_fibfib | lua | -- The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
-- fibfib(0) == 0
-- fibfib(1) == 0
-- fibfib(2) == 1
-- fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
-- Please write a function to efficiently compute the n-th element of the fibfib number sequence.
-- >>... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_63_fibfib.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = fibfib
lu.assertEquals(candidate(2), 1)
lu.assertEquals(candidate(1), 0)
lu.assertEquals(candidate(5), 4)
lu.assertEquals(candidate(8), 24)
lu.assertEquals(candidate(10), 81)
lu.assertEquals(candidate(12), 274)
lu.assertEqu... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_64_vowels_count | lua | -- Write a function vowels_count which takes a string representing
-- a word as input and returns the number of vowels in the string.
-- Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
-- vowel, but only when it is at the end of the given word.
-- Example:
-- >>> vowels_count("abcde")
-- 2
-- >>> v... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_64_vowels_count.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = vowels_count
lu.assertEquals(candidate('abcde'), 2)
lu.assertEquals(candidate('Alone'), 3)
lu.assertEquals(candidate('key'), 2)
lu.assertEquals(candidate('bye'), 1)
lu.assertEquals(candidate('keY'), 2)
lu.assertEquals(candidate... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_65_circular_shift | lua | -- Circular shift the digits of the integer x, shift the digits right by shift
-- and return the result as a string.
-- If shift > number of digits, return digits reversed.
-- >>> circular_shift(12, 1)
-- "21"
-- >>> circular_shift(12, 2)
-- "12"
local function circular_shift(x, shift)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_65_circular_shift.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = circular_shift
lu.assertEquals(candidate(100, 2), '001')
lu.assertEquals(candidate(12, 2), '12')
lu.assertEquals(candidate(97, 8), '79')
lu.assertEquals(candidate(12, 1), '21')
lu.assertEquals(candidate(11, 101), '11')
end
os.exit... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_66_digitSum | lua | -- Task
-- Write a function that takes a string as input and returns the sum of the upper characters only'
-- ASCII codes.
-- Examples:
-- digitSum("") => 0
-- digitSum("abAB") => 131
-- digitSum("abcCd") => 67
-- digitSum("helloE") => 69
-- digitSum("woArBld") => 131
-- digitSum("aAaaaXa") => 1... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_66_digitSum.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = digitSum
lu.assertEquals(candidate(''), 0)
lu.assertEquals(candidate('abAB'), 131)
lu.assertEquals(candidate('abcCd'), 67)
lu.assertEquals(candidate('helloE'), 69)
lu.assertEquals(candidate('woArBld'), 131)
lu.assertEquals(cand... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_67_fruit_distribution | lua | -- In this task, you will be given a string that represents a number of apples and oranges
-- that are distributed in a basket of fruit this basket contains
-- apples, oranges, and mango fruits. Given the string that represents the total number of
-- the oranges and apples and an integer that represent the total num... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_67_fruit_distribution.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = fruit_distribution
lu.assertEquals(candidate('5 apples and 6 oranges', 19), 8)
lu.assertEquals(candidate('5 apples and 6 oranges', 21), 10)
lu.assertEquals(candidate('0 apples and 1 oranges', 3), 2)
lu.assertEquals(candidate('1 apples ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_68_pluck | lua | -- "Given an array representing a branch of a tree that has non-negative integer nodes
-- your task is to pluck one of the nodes and return it.
-- The plucked node should be the node with the smallest even value.
-- If multiple nodes with the same smallest even value are found return the node that has smallest index.
-... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_68_pluck.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = pluck
lu.assertEquals(candidate({4, 2, 3}), {2, 1})
lu.assertEquals(candidate({1, 2, 3}), {2, 1})
lu.assertEquals(candidate({}), {})
lu.assertEquals(candidate({5, 0, 3, 0, 4, 2}), {0, 1})
lu.assertEquals(candidate({1, 2, 3, 0, 5, 3... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_69_search | lua | -- You are given a non-empty list of positive integers. Return the greatest integer that is greater than
-- zero, and has a frequency greater than or equal to the value of the integer itself.
-- The frequency of an integer is the number of times it appears in the list.
-- If no such a value exist, return -1.
-- Examp... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_69_search.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = search
lu.assertEquals(candidate({5, 5, 5, 5, 1}), 1)
lu.assertEquals(candidate({4, 1, 4, 1, 4, 4}), 4)
lu.assertEquals(candidate({3, 3}), -1)
lu.assertEquals(candidate({8, 8, 8, 8, 8, 8, 8, 8}), 8)
lu.assertEquals(candidate({2, 3,... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_6_parse_nested_parens | lua | -- Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
-- For each of the group, output the deepest level of nesting of parentheses.
-- E.g. (()()) has maximum two levels of nesting while ((())) has three.
-- >>> parse_nested_parens('(()()) ((())) () ((())()())')
... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_6_parse_nested_parens.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = parse_nested_parens
lu.assertEquals(candidate('(()()) ((())) () ((())()())'), {2, 3, 1, 3})
lu.assertEquals(candidate('() (()) ((())) (((())))'), {1, 2, 3, 4})
lu.assertEquals(candidate('(()(())((())))'), {4})
end
os.exit(lu.LuaUnit.run()... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_70_strange_sort_list | lua | -- Given list of integers, return list in strange order.
-- Strange sorting, is when you start with the minimum value,
-- then maximum of the remaining integers, then minimum and so on.
-- Examples:
-- strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
-- strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
-- strange_sort_lis... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_70_strange_sort_list.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = strange_sort_list
lu.assertEquals(candidate({1, 2, 3, 4}), {1, 4, 2, 3})
lu.assertEquals(candidate({5, 6, 7, 8, 9}), {5, 9, 6, 8, 7})
lu.assertEquals(candidate({1, 2, 3, 4, 5}), {1, 5, 2, 4, 3})
lu.assertEquals(candidate({5, 6, 7, 8, 9... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_71_triangle_area | lua | -- Given the lengths of the three sides of a triangle. Return the area of
-- the triangle rounded to 2 decimal points if the three sides form a valid triangle.
-- Otherwise return -1
-- Three sides make a valid triangle when the sum of any two sides is greater
-- than the third side.
-- Example:
-- triangle_area(3, 4... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_71_triangle_area.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = triangle_area
lu.assertEquals(candidate(3, 4, 5), 6.0)
lu.assertEquals(candidate(1, 2, 10), -1)
lu.assertEquals(candidate(4, 8, 5), 8.18)
lu.assertEquals(candidate(2, 2, 2), 1.73)
lu.assertEquals(candidate(1, 2, 3), -1)
lu.asse... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_72_will_it_fly | lua | -- Write a function that returns True if the object q will fly, and False otherwise.
-- The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.
-- Example:
-- will_it_fly([1, 2], 5) ➞ False
-- # 1+2 is less than the maximum poss... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_72_will_it_fly.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = will_it_fly
lu.assertEquals(candidate({3, 2, 3}, 9), true)
lu.assertEquals(candidate({1, 2}, 5), false)
lu.assertEquals(candidate({3}, 5), true)
lu.assertEquals(candidate({3, 2, 3}, 1), false)
lu.assertEquals(candidate({1, 2, 3}, 6... | [
"\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.