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_108_count_nums | elixir | # Write a function count_nums which takes an array of integers and returns
# the number of elements which has a sum of digits > 0.
# If a number is negative, then its first signed digit will be negative:
# e.g. -123 has signed digits -1, 2, and 3.
# >>> count_nums([]) == 0
# >>> count_nums([-1, 11, -11]) == 1
# >>> cou... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_108_count_nums.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'count_nums' do
assert 0 == HumanEval.candidate([])
assert 0 == HumanEval.candidate([-1, -2, 0])
assert 6 == HumanEval.candidate([1, 1, 2, -2, 3, 4, 5])
assert 5 == HumanEval.candidate([1, 6, 9, -6, 0, 1, 5])
assert 4 ==... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_109_move_one_ball | elixir | # We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The
# numbers in the array will be randomly ordered. Your task is to determine if
# it is possible to get an array sorted in non-decreasing order by performing
# the following operation on the given array:
# You are allowed to perform right shift opera... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_109_move_one_ball.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'move_one_ball' do
assert true == HumanEval.candidate([3, 4, 5, 1, 2])
assert true == HumanEval.candidate([3, 5, 10, 1, 2])
assert false == HumanEval.candidate([4, 3, 1, 2])
assert false == HumanEval.candidate([3, 5, 4, 1, 2... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_10_make_palindrome | elixir | # Find the shortest palindrome that begins with a supplied string.
# Algorithm idea is simple:
# - Find the longest postfix of supplied string that is a palindrome.
# - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
# >>> make_palindrome('')
# ''
# >>> make_palindro... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_10_make_palindrome.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'make_palindrome' do
assert "" == HumanEval.candidate("")
assert "x" == HumanEval.candidate("x")
assert "xyzyx" == HumanEval.candidate("xyz")
assert "xyx" == HumanEval.candidate("xyx")
assert "jerryrrej" == HumanEval.can... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_110_exchange | elixir | # In this problem, you will implement a function that takes two lists of numbers,
# and determines whether it is possible to perform an exchange of elements
# between them to make lst1 a list of only even numbers.
# There is no limit on the number of exchanged elements between lst1 and lst2.
# If it is possible to exch... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_110_exchange.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'exchange' do
assert "YES" == HumanEval.candidate([1, 2, 3, 4], [1, 2, 3, 4])
assert "NO" == HumanEval.candidate([1, 2, 3, 4], [1, 5, 3, 4])
assert "YES" == HumanEval.candidate([1, 2, 3, 4], [2, 1, 4, 3])
assert "YES" == Hum... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_111_histogram | elixir | # Given a string representing a space separated lowercase letters, return a dictionary
# of the letter with the most repetition and containing the corresponding count.
# If several letters have the same occurrence, return all of them.
# Example:
# histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
# histogram('a b b a') ==... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_111_histogram.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'histogram' do
assert %{"a" => 2, "b" => 2} == HumanEval.candidate("a b b a")
assert %{"a" => 2, "b" => 2} == HumanEval.candidate("a b c a b")
assert %{"a" => 1, "b" => 1, "c" => 1, "d" => 1, "g" => 1} == HumanEval.candidate("a ... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_112_reverse_delete | elixir | # Task
# We are given two strings s and c, you have to deleted all the characters in s that are equal to any character in c
# then check if the result string is palindrome.
# A string is called palindrome if it reads the same backward as forward.
# You should return a tuple containing the result string and True/False f... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_112_reverse_delete.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'reverse_delete' do
assert {"bcd", false} == HumanEval.candidate("abcde", "ae")
assert {"acdef", false} == HumanEval.candidate("abcdef", "b")
assert {"cdedc", true} == HumanEval.candidate("abcdedcba", "ab")
assert {"dik", fa... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_113_odd_count | elixir | # Given a list of strings, where each string consists of only digits, return a list.
# Each element i of the output should be "the number of odd elements in the
# string i of the input." where all the i's should be replaced by the number
# of odd digits in the i'th string of the input.
# >>> odd_count(['1234567'])
# ["... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_113_odd_count.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'odd_count' do
assert ["the number of odd elements 4n the str4ng 4 of the 4nput."] == HumanEval.candidate(["1234567"])
assert ["the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 o... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_114_minSubArraySum | elixir | # Given an array of integers nums, find the minimum sum of any non-empty sub-array
# of nums.
# Example
# minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
# minSubArraySum([-1, -2, -3]) == -6
defmodule HumanEval do
def candidate(nums), do: minSubArraySum(nums)
def minSubArraySum(nums) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_114_minSubArraySum.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'minSubArraySum' do
assert 1 == HumanEval.candidate([2, 3, 4, 1, 2, 4])
assert -6 == HumanEval.candidate([-1, -2, -3])
assert -14 == HumanEval.candidate([-1, -2, -3, 2, -10])
assert -9999999999999999 == HumanEval.candidate([... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_115_max_fill | elixir | # You are given a rectangular grid of wells. Each row represents a single well,
# and each 1 in a row represents a single unit of water.
# Each well has a corresponding bucket that can be used to extract water from it,
# and all buckets have the same capacity.
# Your task is to use the buckets to empty the wells.
# Ou... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_115_max_fill.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'max_fill' do
assert 6 == HumanEval.candidate([[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], 1)
assert 5 == HumanEval.candidate([[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], 2)
assert 0 == HumanEval.candidate([[0, 0, 0]... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_116_sort_array | elixir | # In this Kata, you have to sort an array of non-negative integers according to
# number of ones in their binary representation in ascending order.
# For similar number of ones, sort based on decimal value.
# It must be implemented like this:
# >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
# >>> sort_array([-2, -3... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_116_sort_array.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'sort_array' do
assert [1, 2, 4, 3, 5] == HumanEval.candidate([1, 5, 2, 3, 4])
assert [-4, -2, -6, -5, -3] == HumanEval.candidate([-2, -3, -4, -5, -6])
assert [0, 1, 2, 4, 3] == HumanEval.candidate([1, 0, 2, 3, 4])
assert []... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_117_select_words | elixir | # Given a string s and a natural number n, you have been tasked to implement
# a function that returns a list of all words from string s that contain exactly
# n consonants, in order these words appear in the string s.
# If the string s is empty then the function should return an empty list.
# Note: you may assume th... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_117_select_words.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'select_words' do
assert ["little"] == HumanEval.candidate("Mary had a little lamb", 4)
assert ["Mary", "lamb"] == HumanEval.candidate("Mary had a little lamb", 3)
assert [] == HumanEval.candidate("simple white space", 2)
as... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_118_get_closest_vowel | elixir | # You are given a word. Your task is to find the closest vowel that stands between
# two consonants from the right side of the word (case sensitive).
# Vowels in the beginning and ending doesn't count. Return empty string if you didn't
# find any vowel met the above condition.
# You may assume that the given string c... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_118_get_closest_vowel.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'get_closest_vowel' do
assert "u" == HumanEval.candidate("yogurt")
assert "u" == HumanEval.candidate("full")
assert "" == HumanEval.candidate("easy")
assert "" == HumanEval.candidate("eAsy")
assert "" == HumanEval.candid... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_119_match_parens | elixir | # You are given a list of two strings, both strings consist of open
# parentheses '(' or close parentheses ')' only.
# Your job is to check if it is possible to concatenate the two strings in
# some order, that the resulting string will be good.
# A string S is considered to be good if and only if all parentheses in S
... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_119_match_parens.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'match_parens' do
assert "Yes" == HumanEval.candidate(["()(", ")"])
assert "No" == HumanEval.candidate([")", ")"])
assert "No" == HumanEval.candidate(["(()(())", "())())"])
assert "Yes" == HumanEval.candidate([")())", "(()()... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_11_string_xor | elixir | # Input are two strings a and b consisting only of 1s and 0s.
# Perform binary XOR on these inputs and return result also as a string.
# >>> string_xor('010', '110')
# '100'
defmodule HumanEval do
def candidate(a, b), do: string_xor(a, b)
def string_xor(a, b) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_11_string_xor.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'string_xor' do
assert "010010" == HumanEval.candidate("111000", "101010")
assert "0" == HumanEval.candidate("1", "1")
assert "0101" == HumanEval.candidate("0101", "0000")
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_120_maximum | elixir | # Given an array arr of integers and a positive integer k, return a sorted list
# of length k with the maximum k numbers in arr.
# Example 1:
# Input: arr = [-3, -4, 5], k = 3
# Output: [-4, -3, 5]
# Example 2:
# Input: arr = [4, -4, 4], k = 2
# Output: [4, 4]
# Example 3:
# Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = ... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_120_maximum.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'maximum' do
assert [-4, -3, 5] == HumanEval.candidate([-3, -4, 5], 3)
assert [4, 4] == HumanEval.candidate([4, -4, 4], 2)
assert [2] == HumanEval.candidate([-3, 2, 1, 2, -1, -2, 1], 1)
assert [2, 20, 123] == HumanEval.candi... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_121_solution | elixir | # Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
# Examples
# solution([5, 8, 7, 1]) ==> 12
# solution([3, 3, 3, 3, 3]) ==> 9
# solution([30, 13, 24, 321]) ==>0
defmodule HumanEval do
def candidate(lst), do: solution(lst)
def solution(lst) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_121_solution.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'solution' do
assert 12 == HumanEval.candidate([5, 8, 7, 1])
assert 9 == HumanEval.candidate([3, 3, 3, 3, 3])
assert 0 == HumanEval.candidate([30, 13, 24, 321])
assert 5 == HumanEval.candidate([5, 9])
assert 0 == HumanEv... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_122_add_elements | elixir | # Given a non-empty array of integers arr and an integer k, return
# the sum of the elements with at most two digits from the first k elements of arr.
# Example:
# Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
# Output: 24 # sum of 21 + 3
# Constraints:
# 1. 1 <= len(arr) <= 100
# 2. 1 <= k <= len(arr)
defmodule Human... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_122_add_elements.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'add_elements' do
assert -4 == HumanEval.candidate([1, -2, -3, 41, 57, 76, 87, 88, 99], 3)
assert 0 == HumanEval.candidate([111, 121, 3, 4000, 5, 6], 2)
assert 125 == HumanEval.candidate([11, 21, 3, 90, 5, 6, 7, 8, 9], 4)
as... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_123_get_odd_collatz | elixir | # Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.
# The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
# as follows: start with any positive integer n. Then each term is obtained from the
# previous term as follows: if the previous term... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_123_get_odd_collatz.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'get_odd_collatz' do
assert [1, 5, 7, 11, 13, 17] == HumanEval.candidate(14)
assert [1, 5] == HumanEval.candidate(5)
assert [1, 3, 5] == HumanEval.candidate(12)
assert [1] == HumanEval.candidate(1)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_124_valid_date | elixir | # You have to write a function which validates a given date string and
# returns True if the date is valid otherwise False.
# The date is valid if all of the following rules are satisfied:
# 1. The date string is not empty.
# 2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,12. An... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_124_valid_date.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'valid_date' do
assert true == HumanEval.candidate("03-11-2000")
assert false == HumanEval.candidate("15-01-2012")
assert false == HumanEval.candidate("04-0-2040")
assert true == HumanEval.candidate("06-04-2020")
assert ... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_125_split_words | elixir | # Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
# should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
# alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
# Examples
# split_words("He... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_125_split_words.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'split_words' do
assert ["Hello", "world!"] == HumanEval.candidate("Hello world!")
assert ["Hello", "world!"] == HumanEval.candidate("Hello,world!")
assert ["Hello", "world,!"] == HumanEval.candidate("Hello world,!")
assert ... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_126_is_sorted | elixir | # Given a list of numbers, return whether or not they are sorted
# in ascending order. If list has more than 1 duplicate of the same
# number, return False. Assume no negative numbers and only integers.
# Examples
# is_sorted([5]) ➞ True
# is_sorted([1, 2, 3, 4, 5]) ➞ True
# is_sorted([1, 3, 2, 4, 5]) ➞ False
# is_sort... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_126_is_sorted.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'is_sorted' do
assert true == HumanEval.candidate([5])
assert true == HumanEval.candidate([1, 2, 3, 4, 5])
assert false == HumanEval.candidate([1, 3, 2, 4, 5])
assert true == HumanEval.candidate([1, 2, 3, 4, 5, 6])
asser... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_127_intersection | elixir | # You are given two intervals,
# where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
# The given intervals are closed which means that the interval (start, end)
# includes both start and end.
# For each given interval, it is assumed that its start is less or equal its end.
# Your t... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_127_intersection.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'intersection' do
assert "NO" == HumanEval.candidate({1, 2}, {2, 3})
assert "NO" == HumanEval.candidate({-1, 1}, {0, 4})
assert "YES" == HumanEval.candidate({-3, -1}, {-5, 5})
assert "YES" == HumanEval.candidate({-2, 2}, {-4... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_128_prod_signs | elixir | # You are given an array arr of integers and you need to return
# sum of magnitudes of integers multiplied by product of all signs
# of each number in the array, represented by 1, -1 or 0.
# Note: return None for empty arr.
# Example:
# >>> prod_signs([1, 2, 2, -4]) == -9
# >>> prod_signs([0, 1]) == 0
# >>> prod_signs(... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_128_prod_signs.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'prod_signs' do
assert -9 == HumanEval.candidate([1, 2, 2, -4])
assert 0 == HumanEval.candidate([0, 1])
assert -10 == HumanEval.candidate([1, 1, 1, 2, 3, -1, 1])
assert nil == HumanEval.candidate([])
assert 20 == HumanEv... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_129_minPath | elixir | # Given a grid with N rows and N columns (N >= 2) and a positive integer k,
# each cell of the grid contains a value. Every integer in the range [1, N * N]
# inclusive appears exactly once on the cells of the grid.
# You have to find the minimum path of length k in the grid. You can start
# from any cell, and in each ... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_129_minPath.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'minPath' do
assert [1, 2, 1] == HumanEval.candidate([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3)
assert [1] == HumanEval.candidate([[5, 9, 3], [4, 1, 6], [7, 8, 2]], 1)
assert [1, 2, 1, 2] == HumanEval.candidate([[1, 2, 3, 4], [5, 6, ... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_12_longest | elixir | # Out of list of strings, return the longest one. Return the first one in case of multiple
# strings of the same length. Return None in case the input list is empty.
# >>> longest([])
# >>> longest(['a', 'b', 'c'])
# 'a'
# >>> longest(['a', 'bb', 'ccc'])
# 'ccc'
defmodule HumanEval do
def candidate(strings), do: lon... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_12_longest.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'longest' do
assert nil == HumanEval.candidate([])
assert "x" == HumanEval.candidate(["x", "y", "z"])
assert "zzzz" == HumanEval.candidate(["x", "yyy", "zzzz", "www", "kkkk", "abc"])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_130_tri | elixir | # Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in
# the last couple centuries. However, what people don't know is Tribonacci sequence.
# Tribonacci sequence is defined by the recurrence:
# tri(1) = 3
# tri(n) = 1 + n / 2, if n is even.
# tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), if ... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_130_tri.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'tri' do
assert [1, 3, 2, 8] == HumanEval.candidate(3)
assert [1, 3, 2, 8, 3] == HumanEval.candidate(4)
assert [1, 3, 2, 8, 3, 15] == HumanEval.candidate(5)
assert [1, 3, 2, 8, 3, 15, 4] == HumanEval.candidate(6)
assert ... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_131_digits | elixir | # Given a positive integer n, return the product of the odd digits.
# Return 0 if all digits are even.
# For example:
# digits(1) == 1
# digits(4) == 0
# digits(235) == 15
defmodule HumanEval do
def candidate(n), do: digits(n)
def digits(n) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_131_digits.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'digits' do
assert 5 == HumanEval.candidate(5)
assert 5 == HumanEval.candidate(54)
assert 1 == HumanEval.candidate(120)
assert 5 == HumanEval.candidate(5014)
assert 315 == HumanEval.candidate(98765)
assert 2625 == Hu... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_132_is_nested | elixir | # Create a function that takes a string as input which contains only square brackets.
# The function should return True if and only if there is a valid subsequence of brackets
# where at least one bracket in the subsequence is nested.
# is_nested('[[]]') ➞ True
# is_nested('[]]]]]]][[[[[]') ➞ False
# is_nested('[][]')... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_132_is_nested.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'is_nested' do
assert true == HumanEval.candidate("[[]]")
assert false == HumanEval.candidate("[]]]]]]][[[[[]")
assert false == HumanEval.candidate("[][]")
assert false == HumanEval.candidate("[]")
assert true == HumanEv... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_133_sum_squares | elixir | # You are given a list of numbers.
# You need to return the sum of squared numbers in the given list,
# round each element in the list to the upper int(Ceiling) first.
# Examples:
# For lst = [1,2,3] the output should be 14
# For lst = [1,4,9] the output should be 98
# For lst = [1,3,5,7] the output should be 84
# For ... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_133_sum_squares.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'sum_squares' do
assert 14 == HumanEval.candidate([1.0, 2.0, 3.0])
assert 14 == HumanEval.candidate([1.0, 2.0, 3.0])
assert 84 == HumanEval.candidate([1.0, 3.0, 5.0, 7.0])
assert 29 == HumanEval.candidate([1.4, 4.2, 0.0])
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_134_check_if_last_char_is_a_letter | elixir | # Create a function that returns True if the last character
# of a given string is an alphabetical character and is not
# a part of a word, and False otherwise.
# Note: "word" is a group of characters separated by space.
# Examples:
# check_if_last_char_is_a_letter("apple pie") ➞ False
# check_if_last_char_is_a_letter(... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_134_check_if_last_char_is_a_letter.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'check_if_last_char_is_a_letter' do
assert false == HumanEval.candidate("apple")
assert true == HumanEval.candidate("apple pi e")
assert false == HumanEval.candidate("eeeee")
assert true == HumanEval.candidate("A")
asser... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_135_can_arrange | elixir | # Create a function which returns the largest index of an element which
# is not greater than or equal to the element immediately preceding it. If
# no such element exists then return -1. The given array will not contain
# duplicate values.
# Examples:
# can_arrange([1,2,4,3,5]) = 3
# can_arrange([1,2,3]) = -1
defmodu... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_135_can_arrange.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'can_arrange' do
assert 3 == HumanEval.candidate([1, 2, 4, 3, 5])
assert -1 == HumanEval.candidate([1, 2, 4, 5])
assert 2 == HumanEval.candidate([1, 4, 2, 5, 6, 7, 8, 9, 10])
assert 4 == HumanEval.candidate([4, 8, 5, 7, 3])
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_136_largest_smallest_integers | elixir | # Create a function that returns a tuple (a, b), where 'a' is
# the largest of negative integers, and 'b' is the smallest
# of positive integers in a list.
# If there is no negative or positive integers, return them as None.
# Examples:
# largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
# largest_smallest_int... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_136_largest_smallest_integers.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'largest_smallest_integers' do
assert {nil, 1} == HumanEval.candidate([2, 4, 1, 3, 5, 7])
assert {nil, 1} == HumanEval.candidate([2, 4, 1, 3, 5, 7, 0])
assert {-2, 1} == HumanEval.candidate([1, 3, 2, 4, 5, 6, -2])
assert {-7... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_137_compare_one | elixir | # Create a function that takes integers, floats, or strings representing
# real numbers, and returns the larger variable in its given variable type.
# Return None if the values are equal.
# Note: If a real number is represented as a string, the floating point might be . or ,
# compare_one(1, 2.5) ➞ 2.5
# compare_one(1,... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_137_compare_one.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'compare_one' do
assert 2 == HumanEval.candidate(1, 2)
assert 2.5 == HumanEval.candidate(1, 2.5)
assert 3 == HumanEval.candidate(2, 3)
assert 6 == HumanEval.candidate(5, 6)
assert "2,3" == HumanEval.candidate(1, "2,3")
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_138_is_equal_to_sum_even | elixir | # Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
# Example
# is_equal_to_sum_even(4) == False
# is_equal_to_sum_even(6) == False
# is_equal_to_sum_even(8) == True
defmodule HumanEval do
def candidate(n), do: is_equal_to_sum_even(n)
def is_equal_to_sum_even(n) do
... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_138_is_equal_to_sum_even.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'is_equal_to_sum_even' do
assert false == HumanEval.candidate(4)
assert false == HumanEval.candidate(6)
assert true == HumanEval.candidate(8)
assert true == HumanEval.candidate(10)
assert false == HumanEval.candidate(11)... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_139_special_factorial | elixir | # The Brazilian factorial is defined as:
# brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
# where n > 0
# For example:
# >>> special_factorial(4)
# 288
# The function will receive an integer as input and should return the special
# factorial of this integer.
defmodule HumanEval do
def candidate(n), do: spe... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_139_special_factorial.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'special_factorial' do
assert 288 == HumanEval.candidate(4)
assert 34560 == HumanEval.candidate(5)
assert 125411328000 == HumanEval.candidate(7)
assert 1 == HumanEval.candidate(1)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_13_greatest_common_divisor | elixir | # Return a greatest common divisor of two integers a and b
# >>> greatest_common_divisor(3, 5)
# 1
# >>> greatest_common_divisor(25, 15)
# 5
defmodule HumanEval do
def candidate(a, b), do: greatest_common_divisor(a, b)
def greatest_common_divisor(a, b) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_13_greatest_common_divisor.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'greatest_common_divisor' do
assert 1 == HumanEval.candidate(3, 7)
assert 5 == HumanEval.candidate(10, 15)
assert 7 == HumanEval.candidate(49, 14)
assert 12 == HumanEval.candidate(144, 60)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_140_fix_spaces | elixir | # Given a string text, replace all spaces in it with underscores,
# and if a string has more than 2 consecutive spaces,
# then replace all consecutive spaces with -
# fix_spaces("Example") == "Example"
# fix_spaces("Example 1") == "Example_1"
# fix_spaces(" Example 2") == "_Example_2"
# fix_spaces(" Example 3") ==... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_140_fix_spaces.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'fix_spaces' do
assert "Example" == HumanEval.candidate("Example")
assert "Mudasir_Hanif_" == HumanEval.candidate("Mudasir Hanif ")
assert "Yellow_Yellow__Dirty__Fellow" == HumanEval.candidate("Yellow Yellow Dirty Fellow")
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_141_file_name_check | elixir | # Create a function which takes a string representing a file's name, and returns
# 'Yes' if the the file's name is valid, and returns 'No' otherwise.
# A file's name is considered to be valid if and only if all the following conditions
# are met:
# - There should not be more than three digits ('0'-'9') in the file's n... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_141_file_name_check.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'file_name_check' do
assert "Yes" == HumanEval.candidate("example.txt")
assert "No" == HumanEval.candidate("1example.dll")
assert "No" == HumanEval.candidate("s1sdf3.asd")
assert "Yes" == HumanEval.candidate("K.dll")
ass... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_142_sum_squares | elixir | # "
# This function will take a list of integers. For all entries in the list, the function shall square the integer entry if its index is a
# multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not
# change the entries in the list whose indexes are... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_142_sum_squares.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'sum_squares' do
assert 6 == HumanEval.candidate([1, 2, 3])
assert 14 == HumanEval.candidate([1, 4, 9])
assert 0 == HumanEval.candidate([])
assert 9 == HumanEval.candidate([1, 1, 1, 1, 1, 1, 1, 1, 1])
assert -3 == HumanE... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_143_words_in_sentence | elixir | # You are given a string representing a sentence,
# the sentence contains some words separated by a space,
# and you have to return a string that contains the words from the original sentence,
# whose lengths are prime numbers,
# the order of the words in the new string should be the same as the original one.
# Example... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_143_words_in_sentence.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'words_in_sentence' do
assert "is" == HumanEval.candidate("This is a test")
assert "go for" == HumanEval.candidate("lets go for swimming")
assert "there is no place" == HumanEval.candidate("there is no place available here")
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_144_simplify | elixir | # 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 denominator a... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_144_simplify.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'simplify' do
assert true == HumanEval.candidate("1/5", "5/1")
assert false == HumanEval.candidate("1/6", "2/1")
assert true == HumanEval.candidate("5/1", "3/1")
assert false == HumanEval.candidate("7/10", "10/2")
assert... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_145_order_by_points | elixir | # Write a function which sorts the given list of integers
# in ascending order according to the sum of their digits.
# Note: if there are several items with similar sum of their digits,
# order them based on their index in original list.
# For example:
# >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 1... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_145_order_by_points.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'order_by_points' do
assert [-1, -11, 1, -12, 11] == HumanEval.candidate([1, 11, -1, -11, -12])
assert [0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457] == HumanEval.candidate([1234, 423, 463, 145, 2, 423, 423, 53, 6... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_146_specialFilter | elixir | # Write a function that takes an array of numbers as input and returns
# the number of elements in the array that are greater than 10 and both
# first and last digits of a number are odd (1, 3, 5, 7, 9).
# For example:
# specialFilter([15, -73, 14, -15]) => 1
# specialFilter([33, -2, -3, 45, 21, 109]) => 2
defmodul... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_146_specialFilter.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'specialFilter' do
assert 0 == HumanEval.candidate([5, -2, 1, -5])
assert 1 == HumanEval.candidate([15, -73, 14, -15])
assert 2 == HumanEval.candidate([33, -2, -3, 45, 21, 109])
assert 4 == HumanEval.candidate([43, -12, 93, ... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_147_get_max_triples | elixir | # You are given a positive integer n. You have to create an integer array a of length n.
# For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
# Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
# and a[i] + a[j] + a[k] is a multiple of 3.
# Example :
# Input: n = 5
# Output: 1
# Explanation... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_147_get_max_triples.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'get_max_triples' do
assert 1 == HumanEval.candidate(5)
assert 4 == HumanEval.candidate(6)
assert 36 == HumanEval.candidate(10)
assert 53361 == HumanEval.candidate(100)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_148_bf | elixir | # There are eight planets in our solar system: the closerst to the Sun
# is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
# Uranus, Neptune.
# Write a function that takes two planet names as strings planet1 and planet2.
# The function should return a tuple containing all planets whose orbits are... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_148_bf.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'bf' do
assert {"Saturn", "Uranus"} == HumanEval.candidate("Jupiter", "Neptune")
assert {"Venus"} == HumanEval.candidate("Earth", "Mercury")
assert {"Venus", "Earth", "Mars", "Jupiter", "Saturn"} == HumanEval.candidate("Mercury"... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_149_sorted_list_sum | elixir | # Write a function that accepts a list of strings as a parameter,
# deletes the strings that have odd lengths from it,
# and returns the resulted list with a sorted order,
# The list is always a list of strings and never an array of numbers,
# and it may contain duplicates.
# The order of the list should be ascending b... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_149_sorted_list_sum.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'sorted_list_sum' do
assert ["aa"] == HumanEval.candidate(["aa", "a", "aaa"])
assert ["AI", "asdf", "school"] == HumanEval.candidate(["school", "AI", "asdf", "b"])
assert [] == HumanEval.candidate(["d", "b", "c", "a"])
asser... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_14_all_prefixes | elixir | # Return list of all prefixes from shortest to longest of the input string
# >>> all_prefixes('abc')
# ['a', 'ab', 'abc']
defmodule HumanEval do
def candidate(string), do: all_prefixes(string)
def all_prefixes(string) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_14_all_prefixes.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'all_prefixes' do
assert [] == HumanEval.candidate("")
assert ["a", "as", "asd", "asdf", "asdfg", "asdfgh"] == HumanEval.candidate("asdfgh")
assert ["W", "WW", "WWW"] == HumanEval.candidate("WWW")
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_150_x_or_y | elixir | # A simple program which should return the value of x if n is
# a prime number and should return the value of y otherwise.
# Examples:
# for x_or_y(7, 34, 12) == 34
# for x_or_y(15, 8, 5) == 5
defmodule HumanEval do
def candidate(n, x, y), do: x_or_y(n, x, y)
def x_or_y(n, x, y) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_150_x_or_y.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'x_or_y' do
assert 34 == HumanEval.candidate(7, 34, 12)
assert 5 == HumanEval.candidate(15, 8, 5)
assert 33 == HumanEval.candidate(3, 33, 5212)
assert 3 == HumanEval.candidate(1259, 3, 52)
assert -1 == HumanEval.candidat... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_151_double_the_difference | elixir | # Given a list of numbers, return the sum of squares of the numbers
# in the list that are odd. Ignore numbers that are negative or not integers.
# double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
# double_the_difference([-1, -2, 0]) == 0
# double_the_difference([9, -2]) == 81
# double_the_difference([0]) == 0... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_151_double_the_difference.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'double_the_difference' do
assert 0 == HumanEval.candidate([])
assert 25 == HumanEval.candidate([5.0, 4.0])
assert 0 == HumanEval.candidate([0.1, 0.2, 0.3])
assert 0 == HumanEval.candidate([-10.0, -20.0, -30.0])
assert 0... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_152_compare | elixir | # I think we all remember that feeling when the result of some long-awaited
# event is finally known. The feelings and thoughts you have at that moment are
# definitely worth noting down and comparing.
# Your task is to determine if a person correctly guessed the results of a number of matches.
# You are given two arra... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_152_compare.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'compare' do
assert [0, 0, 0, 0, 3, 3] == HumanEval.candidate([1, 2, 3, 4, 5, 1], [1, 2, 3, 4, 2, -2])
assert [0, 0, 0, 0, 0, 0] == HumanEval.candidate([0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0])
assert [2, 4, 6] == HumanEval.candid... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_153_Strongest_Extension | elixir | # You will be given the name of a class (a string) and a list of extensions.
# The extensions are to be used to load additional classes to the class. The
# strength of the extension is as follows: Let CAP be the number of the uppercase
# letters in the extension's name, and let SM be the number of lowercase letters
# ... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_153_Strongest_Extension.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'Strongest_Extension' do
assert "Watashi.eIGHt8OKe" == HumanEval.candidate("Watashi", ["tEN", "niNE", "eIGHt8OKe"])
assert "Boku123.YEs.WeCaNe" == HumanEval.candidate("Boku123", ["nani", "NazeDa", "YEs.WeCaNe", "32145tggg"])
ass... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_154_cycpattern_check | elixir | # You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
# cycpattern_check("abcd","abd") => False
# cycpattern_check("hello","ell") => True
# cycpattern_check("whassup","psus") => False
# cycpattern_check("abab","baa") => True
# cycpattern_check("efef... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_154_cycpattern_check.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'cycpattern_check' do
assert false == HumanEval.candidate("xyzw", "xyw")
assert true == HumanEval.candidate("yello", "ell")
assert false == HumanEval.candidate("whattup", "ptut")
assert true == HumanEval.candidate("efef", "f... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_155_even_odd_count | elixir | # 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)
defmodule HumanEval do
def candidate(num), do: even_odd_count(num)
def even_odd_count(num) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_155_even_odd_count.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'even_odd_count' do
assert {0, 1} == HumanEval.candidate(7)
assert {1, 1} == HumanEval.candidate(-78)
assert {2, 2} == HumanEval.candidate(3452)
assert {3, 3} == HumanEval.candidate(346211)
assert {3, 3} == HumanEval.can... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_156_int_to_mini_roman | elixir | # 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'
defmodule HumanEval do
def candidate(number), do... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_156_int_to_mini_roman.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'int_to_mini_roman' do
assert "xix" == HumanEval.candidate(19)
assert "clii" == HumanEval.candidate(152)
assert "ccli" == HumanEval.candidate(251)
assert "cdxxvi" == HumanEval.candidate(426)
assert "d" == HumanEval.candi... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_157_right_angle_triangle | elixir | # Given the lengths of the three sides of a triangle. Return True if the three
# sides form a right-angled triangle, False otherwise.
# A right-angled triangle is a triangle in which one angle is right angle or
# 90 degree.
# Example:
# right_angle_triangle(3, 4, 5) == True
# right_angle_triangle(1, 2, 3) == False
de... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_157_right_angle_triangle.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'right_angle_triangle' do
assert true == HumanEval.candidate(3, 4, 5)
assert false == HumanEval.candidate(1, 2, 3)
assert true == HumanEval.candidate(10, 6, 8)
assert false == HumanEval.candidate(2, 2, 2)
assert true == ... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_158_find_max | elixir | # 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"]) == "string"
... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_158_find_max.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'find_max' do
assert "string" == HumanEval.candidate(["name", "of", "string"])
assert "enam" == HumanEval.candidate(["name", "enam", "game"])
assert "aaaaaaa" == HumanEval.candidate(["aaaaaaa", "bb", "cc"])
assert "abc" == H... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_159_eat | elixir | # 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 remaining carr... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_159_eat.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'eat' do
assert [11, 4] == HumanEval.candidate(5, 6, 10)
assert [12, 1] == HumanEval.candidate(4, 8, 9)
assert [11, 0] == HumanEval.candidate(1, 10, 10)
assert [7, 0] == HumanEval.candidate(2, 11, 5)
assert [9, 2] == Hum... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_15_string_sequence | elixir | # 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'
defmodule HumanEval do
def candidate(n), do: string_sequence(n)
def string_sequence(n) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_15_string_sequence.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'string_sequence' do
assert "0" == HumanEval.candidate(0)
assert "0 1 2 3" == HumanEval.candidate(3)
assert "0 1 2 3 4 5 6 7 8 9 10" == HumanEval.candidate(10)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_160_do_algebra | elixir | # 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 ( - )
# Multiplic... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_160_do_algebra.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'do_algebra' do
assert 37 == HumanEval.candidate(["**", "*", "+"], [2, 3, 4, 5])
assert 9 == HumanEval.candidate(["+", "*", "-"], [2, 3, 4, 5])
assert 8 == HumanEval.candidate(["//", "*"], [7, 3, 4])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_161_solve | elixir | # You are given a string s.
# if s[i] is a letter, reverse its case from lower to upper or vise versa,
# otherwise keep it as it is.
# If the string contains no letters, reverse the string.
# The function should return the resulted string.
# Examples
# solve("1234") = "4321"
# solve("ab") = "AB"
# solve("#a@C") = "#A@... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_161_solve.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'solve' do
assert "aSdF" == HumanEval.candidate("AsDf")
assert "4321" == HumanEval.candidate("1234")
assert "AB" == HumanEval.candidate("ab")
assert "#A@c" == HumanEval.candidate("#a@C")
assert "#aSDFw^45" == HumanEval.c... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_162_string_to_md5 | elixir | # Given a string 'text', return its md5 hash equivalent string.
# If 'text' is an empty string, return None.
# >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
defmodule HumanEval do
def candidate(text), do: string_to_md5(text)
def string_to_md5(text) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_162_string_to_md5.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'string_to_md5' do
assert "3e25960a79dbc69b674cd4ec67a72c62" == HumanEval.candidate("Hello world")
assert nil == HumanEval.candidate("")
assert "0ef78513b0cb8cef12743f5aeb35f888" == HumanEval.candidate("A B C")
assert "5f4dc... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_163_generate_integers | elixir | # 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) => []
defmodule HumanEval do
def candidate(a, b), do: generate_integers(a, b)
def gener... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_163_generate_integers.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'generate_integers' do
assert [2, 4, 6, 8] == HumanEval.candidate(2, 10)
assert [2, 4, 6, 8] == HumanEval.candidate(10, 2)
assert [2, 4, 6, 8] == HumanEval.candidate(132, 2)
assert [] == HumanEval.candidate(17, 89)
end
end... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_16_count_distinct_characters | elixir | # 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
defmodule HumanEval do
def candidate(string), do: count_distinct_characters(string)
def count_distinct_characters(string) do
... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_16_count_distinct_characters.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'count_distinct_characters' do
assert 0 == HumanEval.candidate("")
assert 5 == HumanEval.candidate("abcde")
assert 5 == HumanEval.candidate("abcdecadeCADE")
assert 1 == HumanEval.candidate("aaaaAAAAaaaa")
assert 5 == Hum... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_17_parse_music | elixir | # 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
# '.|' - quater no... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_17_parse_music.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'parse_music' do
assert [] == HumanEval.candidate("")
assert [4, 4, 4, 4] == HumanEval.candidate("o o o o")
assert [1, 1, 1, 1] == HumanEval.candidate(".| .| .| .|")
assert [2, 2, 1, 1, 4, 4, 4, 4] == HumanEval.candidate("o|... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_18_how_many_times | elixir | # 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
defmodule HumanEval do
def candidate(string, substring), do: how_many_times(string, substring)
def how_m... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_18_how_many_times.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'how_many_times' do
assert 0 == HumanEval.candidate("", "x")
assert 4 == HumanEval.candidate("xyxyxyx", "x")
assert 4 == HumanEval.candidate("cacacacac", "cac")
assert 1 == HumanEval.candidate("john doe", "john")
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_19_sort_numbers | elixir | # 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'
defmodule HumanEval do
... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_19_sort_numbers.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'sort_numbers' do
assert "" == HumanEval.candidate("")
assert "three" == HumanEval.candidate("three")
assert "three five nine" == HumanEval.candidate("three five nine")
assert "zero four five seven eight nine" == HumanEval.c... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_1_separate_paren_groups | elixir | # 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 string.
... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_1_separate_paren_groups.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'separate_paren_groups' do
assert ["(()())", "((()))", "()", "((())()())"] == HumanEval.candidate("(()()) ((())) () ((())()())")
assert ["()", "(())", "((()))", "(((())))"] == HumanEval.candidate("() (()) ((())) (((())))")
asser... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_20_find_closest_elements | elixir | # From a supplied list of numbers (of length at least two) select and return two that are the closest to each
# other and return them in order (smaller number, larger number).
# >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
# (2.0, 2.2)
# >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
# (2.0, 2.0... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_20_find_closest_elements.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'find_closest_elements' do
assert {3.9, 4.0} == HumanEval.candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2])
assert {5.0, 5.9} == HumanEval.candidate([1.0, 2.0, 5.9, 4.0, 5.0])
assert {2.0, 2.2} == HumanEval.candidate([1.0, 2.0, 3.0, 4.0... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_21_rescale_to_unit | elixir | # 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]
defmodule HumanEval do
def candidate(numbers), do: rescale_to_unit(numb... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_21_rescale_to_unit.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'rescale_to_unit' do
assert [0.0, 1.0] == HumanEval.candidate([2.0, 49.9])
assert [1.0, 0.0] == HumanEval.candidate([100.0, 49.9])
assert [0.0, 0.25, 0.5, 0.75, 1.0] == HumanEval.candidate([1.0, 2.0, 3.0, 4.0, 5.0])
assert [... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_22_filter_integers | elixir | # Filter given list of any python values only for integers
# >>> filter_integers(['a', 3.14, 5])
# [5]
# >>> filter_integers([1, 2, 3, 'abc', {}, []])
# [1, 2, 3]
defmodule HumanEval do
def candidate(values), do: filter_integers(values)
def filter_integers(values) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_22_filter_integers.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'filter_integers' do
assert [] == HumanEval.candidate([])
assert [4, 9] == HumanEval.candidate([4, %{}, [], 23.2, 9, "adasd"])
assert [3, 3, 3] == HumanEval.candidate([3, "c", 3, 3, "a", "b"])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_23_strlen | elixir | # Return length of given string
# >>> strlen('')
# 0
# >>> strlen('abc')
# 3
defmodule HumanEval do
def candidate(string), do: strlen(string)
def strlen(string) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_23_strlen.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'strlen' do
assert 0 == HumanEval.candidate("")
assert 1 == HumanEval.candidate("x")
assert 9 == HumanEval.candidate("asdasnakj")
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_24_largest_divisor | elixir | # For a given number n, find the largest number that divides n evenly, smaller than n
# >>> largest_divisor(15)
# 5
defmodule HumanEval do
def candidate(n), do: largest_divisor(n)
def largest_divisor(n) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_24_largest_divisor.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'largest_divisor' do
assert 1 == HumanEval.candidate(3)
assert 1 == HumanEval.candidate(7)
assert 5 == HumanEval.candidate(10)
assert 50 == HumanEval.candidate(100)
assert 7 == HumanEval.candidate(49)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_25_factorize | elixir | # Return list of prime factors of given integer in the order from smallest to largest.
# Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
# Input number should be equal to the product of all factors
# >>> factorize(8)
# [2, 2, 2]
# >>> factorize(25)
# [5... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_25_factorize.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'factorize' do
assert [2] == HumanEval.candidate(2)
assert [2, 2] == HumanEval.candidate(4)
assert [2, 2, 2] == HumanEval.candidate(8)
assert [3, 19] == HumanEval.candidate(57)
assert [3, 3, 19, 19] == HumanEval.candidat... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_26_remove_duplicates | elixir | # 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]
defmodule HumanEval do
def candidate(numbers), do: remove_duplicates(numbers)
def remove_duplicates(numbers) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_26_remove_duplicates.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'remove_duplicates' do
assert [] == HumanEval.candidate([])
assert [1, 2, 3, 4] == HumanEval.candidate([1, 2, 3, 4])
assert [1, 4, 5] == HumanEval.candidate([1, 2, 3, 2, 4, 3, 5])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_27_flip_case | elixir | # For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
# >>> flip_case('Hello')
# 'hELLO'
defmodule HumanEval do
def candidate(string), do: flip_case(string)
def flip_case(string) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_27_flip_case.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'flip_case' do
assert "" == HumanEval.candidate("")
assert "hELLO!" == HumanEval.candidate("Hello!")
assert "tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS" == HumanEval.candidate("These violent delights have violent ends")
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_28_concatenate | elixir | # Concatenate list of strings into a single string
# >>> concatenate([])
# ''
# >>> concatenate(['a', 'b', 'c'])
# 'abc'
defmodule HumanEval do
def candidate(strings), do: concatenate(strings)
def concatenate(strings) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_28_concatenate.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'concatenate' do
assert "" == HumanEval.candidate([])
assert "xyz" == HumanEval.candidate(["x", "y", "z"])
assert "xyzwk" == HumanEval.candidate(["x", "y", "z", "w", "k"])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_29_filter_by_prefix | elixir | # 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']
defmodule HumanEval do
def candidate(strings, prefix), do: filter_by_prefix(strings, prefix)
def filter_by_prefix(strin... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_29_filter_by_prefix.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'filter_by_prefix' do
assert [] == HumanEval.candidate([], "john")
assert ["xxx", "xxxAAA", "xxx"] == HumanEval.candidate(["xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"], "xxx")
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_2_truncate_number | elixir | # 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
defmodule HumanEval do
def candidate(number), do: truncate... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_2_truncate_number.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'truncate_number' do
assert 0.5 == HumanEval.candidate(3.5)
assert 0.25 == HumanEval.candidate(1.25)
assert 0.0 == HumanEval.candidate(123.0)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_30_get_positive | elixir | # 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]
defmodule HumanEval do
def candidate(l), do: get_positive(l)
def get_positive(l) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_30_get_positive.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'get_positive' do
assert [4, 5, 6] == HumanEval.candidate([-1, -2, 4, 5, 6])
assert [5, 3, 2, 3, 3, 9, 123, 1] == HumanEval.candidate([5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10])
assert [] == HumanEval.candidate([-1, -2])
assert ... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_31_is_prime | elixir | # 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
defmodule HumanEval do
def candidate(n), do: is_prime(n)
def is_pr... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_31_is_prime.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'is_prime' do
assert false == HumanEval.candidate(6)
assert true == HumanEval.candidate(101)
assert true == HumanEval.candidate(11)
assert true == HumanEval.candidate(13441)
assert true == HumanEval.candidate(61)
ass... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_33_sort_third | elixir | # 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]
# >>> sort... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_33_sort_third.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'sort_third' do
assert [2, 6, 3, 4, 8, 9, 5] == HumanEval.candidate([5, 6, 3, 4, 8, 9, 2])
assert [2, 8, 3, 4, 6, 9, 5] == HumanEval.candidate([5, 8, 3, 4, 6, 9, 2])
assert [2, 6, 9, 4, 8, 3, 5] == HumanEval.candidate([5, 6, 9, ... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_34_unique | elixir | # Return sorted unique elements in a list
# >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
# [0, 2, 3, 5, 9, 123]
defmodule HumanEval do
def candidate(l), do: unique(l)
def unique(l) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_34_unique.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'unique' do
assert [0, 2, 3, 5, 9, 123] == HumanEval.candidate([5, 3, 5, 2, 3, 3, 9, 0, 123])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_35_max_element | elixir | # 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
defmodule HumanEval do
def candidate(l), do: max_element(l)
def max_element(l) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_35_max_element.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'max_element' do
assert 3 == HumanEval.candidate([1, 2, 3])
assert 124 == HumanEval.candidate([5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_36_fizz_buzz | elixir | # 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
defmodule HumanEval do
def candidate(n), do: fizz_buzz(n)
def fizz_buzz(n) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_36_fizz_buzz.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'fizz_buzz' do
assert 0 == HumanEval.candidate(50)
assert 2 == HumanEval.candidate(78)
assert 3 == HumanEval.candidate(79)
assert 3 == HumanEval.candidate(100)
assert 6 == HumanEval.candidate(200)
assert 192 == Human... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_37_sort_even | elixir | # 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]
defmodule HumanEval do
... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_37_sort_even.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'sort_even' do
assert [1, 2, 3] == HumanEval.candidate([1, 2, 3])
assert [-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123] == HumanEval.candidate([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
assert [-12, 8, 3, 4, 5, 2, 12, 11, 23, -10] == Hum... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_39_prime_fib | elixir | # 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
defmodule HumanEval do
def candidate(n), do: prime_fib(n)
def prime_fib(n) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_39_prime_fib.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'prime_fib' do
assert 2 == HumanEval.candidate(1)
assert 3 == HumanEval.candidate(2)
assert 5 == HumanEval.candidate(3)
assert 13 == HumanEval.candidate(4)
assert 89 == HumanEval.candidate(5)
assert 233 == HumanEval.... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_3_below_zero | elixir | # 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
# >>> belo... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_3_below_zero.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'below_zero' do
assert false == HumanEval.candidate([])
assert false == HumanEval.candidate([1, 2, -3, 1, 2, -3])
assert true == HumanEval.candidate([1, 2, -4, 5, 6])
assert false == HumanEval.candidate([1, -1, 2, -2, 5, -5,... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_40_triples_sum_to_zero | elixir | # triples_sum_to_zero takes a list of integers as an input.
# it returns True if there are three distinct elements in the list that
# sum to zero, and False otherwise.
# >>> triples_sum_to_zero([1, 3, 5, 0])
# False
# >>> triples_sum_to_zero([1, 3, -2, 1])
# True
# >>> triples_sum_to_zero([1, 2, 3, 7])
# False
# >>> tr... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_40_triples_sum_to_zero.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'triples_sum_to_zero' do
assert false == HumanEval.candidate([1, 3, 5, 0])
assert false == HumanEval.candidate([1, 3, 5, -1])
assert true == HumanEval.candidate([1, 3, -2, 1])
assert false == HumanEval.candidate([1, 2, 3, 7]... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_41_car_race_collision | elixir | # Imagine a road that's a perfectly straight infinitely long line.
# n cars are driving left to right; simultaneously, a different set of n cars
# are driving right to left. The two sets of cars start out being very far from
# each other. All cars move in the same speed. Two cars are said to collide
# when a car t... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_41_car_race_collision.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'car_race_collision' do
assert 4 == HumanEval.candidate(2)
assert 9 == HumanEval.candidate(3)
assert 16 == HumanEval.candidate(4)
assert 64 == HumanEval.candidate(8)
assert 100 == HumanEval.candidate(10)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_42_incr_list | elixir | # 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]
defmodule HumanEval do
def candidate(l), do: incr_list(l)
def incr_list(l) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_42_incr_list.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'incr_list' do
assert [] == HumanEval.candidate([])
assert [4, 3, 2] == HumanEval.candidate([3, 2, 1])
assert [6, 3, 6, 3, 4, 4, 10, 1, 124] == HumanEval.candidate([5, 2, 5, 2, 3, 3, 9, 0, 123])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_43_pairs_sum_to_zero | elixir | # pairs_sum_to_zero takes a list of integers as an input.
# it returns True if there are two distinct elements in the list that
# sum to zero, and False otherwise.
# >>> pairs_sum_to_zero([1, 3, 5, 0])
# False
# >>> pairs_sum_to_zero([1, 3, -2, 1])
# False
# >>> pairs_sum_to_zero([1, 2, 3, 7])
# False
# >>> pairs_sum_t... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_43_pairs_sum_to_zero.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'pairs_sum_to_zero' do
assert false == HumanEval.candidate([1, 3, 5, 0])
assert false == HumanEval.candidate([1, 3, -2, 1])
assert false == HumanEval.candidate([1, 2, 3, 7])
assert true == HumanEval.candidate([2, 4, -5, 3, 5... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_44_change_base | elixir | # 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'
defmodule HumanEval do
def candidate(x, base), do: change_base(x, base)
def change... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_44_change_base.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'change_base' do
assert "22" == HumanEval.candidate(8, 3)
assert "100" == HumanEval.candidate(9, 3)
assert "11101010" == HumanEval.candidate(234, 2)
assert "10000" == HumanEval.candidate(16, 2)
assert "1000" == HumanEval... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_45_triangle_area | elixir | # Given length of a side and high return area for a triangle.
# >>> triangle_area(5, 3)
# 7.5
defmodule HumanEval do
def candidate(a, h), do: triangle_area(a, h)
def triangle_area(a, h) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_45_triangle_area.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'triangle_area' do
assert 7.5 == HumanEval.candidate(5, 3)
assert 2.0 == HumanEval.candidate(2, 2)
assert 40.0 == HumanEval.candidate(10, 8)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_46_fib4 | elixir | # The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
# fib4(0) -> 0
# fib4(1) -> 0
# fib4(2) -> 2
# fib4(3) -> 0
# fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
# Please write a function to efficiently compute the n-th element of the fib4 number sequence. D... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_46_fib4.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'fib4' do
assert 4 == HumanEval.candidate(5)
assert 28 == HumanEval.candidate(8)
assert 104 == HumanEval.candidate(10)
assert 386 == HumanEval.candidate(12)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_47_median | elixir | # Return median of elements in the list l.
# >>> median([3, 1, 2, 4, 5])
# 3
# >>> median([-10, 4, 6, 1000, 10, 20])
# 15.0
defmodule HumanEval do
def candidate(l), do: median(l)
def median(l) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_47_median.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'median' do
assert 3 == HumanEval.candidate([3, 1, 2, 4, 5])
assert 8.0 == HumanEval.candidate([-10, 4, 6, 1000, 10, 20])
assert 5 == HumanEval.candidate([5])
assert 5.5 == HumanEval.candidate([6, 5])
assert 7 == HumanEv... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_48_is_palindrome | elixir | # Checks if given string is a palindrome
# >>> is_palindrome('')
# True
# >>> is_palindrome('aba')
# True
# >>> is_palindrome('aaaaa')
# True
# >>> is_palindrome('zbcd')
# False
defmodule HumanEval do
def candidate(text), do: is_palindrome(text)
def is_palindrome(text) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_48_is_palindrome.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'is_palindrome' do
assert true == HumanEval.candidate("")
assert true == HumanEval.candidate("aba")
assert true == HumanEval.candidate("aaaaa")
assert false == HumanEval.candidate("zbcd")
assert true == HumanEval.candida... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_49_modp | elixir | # 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
defmodule HumanEval do
def candidate(n, p), do: modp(n, p)
def modp(n, p) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_49_modp.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'modp' do
assert 3 == HumanEval.candidate(3, 5)
assert 2 == HumanEval.candidate(1101, 101)
assert 1 == HumanEval.candidate(0, 101)
assert 8 == HumanEval.candidate(3, 11)
assert 1 == HumanEval.candidate(100, 101)
asse... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_4_mean_absolute_deviation | elixir | # For a given list of input numbers, calculate Mean Absolute Deviation
# around the mean of this dataset.
# Mean Absolute Deviation is the average absolute difference between each
# element and a centerpoint (mean in this case):
# MAD = average | x - x_mean |
# >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
# 1.0
d... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_4_mean_absolute_deviation.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'mean_absolute_deviation' do
assert 0.5 == HumanEval.candidate([1.0, 2.0])
assert 1.0 == HumanEval.candidate([1.0, 2.0, 3.0, 4.0])
assert 1.2 == HumanEval.candidate([1.0, 2.0, 3.0, 4.0, 5.0])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_51_remove_vowels | elixir | # 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'
defmodule HumanEval do
def candidate(text), do: remove_vowel... | keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_51_remove_vowels.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'remove_vowels' do
assert "" == HumanEval.candidate("")
assert "bcdf
ghjklm" == HumanEval.candidate("abcdef
ghijklm")
assert "fdcb" == HumanEval.candidate("fedcba")
assert "" == HumanEval.candidate("eeeee")
assert "cB" =... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_52_below_threshold | elixir | # 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
defmodule HumanEval do
def candidate(l, t), do: below_threshold(l, t)
def below_threshold(l, t) do
| keep | /home/MultiPL-E/datasets/../datasets/originals/HumanEval_52_below_threshold.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'below_threshold' do
assert true == HumanEval.candidate([1, 2, 4, 10], 100)
assert false == HumanEval.candidate([1, 20, 4, 10], 5)
assert true == HumanEval.candidate([1, 20, 4, 10], 21)
assert true == HumanEval.candidate([1,... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.