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_71_triangle_area | elixir | # Given the lengths of the three sides of a triangle. Return the area of
# the triangle rounded to 2 decimal points if the three sides form a valid triangle.
# Otherwise return -1
# Three sides make a valid triangle when the sum of any two sides is greater
# than the third side.
# Example:
# >>> HumanEval.triangle_ar... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_71_triangle_area.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'triangle_area' do
assert 6.0 == HumanEval.candidate(3, 4, 5)
assert -1 == HumanEval.candidate(1, 2, 10)
assert 8.18 == HumanEval.candidate(4, 8, 5)
assert 1.73 == HumanEval.candidate(2, 2, 2)
assert -1 == HumanEval.cand... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_72_will_it_fly | elixir | # Write a function that returns True if the object q will fly, and False otherwise.
# The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.
# Example:
# >>> HumanEval.will_it_fly([1, 2], 5)
# false
# # 1+2 is less than the maxi... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_72_will_it_fly.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'will_it_fly' do
assert true == HumanEval.candidate([3, 2, 3], 9)
assert false == HumanEval.candidate([1, 2], 5)
assert true == HumanEval.candidate([3], 5)
assert false == HumanEval.candidate([3, 2, 3], 1)
assert false =... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_73_smallest_change | elixir | # Given an array arr of integers, find the minimum number of elements that
# need to be changed to make the array palindromic. A palindromic array is an array that
# is read the same backwards and forwards. In one change, you can change one element to any other element.
# For example:
# >>> HumanEval.smallest_change([1... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_73_smallest_change.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'smallest_change' do
assert 4 == HumanEval.candidate([1, 2, 3, 5, 4, 7, 9, 6])
assert 1 == HumanEval.candidate([1, 2, 3, 4, 3, 2, 2])
assert 1 == HumanEval.candidate([1, 4, 2])
assert 1 == HumanEval.candidate([1, 4, 4, 2])
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_74_total_match | elixir | # Write a function that accepts two lists of strings and returns the list that has
# total number of chars in the all strings of the list less than the other list.
# if the two lists have the same number of chars, return the first list.
# Examples
# >>> HumanEval.total_match([], [])
# []
# >>> HumanEval.total_match(["... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_74_total_match.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'total_match' do
assert [] == HumanEval.candidate([], [])
assert ["hi", "hi"] == HumanEval.candidate(["hi", "admin"], ["hi", "hi"])
assert ["hi", "admin"] == HumanEval.candidate(["hi", "admin"], ["hi", "hi", "admin", "project"])... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_75_is_multiply_prime | elixir | # Write a function that returns true if the given number is the multiplication of 3 prime numbers
# and false otherwise.
# Knowing that (a) is less then 100.
# Example:
# >>> HumanEval.is_multiply_prime(30)
# true
# 30 = 2 * 3 * 5
defmodule HumanEval do
def candidate(a), do: is_multiply_prime(a)
def is_multiply_p... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_75_is_multiply_prime.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'is_multiply_prime' do
assert false == HumanEval.candidate(5)
assert true == HumanEval.candidate(30)
assert true == HumanEval.candidate(8)
assert false == HumanEval.candidate(10)
assert true == HumanEval.candidate(125)
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_76_is_simple_power | elixir | # Your task is to write a function that returns true if a number x is a simple
# power of n and false in other cases.
# x is a simple power of n if n**int=x
# For example:
# >>> HumanEval.is_simple_power(1, 4)
# true
# >>> HumanEval.is_simple_power(2, 2)
# true
# >>> HumanEval.is_simple_power(8, 2)
# true
# >>> HumanEv... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_76_is_simple_power.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'is_simple_power' do
assert true == HumanEval.candidate(16, 2)
assert false == HumanEval.candidate(143214, 16)
assert true == HumanEval.candidate(4, 2)
assert true == HumanEval.candidate(9, 3)
assert true == HumanEval.ca... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_77_iscube | elixir | # Write a function that takes an integer a and returns True
# if this ingeger is a cube of some integer number.
# Note: you may assume the input is always valid.
# Examples:
# >>> HumanEval.iscube(1)
# true
# >>> HumanEval.iscube(2)
# false
# >>> HumanEval.iscube(-1)
# true
# >>> HumanEval.iscube(64)
# true
# >>> Huma... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_77_iscube.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'iscube' do
assert true == HumanEval.candidate(1)
assert false == HumanEval.candidate(2)
assert true == HumanEval.candidate(-1)
assert true == HumanEval.candidate(64)
assert false == HumanEval.candidate(180)
assert t... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_78_hex_key | elixir | # You have been tasked to write a function that receives
# a hexadecimal number as a string and counts the number of hexadecimal
# digits that are primes (prime number, or a prime, is a natural number
# greater than 1 that is not a product of two smaller natural numbers).
# Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_78_hex_key.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'hex_key' do
assert 1 == HumanEval.candidate("AB")
assert 2 == HumanEval.candidate("1077E")
assert 4 == HumanEval.candidate("ABED1A33")
assert 2 == HumanEval.candidate("2020")
assert 6 == HumanEval.candidate("123456789AB... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_79_decimal_to_binary | elixir | # You will be given a number in decimal form and your task is to convert it to
# binary format. The function should return a string, with each character representing a binary
# number. Each character in the string will be '0' or '1'.
# There will be an extra couple of characters 'db' at the beginning and at the end of ... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_79_decimal_to_binary.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'decimal_to_binary' do
assert "db0db" == HumanEval.candidate(0)
assert "db100000db" == HumanEval.candidate(32)
assert "db1100111db" == HumanEval.candidate(103)
assert "db1111db" == HumanEval.candidate(15)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_7_filter_by_substring | elixir | # Filter an input list of strings only for ones that contain given substring
# >>> HumanEval.filter_by_substring([], "a")
# []
# >>> HumanEval.filter_by_substring(["abc", "bacd", "cde", "array"], "a")
# ["abc", "bacd", "array"]
defmodule HumanEval do
def candidate(strings, substring), do: filter_by_substring(strings... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_7_filter_by_substring.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'filter_by_substring' do
assert [] == HumanEval.candidate([], "john")
assert ["xxx", "xxxAAA", "xxx"] == HumanEval.candidate(["xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"], "xxx")
assert ["xxx", "aaaxxy", "xxxAAA", "xxx"] ==... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_80_is_happy | elixir | # You are given a string s.
# Your task is to check if the string is happy or not.
# A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
# For example:
# >>> HumanEval.is_happy("a")
# false
# >>> HumanEval.is_happy("aa")
# false
# >>> HumanEval.is_happy("abcd")
# true
# >>> HumanE... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_80_is_happy.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'is_happy' do
assert false == HumanEval.candidate("a")
assert false == HumanEval.candidate("aa")
assert true == HumanEval.candidate("abcd")
assert false == HumanEval.candidate("aabb")
assert true == HumanEval.candidate("... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_81_numerical_letter_grade | elixir | # It is the last week of the semester and the teacher has to give the grades
# to students. The teacher has been making her own algorithm for grading.
# The only problem is, she has lost the code she used for grading.
# She has given you a list of GPAs for some students and you have to write
# a function that can outp... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_81_numerical_letter_grade.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'numerical_letter_grade' do
assert ["A+", "B", "C-", "C", "A-"] == HumanEval.candidate([4.0, 3, 1.7, 2, 3.5])
assert ["D+"] == HumanEval.candidate([1.2])
assert ["D-"] == HumanEval.candidate([0.5])
assert ["E"] == HumanEval.... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_82_prime_length | elixir | # Write a function that takes a string and returns True if the string
# length is a prime number or False otherwise
# Examples
# >>> HumanEval.prime_length("Hello")
# true
# >>> HumanEval.prime_length("abcdcba")
# true
# >>> HumanEval.prime_length("kittens")
# true
# >>> HumanEval.prime_length("orange")
# false
defmod... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_82_prime_length.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'prime_length' do
assert true == HumanEval.candidate("Hello")
assert true == HumanEval.candidate("abcdcba")
assert true == HumanEval.candidate("kittens")
assert false == HumanEval.candidate("orange")
assert true == Human... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_83_starts_one_ends | elixir | # Given a positive integer n, return the count of the numbers of n-digit
# positive integers that start or end with 1.
defmodule HumanEval do
def candidate(n), do: starts_one_ends(n)
def starts_one_ends(n) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_83_starts_one_ends.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'starts_one_ends' do
assert 1 == HumanEval.candidate(1)
assert 18 == HumanEval.candidate(2)
assert 180 == HumanEval.candidate(3)
assert 1800 == HumanEval.candidate(4)
assert 18000 == HumanEval.candidate(5)
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_84_solve | elixir | # Given a positive integer N, return the total sum of its digits in binary.
# Example
# >>> HumanEval.solve(1000)
# "1"
# >>> HumanEval.solve(150)
# "110"
# >>> HumanEval.solve(147)
# "1100"
# Variables:
# @N integer
# Constraints: 0 ≤ N ≤ 10000.
# Output:
# a string of binary number
defmodule HumanEval do
def candi... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_84_solve.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'solve' do
assert "1" == HumanEval.candidate(1000)
assert "110" == HumanEval.candidate(150)
assert "1100" == HumanEval.candidate(147)
assert "1001" == HumanEval.candidate(333)
assert "10010" == HumanEval.candidate(963)
... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_85_add | elixir | # Given a non-empty list of integers lst. add the even elements that are at odd indices..
# Examples:
# >>> HumanEval.add([4, 2, 6, 7])
# 2
defmodule HumanEval do
def candidate(lst), do: add(lst)
def add(lst) do
| transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_85_add.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'add' do
assert 88 == HumanEval.candidate([4, 88])
assert 122 == HumanEval.candidate([4, 5, 6, 7, 2, 122])
assert 0 == HumanEval.candidate([4, 0, 6, 7])
assert 12 == HumanEval.candidate([4, 4, 6, 8])
end
end
| [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_86_anti_shuffle | elixir | # Write a function that takes a string and returns an ordered version of it.
# Ordered version of string, is a string where all words (separated by space)
# are replaced by a new word where all the characters arranged in
# ascending order based on ascii value.
# Note: You should keep the order of words and blank spaces... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_86_anti_shuffle.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'anti_shuffle' do
assert "Hi" == HumanEval.candidate("Hi")
assert "ehllo" == HumanEval.candidate("hello")
assert "bemnru" == HumanEval.candidate("number")
assert "abcd" == HumanEval.candidate("abcd")
assert "Hello !!!Wdl... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_87_get_row | elixir | # You are given a 2 dimensional data, as a nested lists,
# which is similar to matrix, however, unlike matrices,
# each row may contain a different number of columns.
# Given lst, and integer x, find integers x in the list,
# and return list of tuples, [(x1, y1), (x2, y2) ...] such that
# each tuple is a coordinate - (... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_87_get_row.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'get_row' do
assert [{0, 0}, {1, 4}, {1, 0}, {2, 5}, {2, 0}] == HumanEval.candidate([[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 1, 6], [1, 2, 3, 4, 5, 1]], 1)
assert [{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}] == HumanEval.candidate([[1,... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_88_sort_array | elixir | # Given an array of non-negative integers, return a copy of the given array after sorting,
# you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
# or sort it in descending order if the sum( first index value, last index value) is even.
# Note:
# * don't change the g... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_88_sort_array.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'sort_array' do
assert [] == HumanEval.candidate([])
assert [5] == HumanEval.candidate([5])
assert [0, 1, 2, 3, 4, 5] == HumanEval.candidate([2, 4, 3, 0, 1, 5])
assert [6, 5, 4, 3, 2, 1, 0] == HumanEval.candidate([2, 4, 3, 0... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_89_encrypt | elixir | # Create a function encrypt that takes a string as an argument and
# returns a string encrypted with the alphabet being rotated.
# The alphabet should be rotated in a manner such that the letters
# shift down by two multiplied to two places.
# For example:
# >>> HumanEval.encrypt("hi")
# "lm"
# >>> HumanEval.encrypt(... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_89_encrypt.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'encrypt' do
assert "lm" == HumanEval.candidate("hi")
assert "ewhjklnop" == HumanEval.candidate("asdfghjkl")
assert "kj" == HumanEval.candidate("gf")
assert "ix" == HumanEval.candidate("et")
assert "jeiajeaijeiak" == Hum... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_8_sum_product | elixir | # For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
# Empty sum should be equal to 0 and empty product should be equal to 1.
# >>> HumanEval.sum_product([])
# {0, 1}
# >>> HumanEval.sum_product([1, 2, 3, 4])
# {10, 24}
defmodule HumanEval do
def candidate(n... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_8_sum_product.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'sum_product' do
assert {0, 1} == HumanEval.candidate([])
assert {3, 1} == HumanEval.candidate([1, 1, 1])
assert {100, 0} == HumanEval.candidate([100, 0])
assert {15, 105} == HumanEval.candidate([3, 5, 7])
assert {10, 10... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
HumanEval_90_next_smallest | elixir | # You are given a list of integers.
# Write a function next_smallest() that returns the 2nd smallest element of the list.
# Return None if there is no such element.
# >>> HumanEval.next_smallest([1, 2, 3, 4, 5])
# 2
# >>> HumanEval.next_smallest([5, 1, 4, 3, 2])
# 2
# >>> HumanEval.next_smallest([])
# nil
# >>> HumanEv... | transform | /home/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_90_next_smallest.py | verbatim | ExUnit.start()
defmodule HumanEvalTest do
use ExUnit.Case, async: true
test 'next_smallest' do
assert 2 == HumanEval.candidate([1, 2, 3, 4, 5])
assert 2 == HumanEval.candidate([5, 1, 4, 3, 2])
assert nil == HumanEval.candidate([])
assert nil == HumanEval.candidate([1, 1])
assert 1 == HumanEval.c... | [
"\ndefmodule",
"\ndefp",
"\ndef ",
"\n#",
"\n\n"
] |
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:
# >>> HumanEval.is_bored("Hello world")
# 0
# >>> HumanEval.is_bored("The sky is blue. The sun is shining. I love t... | transform | /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
# >>> HumanEval.any_int(5, 2, 7)
# true
# >>> HumanEval.any_int(3, 2, 2)
# false
# >>> HumanEval.any_int(3, -2, 1)
# true
# >>... | transform | /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:
# >>> HumanEval.encode("test")
# "TGST"
# >>> HumanEva... | transform | /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:
# >>> HumanEval.skjkasdkd([0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3])
# 10
# >>> HumanEval.skjkasdkd([1, 0, 1, 8, 2, 4597, 2, 1, 3, 40, 1, 2, 1, 2, 4, 2, 5, 1])
# 2... | transform | /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:
# >>> HumanEval.check_dict_case(%{"a" => "apple", "b" => "banana"})
# true
# >>> HumanEval.check_dict_case... | transform | /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:
# >>> HumanEval.count_up_to(5)
# [2, 3]
# >>> HumanEval.count_up_to(11)
# [2, 3, 5, 7]
# >>> HumanEval.count_up_to(0)
# []
# >>> HumanEval.count_up_to(20)
# [2,... | transform | /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:
# >>> HumanEval.multiply(148, 412)
# 16
# >>> HumanEval.multiply(19, 28)
# 72
# >>> HumanEval.multiply(2020, 1851)
# 0
# >>> HumanEval.multiply(14, -15)
# 20
defmodule HumanE... | transform | /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:
# >>> HumanEval.count_upper("aBCdEf")
# 1
# >>> HumanEval.count_upper("abcdefg")
# 0
# >>> HumanEval.count_upper("dBBE")
# 0
defmodule HumanEval do
def candidate(s), do: count_upper(s)
def count_upper(s) do
| transform | /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
# >>> HumanEval.closest_integer("10")
# 10
# >>> HumanEval.closest_integer("15.3")
# 15
# Note:
# Rounding away from zero m... | transform | /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.
# >>> HumanEval.rolling_max([1, 2, 3, 2, 3, 4, 2])
# [1, 2, 3, 3, 3, 4, 4]
defmodule HumanEval do
def candidate(numbers), do: rolling_max(numbers)
def rolling_max(numbers) do
| transform | /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 | go_test.go | package has_close_elements_test
import (
"testing"
"fmt"
)
// Check if in given list of numbers, are any two numbers closer to each other than
// given threshold.
// >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
// False
// >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
// True
func has_close_elem... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_0_has_close_elements.py | verbatim | func TestHas_Close_Elements(t *testing.T) {
candidate := has_close_elements
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]float64{1.0, 2.0, 3.9, 4.0, 5.0, 2.2}, 0.3), expected: true },
{ actual: candidate([]float64{1.0, 2.0, 3.9, 4.0, 5.0, 2.2... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_100_make_a_pile | go_test.go | package make_a_pile_test
import (
"testing"
"fmt"
)
// 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_100_make_a_pile.py | verbatim | func TestMake_A_Pile(t *testing.T) {
candidate := make_a_pile
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3), expected: []int{3, 5, 7} },
{ actual: candidate(4), expected: []int{4, 6, 8, 10} },
{ actual: candidate(5), expected: []int{5, 7... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_101_words_string | go_test.go | package words_string_test
import (
"testing"
"fmt"
)
// You will be given a string of words separated by commas or spaces. Your task is
// to split the string into words and return an array of the words.
// For example:
// words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
// words_stri... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_101_words_string.py | verbatim | func TestWords_String(t *testing.T) {
candidate := words_string
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Hi, my name is John"), expected: []string{"Hi", "my", "name", "is", "John"} },
{ actual: candidate("One, two, three, four, five, six")... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_102_choose_num | go_test.go | package choose_num_test
import (
"testing"
"fmt"
)
// 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:
// choose_num(12, 15) = 14
// choose_n... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_102_choose_num.py | verbatim | func TestChoose_Num(t *testing.T) {
candidate := choose_num
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(12, 15), expected: 14 },
{ actual: candidate(13, 12), expected: -1 },
{ actual: candidate(33, 12354), expected: 12354 },
{ actual... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_104_unique_digits | go_test.go | package unique_digits_test
import (
"testing"
"fmt"
)
// 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:
// >>> unique_digits([15, 33, 1422, 1])
// [1, 15, 33]
// >>> unique_d... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_104_unique_digits.py | verbatim | func TestUnique_Digits(t *testing.T) {
candidate := unique_digits
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{15, 33, 1422, 1}), expected: []int{1, 15, 33} },
{ actual: candidate([]int{152, 323, 1422, 10}), expected: []int{} },
{ ac... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_105_by_length | go_test.go | package by_length_test
import (
"testing"
"fmt"
)
// Given an array of integers, sort the integers that are between 1 and 9 inclusive,
// reverse the resulting array, and then replace each digit by its corresponding name from
// "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
// For ex... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_105_by_length.py | verbatim | func TestBy_Length(t *testing.T) {
candidate := by_length
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{2, 1, 1, 4, 5, 8, 2, 3}), expected: []string{"Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"} },
{ actual: candidate([]int... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_106_f | go_test.go | package f_test
import (
"testing"
"fmt"
)
// 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_106_f.py | verbatim | func TestF(t *testing.T) {
candidate := f
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5), expected: []int{1, 2, 6, 24, 15} },
{ actual: candidate(7), expected: []int{1, 2, 6, 24, 15, 720, 28} },
{ actual: candidate(1), expected: []int{1} ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_107_even_odd_palindrome | go_test.go | package even_odd_palindrome_test
import (
"testing"
"fmt"
)
// 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:
// Input: 3
// Output: (1, 2)
// Explanation:
// Integer palindrome are 1, 2, 3. one o... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_107_even_odd_palindrome.py | verbatim | func TestEven_Odd_Palindrome(t *testing.T) {
candidate := even_odd_palindrome
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(123), expected: []interface{}{8, 13} },
{ actual: candidate(12), expected: []interface{}{4, 6} },
{ actual: candidat... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_108_count_nums | go_test.go | package count_nums_test
import (
"testing"
"fmt"
)
// 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.
// >>> ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_108_count_nums.py | verbatim | func TestCount_Nums(t *testing.T) {
candidate := count_nums
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}), expected: 0 },
{ actual: candidate([]int{-1, -2, 0}), expected: 0 },
{ actual: candidate([]int{1, 1, 2, -2, 3, 4, 5}), expec... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_109_move_one_ball | go_test.go | package move_one_ball_test
import (
"testing"
"fmt"
)
// 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 operatio... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_109_move_one_ball.py | verbatim | func TestMove_One_Ball(t *testing.T) {
candidate := move_one_ball
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{3, 4, 5, 1, 2}), expected: true },
{ actual: candidate([]int{3, 5, 10, 1, 2}), expected: true },
{ actual: candidate([]int... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_10_make_palindrome | go_test.go | package make_palindrome_test
import (
"testing"
"fmt"
)
// 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_10_make_palindrome.py | verbatim | func TestMake_Palindrome(t *testing.T) {
candidate := make_palindrome
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: "" },
{ actual: candidate("x"), expected: "x" },
{ actual: candidate("xyz"), expected: "xyzyx" },
{ actu... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_110_exchange | go_test.go | package exchange_test
import (
"testing"
"fmt"
)
// 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 exchan... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_110_exchange.py | verbatim | func TestExchange(t *testing.T) {
candidate := exchange
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 3, 4}, []int{1, 2, 3, 4}), expected: "YES" },
{ actual: candidate([]int{1, 2, 3, 4}, []int{1, 5, 3, 4}), expected: "NO" },
{ a... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_111_histogram | go_test.go | package histogram_test
import (
"testing"
"fmt"
)
// 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:
// histogr... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_111_histogram.py | verbatim | func TestHistogram(t *testing.T) {
candidate := histogram
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("a b b a"), expected: map[string]int{"a": 2, "b": 2} },
{ actual: candidate("a b c a b"), expected: map[string]int{"a": 2, "b": 2} },
{ ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_112_reverse_delete | go_test.go | package reverse_delete_test
import (
"testing"
"fmt"
)
// 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.
// Y... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_112_reverse_delete.py | verbatim | func TestReverse_Delete(t *testing.T) {
candidate := reverse_delete
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("abcde", "ae"), expected: []interface{}{"bcd", false} },
{ actual: candidate("abcdef", "b"), expected: []interface{}{"acdef", false... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_113_odd_count | go_test.go | package odd_count_test
import (
"testing"
"fmt"
)
// 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_113_odd_count.py | verbatim | func TestOdd_Count(t *testing.T) {
candidate := odd_count
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"1234567"}), expected: []string{"the number of odd elements 4n the str4ng 4 of the 4nput."} },
{ actual: candidate([]string{"3", "11... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_114_minSubArraySum | go_test.go | package minSubArraySum_test
import (
"testing"
"fmt"
)
// 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
func minSubArraySum(nums []int) int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_114_minSubArraySum.py | verbatim | func TestMinsubarraysum(t *testing.T) {
candidate := minSubArraySum
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{2, 3, 4, 1, 2, 4}), expected: 1 },
{ actual: candidate([]int{-1, -2, -3}), expected: -6 },
{ actual: candidate([]int{-1,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_115_max_fill | go_test.go | package max_fill_test
import (
"testing"
"fmt"
)
// 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 capac... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_115_max_fill.py | verbatim | func TestMax_Fill(t *testing.T) {
candidate := max_fill
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([][]int{[]int{0, 0, 1, 0}, []int{0, 1, 0, 0}, []int{1, 1, 1, 1}}, 1), expected: 6 },
{ actual: candidate([][]int{[]int{0, 0, 1, 1}, []int{0, 0,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_116_sort_array | go_test.go | package sort_array_test
import (
"testing"
"fmt"
)
// 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_... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_116_sort_array.py | verbatim | func TestSort_Array(t *testing.T) {
candidate := sort_array
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 5, 2, 3, 4}), expected: []int{1, 2, 4, 3, 5} },
{ actual: candidate([]int{-2, -3, -4, -5, -6}), expected: []int{-4, -2, -6, -5, -3... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_117_select_words | go_test.go | package select_words_test
import (
"testing"
"fmt"
)
// 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_117_select_words.py | verbatim | func TestSelect_Words(t *testing.T) {
candidate := select_words
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Mary had a little lamb", 4), expected: []string{"little"} },
{ actual: candidate("Mary had a little lamb", 3), expected: []string{"Mar... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_118_get_closest_vowel | go_test.go | package get_closest_vowel_test
import (
"testing"
"fmt"
)
// 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_118_get_closest_vowel.py | verbatim | func TestGet_Closest_Vowel(t *testing.T) {
candidate := get_closest_vowel
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("yogurt"), expected: "u" },
{ actual: candidate("full"), expected: "u" },
{ actual: candidate("easy"), expected: "" },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_119_match_parens | go_test.go | package match_parens_test
import (
"testing"
"fmt"
)
// 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 st... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_119_match_parens.py | verbatim | func TestMatch_Parens(t *testing.T) {
candidate := match_parens
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"()(", ")"}), expected: "Yes" },
{ actual: candidate([]string{")", ")"}), expected: "No" },
{ actual: candidate([]string{... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_11_string_xor | go_test.go | package string_xor_test
import (
"testing"
"fmt"
)
// 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'
func string_xor(a string, b string) string {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_11_string_xor.py | verbatim | func TestString_Xor(t *testing.T) {
candidate := string_xor
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("111000", "101010"), expected: "010010" },
{ actual: candidate("1", "1"), expected: "0" },
{ actual: candidate("0101", "0000"), expect... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_120_maximum | go_test.go | package maximum_test
import (
"testing"
"fmt"
)
// 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:... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_120_maximum.py | verbatim | func TestMaximum(t *testing.T) {
candidate := maximum
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{-3, -4, 5}, 3), expected: []int{-4, -3, 5} },
{ actual: candidate([]int{4, -4, 4}, 2), expected: []int{4, 4} },
{ actual: candidate([]... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_121_solution | go_test.go | package solution_test
import (
"testing"
"fmt"
)
// 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
func solution(lst []int) int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_121_solution.py | verbatim | func TestSolution(t *testing.T) {
candidate := solution
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{5, 8, 7, 1}), expected: 12 },
{ actual: candidate([]int{3, 3, 3, 3, 3}), expected: 9 },
{ actual: candidate([]int{30, 13, 24, 321}),... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_122_add_elements | go_test.go | package add_elements_test
import (
"testing"
"fmt"
)
// 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
// Constraint... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_122_add_elements.py | verbatim | func TestAdd_Elements(t *testing.T) {
candidate := add_elements
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, -2, -3, 41, 57, 76, 87, 88, 99}, 3), expected: -4 },
{ actual: candidate([]int{111, 121, 3, 4000, 5, 6}, 2), expected: 0 },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_123_get_odd_collatz | go_test.go | package get_odd_collatz_test
import (
"testing"
"fmt"
)
// 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 i... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_123_get_odd_collatz.py | verbatim | func TestGet_Odd_Collatz(t *testing.T) {
candidate := get_odd_collatz
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(14), expected: []int{1, 5, 7, 11, 13, 17} },
{ actual: candidate(5), expected: []int{1, 5} },
{ actual: candidate(12), expec... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_124_valid_date | go_test.go | package valid_date_test
import (
"testing"
"fmt"
)
// 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_124_valid_date.py | verbatim | func TestValid_Date(t *testing.T) {
candidate := valid_date
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("03-11-2000"), expected: true },
{ actual: candidate("15-01-2012"), expected: false },
{ actual: candidate("04-0-2040"), expected: fal... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_126_is_sorted | go_test.go | package is_sorted_test
import (
"testing"
"fmt"
)
// 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, ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_126_is_sorted.py | verbatim | func TestIs_Sorted(t *testing.T) {
candidate := is_sorted
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{5}), expected: true },
{ actual: candidate([]int{1, 2, 3, 4, 5}), expected: true },
{ actual: candidate([]int{1, 3, 2, 4, 5}), exp... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_127_intersection | go_test.go | package intersection_test
import (
"testing"
"fmt"
)
// 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 inter... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_127_intersection.py | verbatim | func TestIntersection(t *testing.T) {
candidate := intersection
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]interface{}{1, 2}, []interface{}{2, 3}), expected: "NO" },
{ actual: candidate([]interface{}{-1, 1}, []interface{}{0, 4}), expected: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_129_minPath | go_test.go | package minPath_test
import (
"testing"
"fmt"
)
// 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 len... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_129_minPath.py | verbatim | func TestMinpath(t *testing.T) {
candidate := minPath
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([][]int{[]int{1, 2, 3}, []int{4, 5, 6}, []int{7, 8, 9}}, 3), expected: []int{1, 2, 1} },
{ actual: candidate([][]int{[]int{5, 9, 3}, []int{4, 1, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_130_tri | go_test.go | package tri_test
import (
"testing"
"fmt"
)
// 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_130_tri.py | verbatim | func TestTri(t *testing.T) {
candidate := tri
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3), expected: []int{1, 3, 2, 8} },
{ actual: candidate(4), expected: []int{1, 3, 2, 8, 3} },
{ actual: candidate(5), expected: []int{1, 3, 2, 8, 3, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_131_digits | go_test.go | package digits_test
import (
"testing"
"fmt"
)
// 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
func digits(n int) int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_131_digits.py | verbatim | func TestDigits(t *testing.T) {
candidate := digits
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5), expected: 5 },
{ actual: candidate(54), expected: 5 },
{ actual: candidate(120), expected: 1 },
{ actual: candidate(5014), expected: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_132_is_nested | go_test.go | package is_nested_test
import (
"testing"
"fmt"
)
// 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('[[]]') ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_132_is_nested.py | verbatim | func TestIs_Nested(t *testing.T) {
candidate := is_nested
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("[[]]"), expected: true },
{ actual: candidate("[]]]]]]][[[[[]"), expected: false },
{ actual: candidate("[][]"), expected: false },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_133_sum_squares | go_test.go | package sum_squares_test
import (
"testing"
"fmt"
)
// 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 outp... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_133_sum_squares.py | verbatim | func TestSum_Squares(t *testing.T) {
candidate := sum_squares
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]float64{1.0, 2.0, 3.0}), expected: 14 },
{ actual: candidate([]float64{1.0, 2.0, 3.0}), expected: 14 },
{ actual: candidate([]floa... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_134_check_if_last_char_is_a_letter | go_test.go | package check_if_last_char_is_a_letter_test
import (
"testing"
"fmt"
)
// 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:
/... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_134_check_if_last_char_is_a_letter.py | verbatim | func TestCheck_If_Last_Char_Is_A_Letter(t *testing.T) {
candidate := check_if_last_char_is_a_letter
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("apple"), expected: false },
{ actual: candidate("apple pi e"), expected: true },
{ actual: ca... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_135_can_arrange | go_test.go | package can_arrange_test
import (
"testing"
"fmt"
)
// 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:
... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_135_can_arrange.py | verbatim | func TestCan_Arrange(t *testing.T) {
candidate := can_arrange
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 4, 3, 5}), expected: 3 },
{ actual: candidate([]int{1, 2, 4, 5}), expected: -1 },
{ actual: candidate([]int{1, 4, 2, 5, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_136_largest_smallest_integers | go_test.go | package largest_smallest_integers_test
import (
"testing"
"fmt"
)
// 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:
//... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_136_largest_smallest_integers.py | verbatim | func TestLargest_Smallest_Integers(t *testing.T) {
candidate := largest_smallest_integers
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{2, 4, 1, 3, 5, 7}), expected: []interface{}{nil, 1} },
{ actual: candidate([]int{2, 4, 1, 3, 5, 7, 0}),... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_138_is_equal_to_sum_even | go_test.go | package is_equal_to_sum_even_test
import (
"testing"
"fmt"
)
// 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
func is_equal_to_sum_even(n int... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_138_is_equal_to_sum_even.py | verbatim | func TestIs_Equal_To_Sum_Even(t *testing.T) {
candidate := is_equal_to_sum_even
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(4), expected: false },
{ actual: candidate(6), expected: false },
{ actual: candidate(8), expected: true },
{... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_139_special_factorial | go_test.go | package special_factorial_test
import (
"testing"
"fmt"
)
// 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
// fa... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_139_special_factorial.py | verbatim | func TestSpecial_Factorial(t *testing.T) {
candidate := special_factorial
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(4), expected: 288 },
{ actual: candidate(5), expected: 34560 },
{ actual: candidate(7), expected: 125411328000 },
{... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_13_greatest_common_divisor | go_test.go | package greatest_common_divisor_test
import (
"testing"
"fmt"
)
// Return a greatest common divisor of two integers a and b
// >>> greatest_common_divisor(3, 5)
// 1
// >>> greatest_common_divisor(25, 15)
// 5
func greatest_common_divisor(a int, b int) int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_13_greatest_common_divisor.py | verbatim | func TestGreatest_Common_Divisor(t *testing.T) {
candidate := greatest_common_divisor
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3, 7), expected: 1 },
{ actual: candidate(10, 15), expected: 5 },
{ actual: candidate(49, 14), expected: 7 }... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_140_fix_spaces | go_test.go | package fix_spaces_test
import (
"testing"
"fmt"
)
// 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_s... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_140_fix_spaces.py | verbatim | func TestFix_Spaces(t *testing.T) {
candidate := fix_spaces
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Example"), expected: "Example" },
{ actual: candidate("Mudasir Hanif "), expected: "Mudasir_Hanif_" },
{ actual: candidate("Yellow Ye... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_141_file_name_check | go_test.go | package file_name_check_test
import (
"testing"
"fmt"
)
// 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:
//... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_141_file_name_check.py | verbatim | func TestFile_Name_Check(t *testing.T) {
candidate := file_name_check
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("example.txt"), expected: "Yes" },
{ actual: candidate("1example.dll"), expected: "No" },
{ actual: candidate("s1sdf3.asd"),... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_142_sum_squares | go_test.go | package sum_squares_test
import (
"testing"
"fmt"
)
// "
// 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 func... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_142_sum_squares.py | verbatim | func TestSum_Squares(t *testing.T) {
candidate := sum_squares
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 3}), expected: 6 },
{ actual: candidate([]int{1, 4, 9}), expected: 14 },
{ actual: candidate([]int{}), expected: 0 },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_143_words_in_sentence | go_test.go | package words_in_sentence_test
import (
"testing"
"fmt"
)
// 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_143_words_in_sentence.py | verbatim | func TestWords_In_Sentence(t *testing.T) {
candidate := words_in_sentence
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("This is a test"), expected: "is" },
{ actual: candidate("lets go for swimming"), expected: "go for" },
{ actual: candid... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_144_simplify | go_test.go | package simplify_test
import (
"testing"
"fmt"
)
// 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,
// <... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_144_simplify.py | verbatim | func TestSimplify(t *testing.T) {
candidate := simplify
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("1/5", "5/1"), expected: true },
{ actual: candidate("1/6", "2/1"), expected: false },
{ actual: candidate("5/1", "3/1"), expected: true }... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_145_order_by_points | go_test.go | package order_by_points_test
import (
"testing"
"fmt"
)
// 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 examp... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_145_order_by_points.py | verbatim | func TestOrder_By_Points(t *testing.T) {
candidate := order_by_points
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 11, -1, -11, -12}), expected: []int{-1, -11, 1, -12, 11} },
{ actual: candidate([]int{1234, 423, 463, 145, 2, 423, 423, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_146_specialFilter | go_test.go | package specialFilter_test
import (
"testing"
"fmt"
)
// 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, ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_146_specialFilter.py | verbatim | func TestSpecialfilter(t *testing.T) {
candidate := specialFilter
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{5, -2, 1, -5}), expected: 0 },
{ actual: candidate([]int{15, -73, 14, -15}), expected: 1 },
{ actual: candidate([]int{33, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_147_get_max_triples | go_test.go | package get_max_triples_test
import (
"testing"
"fmt"
)
// 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_147_get_max_triples.py | verbatim | func TestGet_Max_Triples(t *testing.T) {
candidate := get_max_triples
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5), expected: 1 },
{ actual: candidate(6), expected: 4 },
{ actual: candidate(10), expected: 36 },
{ actual: candidate(... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_148_bf | go_test.go | package bf_test
import (
"testing"
"fmt"
)
// 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 sho... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_148_bf.py | verbatim | func TestBf(t *testing.T) {
candidate := bf
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Jupiter", "Neptune"), expected: []interface{}{"Saturn", "Uranus"} },
{ actual: candidate("Earth", "Mercury"), expected: []interface{}{"Venus"} },
{ a... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_149_sorted_list_sum | go_test.go | package sorted_list_sum_test
import (
"testing"
"fmt"
)
// 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 i... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_149_sorted_list_sum.py | verbatim | func TestSorted_List_Sum(t *testing.T) {
candidate := sorted_list_sum
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"aa", "a", "aaa"}), expected: []string{"aa"} },
{ actual: candidate([]string{"school", "AI", "asdf", "b"}), expected: []... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_14_all_prefixes | go_test.go | package all_prefixes_test
import (
"testing"
"fmt"
)
// Return list of all prefixes from shortest to longest of the input string
// >>> all_prefixes('abc')
// ['a', 'ab', 'abc']
func all_prefixes(myString string) []string {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_14_all_prefixes.py | verbatim | func TestAll_Prefixes(t *testing.T) {
candidate := all_prefixes
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: []string{} },
{ actual: candidate("asdfgh"), expected: []string{"a", "as", "asd", "asdf", "asdfg", "asdfgh"} },
{ a... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_150_x_or_y | go_test.go | package x_or_y_test
import (
"testing"
"fmt"
)
// 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
func x_or_y(n int, x int, y int) int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_150_x_or_y.py | verbatim | func TestX_Or_Y(t *testing.T) {
candidate := x_or_y
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(7, 34, 12), expected: 34 },
{ actual: candidate(15, 8, 5), expected: 5 },
{ actual: candidate(3, 33, 5212), expected: 33 },
{ actual: can... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_151_double_the_difference | go_test.go | package double_the_difference_test
import (
"testing"
"fmt"
)
// 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]) =... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_151_double_the_difference.py | verbatim | func TestDouble_The_Difference(t *testing.T) {
candidate := double_the_difference
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]float64{}), expected: 0 },
{ actual: candidate([]float64{5.0, 4.0}), expected: 25 },
{ actual: candidate([]flo... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_152_compare | go_test.go | package compare_test
import (
"testing"
"fmt"
)
// 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 guesse... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_152_compare.py | verbatim | func TestCompare(t *testing.T) {
candidate := compare
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 3, 4, 5, 1}, []int{1, 2, 3, 4, 2, -2}), expected: []int{0, 0, 0, 0, 3, 3} },
{ actual: candidate([]int{0, 0, 0, 0, 0, 0}, []int{0, 0,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_153_Strongest_Extension | go_test.go | package Strongest_Extension_test
import (
"testing"
"fmt"
)
// 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_153_Strongest_Extension.py | verbatim | func TestStrongest_Extension(t *testing.T) {
candidate := Strongest_Extension
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Watashi", []string{"tEN", "niNE", "eIGHt8OKe"}), expected: "Watashi.eIGHt8OKe" },
{ actual: candidate("Boku123", []strin... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_154_cycpattern_check | go_test.go | package cycpattern_check_test
import (
"testing"
"fmt"
)
// 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") => ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_154_cycpattern_check.py | verbatim | func TestCycpattern_Check(t *testing.T) {
candidate := cycpattern_check
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("xyzw", "xyw"), expected: false },
{ actual: candidate("yello", "ell"), expected: true },
{ actual: candidate("whattup", "... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_155_even_odd_count | go_test.go | package even_odd_count_test
import (
"testing"
"fmt"
)
// 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)
func even_odd_count(num int) []interface{} {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_155_even_odd_count.py | verbatim | func TestEven_Odd_Count(t *testing.T) {
candidate := even_odd_count
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(7), expected: []interface{}{0, 1} },
{ actual: candidate(-78), expected: []interface{}{1, 1} },
{ actual: candidate(3452), exp... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_156_int_to_mini_roman | go_test.go | package int_to_mini_roman_test
import (
"testing"
"fmt"
)
// 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_156_int_to_mini_roman.py | verbatim | func TestInt_To_Mini_Roman(t *testing.T) {
candidate := int_to_mini_roman
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(19), expected: "xix" },
{ actual: candidate(152), expected: "clii" },
{ actual: candidate(251), expected: "ccli" },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_157_right_angle_triangle | go_test.go | package right_angle_triangle_test
import (
"testing"
"fmt"
)
// 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_157_right_angle_triangle.py | verbatim | func TestRight_Angle_Triangle(t *testing.T) {
candidate := right_angle_triangle
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3, 4, 5), expected: true },
{ actual: candidate(1, 2, 3), expected: false },
{ actual: candidate(10, 6, 8), expect... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_158_find_max | go_test.go | package find_max_test
import (
"testing"
"fmt"
)
// 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 lexicogra... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_158_find_max.py | verbatim | func TestFind_Max(t *testing.T) {
candidate := find_max
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"name", "of", "string"}), expected: "string" },
{ actual: candidate([]string{"name", "enam", "game"}), expected: "enam" },
{ actu... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_159_eat | go_test.go | package eat_test
import (
"testing"
"fmt"
)
// 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 a... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_159_eat.py | verbatim | func TestEat(t *testing.T) {
candidate := eat
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5, 6, 10), expected: []int{11, 4} },
{ actual: candidate(4, 8, 9), expected: []int{12, 1} },
{ actual: candidate(1, 10, 10), expected: []int{11, 0} ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_15_string_sequence | go_test.go | package string_sequence_test
import (
"testing"
"fmt"
)
// 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'
func string_sequence(n int) string {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_15_string_sequence.py | verbatim | func TestString_Sequence(t *testing.T) {
candidate := string_sequence
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(0), expected: "0" },
{ actual: candidate(3), expected: "0 1 2 3" },
{ actual: candidate(10), expected: "0 1 2 3 4 5 6 7 8 9 ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_160_do_algebra | go_test.go | package do_algebra_test
import (
"testing"
"fmt"
)
// 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 algeb... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_160_do_algebra.py | verbatim | func TestDo_Algebra(t *testing.T) {
candidate := do_algebra
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"**", "*", "+"}, []int{2, 3, 4, 5}), expected: 37 },
{ actual: candidate([]string{"+", "*", "-"}, []int{2, 3, 4, 5}), expected: 9 ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_161_solve | go_test.go | package solve_test
import (
"testing"
"fmt"
)
// 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
// sol... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_161_solve.py | verbatim | func TestSolve(t *testing.T) {
candidate := solve
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("AsDf"), expected: "aSdF" },
{ actual: candidate("1234"), expected: "4321" },
{ actual: candidate("ab"), expected: "AB" },
{ actual: candid... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_163_generate_integers | go_test.go | package generate_integers_test
import (
"testing"
"fmt"
)
// 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) => []
func generat... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_163_generate_integers.py | verbatim | func TestGenerate_Integers(t *testing.T) {
candidate := generate_integers
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(2, 10), expected: []int{2, 4, 6, 8} },
{ actual: candidate(10, 2), expected: []int{2, 4, 6, 8} },
{ actual: candidate(13... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_16_count_distinct_characters | go_test.go | package count_distinct_characters_test
import (
"testing"
"fmt"
)
// 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
func count_distinct_characters(myString string) int ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_16_count_distinct_characters.py | verbatim | func TestCount_Distinct_Characters(t *testing.T) {
candidate := count_distinct_characters
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: 0 },
{ actual: candidate("abcde"), expected: 5 },
{ actual: candidate("abcdecadeCADE"), e... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_17_parse_music | go_test.go | package parse_music_test
import (
"testing"
"fmt"
)
// 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, last... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_17_parse_music.py | verbatim | func TestParse_Music(t *testing.T) {
candidate := parse_music
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: []int{} },
{ actual: candidate("o o o o"), expected: []int{4, 4, 4, 4} },
{ actual: candidate(".| .| .| .|"), expecte... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_18_how_many_times | go_test.go | package how_many_times_test
import (
"testing"
"fmt"
)
// 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
func how_many_times(myString string, ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_18_how_many_times.py | verbatim | func TestHow_Many_Times(t *testing.T) {
candidate := how_many_times
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("", "x"), expected: 0 },
{ actual: candidate("xyxyxyx", "x"), expected: 4 },
{ actual: candidate("cacacacac", "cac"), expected... | [
"\nfunc",
"struct",
"\n// "
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.