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_144_simplify | hs | -- | 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 deno... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_144_simplify.py | reworded |
main :: IO ()
main = do
let candidate = simplify
if candidate "1/5" "5/1" == True then pure () else error "assertion failed"
if candidate "1/6" "2/1" == False then pure () else error "assertion failed"
if candidate "5/1" "3/1" == True then pure () else error "assertion failed"
if candidate "7/10" "10/2" == F... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_145_order_by_points | hs | -- | 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:
-- >>> orderByPoints [1,11,(-1),(-11),(-12)]
-- [(-1),... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_145_order_by_points.py | reworded |
main :: IO ()
main = do
let candidate = orderByPoints
if candidate [1,11,(-1),(-11),(-12)] == [(-1),(-11),1,(-12),11] then pure () else error "assertion failed"
if 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,3457] then pure () else error "asserti... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_146_specialFilter | hs | -- | Write a function that takes a list of numbers as input and returns
-- the number of elements in the list 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 | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_146_specialFilter.py | reworded |
main :: IO ()
main = do
let candidate = specialfilter
if candidate [5,(-2),1,(-5)] == 0 then pure () else error "assertion failed"
if candidate [15,(-73),14,(-15)] == 1 then pure () else error "assertion failed"
if candidate [33,(-2),(-3),45,21,109] == 2 then pure () else error "assertion failed"
if candidat... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_147_get_max_triples | hs | -- | You are given a positive integer n. You have to create an integer list 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 :
-- >>> getMaxTriples 5
--... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_147_get_max_triples.py | reworded |
main :: IO ()
main = do
let candidate = getMaxTriples
if candidate 5 == 1 then pure () else error "assertion failed"
if candidate 6 == 4 then pure () else error "assertion failed"
if candidate 10 == 36 then pure () else error "assertion failed"
if candidate 100 == 53361 then pure () else error "assertion fai... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_149_sorted_list_sum | hs | -- | 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 a list of numbers,
-- and it may contain duplicates.
-- The order of the list should be ... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_149_sorted_list_sum.py | reworded |
main :: IO ()
main = do
let candidate = sortedListSum
if candidate ["aa","a","aaa"] == ["aa"] then pure () else error "assertion failed"
if candidate ["school","AI","asdf","b"] == ["AI","asdf","school"] then pure () else error "assertion failed"
if candidate ["d","b","c","a"] == [] then pure () else error "ass... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_14_all_prefixes | hs | -- | Return list of all prefixes from shortest to longest of the input string
-- >>> allPrefixes "abc"
-- ["a","ab","abc"]
allPrefixes :: String -> [String]
allPrefixes string = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_14_all_prefixes.py | reworded |
main :: IO ()
main = do
let candidate = allPrefixes
if candidate "" == [] then pure () else error "assertion failed"
if candidate "asdfgh" == ["a","as","asd","asdf","asdfg","asdfgh"] then pure () else error "assertion failed"
if candidate "WWW" == ["W","WW","WWW"] then pure () else error "assertion failed"
p... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_150_x_or_y | hs | -- | 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:
-- >>> xOrY 7 34 12
-- 34
-- >>> xOrY 15 8 5
-- 5
xOrY :: Int -> Int -> Int -> Int
xOrY n x y = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_150_x_or_y.py | reworded |
main :: IO ()
main = do
let candidate = xOrY
if candidate 7 34 12 == 34 then pure () else error "assertion failed"
if candidate 15 8 5 == 5 then pure () else error "assertion failed"
if candidate 3 33 5212 == 33 then pure () else error "assertion failed"
if candidate 1259 3 52 == 3 then pure () else error "a... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_151_double_the_difference | hs | -- | 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.
-- >>> doubleTheDifference [1,3,2,0]
-- 10
-- >>> doubleTheDifference [(-1),(-2),0]
-- 0
-- >>> doubleTheDifference [9,(-2)]
-- 81
-- >>> doubleTheDifference [0]
... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_151_double_the_difference.py | reworded |
main :: IO ()
main = do
let candidate = doubleTheDifference
if candidate [.0] == 0 then pure () else error "assertion failed"
if candidate [5.0,4.0] == 25 then pure () else error "assertion failed"
if candidate [0.1,0.2,0.3] == 0 then pure () else error "assertion failed"
if candidate [-10.0,-20.0,-30.0] == ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_152_compare | hs | -- | 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 giv... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_152_compare.py | reworded |
main :: IO ()
main = do
let candidate = compare
if candidate [1,2,3,4,5,1] [1,2,3,4,2,(-2)] == [0,0,0,0,3,3] then pure () else error "assertion failed"
if candidate [0,0,0,0,0,0] [0,0,0,0,0,0] == [0,0,0,0,0,0] then pure () else error "assertion failed"
if candidate [1,2,3] [(-1),(-2),(-3)] == [2,4,6] then pure... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_153_Strongest_Extension | hs | -- | 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 le... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_153_Strongest_Extension.py | reworded |
main :: IO ()
main = do
let candidate = strongestExtension
if candidate "Watashi" ["tEN","niNE","eIGHt8OKe"] == "Watashi.eIGHt8OKe" then pure () else error "assertion failed"
if candidate "Boku123" ["nani","NazeDa","YEs.WeCaNe","32145tggg"] == "Boku123.YEs.WeCaNe" then pure () else error "assertion failed"
if ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_154_cycpattern_check | hs | -- | 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
-- >>> cycpatternCheck "abcd" "abd"
-- False
-- >>> cycpatternCheck "hello" "ell"
-- True
-- >>> cycpatternCheck "whassup" "psus"
-- False
-- >>> cycpatternCheck "abab" "baa"
-- True
-... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_154_cycpattern_check.py | reworded |
main :: IO ()
main = do
let candidate = cycpatternCheck
if candidate "xyzw" "xyw" == False then pure () else error "assertion failed"
if candidate "yello" "ell" == True then pure () else error "assertion failed"
if candidate "whattup" "ptut" == False then pure () else error "assertion failed"
if candidate "e... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_155_even_odd_count | hs | -- | Given an integer. return a tuple that has the number of even and odd digits respectively.
-- Example:
-- >>> evenOddCount (-12)
-- (1, 1)
-- >>> evenOddCount 123
-- (1, 2)
evenOddCount :: Int -> (Int, Int)
evenOddCount num = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_155_even_odd_count.py | reworded |
main :: IO ()
main = do
let candidate = evenOddCount
if candidate 7 == (0, 1) then pure () else error "assertion failed"
if candidate (-78) == (1, 1) then pure () else error "assertion failed"
if candidate 3452 == (2, 2) then pure () else error "assertion failed"
if candidate 346211 == (3, 3) then pure () el... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_156_int_to_mini_roman | hs | -- | Given a positive integer, obtain its roman numeral equivalent as a string,
-- and return it in lowercase.
-- Restrictions: 1 <= num <= 1000
-- Examples:
-- >>> intToMiniRoman 19
-- "xix"
-- >>> intToMiniRoman 152
-- "clii"
-- >>> intToMiniRoman 426
-- "cdxxvi"
intToMiniRoman :: Int -> String
intToMiniRoma... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_156_int_to_mini_roman.py | reworded |
main :: IO ()
main = do
let candidate = intToMiniRoman
if candidate 19 == "xix" then pure () else error "assertion failed"
if candidate 152 == "clii" then pure () else error "assertion failed"
if candidate 251 == "ccli" then pure () else error "assertion failed"
if candidate 426 == "cdxxvi" then pure () else... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_157_right_angle_triangle | hs | -- | 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:
-- >>> rightAngleTriangle 3 4 5
-- True
-- >>> rightAngleTriangle 1 2 ... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_157_right_angle_triangle.py | reworded |
main :: IO ()
main = do
let candidate = rightAngleTriangle
if candidate 3 4 5 == True then pure () else error "assertion failed"
if candidate 1 2 3 == False then pure () else error "assertion failed"
if candidate 10 6 8 == True then pure () else error "assertion failed"
if candidate 2 2 2 == False then pure ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_158_find_max | hs | -- | 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.
-- >>> findMax ["name","of","string"]
-... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_158_find_max.py | reworded |
main :: IO ()
main = do
let candidate = findMax
if candidate ["name","of","string"] == "string" then pure () else error "assertion failed"
if candidate ["name","enam","game"] == "enam" then pure () else error "assertion failed"
if candidate ["aaaaaaa","bb","cc"] == "aaaaaaa" then pure () else error "assertion ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_159_eat | hs | -- | 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 list of [ total number of eaten carrots after your meals,
-- the number of carrots left after your meals ]
-- if there are not enough remai... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_159_eat.py | reworded |
main :: IO ()
main = do
let candidate = eat
if candidate 5 6 10 == [11,4] then pure () else error "assertion failed"
if candidate 4 8 9 == [12,1] then pure () else error "assertion failed"
if candidate 1 10 10 == [11,0] then pure () else error "assertion failed"
if candidate 2 11 5 == [7,0] then pure () else... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_15_string_sequence | hs | -- | Return a string containing space-delimited numbers starting from 0 upto n inclusive.
-- >>> stringSequence 0
-- "0"
-- >>> stringSequence 5
-- "0 1 2 3 4 5"
stringSequence :: Int -> String
stringSequence n = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_15_string_sequence.py | reworded |
main :: IO ()
main = do
let candidate = stringSequence
if candidate 0 == "0" then pure () else error "assertion failed"
if candidate 3 == "0 1 2 3" then pure () else error "assertion failed"
if candidate 10 == "0 1 2 3 4 5 6 7 8 9 10" then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_160_do_algebra | hs | -- | 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 ( - )... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_160_do_algebra.py | reworded |
main :: IO ()
main = do
let candidate = doAlgebra
if candidate ["**","*","+"] [2,3,4,5] == 37 then pure () else error "assertion failed"
if candidate ["+","*","-"] [2,3,4,5] == 9 then pure () else error "assertion failed"
if candidate ["//","*"] [7,3,4] == 8 then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_161_solve | hs | -- | 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"
-- ... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_161_solve.py | reworded |
main :: IO ()
main = do
let candidate = solve
if candidate "AsDf" == "aSdF" then pure () else error "assertion failed"
if candidate "1234" == "4321" then pure () else error "assertion failed"
if candidate "ab" == "AB" then pure () else error "assertion failed"
if candidate "#a@C" == "#A@c" then pure () else ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_162_string_to_md5 | hs | -- | Given a string 'text', return its md5 hash equivalent string.
-- If 'text' is an empty string, return Nothing.
-- >>> stringToMd5 "Hello world"
-- Just ("3e25960a79dbc69b674cd4ec67a72c62")
stringToMd5 :: String -> Maybe String
stringToMd5 text = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_162_string_to_md5.py | reworded |
main :: IO ()
main = do
let candidate = stringToMd5
if candidate "Hello world" == Just ("3e25960a79dbc69b674cd4ec67a72c62") then pure () else error "assertion failed"
if candidate "" == Just (Nothing) then pure () else error "assertion failed"
if candidate "A B C" == Just ("0ef78513b0cb8cef12743f5aeb35f888") t... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_163_generate_integers | hs | -- | Given two positive integers a and b, return the even digits between a
-- and b, in ascending order.
-- For example:
-- >>> generateIntegers 2 8
-- [2,4,6,8]
-- >>> generateIntegers 8 2
-- [2,4,6,8]
-- >>> generateIntegers 10 14
-- []
generateIntegers :: Int -> Int -> [Int]
generateIntegers a b = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_163_generate_integers.py | reworded |
main :: IO ()
main = do
let candidate = generateIntegers
if candidate 2 10 == [2,4,6,8] then pure () else error "assertion failed"
if candidate 10 2 == [2,4,6,8] then pure () else error "assertion failed"
if candidate 132 2 == [2,4,6,8] then pure () else error "assertion failed"
if candidate 17 89 == [] then... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_16_count_distinct_characters | hs | -- | Given a string, find out how many distinct characters (regardless of case) does it consist of
-- >>> countDistinctCharacters "xyzXYZ"
-- 3
-- >>> countDistinctCharacters "Jerry"
-- 4
countDistinctCharacters :: String -> Int
countDistinctCharacters string = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_16_count_distinct_characters.py | reworded |
main :: IO ()
main = do
let candidate = countDistinctCharacters
if candidate "" == 0 then pure () else error "assertion failed"
if candidate "abcde" == 5 then pure () else error "assertion failed"
if candidate "abcdecadeCADE" == 5 then pure () else error "assertion failed"
if candidate "aaaaAAAAaaaa" == 1 th... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_17_parse_music | hs | -- | 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
-- '... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_17_parse_music.py | reworded |
main :: IO ()
main = do
let candidate = parseMusic
if candidate "" == [] then pure () else error "assertion failed"
if candidate "o o o o" == [4,4,4,4] then pure () else error "assertion failed"
if candidate ".| .| .| .|" == [1,1,1,1] then pure () else error "assertion failed"
if candidate "o| o| .| .| o o o... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_18_how_many_times | hs | -- | Find how many times a given substring can be found in the original string. Count overlaping cases.
-- >>> howManyTimes "" "a"
-- 0
-- >>> howManyTimes "aaa" "a"
-- 3
-- >>> howManyTimes "aaaa" "aa"
-- 3
howManyTimes :: String -> String -> Int
howManyTimes string substring = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_18_how_many_times.py | reworded |
main :: IO ()
main = do
let candidate = howManyTimes
if candidate "" "x" == 0 then pure () else error "assertion failed"
if candidate "xyxyxyx" "x" == 4 then pure () else error "assertion failed"
if candidate "cacacacac" "cac" == 4 then pure () else error "assertion failed"
if candidate "john doe" "john" == ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_19_sort_numbers | hs | -- | 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
-- >>> sortNumbers "three one five"
-- "one three five"
sortNumbers :: ... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_19_sort_numbers.py | reworded |
main :: IO ()
main = do
let candidate = sortNumbers
if candidate "" == "" then pure () else error "assertion failed"
if candidate "three" == "three" then pure () else error "assertion failed"
if candidate "three five nine" == "three five nine" then pure () else error "assertion failed"
if candidate "five zer... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_1_separate_paren_groups | hs | -- | 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... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_1_separate_paren_groups.py | reworded |
main :: IO ()
main = do
let candidate = separateParenGroups
if candidate "(()()) ((())) () ((())()())" == ["(()())","((()))","()","((())()())"] then pure () else error "assertion failed"
if candidate "() (()) ((())) (((())))" == ["()","(())","((()))","(((())))"] then pure () else error "assertion failed"
if ca... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_20_find_closest_elements | hs | -- | 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).
-- >>> findClosestElements [1.0,2.0,3.0,4.0,5.0,2.2]
-- (2.0, 2.2)
-- >>> findClosestElements [1.0,2.0,3.0,4.0,5.0,2.0]
-- (2.0, 2.0)
f... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_20_find_closest_elements.py | reworded |
main :: IO ()
main = do
let candidate = findClosestElements
if candidate [1.0,2.0,3.9,4.0,5.0,2.2] == (3.9, 4.0) then pure () else error "assertion failed"
if candidate [1.0,2.0,5.9,4.0,5.0] == (5.0, 5.9) then pure () else error "assertion failed"
if candidate [1.0,2.0,3.0,4.0,5.0,2.2] == (2.0, 2.2) then pure ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_21_rescale_to_unit | hs | -- | 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
-- >>> rescaleToUnit [1.0,2.0,3.0,4.0,5.0]
-- [0.0,0.25,0.5,0.75,1.0]
rescaleToUnit :: [Float] -> [Float]
rescaleToUnit numbers = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_21_rescale_to_unit.py | reworded |
main :: IO ()
main = do
let candidate = rescaleToUnit
if candidate [2.0,49.9] == [0.0,1.0] then pure () else error "assertion failed"
if candidate [100.0,49.9] == [1.0,0.0] then pure () else error "assertion failed"
if candidate [1.0,2.0,3.0,4.0,5.0] == [0.0,0.25,0.5,0.75,1.0] then pure () else error "assertio... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_23_strlen | hs | -- | Return length of given string
-- >>> strlen ""
-- 0
-- >>> strlen "abc"
-- 3
strlen :: String -> Int
strlen string = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_23_strlen.py | reworded |
main :: IO ()
main = do
let candidate = strlen
if candidate "" == 0 then pure () else error "assertion failed"
if candidate "x" == 1 then pure () else error "assertion failed"
if candidate "asdasnakj" == 9 then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_24_largest_divisor | hs | -- | For a given number n, find the largest number that divides n evenly, smaller than n
-- >>> largestDivisor 15
-- 5
largestDivisor :: Int -> Int
largestDivisor n = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_24_largest_divisor.py | reworded |
main :: IO ()
main = do
let candidate = largestDivisor
if candidate 3 == 1 then pure () else error "assertion failed"
if candidate 7 == 1 then pure () else error "assertion failed"
if candidate 10 == 5 then pure () else error "assertion failed"
if candidate 100 == 50 then pure () else error "assertion failed... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_25_factorize | hs | -- | 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]
-- >>> factoriz... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_25_factorize.py | reworded |
main :: IO ()
main = do
let candidate = factorize
if candidate 2 == [2] then pure () else error "assertion failed"
if candidate 4 == [2,2] then pure () else error "assertion failed"
if candidate 8 == [2,2,2] then pure () else error "assertion failed"
if candidate 57 == [3,19] then pure () else error "asserti... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_26_remove_duplicates | hs | -- | From a list of integers, remove all elements that occur more than once.
-- Keep order of elements left the same as in the input.
-- >>> removeDuplicates [1,2,3,2,4]
-- [1,3,4]
removeDuplicates :: [Int] -> [Int]
removeDuplicates numbers = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_26_remove_duplicates.py | reworded |
main :: IO ()
main = do
let candidate = removeDuplicates
if candidate [] == [] then pure () else error "assertion failed"
if candidate [1,2,3,4] == [1,2,3,4] then pure () else error "assertion failed"
if candidate [1,2,3,2,4,3,5] == [1,4,5] then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_27_flip_case | hs | -- | For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
-- >>> flipCase "Hello"
-- "hELLO"
flipCase :: String -> String
flipCase string = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_27_flip_case.py | reworded |
main :: IO ()
main = do
let candidate = flipCase
if candidate "" == "" then pure () else error "assertion failed"
if candidate "Hello!" == "hELLO!" then pure () else error "assertion failed"
if candidate "These violent delights have violent ends" == "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS" then pure () else ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_28_concatenate | hs | -- | Concatenate list of strings into a single string
-- >>> concatenate []
-- ""
-- >>> concatenate ["a","b","c"]
-- "abc"
concatenate :: [String] -> String
concatenate strings = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_28_concatenate.py | reworded |
main :: IO ()
main = do
let candidate = concatenate
if candidate [] == "" then pure () else error "assertion failed"
if candidate ["x","y","z"] == "xyz" then pure () else error "assertion failed"
if candidate ["x","y","z","w","k"] == "xyzwk" then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_29_filter_by_prefix | hs | -- | Filter an input list of strings only for ones that start with a given prefix.
-- >>> filterByPrefix [] "a"
-- []
-- >>> filterByPrefix ["abc","bcd","cde","array"] "a"
-- ["abc","array"]
filterByPrefix :: [String] -> String -> [String]
filterByPrefix strings prefix = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_29_filter_by_prefix.py | reworded |
main :: IO ()
main = do
let candidate = filterByPrefix
if candidate [] "john" == [] then pure () else error "assertion failed"
if candidate ["xxx","asd","xxy","john doe","xxxAAA","xxx"] "xxx" == ["xxx","xxxAAA","xxx"] then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_2_truncate_number | hs | -- | 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.
-- >>> truncateNumber 3.5
-- 0.5
truncateNumber :: Float -> Float
truncateNumber nu... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_2_truncate_number.py | reworded |
main :: IO ()
main = do
let candidate = truncateNumber
if candidate 3.5 == 0.5 then pure () else error "assertion failed"
if candidate 1.25 == 0.25 then pure () else error "assertion failed"
if candidate 123.0 == 0.0 then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_30_get_positive | hs | -- | Return only positive numbers in the list.
-- >>> getPositive [(-1),2,(-4),5,6]
-- [2,5,6]
-- >>> getPositive [5,3,(-5),2,(-3),3,9,0,123,1,(-10)]
-- [5,3,2,3,9,123,1]
getPositive :: [Int] -> [Int]
getPositive l = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_30_get_positive.py | reworded |
main :: IO ()
main = do
let candidate = getPositive
if candidate [(-1),(-2),4,5,6] == [4,5,6] then pure () else error "assertion failed"
if candidate [5,3,(-5),2,3,3,9,0,123,1,(-10)] == [5,3,2,3,3,9,123,1] then pure () else error "assertion failed"
if candidate [(-1),(-2)] == [] then pure () else error "assert... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_31_is_prime | hs | -- | Return true if a given number is prime, and false otherwise.
-- >>> isPrime 6
-- False
-- >>> isPrime 101
-- True
-- >>> isPrime 11
-- True
-- >>> isPrime 13441
-- True
-- >>> isPrime 61
-- True
-- >>> isPrime 4
-- False
-- >>> isPrime 1
-- False
isPrime :: Int -> Bool
isPrime n = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_31_is_prime.py | reworded |
main :: IO ()
main = do
let candidate = isPrime
if candidate 6 == False then pure () else error "assertion failed"
if candidate 101 == True then pure () else error "assertion failed"
if candidate 11 == True then pure () else error "assertion failed"
if candidate 13441 == True then pure () else error "asserti... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_33_sort_third | hs | -- | 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.
-- >>> sortThird [1,2,3]
-- [1,2,3]
-- >... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_33_sort_third.py | reworded |
main :: IO ()
main = do
let candidate = sortThird
if candidate [5,6,3,4,8,9,2] == [2,6,3,4,8,9,5] then pure () else error "assertion failed"
if candidate [5,8,3,4,6,9,2] == [2,8,3,4,6,9,5] then pure () else error "assertion failed"
if candidate [5,6,9,4,8,3,2] == [2,6,9,4,8,3,5] then pure () else error "assert... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_34_unique | hs | -- | Return sorted unique elements in a list
-- >>> unique [5,3,5,2,3,3,9,0,123]
-- [0,2,3,5,9,123]
unique :: [Int] -> [Int]
unique l = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_34_unique.py | reworded |
main :: IO ()
main = do
let candidate = unique
if candidate [5,3,5,2,3,3,9,0,123] == [0,2,3,5,9,123] then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_35_max_element | hs | -- | Return maximum element in the list.
-- >>> maxElement [1,2,3]
-- 3
-- >>> maxElement [5,3,(-5),2,(-3),3,9,0,123,1,(-10)]
-- 123
maxElement :: [Int] -> Int
maxElement l = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_35_max_element.py | reworded |
main :: IO ()
main = do
let candidate = maxElement
if candidate [1,2,3] == 3 then pure () else error "assertion failed"
if candidate [5,3,(-5),2,(-3),3,9,0,124,1,(-10)] == 124 then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_36_fizz_buzz | hs | -- | Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
-- >>> fizzBuzz 50
-- 0
-- >>> fizzBuzz 78
-- 2
-- >>> fizzBuzz 79
-- 3
fizzBuzz :: Int -> Int
fizzBuzz n = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_36_fizz_buzz.py | reworded |
main :: IO ()
main = do
let candidate = fizzBuzz
if candidate 50 == 0 then pure () else error "assertion failed"
if candidate 78 == 2 then pure () else error "assertion failed"
if candidate 79 == 3 then pure () else error "assertion failed"
if candidate 100 == 3 then pure () else error "assertion failed"
i... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_37_sort_even | hs | -- | 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.
-- >>> sortEven [1,2,3]
-- [1,2,3]
-- >>> sortEven [5,6,3,4]
-- [3,6,5,4]
sortEven :: [Int] -> [Int... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_37_sort_even.py | reworded |
main :: IO ()
main = do
let candidate = sortEven
if candidate [1,2,3] == [1,2,3] then pure () else error "assertion failed"
if candidate [5,3,(-5),2,(-3),3,9,0,123,1,(-10)] == [(-10),3,(-5),2,(-3),3,5,0,9,1,123] then pure () else error "assertion failed"
if candidate [5,8,(-12),4,23,2,3,11,12,(-10)] == [(-12),... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_39_prime_fib | hs | -- | prime_fib returns n-th number that is a Fibonacci number and it's also prime.
-- >>> primeFib 1
-- 2
-- >>> primeFib 2
-- 3
-- >>> primeFib 3
-- 5
-- >>> primeFib 4
-- 13
-- >>> primeFib 5
-- 89
primeFib :: Int -> Int
primeFib n = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_39_prime_fib.py | reworded |
main :: IO ()
main = do
let candidate = primeFib
if candidate 1 == 2 then pure () else error "assertion failed"
if candidate 2 == 3 then pure () else error "assertion failed"
if candidate 3 == 5 then pure () else error "assertion failed"
if candidate 4 == 13 then pure () else error "assertion failed"
if ca... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_3_below_zero | hs | -- | 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.
-- >>> belowZero [1,2,3]
-- False
-- ... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_3_below_zero.py | reworded |
main :: IO ()
main = do
let candidate = belowZero
if candidate [] == False then pure () else error "assertion failed"
if candidate [1,2,(-3),1,2,(-3)] == False then pure () else error "assertion failed"
if candidate [1,2,(-4),5,6] == True then pure () else error "assertion failed"
if candidate [1,(-1),2,(-2)... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_40_triples_sum_to_zero | hs | -- | 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.
-- >>> triplesSumToZero [1,3,5,0]
-- False
-- >>> triplesSumToZero [1,3,(-2),1]
-- True
-- >>> triplesSumToZero [1,2,3,7]
-- False
-- >>> ... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_40_triples_sum_to_zero.py | reworded |
main :: IO ()
main = do
let candidate = triplesSumToZero
if candidate [1,3,5,0] == False then pure () else error "assertion failed"
if candidate [1,3,5,(-1)] == False then pure () else error "assertion failed"
if candidate [1,3,(-2),1] == True then pure () else error "assertion failed"
if candidate [1,2,3,7]... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_41_car_race_collision | hs | -- | 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
-- w... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_41_car_race_collision.py | reworded |
main :: IO ()
main = do
let candidate = carRaceCollision
if candidate 2 == 4 then pure () else error "assertion failed"
if candidate 3 == 9 then pure () else error "assertion failed"
if candidate 4 == 16 then pure () else error "assertion failed"
if candidate 8 == 64 then pure () else error "assertion failed... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_42_incr_list | hs | -- | Return list with elements incremented by 1.
-- >>> incrList [1,2,3]
-- [2,3,4]
-- >>> incrList [5,3,5,2,3,3,9,0,123]
-- [6,4,6,3,4,4,10,1,124]
incrList :: [Int] -> [Int]
incrList l = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_42_incr_list.py | reworded |
main :: IO ()
main = do
let candidate = incrList
if candidate [] == [] then pure () else error "assertion failed"
if candidate [3,2,1] == [4,3,2] then pure () else error "assertion failed"
if candidate [5,2,5,2,3,3,9,0,123] == [6,3,6,3,4,4,10,1,124] then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_43_pairs_sum_to_zero | hs | -- | 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.
-- >>> pairsSumToZero [1,3,5,0]
-- False
-- >>> pairsSumToZero [1,3,(-2),1]
-- False
-- >>> pairsSumToZero [1,2,3,7]
-- False
-- >>> pairsSumT... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_43_pairs_sum_to_zero.py | reworded |
main :: IO ()
main = do
let candidate = pairsSumToZero
if candidate [1,3,5,0] == False then pure () else error "assertion failed"
if candidate [1,3,(-2),1] == False then pure () else error "assertion failed"
if candidate [1,2,3,7] == False then pure () else error "assertion failed"
if candidate [2,4,(-5),3,5... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_44_change_base | hs | -- | Change numerical base of input number x to base.
-- return string representation after the conversion.
-- base numbers are less than 10.
-- >>> changeBase 8 3
-- "22"
-- >>> changeBase 8 2
-- "1000"
-- >>> changeBase 7 2
-- "111"
changeBase :: Int -> Int -> String
changeBase x base = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_44_change_base.py | reworded |
main :: IO ()
main = do
let candidate = changeBase
if candidate 8 3 == "22" then pure () else error "assertion failed"
if candidate 9 3 == "100" then pure () else error "assertion failed"
if candidate 234 2 == "11101010" then pure () else error "assertion failed"
if candidate 16 2 == "10000" then pure () els... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_45_triangle_area | hs | -- | Given length of a side and high return area for a triangle.
-- >>> triangleArea 5 3
-- 7.5
triangleArea :: Int -> Int -> Float
triangleArea a h = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_45_triangle_area.py | reworded |
main :: IO ()
main = do
let candidate = triangleArea
if candidate 5 3 == 7.5 then pure () else error "assertion failed"
if candidate 2 2 == 2.0 then pure () else error "assertion failed"
if candidate 10 8 == 40.0 then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_46_fib4 | hs | -- | 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 numb... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_46_fib4.py | reworded |
main :: IO ()
main = do
let candidate = fib4
if candidate 5 == 4 then pure () else error "assertion failed"
if candidate 8 == 28 then pure () else error "assertion failed"
if candidate 10 == 104 then pure () else error "assertion failed"
if candidate 12 == 386 then pure () else error "assertion failed"
pur... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_47_median | hs | -- | Return median of elements in the list l.
-- >>> median [3,1,2,4,5]
-- 3.0
-- >>> median [(-10),4,6,1000,10,20]
-- 15.0
median :: [Int] -> Float
median l = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_47_median.py | reworded |
main :: IO ()
main = do
let candidate = median
if candidate [3,1,2,4,5] == 3.0 then pure () else error "assertion failed"
if candidate [(-10),4,6,1000,10,20] == 8.0 then pure () else error "assertion failed"
if candidate [5] == 5.0 then pure () else error "assertion failed"
if candidate [6,5] == 5.5 then pur... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_48_is_palindrome | hs | -- | Checks if given string is a palindrome
-- >>> isPalindrome ""
-- True
-- >>> isPalindrome "aba"
-- True
-- >>> isPalindrome "aaaaa"
-- True
-- >>> isPalindrome "zbcd"
-- False
isPalindrome :: String -> Bool
isPalindrome text = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_48_is_palindrome.py | reworded |
main :: IO ()
main = do
let candidate = isPalindrome
if candidate "" == True then pure () else error "assertion failed"
if candidate "aba" == True then pure () else error "assertion failed"
if candidate "aaaaa" == True then pure () else error "assertion failed"
if candidate "zbcd" == False then pure () else ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_49_modp | hs | -- | 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
modp :: Int -> Int -> Int
modp n p = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_49_modp.py | reworded |
main :: IO ()
main = do
let candidate = modp
if candidate 3 5 == 3 then pure () else error "assertion failed"
if candidate 1101 101 == 2 then pure () else error "assertion failed"
if candidate 0 101 == 1 then pure () else error "assertion failed"
if candidate 3 11 == 8 then pure () else error "assertion fail... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_4_mean_absolute_deviation | hs | -- | 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 |
-- >>> meanAbsoluteDeviation [1.0,2.0,3.0,4.0]
-... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_4_mean_absolute_deviation.py | reworded |
main :: IO ()
main = do
let candidate = meanAbsoluteDeviation
if candidate [1.0,2.0] == 0.5 then pure () else error "assertion failed"
if candidate [1.0,2.0,3.0,4.0] == 1.0 then pure () else error "assertion failed"
if candidate [1.0,2.0,3.0,4.0,5.0] == 1.2 then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_51_remove_vowels | hs | -- | remove_vowels is a function that takes string and returns string without vowels.
-- >>> removeVowels ""
-- ""
-- >>> removeVowels "abcdef"
-- "bcdf"
-- >>> removeVowels "aaaaa"
-- ""
-- >>> removeVowels "aaBAA"
-- "B"
-- >>> removeVowels "zbcd"
-- "zbcd"
removeVowels :: String -> String
removeVowels text... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_51_remove_vowels.py | reworded |
main :: IO ()
main = do
let candidate = removeVowels
if candidate "" == "" then pure () else error "assertion failed"
if candidate "abcdef
ghijklm" == "bcdf
ghjklm" then pure () else error "assertion failed"
if candidate "fedcba" == "fdcb" then pure () else error "assertion failed"
if candidate "eeeee" == ""... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_52_below_threshold | hs | -- | Return True if all numbers in the list l are below threshold t.
-- >>> belowThreshold [1,2,4,10] 100
-- True
-- >>> belowThreshold [1,20,4,10] 5
-- False
belowThreshold :: [Int] -> Int -> Bool
belowThreshold l t = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_52_below_threshold.py | reworded |
main :: IO ()
main = do
let candidate = belowThreshold
if candidate [1,2,4,10] 100 == True then pure () else error "assertion failed"
if candidate [1,20,4,10] 5 == False then pure () else error "assertion failed"
if candidate [1,20,4,10] 21 == True then pure () else error "assertion failed"
if candidate [1,2... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_53_add | hs | -- | Add two numbers x and y
-- >>> add 2 3
-- 5
-- >>> add 5 7
-- 12
add :: Int -> Int -> Int
add x y = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_53_add.py | reworded |
main :: IO ()
main = do
let candidate = add
if candidate 0 1 == 1 then pure () else error "assertion failed"
if candidate 1 0 == 1 then pure () else error "assertion failed"
if candidate 2 3 == 5 then pure () else error "assertion failed"
if candidate 5 7 == 12 then pure () else error "assertion failed"
if... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_54_same_chars | hs | -- | Check if two words have the same characters.
-- >>> sameChars "eabcdzzzz" "dddzzzzzzzddeddabc"
-- True
-- >>> sameChars "abcd" "dddddddabc"
-- True
-- >>> sameChars "dddddddabc" "abcd"
-- True
-- >>> sameChars "eabcd" "dddddddabc"
-- False
-- >>> sameChars "abcd" "dddddddabce"
-- False
-- >>> sameChars ... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_54_same_chars.py | reworded |
main :: IO ()
main = do
let candidate = sameChars
if candidate "eabcdzzzz" "dddzzzzzzzddeddabc" == True then pure () else error "assertion failed"
if candidate "abcd" "dddddddabc" == True then pure () else error "assertion failed"
if candidate "dddddddabc" "abcd" == True then pure () else error "assertion fail... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_55_fib | hs | -- | Return n-th Fibonacci number.
-- >>> fib 10
-- 55
-- >>> fib 1
-- 1
-- >>> fib 8
-- 21
fib :: Int -> Int
fib n = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_55_fib.py | reworded |
main :: IO ()
main = do
let candidate = fib
if candidate 10 == 55 then pure () else error "assertion failed"
if candidate 1 == 1 then pure () else error "assertion failed"
if candidate 8 == 21 then pure () else error "assertion failed"
if candidate 11 == 89 then pure () else error "assertion failed"
if can... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_56_correct_bracketing | hs | -- | brackets is a string of "<" and ">".
-- return True if every opening bracket has a corresponding closing bracket.
-- >>> correctBracketing "<"
-- False
-- >>> correctBracketing "<>"
-- True
-- >>> correctBracketing "<<><>>"
-- True
-- >>> correctBracketing "><<>"
-- False
correctBracketing :: String -> Bo... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_56_correct_bracketing.py | reworded |
main :: IO ()
main = do
let candidate = correctBracketing
if candidate "<>" == True then pure () else error "assertion failed"
if candidate "<<><>>" == True then pure () else error "assertion failed"
if candidate "<><><<><>><>" == True then pure () else error "assertion failed"
if candidate "<><><<<><><>><>>... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_57_monotonic | hs | -- | 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
monotonic :: [Int] -> Bool
monotonic l = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_57_monotonic.py | reworded |
main :: IO ()
main = do
let candidate = monotonic
if candidate [1,2,4,10] == True then pure () else error "assertion failed"
if candidate [1,2,4,20] == True then pure () else error "assertion failed"
if candidate [1,20,4,10] == False then pure () else error "assertion failed"
if candidate [4,1,0,(-10)] == Tr... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_58_common | hs | -- | 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]
common :: [Int] -> [Int] -> [Int]
common l1 l2 = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_58_common.py | reworded |
main :: IO ()
main = do
let candidate = common
if candidate [1,4,3,34,653,2,5] [5,7,1,5,9,653,121] == [1,5,653] then pure () else error "assertion failed"
if candidate [5,3,2,8] [3,2] == [2,3] then pure () else error "assertion failed"
if candidate [4,3,2,8] [3,2,4] == [2,3,4] then pure () else error "assertio... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_59_largest_prime_factor | hs | -- | Return the largest prime factor of n. Assume n > 1 and is not a prime.
-- >>> largestPrimeFactor 13195
-- 29
-- >>> largestPrimeFactor 2048
-- 2
largestPrimeFactor :: Int -> Int
largestPrimeFactor n = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_59_largest_prime_factor.py | reworded |
main :: IO ()
main = do
let candidate = largestPrimeFactor
if candidate 15 == 5 then pure () else error "assertion failed"
if candidate 27 == 3 then pure () else error "assertion failed"
if candidate 63 == 7 then pure () else error "assertion failed"
if candidate 330 == 11 then pure () else error "assertion ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_5_intersperse | hs | -- | 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]
intersperse :: [Int] -> Int -> [Int]
intersperse numbers delimeter = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_5_intersperse.py | reworded |
main :: IO ()
main = do
let candidate = intersperse
if candidate [] 7 == [] then pure () else error "assertion failed"
if candidate [5,6,3,2] 8 == [5,8,6,8,3,8,2] then pure () else error "assertion failed"
if candidate [2,2,2] 2 == [2,2,2,2,2] then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_60_sum_to_n | hs | -- | sum_to_n is a function that sums numbers from 1 to n.
-- >>> sumToN 30
-- 465
-- >>> sumToN 100
-- 5050
-- >>> sumToN 5
-- 15
-- >>> sumToN 10
-- 55
-- >>> sumToN 1
-- 1
sumToN :: Int -> Int
sumToN n = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_60_sum_to_n.py | reworded |
main :: IO ()
main = do
let candidate = sumToN
if candidate 1 == 1 then pure () else error "assertion failed"
if candidate 6 == 21 then pure () else error "assertion failed"
if candidate 11 == 66 then pure () else error "assertion failed"
if candidate 30 == 465 then pure () else error "assertion failed"
if... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_61_correct_bracketing | hs | -- | brackets is a string of "(" and ")".
-- return True if every opening bracket has a corresponding closing bracket.
-- >>> correctBracketing "("
-- False
-- >>> correctBracketing "()"
-- True
-- >>> correctBracketing "(()())"
-- True
-- >>> correctBracketing ")(()"
-- False
correctBracketing :: String -> Bo... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_61_correct_bracketing.py | reworded |
main :: IO ()
main = do
let candidate = correctBracketing
if candidate "()" == True then pure () else error "assertion failed"
if candidate "(()())" == True then pure () else error "assertion failed"
if candidate "()()(()())()" == True then pure () else error "assertion failed"
if candidate "()()((()()())())... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_62_derivative | hs | -- | 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]
derivative :: [Int] -> [Int]
derivative xs = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_62_derivative.py | reworded |
main :: IO ()
main = do
let candidate = derivative
if candidate [3,1,2,4,5] == [1,4,12,20] then pure () else error "assertion failed"
if candidate [1,2,3] == [2,6] then pure () else error "assertion failed"
if candidate [3,2,1] == [2,2] then pure () else error "assertion failed"
if candidate [3,2,1,0,4] == [... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_63_fibfib | hs | -- | 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... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_63_fibfib.py | reworded |
main :: IO ()
main = do
let candidate = fibfib
if candidate 2 == 1 then pure () else error "assertion failed"
if candidate 1 == 0 then pure () else error "assertion failed"
if candidate 5 == 4 then pure () else error "assertion failed"
if candidate 8 == 24 then pure () else error "assertion failed"
if cand... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_64_vowels_count | hs | -- | 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:
-- >>> vowelsCount "abcde"
-- 2
--... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_64_vowels_count.py | reworded |
main :: IO ()
main = do
let candidate = vowelsCount
if candidate "abcde" == 2 then pure () else error "assertion failed"
if candidate "Alone" == 3 then pure () else error "assertion failed"
if candidate "key" == 2 then pure () else error "assertion failed"
if candidate "bye" == 1 then pure () else error "ass... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_65_circular_shift | hs | -- | 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.
-- >>> circularShift 12 1
-- "21"
-- >>> circularShift 12 2
-- "12"
circularShift :: Int -> Int -> String
circularShift x shift = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_65_circular_shift.py | reworded |
main :: IO ()
main = do
let candidate = circularShift
if candidate 100 2 == "001" then pure () else error "assertion failed"
if candidate 12 2 == "12" then pure () else error "assertion failed"
if candidate 97 8 == "79" then pure () else error "assertion failed"
if candidate 12 1 == "21" then pure () else er... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_66_digitSum | hs | -- | 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 "aAa... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_66_digitSum.py | reworded |
main :: IO ()
main = do
let candidate = digitsum
if candidate "" == 0 then pure () else error "assertion failed"
if candidate "abAB" == 131 then pure () else error "assertion failed"
if candidate "abcCd" == 67 then pure () else error "assertion failed"
if candidate "helloE" == 69 then pure () else error "ass... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_67_fruit_distribution | hs | -- | 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 tota... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_67_fruit_distribution.py | reworded |
main :: IO ()
main = do
let candidate = fruitDistribution
if candidate "5 apples and 6 oranges" 19 == 8 then pure () else error "assertion failed"
if candidate "5 apples and 6 oranges" 21 == 10 then pure () else error "assertion failed"
if candidate "0 apples and 1 oranges" 3 == 2 then pure () else error "asse... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_68_pluck | hs | -- | "Given a list 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... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_68_pluck.py | reworded |
main :: IO ()
main = do
let candidate = pluck
if candidate [4,2,3] == [2,1] then pure () else error "assertion failed"
if candidate [1,2,3] == [2,1] then pure () else error "assertion failed"
if candidate [] == [] then pure () else error "assertion failed"
if candidate [5,0,3,0,4,2] == [0,1] then pure () els... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_69_search | hs | -- | 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.
-- ... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_69_search.py | reworded |
main :: IO ()
main = do
let candidate = search
if candidate [5,5,5,5,1] == 1 then pure () else error "assertion failed"
if candidate [4,1,4,1,4,4] == 4 then pure () else error "assertion failed"
if candidate [3,3] == (-1) then pure () else error "assertion failed"
if candidate [8,8,8,8,8,8,8,8] == 8 then pur... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_6_parse_nested_parens | hs | -- | 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.
-- >>> parseNestedParens "(()()) ((())) () ((())()())"... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_6_parse_nested_parens.py | reworded |
main :: IO ()
main = do
let candidate = parseNestedParens
if candidate "(()()) ((())) () ((())()())" == [2,3,1,3] then pure () else error "assertion failed"
if candidate "() (()) ((())) (((())))" == [1,2,3,4] then pure () else error "assertion failed"
if candidate "(()(())((())))" == [4] then pure () else erro... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_70_strange_sort_list | hs | -- | 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:
-- >>> strangeSortList [1,2,3,4]
-- [1,4,2,3]
-- >>> strangeSortList [5,5,5,5]
-- [5,5,5,5]
-- >>> strangeSortL... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_70_strange_sort_list.py | reworded |
main :: IO ()
main = do
let candidate = strangeSortList
if candidate [1,2,3,4] == [1,4,2,3] then pure () else error "assertion failed"
if candidate [5,6,7,8,9] == [5,9,6,8,7] then pure () else error "assertion failed"
if candidate [1,2,3,4,5] == [1,5,2,4,3] then pure () else error "assertion failed"
if candi... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_71_triangle_area | hs | -- | 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:
-- >>> triang... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_71_triangle_area.py | reworded |
main :: IO ()
main = do
let candidate = triangleArea
if candidate 3 4 5 == 6.0 then pure () else error "assertion failed"
if candidate 1 2 10 == (-1).0 then pure () else error "assertion failed"
if candidate 4 8 5 == 8.18 then pure () else error "assertion failed"
if candidate 2 2 2 == 1.73 then pure () else... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_72_will_it_fly | hs | -- | 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:
-- >>> willItFly [1,2] 5
-- False
-- # 1+2 is less than the maximu... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_72_will_it_fly.py | reworded |
main :: IO ()
main = do
let candidate = willItFly
if candidate [3,2,3] 9 == True then pure () else error "assertion failed"
if candidate [1,2] 5 == False then pure () else error "assertion failed"
if candidate [3] 5 == True then pure () else error "assertion failed"
if candidate [3,2,3] 1 == False then pure ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_73_smallest_change | hs | -- | Given a list arr of integers, find the minimum number of elements that
-- need to be changed to make the list palindromic. A palindromic list is a list that
-- is read the same backwards and forwards. In one change, you can change one element to any other element.
-- For example:
-- >>> smallestChange [1,2,3,5... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_73_smallest_change.py | reworded |
main :: IO ()
main = do
let candidate = smallestChange
if candidate [1,2,3,5,4,7,9,6] == 4 then pure () else error "assertion failed"
if candidate [1,2,3,4,3,2,2] == 1 then pure () else error "assertion failed"
if candidate [1,4,2] == 1 then pure () else error "assertion failed"
if candidate [1,4,4,2] == 1 t... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_74_total_match | hs | -- | Write a function that accepts two lists of strings and returns the list that has
-- total number of chars in the all strings of the list less than the other list.
-- if the two lists have the same number of chars, return the first list.
-- Examples
-- >>> totalMatch [] []
-- []
-- >>> totalMatch ["hi","admi... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_74_total_match.py | reworded |
main :: IO ()
main = do
let candidate = totalMatch
if candidate [] [] == [] then pure () else error "assertion failed"
if candidate ["hi","admin"] ["hi","hi"] == ["hi","hi"] then pure () else error "assertion failed"
if candidate ["hi","admin"] ["hi","hi","admin","project"] == ["hi","admin"] then pure () else ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_75_is_multiply_prime | hs | -- | Write a function that returns true if the given number is the multiplication of 3 prime numbers
-- and false otherwise.
-- Knowing that (a) is less then 100.
-- Example:
-- >>> isMultiplyPrime 30
-- True
-- 30 = 2 * 3 * 5
isMultiplyPrime :: Int -> Bool
isMultiplyPrime a = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_75_is_multiply_prime.py | reworded |
main :: IO ()
main = do
let candidate = isMultiplyPrime
if candidate 5 == False then pure () else error "assertion failed"
if candidate 30 == True then pure () else error "assertion failed"
if candidate 8 == True then pure () else error "assertion failed"
if candidate 10 == False then pure () else error "ass... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_76_is_simple_power | hs | -- | Your task is to write a function that returns true if a number x is a simple
-- power of n and false in other cases.
-- x is a simple power of n if n**int=x
-- For example:
-- >>> isSimplePower 1 4
-- True
-- >>> isSimplePower 2 2
-- True
-- >>> isSimplePower 8 2
-- True
-- >>> isSimplePower 3 2
-- Fals... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_76_is_simple_power.py | reworded |
main :: IO ()
main = do
let candidate = isSimplePower
if candidate 16 2 == True then pure () else error "assertion failed"
if candidate 143214 16 == False then pure () else error "assertion failed"
if candidate 4 2 == True then pure () else error "assertion failed"
if candidate 9 3 == True then pure () else ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_77_iscube | hs | -- | Write a function that takes an integer a and returns True
-- if this ingeger is a cube of some integer number.
-- Note: you may assume the input is always valid.
-- Examples:
-- >>> iscube 1
-- True
-- >>> iscube 2
-- False
-- >>> iscube (-1)
-- True
-- >>> iscube 64
-- True
-- >>> iscube 0
-- True
-... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_77_iscube.py | reworded |
main :: IO ()
main = do
let candidate = iscube
if candidate 1 == True then pure () else error "assertion failed"
if candidate 2 == False then pure () else error "assertion failed"
if candidate (-1) == True then pure () else error "assertion failed"
if candidate 64 == True then pure () else error "assertion f... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_78_hex_key | hs | -- | You have been tasked to write a function that receives
-- a hexadecimal number as a string and counts the number of hexadecimal
-- digits that are primes (prime number, or a prime, is a natural number
-- greater than 1 that is not a product of two smaller natural numbers).
-- Hexadecimal digits are 0, 1, 2,... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_78_hex_key.py | reworded |
main :: IO ()
main = do
let candidate = hexKey
if candidate "AB" == 1 then pure () else error "assertion failed"
if candidate "1077E" == 2 then pure () else error "assertion failed"
if candidate "ABED1A33" == 4 then pure () else error "assertion failed"
if candidate "2020" == 2 then pure () else error "asser... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_79_decimal_to_binary | hs | -- | You will be given a number in decimal form and your task is to convert it to
-- binary format. The function should return a string, with each character representing a binary
-- number. Each character in the string will be '0' or '1'.
-- There will be an extra couple of characters 'db' at the beginning and at th... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_79_decimal_to_binary.py | reworded |
main :: IO ()
main = do
let candidate = decimalToBinary
if candidate 0 == "db0db" then pure () else error "assertion failed"
if candidate 32 == "db100000db" then pure () else error "assertion failed"
if candidate 103 == "db1100111db" then pure () else error "assertion failed"
if candidate 15 == "db1111db" th... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_7_filter_by_substring | hs | -- | Filter an input list of strings only for ones that contain given substring
-- >>> filterBySubstring [] "a"
-- []
-- >>> filterBySubstring ["abc","bacd","cde","array"] "a"
-- ["abc","bacd","array"]
filterBySubstring :: [String] -> String -> [String]
filterBySubstring strings substring = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_7_filter_by_substring.py | reworded |
main :: IO ()
main = do
let candidate = filterBySubstring
if candidate [] "john" == [] then pure () else error "assertion failed"
if candidate ["xxx","asd","xxy","john doe","xxxAAA","xxx"] "xxx" == ["xxx","xxxAAA","xxx"] then pure () else error "assertion failed"
if candidate ["xxx","asd","aaaxxy","john doe","... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_80_is_happy | hs | -- | You are given a string s.
-- Your task is to check if the string is haphs or not.
-- A string is haphs if its length is at least 3 and every 3 consecutive letters are distinct
-- For example:
-- >>> isHappy "a"
-- False
-- >>> isHappy "aa"
-- False
-- >>> isHappy "abcd"
-- True
-- >>> isHappy "aabb"
-- ... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_80_is_happy.py | reworded |
main :: IO ()
main = do
let candidate = isHappy
if candidate "a" == False then pure () else error "assertion failed"
if candidate "aa" == False then pure () else error "assertion failed"
if candidate "abcd" == True then pure () else error "assertion failed"
if candidate "aabb" == False then pure () else erro... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_81_numerical_letter_grade | hs | -- | It is the last week of the semester and the teacher has to give the grades
-- to students. The teacher has been making her own algorithm for grading.
-- The only problem is, she has lost the code she used for grading.
-- She has given you a list of GPAs for some students and you have to write
-- a function th... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_81_numerical_letter_grade.py | reworded |
main :: IO ()
main = do
let candidate = numericalLetterGrade
if candidate [4.0,3,1.7,2,3.5] == ["A+","B","C-","C","A-"] then pure () else error "assertion failed"
if candidate [1.2] == ["D+"] then pure () else error "assertion failed"
if candidate [0.5] == ["D-"] then pure () else error "assertion failed"
if... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_82_prime_length | hs | -- | Write a function that takes a string and returns True if the string
-- length is a prime number or False otherwise
-- Examples
-- >>> primeLength "Hello"
-- True
-- >>> primeLength "abcdcba"
-- True
-- >>> primeLength "kittens"
-- True
-- >>> primeLength "orange"
-- False
primeLength :: String -> Bool
pr... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_82_prime_length.py | reworded |
main :: IO ()
main = do
let candidate = primeLength
if candidate "Hello" == True then pure () else error "assertion failed"
if candidate "abcdcba" == True then pure () else error "assertion failed"
if candidate "kittens" == True then pure () else error "assertion failed"
if candidate "orange" == False then p... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_83_starts_one_ends | hs | -- | Given a positive integer n, return the count of the numbers of n-digit
-- positive integers that start or end with 1.
startsOneEnds :: Int -> Int
startsOneEnds n = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_83_starts_one_ends.py | reworded |
main :: IO ()
main = do
let candidate = startsOneEnds
if candidate 1 == 1 then pure () else error "assertion failed"
if candidate 2 == 18 then pure () else error "assertion failed"
if candidate 3 == 180 then pure () else error "assertion failed"
if candidate 4 == 1800 then pure () else error "assertion faile... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_84_solve | hs | -- | Given a positive integer N, return the total sum of its digits in binary.
-- Example
-- >>> solve 1000
-- "1"
-- >>> solve 150
-- "110"
-- >>> solve 147
-- "1100"
-- Variables:
-- @N integer
-- Constraints: 0 ≤ N ≤ 10000.
-- Output:
-- a string of binary number
solve :: Int -> String
solve N = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_84_solve.py | reworded |
main :: IO ()
main = do
let candidate = solve
if candidate 1000 == "1" then pure () else error "assertion failed"
if candidate 150 == "110" then pure () else error "assertion failed"
if candidate 147 == "1100" then pure () else error "assertion failed"
if candidate 333 == "1001" then pure () else error "asse... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_85_add | hs | -- | Given a non-empty list of integers lst. add the even elements that are at odd indices..
-- Examples:
-- >>> add [4,2,6,7]
-- 2
add :: [Int] -> Int
add lst = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_85_add.py | reworded |
main :: IO ()
main = do
let candidate = add
if candidate [4,88] == 88 then pure () else error "assertion failed"
if candidate [4,5,6,7,2,122] == 122 then pure () else error "assertion failed"
if candidate [4,0,6,7] == 0 then pure () else error "assertion failed"
if candidate [4,4,6,8] == 12 then pure () else... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_86_anti_shuffle | hs | -- | Write a function that takes a string and returns an ordered version of it.
-- Ordered version of string, is a string where all words (separated by space)
-- are replaced by a new word where all the characters arranged in
-- ascending order based on ascii value.
-- Note: You should keep the order of words and b... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_86_anti_shuffle.py | reworded |
main :: IO ()
main = do
let candidate = antiShuffle
if candidate "Hi" == "Hi" then pure () else error "assertion failed"
if candidate "hello" == "ehllo" then pure () else error "assertion failed"
if candidate "number" == "bemnru" then pure () else error "assertion failed"
if candidate "abcd" == "abcd" then p... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_87_get_row | hs | -- | You are given a 2 dimensional data, as a nested lists,
-- which is similar to matrix, however, unlike matrices,
-- each row may contain a different number of columns.
-- Given lst, and integer x, find integers x in the list,
-- and return list of tuples, [(x1, y1), (x2, y2) ...] such that
-- each tuple is a c... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_87_get_row.py | reworded |
main :: IO ()
main = do
let candidate = getRow
if candidate [[1,2,3,4,5,6],[1,2,3,4,1,6],[1,2,3,4,5,1]] 1 == [(0, 0),(1, 4),(1, 0),(2, 5),(2, 0)] then pure () else error "assertion failed"
if candidate [[1,2,3,4,5,6],[1,2,3,4,5,6],[1,2,3,4,5,6],[1,2,3,4,5,6],[1,2,3,4,5,6],[1,2,3,4,5,6]] 2 == [(0, 1),(1, 1),(2, 1... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_88_sort_array | hs | -- | Given a list of non-negative integers, return a cohs of the given list after sorting,
-- you will sort the given list in ascending order if the sum( first index value, last index value) is odd,
-- or sort it in descending order if the sum( first index value, last index value) is even.
-- Note:
-- * don't chang... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_88_sort_array.py | reworded |
main :: IO ()
main = do
let candidate = sortArray
if candidate [] == [] then pure () else error "assertion failed"
if candidate [5] == [5] then pure () else error "assertion failed"
if candidate [2,4,3,0,1,5] == [0,1,2,3,4,5] then pure () else error "assertion failed"
if candidate [2,4,3,0,1,5,6] == [6,5,4,3... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_89_encrypt | hs | -- | Create a function encrypt that takes a string as an argument and
-- returns a string encrypted with the alphabet being rotated.
-- The alphabet should be rotated in a manner such that the letters
-- shift down by two multiplied to two places.
-- For example:
-- >>> encrypt "hi"
-- "lm"
-- >>> encrypt "asd... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_89_encrypt.py | reworded |
main :: IO ()
main = do
let candidate = encrypt
if candidate "hi" == "lm" then pure () else error "assertion failed"
if candidate "asdfghjkl" == "ewhjklnop" then pure () else error "assertion failed"
if candidate "gf" == "kj" then pure () else error "assertion failed"
if candidate "et" == "ix" then pure () e... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_8_sum_product | hs | -- | For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
-- Empty sum should be equal to 0 and empty product should be equal to 1.
-- >>> sumProduct []
-- (0, 1)
-- >>> sumProduct [1,2,3,4]
-- (10, 24)
sumProduct :: [Int] -> (Int, Int)
sumProduct numbers = | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_8_sum_product.py | reworded |
main :: IO ()
main = do
let candidate = sumProduct
if candidate [] == (0, 1) then pure () else error "assertion failed"
if candidate [1,1,1] == (3, 1) then pure () else error "assertion failed"
if candidate [100,0] == (100, 0) then pure () else error "assertion failed"
if candidate [3,5,7] == (15, 105) then ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_90_next_smallest | hs | -- | You are given a list of integers.
-- Write a function next_smallest() that returns the 2nd smallest element of the list.
-- Return Nothing if there is no such element.
-- >>> nextSmallest [1,2,3,4,5]
-- Just (2)
-- >>> nextSmallest [5,1,4,3,2]
-- Just (2)
-- >>> nextSmallest []
-- Just (Nothing)
-- >>> ne... | transform | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals-with-cleaned-doctests\HumanEval_90_next_smallest.py | reworded |
main :: IO ()
main = do
let candidate = nextSmallest
if candidate [1,2,3,4,5] == Just (2) then pure () else error "assertion failed"
if candidate [5,1,4,3,2] == Just (2) then pure () else error "assertion failed"
if candidate [] == Just (Nothing) then pure () else error "assertion failed"
if candidate [1,1] ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.