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_91_is_bored | elixir | # 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:
defmodule HumanEval do
def candidate(S), do: is_bored(S)
def is_bored(S) do
| remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_91_is_bored.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'is_bored' do
assert 0 == HumanEval.candidate("Hello world")
assert 0 == HumanEval.candidate("Is the sky blue?")
assert 1 == HumanEval.candidate("I love It !")
assert 0 == HumanEval.candidate("bIt")
assert 2 == HumanEval... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_92_any_int | elixir | # 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
defmodule HumanEval do
def candidate(x, y, z), do: any_int(x, y, z)
def any_int(x, y, z) do
| remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_92_any_int.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'any_int' do
assert true == HumanEval.candidate(2, 3, 1)
assert false == HumanEval.candidate(2.5, 2, 3)
assert false == HumanEval.candidate(1.5, 5, 3.5)
assert false == HumanEval.candidate(2, 6, 2)
assert true == HumanEv... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_93_encode | elixir | # 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:
defmodule HumanEval do
def candidate(message), do: ... | remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_93_encode.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'encode' do
assert "tgst" == HumanEval.candidate("TEST")
assert "mWDCSKR" == HumanEval.candidate("Mudasir")
assert "ygs" == HumanEval.candidate("YES")
assert "tHKS KS C MGSSCGG" == HumanEval.candidate("This is a message")
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_94_skjkasdkd | elixir | # You are given a list of integers.
# You need to find the largest prime value and return the sum of its digits.
# Examples:
defmodule HumanEval do
def candidate(lst), do: skjkasdkd(lst)
def skjkasdkd(lst) do
| remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_94_skjkasdkd.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'skjkasdkd' do
assert 10 == HumanEval.candidate([0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3])
assert 25 == HumanEval.candidate([1, 0, 1, 8, 2, 4597, 2, 1, 3, 40, 1, 2, 1, 2, 4, 2, 5, 1])
assert 13 ==... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_95_check_dict_case | elixir | # 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:
defmodule HumanEval do
def candidate(dict), do: check_dict_case(dict)
def check_dict_case(dict) do
... | remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_95_check_dict_case.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'check_dict_case' do
assert true == HumanEval.candidate(%{"p" => "pineapple", "b" => "banana"})
assert false == HumanEval.candidate(%{"p" => "pineapple", "A" => "banana", "B" => "banana"})
assert false == HumanEval.candidate(%{"... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_96_count_up_to | elixir | # 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:
defmodule HumanEval do
def candidate(n), do: count_up_to(n)
def count_up_to(n) do
| remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_96_count_up_to.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'count_up_to' do
assert [2, 3] == HumanEval.candidate(5)
assert [2, 3, 5] == HumanEval.candidate(6)
assert [2, 3, 5] == HumanEval.candidate(7)
assert [2, 3, 5, 7] == HumanEval.candidate(10)
assert [] == HumanEval.candida... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_97_multiply | elixir | # Complete the function that takes two integers and returns
# the product of their unit digits.
# Assume the input is always valid.
# Examples:
defmodule HumanEval do
def candidate(a, b), do: multiply(a, b)
def multiply(a, b) do
| remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_97_multiply.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'multiply' do
assert 16 == HumanEval.candidate(148, 412)
assert 72 == HumanEval.candidate(19, 28)
assert 0 == HumanEval.candidate(2020, 1851)
assert 20 == HumanEval.candidate(14, -15)
assert 42 == HumanEval.candidate(76,... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_98_count_upper | elixir | # Given a string s, count the number of uppercase vowels in even indices.
# For example:
defmodule HumanEval do
def candidate(s), do: count_upper(s)
def count_upper(s) do
| remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_98_count_upper.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'count_upper' do
assert 1 == HumanEval.candidate("aBCdEf")
assert 0 == HumanEval.candidate("abcdefg")
assert 0 == HumanEval.candidate("dBBE")
assert 0 == HumanEval.candidate("B")
assert 1 == HumanEval.candidate("U")
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_99_closest_integer | elixir | # 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
# Note:
# Rounding away from zero means that if the given number is equidistant
# from two integers, the one you should ret... | remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_99_closest_integer.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'closest_integer' do
assert 10 == HumanEval.candidate("10")
assert 15 == HumanEval.candidate("14.5")
assert -16 == HumanEval.candidate("-15.5")
assert 15 == HumanEval.candidate("15.3")
assert 0 == HumanEval.candidate("0"... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_9_rolling_max | elixir | # From a given list of integers, generate a list of rolling maximum element found until given moment
# in the sequence.
defmodule HumanEval do
def candidate(numbers), do: rolling_max(numbers)
def rolling_max(numbers) do
| remove | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_9_rolling_max.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'rolling_max' do
assert [] == HumanEval.candidate([])
assert [1, 2, 3, 4] == HumanEval.candidate([1, 2, 3, 4])
assert [4, 4, 4, 4] == HumanEval.candidate([4, 3, 2, 1])
assert [3, 3, 3, 100, 100] == HumanEval.candidate([3, 2,... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_0_has_close_elements | elixir | # Check if in given list of numbers, are any two numbers closer to each other than
# given threshold.
# >>> HumanEval.has_close_elements([1.0, 2.0, 3.0], 0.5)
# false
# >>> HumanEval.has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
# true
defmodule HumanEval do
def candidate(numbers, threshold), do: has_close... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_0_has_close_elements.py | reworded | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'has_close_elements' do
assert true == HumanEval.candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3)
assert false == HumanEval.candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05)
assert true == HumanEval.candidate([1.0, 2.0, 5.9, 4.0, 5.... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_100_make_a_pile | elixir | # Given a positive integer n, you have to make a pile of n levels of stones.
# The first level has n stones.
# The number of stones in the next level is:
# - the next odd number if n is odd.
# - the next even number if n is even.
# Return the number of stones in each level in a list, where element at index
# i represen... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_100_make_a_pile.py | reworded | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'make_a_pile' do
assert [3, 5, 7] == HumanEval.candidate(3)
assert [4, 6, 8, 10] == HumanEval.candidate(4)
assert [5, 7, 9, 11, 13] == HumanEval.candidate(5)
assert [6, 8, 10, 12, 14, 16] == HumanEval.candidate(6)
assert... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_101_words_string | elixir | # You will be given a string of words separated by commas or spaces. Your task is
# to split the string into words and return a list of the words.
# For example:
# >>> HumanEval.words_string("Hi, my name is John")
# ["Hi", "my", "name", "is", "John"]
# >>> HumanEval.words_string("One, two, three, four, five, six")
# ["... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_101_words_string.py | reworded | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'words_string' do
assert ["Hi", "my", "name", "is", "John"] == HumanEval.candidate("Hi, my name is John")
assert ["One", "two", "three", "four", "five", "six"] == HumanEval.candidate("One, two, three, four, five, six")
assert ["... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_102_choose_num | elixir | # This function takes two positive numbers x and y and returns the
# biggest even integer number that is in the range [x, y] inclusive. If
# there's no such number, then the function should return -1.
# For example:
# >>> HumanEval.choose_num(12, 15)
# 14
# >>> HumanEval.choose_num(13, 12)
# -1
defmodule HumanEval do... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_102_choose_num.py | reworded | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'choose_num' do
assert 14 == HumanEval.candidate(12, 15)
assert -1 == HumanEval.candidate(13, 12)
assert 12354 == HumanEval.candidate(33, 12354)
assert -1 == HumanEval.candidate(5234, 5233)
assert 28 == HumanEval.candida... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_103_rounded_avg | elixir | # You are given two positive integers n and m, and your task is to compute the
# average of the integers from n through m (including n and m).
# Round the answer to the nearest integer and convert that to binary.
# If n is greater than m, return -1.
# Example:
# >>> HumanEval.rounded_avg(1, 5)
# "0b11"
# >>> HumanEval... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_103_rounded_avg.py | reworded | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'rounded_avg' do
assert "0b11" == HumanEval.candidate(1, 5)
assert "0b1010" == HumanEval.candidate(7, 13)
assert "0b1111001010" == HumanEval.candidate(964, 977)
assert "0b1111100100" == HumanEval.candidate(996, 997)
asse... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_104_unique_digits | elixir | # Given a list of positive integers x. return a sorted list of all
# elements that hasn't any even digit.
# Note: Returned list should be sorted in increasing order.
# For example:
# >>> HumanEval.unique_digits([15, 33, 1422, 1])
# [1, 15, 33]
# >>> HumanEval.unique_digits([152, 323, 1422, 10])
# []
defmodule HumanEv... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_104_unique_digits.py | reworded | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'unique_digits' do
assert [1, 15, 33] == HumanEval.candidate([15, 33, 1422, 1])
assert [] == HumanEval.candidate([152, 323, 1422, 10])
assert [111, 151] == HumanEval.candidate([12345, 2033, 111, 151])
assert [31, 135] == Hum... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_105_by_length | elixir | # Given a list of integers, sort the integers that are between 1 and 9 inclusive,
# reverse the resulting list, and then replace each digit by its corresponding name from
# "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
# For example:
# >>> HumanEval.by_length([2, 1, 1, 4, 5, 8, 2, 3])
# ["Eigh... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_105_by_length.py | reworded | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'by_length' do
assert ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"] == HumanEval.candidate([2, 1, 1, 4, 5, 8, 2, 3])
assert [] == HumanEval.candidate([])
assert ["One"] == HumanEval.candidate([1, -1, 55])
as... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_106_f | elixir | # Implement the function f that takes n as a parameter,
# and returns a list of size n, such that the value of the element at index i is the factorial of i if i is even
# or the sum of numbers from 1 to i otherwise.
# i starts from 1.
# the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * ... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_106_f.py | reworded | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'f' do
assert [1, 2, 6, 24, 15] == HumanEval.candidate(5)
assert [1, 2, 6, 24, 15, 720, 28] == HumanEval.candidate(7)
assert [1] == HumanEval.candidate(1)
assert [1, 2, 6] == HumanEval.candidate(3)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_107_even_odd_palindrome | elixir | # Given a positive integer n, return a tuple that has the number of even and odd
# integer palindromes that fall within the range(1, n), inclusive.
# Example 1:
# >>> HumanEval.even_odd_palindrome(3)
# {1, 2}
# Explanation:
# Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
# Example 2:
# >... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_107_even_odd_palindrome.py | reworded | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'even_odd_palindrome' do
assert {8, 13} == HumanEval.candidate(123)
assert {4, 6} == HumanEval.candidate(12)
assert {1, 2} == HumanEval.candidate(3)
assert {6, 8} == HumanEval.candidate(63)
assert {5, 6} == HumanEval.can... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_108_count_nums | elixir | # Write a function count_nums which takes a list 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.
# >>> HumanEval.count_nums([])
# 0
# >>> HumanEval.count_nums([-1, 11, -11... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_108_count_nums.py | reworded | 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 a list 'arr' of N integers arr[1], arr[2], ..., arr[N].The
# numbers in the list will be randomly ordered. Your task is to determine if
# it is possible to get a list sorted in non-decreasing order by performing
# the following operation on the given list:
# You are allowed to perform right shift operation a... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_109_move_one_ball.py | reworded | 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.
# >>> HumanEval.make_palindrome("")
# ""
# >>> Hum... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_10_make_palindrome.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py | reworded | 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 map
# of the letter with the most repetition and containing the corresponding count.
# If several letters have the same occurrence, return all of them.
# Example:
# >>> HumanEval.histogram("a b c")
# %{"a" => 1, "b" => 1, "c" => 1}
# >>> HumanE... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py | reworded | 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.
# >>> HumanEval.odd_count(["12345... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py | reworded | 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 a list of integers nums, find the minimum sum of any non-empty sub-list
# of nums.
# Example
# >>> HumanEval.minSubArraySum([2, 3, 4, 1, 2, 4])
# 1
# >>> HumanEval.minSubArraySum([-1, -2, -3])
# -6
defmodule HumanEval do
def candidate(nums), do: minSubArraySum(nums)
def minSubArraySum(nums) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py | reworded | 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 a list 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:
# >>> HumanEval.sort_array([1, 5, 2, 3, 4])
# [1, 2, 3, 4, 5]
# >>> HumanEval.s... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_sort_array.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py | reworded | 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
... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py | reworded | 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.
# >>> HumanEval.string_xor("010", "110")
# "100"
defmodule HumanEval do
def candidate(a, b), do: string_xor(a, b)
def string_xor(a, b) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_11_string_xor.py | reworded | 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 a list arr of integers and a positive integer k, return a sorted list
# of length k with the maximum k numbers in arr.
# Example 1:
# >>> HumanEval.maximum([-3, -4, 5], 3)
# [-4, -3, 5]
# Example 2:
# >>> HumanEval.maximum([4, -4, 4], 2)
# [4, 4]
# Example 3:
# >>> HumanEval.maximum([-3, 2, 1, 2, -1, -2, 1], 1... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py | reworded | 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
# >>> HumanEval.solution([5, 8, 7, 1])
# 12
# >>> HumanEval.solution([3, 3, 3, 3, 3])
# 9
# >>> HumanEval.solution([30, 13, 24, 321])
# 0
defmodule HumanEval do
def candidate(lst), do: solution(lst)... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py | reworded | 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 list 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:
# >>> HumanEval.add_elements([111, 21, 3, 4000, 5, 6, 7, 8, 9], 4)
# 24
# Constraints:
# 1. 1 <= len(arr) <= 100
# 2. 1 <= k <= len(arr)
defmodule HumanEval d... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py | reworded | 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
# >>> HumanEval.s... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_125_split_words.py | reworded | 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
# >>> HumanEval.is_sorted([5])
# true
# >>> HumanEval.is_sorted([1, 2, 3, 4, 5])
# true
# >>> HumanEval.is... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py | reworded | 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 a list arr of integers and you need to return
# sum of magnitudes of integers multiplied by product of all signs
# of each number in the list, represented by 1, -1 or 0.
# Note: return nil for empty arr.
# Example:
# >>> HumanEval.prod_signs([1, 2, 2, -4])
# 9
# >>> HumanEval.prod_signs([0, 1])
# 0
# >>... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_128_prod_signs.py | reworded | 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 ... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py | reworded | 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 nil in case the input list is empty.
# >>> HumanEval.longest([])
# nil
# >>> HumanEval.longest(["a", "b", "c"])
# "a"
# >>> HumanEval.longest(["a", "bb", "ccc"])
# "ccc"
defmodule HumanEval d... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_12_longest.py | reworded | 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 ... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py | reworded | 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:
# >>> HumanEval.digits(1)
# 1
# >>> HumanEval.digits(4)
# 0
# >>> HumanEval.digits(235)
# 15
defmodule HumanEval do
def candidate(n), do: digits(n)
def digits(n) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py | reworded | 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.
# >>> HumanEval.is_nested("[[]]")
# true
# >>> HumanEval.is_nested("[]]]]]]][[[[[]")... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py | reworded | 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:
# >>> HumanEval.lst([1.0, 2.0, 3.0])
# 14
# >>> HumanEval.lst([1.0, 4.0, 9.0])
# 98
# >>> HumanEval.lst([1.0, 3.0, 5.0, 7.0])
# 84
# >>> Hum... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py | reworded | 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:
# >>> HumanEval.check_if_last_char_is_a_letter("apple pie")
# false
# >>> HumanEval.che... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py | reworded | 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 list will not contain
# duplicate values.
# Examples:
# >>> HumanEval.can_arrange([1, 2, 4, 3, 5])
# 3
# >>> HumanEval.can... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py | reworded | 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 nil.
# Examples:
# >>> HumanEval.largest_smallest_integers([2, 4, 1, 3, 5, 7])
# {nil, 1}
# >>> Human... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py | reworded | 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 nil if the values are equal.
# Note: If a real number is represented as a string, the floating point might be . or ,
# >>> HumanEval.compare_one(1, 2.5)
# 2.5
# >... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_137_compare_one.py | reworded | 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
# >>> HumanEval.is_equal_to_sum_even(4)
# false
# >>> HumanEval.is_equal_to_sum_even(6)
# false
# >>> HumanEval.is_equal_to_sum_even(8)
# true
defmodule HumanEval do
def candidate(n), do: is_equal_to_sum_even... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py | reworded | 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:
# >>> HumanEval.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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py | reworded | 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
# >>> HumanEval.greatest_common_divisor(3, 5)
# 1
# >>> HumanEval.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
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_13_greatest_common_divisor.py | reworded | 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 -
# >>> HumanEval.fix_spaces(" Example")
# "Example"
# >>> HumanEval.fix_spaces(" Example 1")
# "Example_1"
# >>> HumanEval.fix_spaces(" Example 2")
# "_E... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py | reworded | 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:
# >>> HumanEval.order_by_points([1, 11, -1, -11, -12])
# [-1, -11, ... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py | reworded | 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 a list of numbers as input and returns
# the number of elements in the list that are greater than 10 and both
# first and last digits of a number are odd (1, 3, 5, 7, 9).
# For example:
# >>> HumanEval.specialFilter([15, -73, 14, -15])
# 1
# >>> HumanEval.specialFilter([33, -2, -3, 45, 2... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py | reworded | 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 list a of length n.
# For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
# Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
# and a[i] + a[j] + a[k] is a multiple of 3.
# Example :
# >>> HumanEval.get_max_triples(5)
# 1
# ... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_148_bf.py | reworded | 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 a list of numbers,
# and it may contain duplicates.
# The order of the list should be ascending by ... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py | reworded | 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
# >>> HumanEval.all_prefixes("abc")
# ["a", "ab", "abc"]
defmodule HumanEval do
def candidate(string), do: all_prefixes(string)
def all_prefixes(string) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_14_all_prefixes.py | reworded | 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:
# >>> HumanEval.x_or_y(7, 34, 12)
# 34
# >>> HumanEval.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
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py | reworded | 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.
# >>> HumanEval.double_the_difference([1, 3, 2, 0])
# 10
# >>> HumanEval.double_the_difference([-1, -2, 0])
# 0
# >>> HumanEval.double_the_difference([9, -2])
# 81
# >>> Huma... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py | reworded | 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 list... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py | reworded | 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
# ... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py | reworded | 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
# >>> HumanEval.cycpattern_check("abcd", "abd")
# false
# >>> HumanEval.cycpattern_check("hello", "ell")
# true
# >>> HumanEval.cycpattern_check("whassup", "psus")
# false
# >>> HumanEval.cycpatt... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py | reworded | 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:
# >>> HumanEval.even_odd_count(-12)
# {1, 1}
# >>> HumanEval.even_odd_count(123)
# {1, 2}
defmodule HumanEval do
def candidate(num), do: even_odd_count(num)
def even_odd_count(num) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py | reworded | 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:
# >>> HumanEval.int_to_mini_roman(19)
# "xix"
# >>> HumanEval.int_to_mini_roman(152)
# "clii"
# >>> HumanEval.int_to_mini_roman(426)
# "cdxxvi"
defmodule HumanEval do
... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py | reworded | 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:
# >>> HumanEval.right_angle_triangle(3, 4, 5)
# true
# >>> HumanEval.right_angle_tri... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py | reworded | 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.
# >>> HumanEval.find_max(["name", "of", "string"]... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py | reworded | 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 a list of [ total number of eaten carrots after your meals,
# the number of carrots left after your meals ]
# if there are not enough remaining carrot... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py | reworded | 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.
# >>> HumanEval.string_sequence(0)
# "0"
# >>> HumanEval.string_sequence(5)
# "0 1 2 3 4 5"
defmodule HumanEval do
def candidate(n), do: string_sequence(n)
def string_sequence(n) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_15_string_sequence.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py | reworded | 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
# >>> HumanEval.solve("1234")
# "4321"
# >>> HumanEval.solve("ab")
#... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py | reworded | 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 nil.
# >>> HumanEval.string_to_md5("Hello world")
# "3e25960a79dbc69b674cd4ec67a72c62"
defmodule HumanEval do
def candidate(text), do: string_to_md5(text)
def string_to_md5(text) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_162_string_to_md5.py | reworded | 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:
# >>> HumanEval.generate_integers(2, 8)
# [2, 4, 6, 8]
# >>> HumanEval.generate_integers(8, 2)
# [2, 4, 6, 8]
# >>> HumanEval.generate_integers(10, 14)
# []
defmodule HumanEval do
def candidate(a, b), ... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py | reworded | 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
# >>> HumanEval.count_distinct_characters("xyzXYZ")
# 3
# >>> HumanEval.count_distinct_characters("Jerry")
# 4
defmodule HumanEval do
def candidate(string), do: count_distinct_characters(string)
def count_distinct_chara... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_16_count_distinct_characters.py | reworded | 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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_17_parse_music.py | reworded | 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.
# >>> HumanEval.how_many_times("", "a")
# 0
# >>> HumanEval.how_many_times("aaa", "a")
# 3
# >>> HumanEval.how_many_times("aaaa", "aa")
# 3
defmodule HumanEval do
def candidate(string, substring), do: how_many_times(... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_18_how_many_times.py | reworded | 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
# >>> HumanEval.sort_numbers("three one five")
# "one three five"
defmodule Hum... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_19_sort_numbers.py | reworded | 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.
... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_1_separate_paren_groups.py | reworded | 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).
# >>> HumanEval.find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
# {2.0, 2.2}
# >>> HumanEval.find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_20_find_closest_elements.py | reworded | 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
# >>> HumanEval.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... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_21_rescale_to_unit.py | reworded | 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 elixirthon values only for integers
# >>> HumanEval.filter_integers(["a", 3.14, 5])
# [5]
# >>> HumanEval.filter_integers([1, 2, 3, "abc", %{}, []])
# [1, 2, 3]
defmodule HumanEval do
def candidate(values), do: filter_integers(values)
def filter_integers(values) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_22_filter_integers.py | reworded | 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
# >>> HumanEval.strlen("")
# 0
# >>> HumanEval.strlen("abc")
# 3
defmodule HumanEval do
def candidate(string), do: strlen(string)
def strlen(string) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_23_strlen.py | reworded | 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
# >>> HumanEval.largest_divisor(15)
# 5
defmodule HumanEval do
def candidate(n), do: largest_divisor(n)
def largest_divisor(n) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_24_largest_divisor.py | reworded | 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
# >>> HumanEval.factorize(8)
# [2, 2, 2]
# >>> HumanEva... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_25_factorize.py | reworded | 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.
# >>> HumanEval.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
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_26_remove_duplicates.py | reworded | 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.
# >>> HumanEval.flip_case("Hello")
# "hELLO"
defmodule HumanEval do
def candidate(string), do: flip_case(string)
def flip_case(string) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_27_flip_case.py | reworded | 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
# >>> HumanEval.concatenate([])
# ""
# >>> HumanEval.concatenate(["a", "b", "c"])
# "abc"
defmodule HumanEval do
def candidate(strings), do: concatenate(strings)
def concatenate(strings) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_28_concatenate.py | reworded | 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.
# >>> HumanEval.filter_by_prefix([], "a")
# []
# >>> HumanEval.filter_by_prefix(["abc", "bcd", "cde", "array"], "a")
# ["abc", "array"]
defmodule HumanEval do
def candidate(strings, prefix), do: filter_by_prefix(strings, prefix)
def fi... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_29_filter_by_prefix.py | reworded | 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.
# >>> HumanEval.truncate_number(3.5)
# 0.5
defmodule HumanEval do
def candidate(number), do... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_2_truncate_number.py | reworded | 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.
# >>> HumanEval.get_positive([-1, 2, -4, 5, 6])
# [2, 5, 6]
# >>> HumanEval.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
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_30_get_positive.py | reworded | 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.
# >>> HumanEval.is_prime(6)
# false
# >>> HumanEval.is_prime(101)
# true
# >>> HumanEval.is_prime(11)
# true
# >>> HumanEval.is_prime(13441)
# true
# >>> HumanEval.is_prime(61)
# true
# >>> HumanEval.is_prime(4)
# false
# >>> HumanEval.is_prime(1)
# false
... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_31_is_prime.py | reworded | 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.
# >>> HumanEval.sort_third([1, 2, 3])
# [1, 2, 3]
... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_33_sort_third.py | reworded | 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"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.