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_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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_153_Strongest_Extension.py | verbatim |
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
-- cycpattern_check("abcd","abd") => False
-- cycpattern_check("hello","ell") => True
-- cycpattern_check("whassup","psus") => False
-- cycpattern_check("abab","baa") => True
-- cycpatter... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_154_cycpattern_check.py | verbatim |
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:
-- even_odd_count(-12) ==> (1, 1)
-- even_odd_count(123) ==> (1, 2)
evenOddCount :: Int -> (Int, Int)
evenOddCount num = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_155_even_odd_count.py | verbatim |
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:
-- >>> int_to_mini_roman(19) == 'xix'
-- >>> int_to_mini_roman(152) == 'clii'
-- >>> int_to_mini_roman(426) == 'cdxxvi'
intToMiniRoman :: Int -> String
intT... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_156_int_to_mini_roman.py | verbatim |
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:
-- right_angle_triangle(3, 4, 5) == True
-- right_angle_triangle(1, 2, ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_157_right_angle_triangle.py | verbatim |
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.
-- find_max(["name", "of", "string"]) =... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_158_find_max.py | verbatim |
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 an array of [ total number of eaten carrots after your meals,
-- the number of carrots left after your meals ]
-- if there are not enough rem... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_159_eat.py | verbatim |
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.
-- >>> string_sequence(0)
-- '0'
-- >>> string_sequence(5)
-- '0 1 2 3 4 5'
stringSequence :: Int -> String
stringSequence n = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_15_string_sequence.py | verbatim |
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 ( - )... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_160_do_algebra.py | verbatim |
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") = "AB"
-- s... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_161_solve.py | verbatim |
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 None.
-- >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
stringToMd5 :: String -> Maybe String
stringToMd5 text = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_162_string_to_md5.py | verbatim |
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:
-- generate_integers(2, 8) => [2, 4, 6, 8]
-- generate_integers(8, 2) => [2, 4, 6, 8]
-- generate_integers(10, 14) => []
generateIntegers :: Int -> Int -> [Int]
generateIntegers a b = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_163_generate_integers.py | verbatim |
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
-- >>> count_distinct_characters('xyzXYZ')
-- 3
-- >>> count_distinct_characters('Jerry')
-- 4
countDistinctCharacters :: String -> Int
countDistinctCharacters string = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_16_count_distinct_characters.py | verbatim |
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
-- '... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_17_parse_music.py | verbatim |
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.
-- >>> how_many_times('', 'a')
-- 0
-- >>> how_many_times('aaa', 'a')
-- 3
-- >>> how_many_times('aaaa', 'aa')
-- 3
howManyTimes :: String -> String -> Int
howManyTimes string substring = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_18_how_many_times.py | verbatim |
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
-- >>> sort_numbers('three one five')
-- 'one three five'
sortNumbers :... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_19_sort_numbers.py | verbatim |
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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_1_separate_paren_groups.py | verbatim |
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).
-- >>> 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])
... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_20_find_closest_elements.py | verbatim |
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
-- >>> rescale_to_unit([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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_21_rescale_to_unit.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_23_strlen.py | verbatim |
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
-- >>> largest_divisor(15)
-- 5
largestDivisor :: Int -> Int
largestDivisor n = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_24_largest_divisor.py | verbatim |
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]
-- >>> facto... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_25_factorize.py | verbatim |
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.
-- >>> remove_duplicates([1, 2, 3, 2, 4])
-- [1, 3, 4]
removeDuplicates :: [Int] -> [Int]
removeDuplicates numbers = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_26_remove_duplicates.py | verbatim |
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.
-- >>> flip_case('Hello')
-- 'hELLO'
flipCase :: String -> String
flipCase string = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_27_flip_case.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_28_concatenate.py | verbatim |
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.
-- >>> filter_by_prefix([], 'a')
-- []
-- >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
-- ['abc', 'array']
filterByPrefix :: [String] -> String -> [String]
filterByPrefix strings prefix = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_29_filter_by_prefix.py | verbatim |
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.
-- >>> truncate_number(3.5)
-- 0.5
truncateNumber :: Float -> Float
truncateNumber ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_2_truncate_number.py | verbatim |
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.
-- >>> 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]
getPositive :: [Int] -> [Int]
getPositive l = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_30_get_positive.py | verbatim |
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.
-- >>> 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
isPrime :: Int -> Bool
isPrime n = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_31_is_prime.py | verbatim |
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.
-- >>> sort_third([1, 2, 3])
-- [1, 2, 3]... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_33_sort_third.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_34_unique.py | verbatim |
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.
-- >>> max_element([1, 2, 3])
-- 3
-- >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
-- 123
maxElement :: [Int] -> Int
maxElement l = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_35_max_element.py | verbatim |
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.
-- >>> fizz_buzz(50)
-- 0
-- >>> fizz_buzz(78)
-- 2
-- >>> fizz_buzz(79)
-- 3
fizzBuzz :: Int -> Int
fizzBuzz n = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_36_fizz_buzz.py | verbatim |
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.
-- >>> sort_even([1, 2, 3])
-- [1, 2, 3]
-- >>> sort_even([5, 6, 3, 4])
-- [3, 6, 5, 4]
sortEven ::... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_37_sort_even.py | verbatim |
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.
-- >>> prime_fib(1)
-- 2
-- >>> prime_fib(2)
-- 3
-- >>> prime_fib(3)
-- 5
-- >>> prime_fib(4)
-- 13
-- >>> prime_fib(5)
-- 89
primeFib :: Int -> Int
primeFib n = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_39_prime_fib.py | verbatim |
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.
-- >>> below_zero([1, 2, 3])
-- False... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_3_below_zero.py | verbatim |
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.
-- >>> 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])... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_40_triples_sum_to_zero.py | verbatim |
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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_41_car_race_collision.py | verbatim |
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.
-- >>> 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]
incrList :: [Int] -> [Int]
incrList l = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_42_incr_list.py | verbatim |
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.
-- >>> 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])
-- Fals... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_43_pairs_sum_to_zero.py | verbatim |
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.
-- >>> change_base(8, 3)
-- '22'
-- >>> change_base(8, 2)
-- '1000'
-- >>> change_base(7, 2)
-- '111'
changeBase :: Int -> Int -> String
changeBase x base = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_44_change_base.py | verbatim |
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.
-- >>> triangle_area(5, 3)
-- 7.5
triangleArea :: Int -> Int -> Float
triangleArea a h = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_45_triangle_area.py | verbatim |
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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_46_fib4.py | verbatim |
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
-- >>> median([-10, 4, 6, 1000, 10, 20])
-- 15.0
median :: [Int] -> Float
median l = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_47_median.py | verbatim |
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
-- >>> is_palindrome('')
-- True
-- >>> is_palindrome('aba')
-- True
-- >>> is_palindrome('aaaaa')
-- True
-- >>> is_palindrome('zbcd')
-- False
isPalindrome :: String -> Bool
isPalindrome text = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_48_is_palindrome.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_49_modp.py | verbatim |
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 |
-- >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_4_mean_absolute_deviation.py | verbatim |
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.
-- >>> remove_vowels('')
-- ''
-- >>> remove_vowels('abcdef')
-- 'bcdf'
-- >>> remove_vowels('aaaaa')
-- ''
-- >>> remove_vowels('aaBAA')
-- 'B'
-- >>> remove_vowels('zbcd')
-- 'zbcd'
removeVowels :: String -> String
removeV... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_51_remove_vowels.py | verbatim |
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.
-- >>> below_threshold([1, 2, 4, 10], 100)
-- True
-- >>> below_threshold([1, 20, 4, 10], 5)
-- False
belowThreshold :: [Int] -> Int -> Bool
belowThreshold l t = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_52_below_threshold.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_53_add.py | verbatim |
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.
-- >>> 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
-- ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_54_same_chars.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_55_fib.py | verbatim |
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.
-- >>> correct_bracketing("<")
-- False
-- >>> correct_bracketing("<>")
-- True
-- >>> correct_bracketing("<<><>>")
-- True
-- >>> correct_bracketing("><<>")
-- False
correctBracketing :: Stri... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_56_correct_bracketing.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_57_monotonic.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_58_common.py | verbatim |
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.
-- >>> largest_prime_factor(13195)
-- 29
-- >>> largest_prime_factor(2048)
-- 2
largestPrimeFactor :: Int -> Int
largestPrimeFactor n = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_59_largest_prime_factor.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_5_intersperse.py | verbatim |
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.
-- >>> 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
sumToN :: Int -> Int
sumToN n = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_60_sum_to_n.py | verbatim |
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.
-- >>> correct_bracketing("(")
-- False
-- >>> correct_bracketing("()")
-- True
-- >>> correct_bracketing("(()())")
-- True
-- >>> correct_bracketing(")(()")
-- False
correctBracketing :: Stri... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_61_correct_bracketing.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_62_derivative.py | verbatim |
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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_63_fibfib.py | verbatim |
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:
-- >>> vowels_count("abcde")
-- 2
... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_64_vowels_count.py | verbatim |
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.
-- >>> circular_shift(12, 1)
-- "21"
-- >>> circular_shift(12, 2)
-- "12"
circularShift :: Int -> Int -> String
circularShift x shift = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_65_circular_shift.py | verbatim |
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("aAaaaXa") => 153
digitsum :... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_66_digitSum.py | verbatim |
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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_67_fruit_distribution.py | verbatim |
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 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 ind... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_68_pluck.py | verbatim |
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.
-- ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_69_search.py | verbatim |
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.
-- >>> parse_nested_parens('(()()) ((())) () ((())()()... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_6_parse_nested_parens.py | verbatim |
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:
-- strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
-- strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
-- strange_... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_70_strange_sort_list.py | verbatim |
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:
-- triangle_a... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_71_triangle_area.py | verbatim |
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:
-- will_it_fly([1, 2], 5) âžž False
-- # 1+2 is less than the maxi... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_72_will_it_fly.py | verbatim |
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 an array arr of integers, find the minimum number of elements that
-- need to be changed to make the array palindromic. A palindromic array is an array that
-- is read the same backwards and forwards. In one change, you can change one element to any other element.
-- For example:
-- smallest_change([1,2,... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_73_smallest_change.py | verbatim |
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
-- total_match([], []) âžž []
-- total_match(['hi', 'admin']... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_74_total_match.py | verbatim |
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:
-- is_multiply_prime(30) == True
-- 30 = 2 * 3 * 5
isMultiplyPrime :: Int -> Bool
isMultiplyPrime a = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_75_is_multiply_prime.py | verbatim |
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:
-- is_simple_power(1, 4) => true
-- is_simple_power(2, 2) => true
-- is_simple_power(8, 2) => true
-- is_simple_power(3, 2) => false
--... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_76_is_simple_power.py | verbatim |
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
-- iscube(180) ==... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_77_iscube.py | verbatim |
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,... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_78_hex_key.py | verbatim |
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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_79_decimal_to_binary.py | verbatim |
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
-- >>> filter_by_substring([], 'a')
-- []
-- >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
-- ['abc', 'bacd', 'array']
filterBySubstring :: [String] -> String -> [String]
filterBySubstring strings substring = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_7_filter_by_substring.py | verbatim |
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 happy or not.
-- A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
-- For example:
-- is_happy(a) => False
-- is_happy(aa) => False
-- is_happy(abcd) => True
-- is_happy(aabb) => False
-- is_happy(a... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_80_is_happy.py | verbatim |
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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_81_numerical_letter_grade.py | verbatim |
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
-- prime_length('Hello') == True
-- prime_length('abcdcba') == True
-- prime_length('kittens') == True
-- prime_length('orange') == False
primeLength :: String -> Bool
primeLength st... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_82_prime_length.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_83_starts_one_ends.py | verbatim |
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
-- For N = 1000, the sum of digits will be 1 the output should be "1".
-- For N = 150, the sum of digits will be 6 the output should be "110".
-- For N = 147, the sum of digits will be 12 the output should be "1100".
-- Varia... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_84_solve.py | verbatim |
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 = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_85_add.py | verbatim |
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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_86_anti_shuffle.py | verbatim |
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... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_87_get_row.py | verbatim |
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 an array of non-negative integers, return a copy of the given array after sorting,
-- you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
-- or sort it in descending order if the sum( first index value, last index value) is even.
-- Note:
-- * don't c... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_88_sort_array.py | verbatim |
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') returns 'lm'
-- encrypt('asdfgh... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_89_encrypt.py | verbatim |
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.
-- >>> sum_product([])
-- (0, 1)
-- >>> sum_product([1, 2, 3, 4])
-- (10, 24)
sumProduct :: [Int] -> (Int, Int)
sumProduct num... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_8_sum_product.py | verbatim |
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 None if there is no such element.
-- next_smallest([1, 2, 3, 4, 5]) == 2
-- next_smallest([5, 1, 4, 3, 2]) == 2
-- next_smallest([]) == None
-- next_smallest([1, 1]) == None
next... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_90_next_smallest.py | verbatim |
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"
] |
HumanEval_91_is_bored | hs | -- | You'll be given a string of words, and your task is to count the number
-- of boredoms. A boredom is a sentence that starts with the word "I".
-- Sentences are delimited by '.', '?' or '!'.
-- For example:
-- >>> is_bored("Hello world")
-- 0
-- >>> is_bored("The sky is blue. The sun is shining. I love this w... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_91_is_bored.py | verbatim |
main :: IO ()
main = do
let candidate = isBored
if candidate "Hello world" == 0 then pure () else error "assertion failed"
if candidate "Is the sky blue?" == 0 then pure () else error "assertion failed"
if candidate "I love It !" == 1 then pure () else error "assertion failed"
if candidate "bIt" == 0 then pu... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_92_any_int | hs | -- | Create a function that takes 3 numbers.
-- Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
-- Returns false in any other cases.
-- Examples
-- any_int(5, 2, 7) âžž True
-- any_int(3, 2, 2) âžž False
-- any_int(3, -2, 1) âžž True
-- any_int(3.6, -2.2, 2)... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_92_any_int.py | verbatim |
main :: IO ()
main = do
let candidate = anyInt
if candidate 2.0 3.0 1.0 == True then pure () else error "assertion failed"
if candidate 2.5 2.0 3.0 == False then pure () else error "assertion failed"
if candidate 1.5 5.0 3.5 == False then pure () else error "assertion failed"
if candidate 2.0 6.0 2.0 == Fals... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_93_encode | hs | -- | Write a function that takes a message, and encodes in such a
-- way that it swaps case of all letters, replaces all vowels in
-- the message with the letter that appears 2 places ahead of that
-- vowel in the english alphabet.
-- Assume only letters.
-- Examples:
-- >>> encode('test')
-- 'TGST'
-- >>>... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_93_encode.py | verbatim |
main :: IO ()
main = do
let candidate = encode
if candidate "TEST" == "tgst" then pure () else error "assertion failed"
if candidate "Mudasir" == "mWDCSKR" then pure () else error "assertion failed"
if candidate "YES" == "ygs" then pure () else error "assertion failed"
if candidate "This is a message" == "tH... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_94_skjkasdkd | hs | -- | You are given a list of integers.
-- You need to find the largest prime value and return the sum of its digits.
-- Examples:
-- For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
-- For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25
-- For lst = [1,... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_94_skjkasdkd.py | verbatim |
main :: IO ()
main = do
let candidate = skjkasdkd
if candidate [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] == 10 then pure () else error "assertion failed"
if candidate [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] == 25 then pure () else error "assertion failed"
if candidate [1,3,1,32,5107,34,83278,109,1... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_95_check_dict_case | hs | -- | Given a dictionary, return True if all keys are strings in lower
-- case or all keys are strings in upper case, else return False.
-- The function should return False is the given dictionary is empty.
-- Examples:
-- check_dict_case({"a":"apple", "b":"banana"}) should return True.
-- check_dict_case({"a":"ap... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_95_check_dict_case.py | verbatim |
main :: IO ()
main = do
let candidate = checkDictCase
if candidate [("p", "pineapple"), ("b", "banana")] == True then pure () else error "assertion failed"
if candidate [("p", "pineapple"), ("A", "banana"), ("B", "banana")] == False then pure () else error "assertion failed"
if candidate [("p", "pineapple"), (... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_96_count_up_to | hs | -- | Implement a function that takes an non-negative integer and returns an array of the first n
-- integers that are prime numbers and less than n.
-- for example:
-- count_up_to(5) => [2,3]
-- count_up_to(11) => [2,3,5,7]
-- count_up_to(0) => []
-- count_up_to(20) => [2,3,5,7,11,13,17,19]
-- count_up_to(1) => ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_96_count_up_to.py | verbatim |
main :: IO ()
main = do
let candidate = countUpTo
if candidate 5 == [2,3] then pure () else error "assertion failed"
if candidate 6 == [2,3,5] then pure () else error "assertion failed"
if candidate 7 == [2,3,5] then pure () else error "assertion failed"
if candidate 10 == [2,3,5,7] then pure () else error "... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_97_multiply | hs | -- | Complete the function that takes two integers and returns
-- the product of their unit digits.
-- Assume the input is always valid.
-- Examples:
-- multiply(148, 412) should return 16.
-- multiply(19, 28) should return 72.
-- multiply(2020, 1851) should return 0.
-- multiply(14,-15) should return 20.
multi... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_97_multiply.py | verbatim |
main :: IO ()
main = do
let candidate = multiply
if candidate 148 412 == 16 then pure () else error "assertion failed"
if candidate 19 28 == 72 then pure () else error "assertion failed"
if candidate 2020 1851 == 0 then pure () else error "assertion failed"
if candidate 14 (-15) == 20 then pure () else error... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_98_count_upper | hs | -- | Given a string s, count the number of uppercase vowels in even indices.
-- For example:
-- count_upper('aBCdEf') returns 1
-- count_upper('abcdefg') returns 0
-- count_upper('dBBE') returns 0
countUpper :: String -> Int
countUpper s = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_98_count_upper.py | verbatim |
main :: IO ()
main = do
let candidate = countUpper
if candidate "aBCdEf" == 1 then pure () else error "assertion failed"
if candidate "abcdefg" == 0 then pure () else error "assertion failed"
if candidate "dBBE" == 0 then pure () else error "assertion failed"
if candidate "B" == 0 then pure () else error "as... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_99_closest_integer | hs | -- | Create a function that takes a value (string) representing a number
-- and returns the closest integer to it. If the number is equidistant
-- from two integers, round it away from zero.
-- Examples
-- >>> closest_integer("10")
-- 10
-- >>> closest_integer("15.3")
-- 15
-- Note:
-- Rounding away from zero ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_99_closest_integer.py | verbatim |
main :: IO ()
main = do
let candidate = closestInteger
if candidate "10" == 10 then pure () else error "assertion failed"
if candidate "14.5" == 15 then pure () else error "assertion failed"
if candidate "-15.5" == (-16) then pure () else error "assertion failed"
if candidate "15.3" == 15 then pure () else e... | [
"\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.