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_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
// >>>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_161_solve.py | reworded | 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)
// []int{2, 4, 6, 8}
// >>> generate_integers(8, 2)
// []int{2, 4, 6, 8}
// >>> generate_integers(10, ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_163_generate_integers.py | reworded | 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 ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_16_count_distinct_characters.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_17_parse_music.py | reworded | 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, ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_18_how_many_times.py | reworded | 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// "
] |
HumanEval_19_sort_numbers | go_test.go | package sort_numbers_test
import (
"testing"
"fmt"
)
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// >>> sort_nu... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_19_sort_numbers.py | reworded | func TestSort_Numbers(t *testing.T) {
candidate := sort_numbers
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: "" },
{ actual: candidate("three"), expected: "three" },
{ actual: candidate("three five nine"), expected: "three f... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_1_separate_paren_groups | go_test.go | package separate_paren_groups_test
import (
"testing"
"fmt"
)
// 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)... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_1_separate_paren_groups.py | reworded | func TestSeparate_Paren_Groups(t *testing.T) {
candidate := separate_paren_groups
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("(()()) ((())) () ((())()())"), expected: []string{"(()())", "((()))", "()", "((())()())"} },
{ actual: candidate("()... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_20_find_closest_elements | go_test.go | package find_closest_elements_test
import (
"testing"
"fmt"
)
// From a supplied list of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// >>> find_closest_elements([]float64{1.0, 2.0, 3.0, 4.0, 5.0, 2.2})
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_20_find_closest_elements.py | reworded | func TestFind_Closest_Elements(t *testing.T) {
candidate := find_closest_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}), expected: []interface{}{3.9, 4.0} },
{ actual: candidate([]float64{1.0, 2.0... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_21_rescale_to_unit | go_test.go | package rescale_to_unit_test
import (
"testing"
"fmt"
)
// Given list of numbers (of at least two elements), apply a linear transform to that list,
// such that the smallest number will become 0 and the largest will become 1
// >>> rescale_to_unit([]float64{1.0, 2.0, 3.0, 4.0, 5.0})
// []float64{0.0, 0.25, 0.... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_21_rescale_to_unit.py | reworded | func TestRescale_To_Unit(t *testing.T) {
candidate := rescale_to_unit
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]float64{2.0, 49.9}), expected: []float64{0.0, 1.0} },
{ actual: candidate([]float64{100.0, 49.9}), expected: []float64{1.0, 0.0... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_22_filter_integers | go_test.go | package filter_integers_test
import (
"testing"
"fmt"
)
// Filter given list of any gothon values only for integers
// >>> filter_integers([]float64{"a", 3.14, 5})
// []int{5}
// >>> filter_integers([]interface{}{1, 2, 3, "abc", map[interface{}]interface{}{}, []interface{}{}})
// []int{1, 2, 3}
func filter_in... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_22_filter_integers.py | reworded | func TestFilter_Integers(t *testing.T) {
candidate := filter_integers
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]interface{}{}), expected: []int{} },
{ actual: candidate([]interface{}{4, map[interface{}]interface{}{}, []interface{}{}, 23.2,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_23_strlen | go_test.go | package strlen_test
import (
"testing"
"fmt"
)
// Return length of given string
// >>> strlen("")
// 0
// >>> strlen("abc")
// 3
func strlen(myString string) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_23_strlen.py | reworded | func TestStrlen(t *testing.T) {
candidate := strlen
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: 0 },
{ actual: candidate("x"), expected: 1 },
{ actual: candidate("asdasnakj"), expected: 9 },
}
for i, tc := range tests ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_24_largest_divisor | go_test.go | package largest_divisor_test
import (
"testing"
"fmt"
)
// For a given number n, find the largest number that divides n evenly, smaller than n
// >>> largest_divisor(15)
// 5
func largest_divisor(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_24_largest_divisor.py | reworded | func TestLargest_Divisor(t *testing.T) {
candidate := largest_divisor
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3), expected: 1 },
{ actual: candidate(7), expected: 1 },
{ actual: candidate(10), expected: 5 },
{ actual: candidate(1... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_25_factorize | go_test.go | package factorize_test
import (
"testing"
"fmt"
)
// 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 ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_25_factorize.py | reworded | func TestFactorize(t *testing.T) {
candidate := factorize
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(2), expected: []int{2} },
{ actual: candidate(4), expected: []int{2, 2} },
{ actual: candidate(8), expected: []int{2, 2, 2} },
{ ac... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_26_remove_duplicates | go_test.go | package remove_duplicates_test
import (
"testing"
"fmt"
)
// From a list of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// >>> remove_duplicates([]int{1, 2, 3, 2, 4})
// []int{1, 3, 4}
func remove_duplicates(numbers []int) []int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_26_remove_duplicates.py | reworded | func TestRemove_Duplicates(t *testing.T) {
candidate := remove_duplicates
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}), expected: []int{} },
{ actual: candidate([]int{1, 2, 3, 4}), expected: []int{1, 2, 3, 4} },
{ actual: candidat... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_27_flip_case | go_test.go | package flip_case_test
import (
"testing"
"fmt"
)
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// >>> flip_case("Hello")
// "hELLO"
func flip_case(myString string) string {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_27_flip_case.py | reworded | func TestFlip_Case(t *testing.T) {
candidate := flip_case
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: "" },
{ actual: candidate("Hello!"), expected: "hELLO!" },
{ actual: candidate("These violent delights have violent ends"... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_28_concatenate | go_test.go | package concatenate_test
import (
"testing"
"fmt"
)
// Concatenate list of strings into a single string
// >>> concatenate([]string{})
// ""
// >>> concatenate([]string{"a", "b", "c"})
// "abc"
func concatenate(strings []string) string {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_28_concatenate.py | reworded | func TestConcatenate(t *testing.T) {
candidate := concatenate
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{}), expected: "" },
{ actual: candidate([]string{"x", "y", "z"}), expected: "xyz" },
{ actual: candidate([]string{"x", "y",... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_29_filter_by_prefix | go_test.go | package filter_by_prefix_test
import (
"testing"
"fmt"
)
// Filter an input list of strings only for ones that start with a given prefix.
// >>> filter_by_prefix([]string{}, "a")
// []string{}
// >>> filter_by_prefix([]string{"abc", "bcd", "cde", "array"}, "a")
// []string{"abc", "array"}
func filter_by_prefi... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_29_filter_by_prefix.py | reworded | func TestFilter_By_Prefix(t *testing.T) {
candidate := filter_by_prefix
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{}, "john"), expected: []string{} },
{ actual: candidate([]string{"xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"}, "x... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_2_truncate_number | go_test.go | package truncate_number_test
import (
"testing"
"fmt"
)
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// >>> truncate_number(3... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_2_truncate_number.py | reworded | func TestTruncate_Number(t *testing.T) {
candidate := truncate_number
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3.5), expected: 0.5 },
{ actual: candidate(1.25), expected: 0.25 },
{ actual: candidate(123.0), expected: 0.0 },
}
for ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_30_get_positive | go_test.go | package get_positive_test
import (
"testing"
"fmt"
)
// Return only positive numbers in the list.
// >>> get_positive([]int{-1, 2, -4, 5, 6})
// []int{2, 5, 6}
// >>> get_positive([]int{5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10})
// []int{5, 3, 2, 3, 9, 123, 1}
func get_positive(l []int) []int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_30_get_positive.py | reworded | func TestGet_Positive(t *testing.T) {
candidate := get_positive
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{-1, -2, 4, 5, 6}), expected: []int{4, 5, 6} },
{ actual: candidate([]int{5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10}), expected: []int{... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_31_is_prime | go_test.go | package is_prime_test
import (
"testing"
"fmt"
)
// Return true if a given number is prime, and false otherwise.
// >>> is_prime(6)
// false
// >>> is_prime(101)
// true
// >>> is_prime(11)
// true
// >>> is_prime(13441)
// true
// >>> is_prime(61)
// true
// >>> is_prime(4)
// false
// >>> is_prime(1)
// fal... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_31_is_prime.py | reworded | func TestIs_Prime(t *testing.T) {
candidate := is_prime
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(6), expected: false },
{ actual: candidate(101), expected: true },
{ actual: candidate(11), expected: true },
{ actual: candidate(134... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_33_sort_third | go_test.go | package sort_third_test
import (
"testing"
"fmt"
)
// 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_33_sort_third.py | reworded | func TestSort_Third(t *testing.T) {
candidate := sort_third
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{5, 6, 3, 4, 8, 9, 2}), expected: []int{2, 6, 3, 4, 8, 9, 5} },
{ actual: candidate([]int{5, 8, 3, 4, 6, 9, 2}), expected: []int{2, 8,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_34_unique | go_test.go | package unique_test
import (
"testing"
"fmt"
)
// Return sorted unique elements in a list
// >>> unique([]int{5, 3, 5, 2, 3, 3, 9, 0, 123})
// []int{0, 2, 3, 5, 9, 123}
func unique(l []int) []int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_34_unique.py | reworded | func TestUnique(t *testing.T) {
candidate := unique
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{5, 3, 5, 2, 3, 3, 9, 0, 123}), expected: []int{0, 2, 3, 5, 9, 123} },
}
for i, tc := range tests {
t.Run(fmt.Sprintf("test num % d", i), fu... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_35_max_element | go_test.go | package max_element_test
import (
"testing"
"fmt"
)
// Return maximum element in the list.
// >>> max_element([]int{1, 2, 3})
// 3
// >>> max_element([]int{5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10})
// 123
func max_element(l []int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_35_max_element.py | reworded | func TestMax_Element(t *testing.T) {
candidate := max_element
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 3}), expected: 3 },
{ actual: candidate([]int{5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10}), expected: 124 },
}
for i, tc := r... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_36_fizz_buzz | go_test.go | package fizz_buzz_test
import (
"testing"
"fmt"
)
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// >>> fizz_buzz(50)
// 0
// >>> fizz_buzz(78)
// 2
// >>> fizz_buzz(79)
// 3
func fizz_buzz(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_36_fizz_buzz.py | reworded | func TestFizz_Buzz(t *testing.T) {
candidate := fizz_buzz
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(50), expected: 0 },
{ actual: candidate(78), expected: 2 },
{ actual: candidate(79), expected: 3 },
{ actual: candidate(100), expec... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_37_sort_even | go_test.go | package sort_even_test
import (
"testing"
"fmt"
)
// This function takes a list l and returns a list l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// >>> sort_even([]int{1, 2, 3})
// []int{1, 2,... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_37_sort_even.py | reworded | func TestSort_Even(t *testing.T) {
candidate := sort_even
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 3}), expected: []int{1, 2, 3} },
{ actual: candidate([]int{5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10}), expected: []int{-10, 3, -5, 2... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_39_prime_fib | go_test.go | package prime_fib_test
import (
"testing"
"fmt"
)
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// >>> prime_fib(1)
// 2
// >>> prime_fib(2)
// 3
// >>> prime_fib(3)
// 5
// >>> prime_fib(4)
// 13
// >>> prime_fib(5)
// 89
func prime_fib(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_39_prime_fib.py | reworded | func TestPrime_Fib(t *testing.T) {
candidate := prime_fib
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(1), expected: 2 },
{ actual: candidate(2), expected: 3 },
{ actual: candidate(3), expected: 5 },
{ actual: candidate(4), expected: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_3_below_zero | go_test.go | package below_zero_test
import (
"testing"
"fmt"
)
// You're given a list of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it sho... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_3_below_zero.py | reworded | func TestBelow_Zero(t *testing.T) {
candidate := below_zero
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}), expected: false },
{ actual: candidate([]int{1, 2, -3, 1, 2, -3}), expected: false },
{ actual: candidate([]int{1, 2, -4, 5,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_40_triples_sum_to_zero | go_test.go | package triples_sum_to_zero_test
import (
"testing"
"fmt"
)
// triples_sum_to_zero takes a list of integers as an input.
// it returns true if there are three distinct elements in the list that
// sum to zero, and false otherwise.
// >>> triples_sum_to_zero([]int{1, 3, 5, 0})
// false
// >>> triples_sum_to_ze... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_40_triples_sum_to_zero.py | reworded | func TestTriples_Sum_To_Zero(t *testing.T) {
candidate := triples_sum_to_zero
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 3, 5, 0}), expected: false },
{ actual: candidate([]int{1, 3, 5, -1}), expected: false },
{ actual: candida... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_41_car_race_collision | go_test.go | package car_race_collision_test
import (
"testing"
"fmt"
)
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right; simultaneously, a different set of n cars
// are driving right to left. The two sets of cars start out being very far from
// each other. All ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_41_car_race_collision.py | reworded | func TestCar_Race_Collision(t *testing.T) {
candidate := car_race_collision
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(2), expected: 4 },
{ actual: candidate(3), expected: 9 },
{ actual: candidate(4), expected: 16 },
{ actual: candi... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_42_incr_list | go_test.go | package incr_list_test
import (
"testing"
"fmt"
)
// Return list with elements incremented by 1.
// >>> incr_list([]int{1, 2, 3})
// []int{2, 3, 4}
// >>> incr_list([]int{5, 3, 5, 2, 3, 3, 9, 0, 123})
// []int{6, 4, 6, 3, 4, 4, 10, 1, 124}
func incr_list(l []int) []int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_42_incr_list.py | reworded | func TestIncr_List(t *testing.T) {
candidate := incr_list
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}), expected: []int{} },
{ actual: candidate([]int{3, 2, 1}), expected: []int{4, 3, 2} },
{ actual: candidate([]int{5, 2, 5, 2, 3,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_43_pairs_sum_to_zero | go_test.go | package pairs_sum_to_zero_test
import (
"testing"
"fmt"
)
// pairs_sum_to_zero takes a list of integers as an input.
// it returns true if there are two distinct elements in the list that
// sum to zero, and false otherwise.
// >>> pairs_sum_to_zero([]int{1, 3, 5, 0})
// false
// >>> pairs_sum_to_zero([]int{1... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_43_pairs_sum_to_zero.py | reworded | func TestPairs_Sum_To_Zero(t *testing.T) {
candidate := pairs_sum_to_zero
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 3, 5, 0}), expected: false },
{ actual: candidate([]int{1, 3, -2, 1}), expected: false },
{ actual: candidate([... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_44_change_base | go_test.go | package change_base_test
import (
"testing"
"fmt"
)
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// >>> change_base(8, 3)
// "22"
// >>> change_base(8, 2)
// "1000"
// >>> change_base(7, 2)
// "111"
func change_base... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_44_change_base.py | reworded | func TestChange_Base(t *testing.T) {
candidate := change_base
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(8, 3), expected: "22" },
{ actual: candidate(9, 3), expected: "100" },
{ actual: candidate(234, 2), expected: "11101010" },
{ a... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_45_triangle_area | go_test.go | package triangle_area_test
import (
"testing"
"fmt"
)
// Given length of a side and high return area for a triangle.
// >>> triangle_area(5, 3)
// 7.5
func triangle_area(a int, h int) float64 {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_45_triangle_area.py | reworded | func TestTriangle_Area(t *testing.T) {
candidate := triangle_area
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5, 3), expected: 7.5 },
{ actual: candidate(2, 2), expected: 2.0 },
{ actual: candidate(10, 8), expected: 40.0 },
}
for i, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_46_fib4 | go_test.go | package fib4_test
import (
"testing"
"fmt"
)
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to effici... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_46_fib4.py | reworded | func TestFib4(t *testing.T) {
candidate := fib4
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5), expected: 4 },
{ actual: candidate(8), expected: 28 },
{ actual: candidate(10), expected: 104 },
{ actual: candidate(12), expected: 386 }... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_47_median | go_test.go | package median_test
import (
"testing"
"fmt"
)
// Return median of elements in the list l.
// >>> median([]int{3, 1, 2, 4, 5})
// 3
// >>> median([]int{-10, 4, 6, 1000, 10, 20})
// 15.0
func median(l []int) float64 {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_47_median.py | reworded | func TestMedian(t *testing.T) {
candidate := median
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{3, 1, 2, 4, 5}), expected: 3 },
{ actual: candidate([]int{-10, 4, 6, 1000, 10, 20}), expected: 8.0 },
{ actual: candidate([]int{5}), exp... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_48_is_palindrome | go_test.go | package is_palindrome_test
import (
"testing"
"fmt"
)
// Checks if given string is a palindrome
// >>> is_palindrome("")
// true
// >>> is_palindrome("aba")
// true
// >>> is_palindrome("aaaaa")
// true
// >>> is_palindrome("zbcd")
// false
func is_palindrome(text string) bool {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_48_is_palindrome.py | reworded | func TestIs_Palindrome(t *testing.T) {
candidate := is_palindrome
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: true },
{ actual: candidate("aba"), expected: true },
{ actual: candidate("aaaaa"), expected: true },
{ actu... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_49_modp | go_test.go | package modp_test
import (
"testing"
"fmt"
)
// Return 2^n modulo p (be aware of numerics).
// >>> modp(3, 5)
// 3
// >>> modp(1101, 101)
// 2
// >>> modp(0, 101)
// 1
// >>> modp(3, 11)
// 8
// >>> modp(100, 101)
// 1
func modp(n int, p int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_49_modp.py | reworded | func TestModp(t *testing.T) {
candidate := modp
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3, 5), expected: 3 },
{ actual: candidate(1101, 101), expected: 2 },
{ actual: candidate(0, 101), expected: 1 },
{ actual: candidate(3, 11), ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_4_mean_absolute_deviation | go_test.go | package mean_absolute_deviation_test
import (
"testing"
"fmt"
)
// For a given list of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = aver... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_4_mean_absolute_deviation.py | reworded | func TestMean_Absolute_Deviation(t *testing.T) {
candidate := mean_absolute_deviation
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]float64{1.0, 2.0}), expected: 0.5 },
{ actual: candidate([]float64{1.0, 2.0, 3.0, 4.0}), expected: 1.0 },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_51_remove_vowels | go_test.go | package remove_vowels_test
import (
"testing"
"fmt"
)
// remove_vowels is a function that takes string and returns string without vowels.
// >>> remove_vowels("")
// ""
// >>> remove_vowels("abcdef")
// "bcdf"
// >>> remove_vowels("aaaaa")
// ""
// >>> remove_vowels("aaBAA")
// "B"
// >>> remove_vowels("zbcd"... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_51_remove_vowels.py | reworded | func TestRemove_Vowels(t *testing.T) {
candidate := remove_vowels
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: "" },
{ actual: candidate("abcdef\nghijklm"), expected: "bcdf\nghjklm" },
{ actual: candidate("fedcba"), expected... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_52_below_threshold | go_test.go | package below_threshold_test
import (
"testing"
"fmt"
)
// Return true if all numbers in the list l are below threshold t.
// >>> below_threshold([]int{1, 2, 4, 10}, 100)
// true
// >>> below_threshold([]int{1, 20, 4, 10}, 5)
// false
func below_threshold(l []int, t int) bool {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_52_below_threshold.py | reworded | func TestBelow_Threshold(t *testing.T) {
candidate := below_threshold
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 4, 10}, 100), expected: true },
{ actual: candidate([]int{1, 20, 4, 10}, 5), expected: false },
{ actual: candid... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_53_add | go_test.go | package add_test
import (
"testing"
"fmt"
)
// Add two numbers x and y
// >>> add(2, 3)
// 5
// >>> add(5, 7)
// 12
func add(x int, y int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_53_add.py | reworded | func TestAdd(t *testing.T) {
candidate := add
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(0, 1), expected: 1 },
{ actual: candidate(1, 0), expected: 1 },
{ actual: candidate(2, 3), expected: 5 },
{ actual: candidate(5, 7), expected: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_54_same_chars | go_test.go | package same_chars_test
import (
"testing"
"fmt"
)
// Check if two words have the same characters.
// >>> same_chars("eabcdzzzz", "dddzzzzzzzddeddabc")
// true
// >>> same_chars("abcd", "dddddddabc")
// true
// >>> same_chars("dddddddabc", "abcd")
// true
// >>> same_chars("eabcd", "dddddddabc")
// false
// >... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_54_same_chars.py | reworded | func TestSame_Chars(t *testing.T) {
candidate := same_chars
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("eabcdzzzz", "dddzzzzzzzddeddabc"), expected: true },
{ actual: candidate("abcd", "dddddddabc"), expected: true },
{ actual: candidate... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_55_fib | go_test.go | package fib_test
import (
"testing"
"fmt"
)
// Return n-th Fibonacci number.
// >>> fib(10)
// 55
// >>> fib(1)
// 1
// >>> fib(8)
// 21
func fib(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_55_fib.py | reworded | func TestFib(t *testing.T) {
candidate := fib
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(10), expected: 55 },
{ actual: candidate(1), expected: 1 },
{ actual: candidate(8), expected: 21 },
{ actual: candidate(11), expected: 89 },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_56_correct_bracketing | go_test.go | package correct_bracketing_test
import (
"testing"
"fmt"
)
// brackets is a string of "<" and ">".
// return true if every opening bracket has a corresponding closing bracket.
// >>> correct_bracketing("<")
// false
// >>> correct_bracketing("<>")
// true
// >>> correct_bracketing("<<><>>")
// true
// >>> cor... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_56_correct_bracketing.py | reworded | func TestCorrect_Bracketing(t *testing.T) {
candidate := correct_bracketing
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("<>"), expected: true },
{ actual: candidate("<<><>>"), expected: true },
{ actual: candidate("<><><<><>><>"), expecte... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_57_monotonic | go_test.go | package monotonic_test
import (
"testing"
"fmt"
)
// Return true is list elements are monotonically increasing or decreasing.
// >>> monotonic([]int{1, 2, 4, 20})
// true
// >>> monotonic([]int{1, 20, 4, 10})
// false
// >>> monotonic([]int{4, 1, 0, -10})
// true
func monotonic(l []int) bool {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_57_monotonic.py | reworded | func TestMonotonic(t *testing.T) {
candidate := monotonic
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 4, 10}), expected: true },
{ actual: candidate([]int{1, 2, 4, 20}), expected: true },
{ actual: candidate([]int{1, 20, 4, 10... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_58_common | go_test.go | package common_test
import (
"testing"
"fmt"
)
// Return sorted unique common elements for two lists.
// >>> common([]int{1, 4, 3, 34, 653, 2, 5}, []int{5, 7, 1, 5, 9, 653, 121})
// []int{1, 5, 653}
// >>> common([]int{5, 3, 2, 8}, []int{3, 2})
// []int{2, 3}
func common(l1 []int, l2 []int) []int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_58_common.py | reworded | func TestCommon(t *testing.T) {
candidate := common
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 4, 3, 34, 653, 2, 5}, []int{5, 7, 1, 5, 9, 653, 121}), expected: []int{1, 5, 653} },
{ actual: candidate([]int{5, 3, 2, 8}, []int{3, 2}), ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_59_largest_prime_factor | go_test.go | package largest_prime_factor_test
import (
"testing"
"fmt"
)
// Return the largest prime factor of n. Assume n > 1 and is not a prime.
// >>> largest_prime_factor(13195)
// 29
// >>> largest_prime_factor(2048)
// 2
func largest_prime_factor(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_59_largest_prime_factor.py | reworded | func TestLargest_Prime_Factor(t *testing.T) {
candidate := largest_prime_factor
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(15), expected: 5 },
{ actual: candidate(27), expected: 3 },
{ actual: candidate(63), expected: 7 },
{ actual:... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_5_intersperse | go_test.go | package intersperse_test
import (
"testing"
"fmt"
)
// Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
// >>> intersperse([]int{}, 4)
// []int{}
// >>> intersperse([]int{1, 2, 3}, 4)
// []int{1, 4, 2, 4, 3}
func intersperse(numbers []int, delimeter int) []int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_5_intersperse.py | reworded | func TestIntersperse(t *testing.T) {
candidate := intersperse
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}, 7), expected: []int{} },
{ actual: candidate([]int{5, 6, 3, 2}, 8), expected: []int{5, 8, 6, 8, 3, 8, 2} },
{ actual: candi... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_60_sum_to_n | go_test.go | package sum_to_n_test
import (
"testing"
"fmt"
)
// sum_to_n is a function that sums numbers from 1 to n.
// >>> sum_to_n(30)
// 465
// >>> sum_to_n(100)
// 5050
// >>> sum_to_n(5)
// 15
// >>> sum_to_n(10)
// 55
// >>> sum_to_n(1)
// 1
func sum_to_n(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_60_sum_to_n.py | reworded | func TestSum_To_N(t *testing.T) {
candidate := sum_to_n
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(1), expected: 1 },
{ actual: candidate(6), expected: 21 },
{ actual: candidate(11), expected: 66 },
{ actual: candidate(30), expected... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_61_correct_bracketing | go_test.go | package correct_bracketing_test
import (
"testing"
"fmt"
)
// brackets is a string of "(" and ")".
// return true if every opening bracket has a corresponding closing bracket.
// >>> correct_bracketing("(")
// false
// >>> correct_bracketing("()")
// true
// >>> correct_bracketing("(()())")
// true
// >>> cor... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_61_correct_bracketing.py | reworded | func TestCorrect_Bracketing(t *testing.T) {
candidate := correct_bracketing
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("()"), expected: true },
{ actual: candidate("(()())"), expected: true },
{ actual: candidate("()()(()())()"), expecte... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_62_derivative | go_test.go | package derivative_test
import (
"testing"
"fmt"
)
// xs represent coefficients of a polynomial.
// xs[0] + xs[1] * x + xs[2] * x^2 + ....
// Return derivative of this polynomial in the same form.
// >>> derivative([]int{3, 1, 2, 4, 5})
// []int{1, 4, 12, 20}
// >>> derivative([]int{1, 2, 3})
// []int{2, 6}
f... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_62_derivative.py | reworded | func TestDerivative(t *testing.T) {
candidate := derivative
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{3, 1, 2, 4, 5}), expected: []int{1, 4, 12, 20} },
{ actual: candidate([]int{1, 2, 3}), expected: []int{2, 6} },
{ actual: candid... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_63_fibfib | go_test.go | package fibfib_test
import (
"testing"
"fmt"
)
// The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fibfib(0) == 0
// fibfib(1) == 0
// fibfib(2) == 1
// fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
// Please write a function to efficiently comp... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_63_fibfib.py | reworded | func TestFibfib(t *testing.T) {
candidate := fibfib
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(2), expected: 1 },
{ actual: candidate(1), expected: 0 },
{ actual: candidate(5), expected: 4 },
{ actual: candidate(8), expected: 24 },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_64_vowels_count | go_test.go | package vowels_count_test
import (
"testing"
"fmt"
)
// Write a function vowels_count which takes a string representing
// a word as input and returns the number of vowels in the string.
// Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
// vowel, but only when it is at the end of the giv... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_64_vowels_count.py | reworded | func TestVowels_Count(t *testing.T) {
candidate := vowels_count
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("abcde"), expected: 2 },
{ actual: candidate("Alone"), expected: 3 },
{ actual: candidate("key"), expected: 2 },
{ actual: ca... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_65_circular_shift | go_test.go | package circular_shift_test
import (
"testing"
"fmt"
)
// Circular shift the digits of the integer x, shift the digits right by shift
// and return the result as a string.
// If shift > number of digits, return digits reversed.
// >>> circular_shift(12, 1)
// "21"
// >>> circular_shift(12, 2)
// "12"
func cir... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_65_circular_shift.py | reworded | func TestCircular_Shift(t *testing.T) {
candidate := circular_shift
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(100, 2), expected: "001" },
{ actual: candidate(12, 2), expected: "12" },
{ actual: candidate(97, 8), expected: "79" },
{... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_66_digitSum | go_test.go | package digitSum_test
import (
"testing"
"fmt"
)
// Task
// Write a function that takes a string as input and returns the sum of the upper characters only'
// ASCII codes.
// Examples:
// >>> digitSum("")
// 0
// >>> digitSum("abAB")
// 131
// >>> digitSum("abcCd")
// 67
// >>> digitSum("helloE")
// 69
// >>>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_66_digitSum.py | reworded | func TestDigitsum(t *testing.T) {
candidate := digitSum
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: 0 },
{ actual: candidate("abAB"), expected: 131 },
{ actual: candidate("abcCd"), expected: 67 },
{ actual: candidate("... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_67_fruit_distribution | go_test.go | package fruit_distribution_test
import (
"testing"
"fmt"
)
// In this task, you will be given a string that represents a number of apples and oranges
// that are distributed in a basket of fruit this basket contains
// apples, oranges, and mango fruits. Given the string that represents the total number of
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_67_fruit_distribution.py | reworded | func TestFruit_Distribution(t *testing.T) {
candidate := fruit_distribution
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("5 apples and 6 oranges", 19), expected: 8 },
{ actual: candidate("5 apples and 6 oranges", 21), expected: 10 },
{ act... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_68_pluck | go_test.go | package pluck_test
import (
"testing"
"fmt"
)
// "Given a list representing a branch of a tree that has non-negative integer nodes
// your task is to pluck one of the nodes and return it.
// The plucked node should be the node with the smallest even value.
// If multiple nodes with the same smallest even valu... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_68_pluck.py | reworded | func TestPluck(t *testing.T) {
candidate := pluck
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{4, 2, 3}), expected: []int{2, 1} },
{ actual: candidate([]int{1, 2, 3}), expected: []int{2, 1} },
{ actual: candidate([]int{}), expected: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_69_search | go_test.go | package search_test
import (
"testing"
"fmt"
)
// You are given a non-empty list of positive integers. Return the greatest integer that is greater than
// zero, and has a frequency greater than or equal to the value of the integer itself.
// The frequency of an integer is the number of times it appears in t... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_69_search.py | reworded | func TestSearch(t *testing.T) {
candidate := search
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{5, 5, 5, 5, 1}), expected: 1 },
{ actual: candidate([]int{4, 1, 4, 1, 4, 4}), expected: 4 },
{ actual: candidate([]int{3, 3}), expected:... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_6_parse_nested_parens | go_test.go | package parse_nested_parens_test
import (
"testing"
"fmt"
)
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_6_parse_nested_parens.py | reworded | func TestParse_Nested_Parens(t *testing.T) {
candidate := parse_nested_parens
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("(()()) ((())) () ((())()())"), expected: []int{2, 3, 1, 3} },
{ actual: candidate("() (()) ((())) (((())))"), expected: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_70_strange_sort_list | go_test.go | package strange_sort_list_test
import (
"testing"
"fmt"
)
// Given list of integers, return list in strange order.
// Strange sorting, is when you start with the minimum value,
// then maximum of the remaining integers, then minimum and so on.
// Examples:
// >>> strange_sort_list([]int{1, 2, 3, 4})
// []int{... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_70_strange_sort_list.py | reworded | func TestStrange_Sort_List(t *testing.T) {
candidate := strange_sort_list
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 3, 4}), expected: []int{1, 4, 2, 3} },
{ actual: candidate([]int{5, 6, 7, 8, 9}), expected: []int{5, 9, 6, 8, 7} ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_71_triangle_area | go_test.go | package triangle_area_test
import (
"testing"
"fmt"
)
// 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 gr... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_71_triangle_area.py | reworded | func TestTriangle_Area(t *testing.T) {
candidate := triangle_area
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3, 4, 5), expected: 6.0 },
{ actual: candidate(1, 2, 10), expected: -1 },
{ actual: candidate(4, 8, 5), expected: 8.18 },
{... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_72_will_it_fly | go_test.go | package will_it_fly_test
import (
"testing"
"fmt"
)
// Write a function that returns true if the object q will fly, and false otherwise.
// The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.
// Example:
// >>> will... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_72_will_it_fly.py | reworded | func TestWill_It_Fly(t *testing.T) {
candidate := will_it_fly
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{3, 2, 3}, 9), expected: true },
{ actual: candidate([]int{1, 2}, 5), expected: false },
{ actual: candidate([]int{3}, 5), expe... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_73_smallest_change | go_test.go | package smallest_change_test
import (
"testing"
"fmt"
)
// Given a list arr of integers, find the minimum number of elements that
// need to be changed to make the list palindromic. A palindromic list is a list that
// is read the same backwards and forwards. In one change, you can change one element to any o... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_73_smallest_change.py | reworded | func TestSmallest_Change(t *testing.T) {
candidate := smallest_change
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 3, 5, 4, 7, 9, 6}), expected: 4 },
{ actual: candidate([]int{1, 2, 3, 4, 3, 2, 2}), expected: 1 },
{ actual: can... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_74_total_match | go_test.go | package total_match_test
import (
"testing"
"fmt"
)
// 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
// >>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_74_total_match.py | reworded | func TestTotal_Match(t *testing.T) {
candidate := total_match
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{}, []string{}), expected: []string{} },
{ actual: candidate([]string{"hi", "admin"}, []string{"hi", "hi"}), expected: []string{"... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_75_is_multiply_prime | go_test.go | package is_multiply_prime_test
import (
"testing"
"fmt"
)
// Write a function that returns true if the given number is the multiplication of 3 prime numbers
// and false otherwise.
// Knowing that (a) is less then 100.
// Example:
// >>> is_multiply_prime(30)
// true
// 30 = 2 * 3 * 5
func is_multiply_prime(... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_75_is_multiply_prime.py | reworded | func TestIs_Multiply_Prime(t *testing.T) {
candidate := is_multiply_prime
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5), expected: false },
{ actual: candidate(30), expected: true },
{ actual: candidate(8), expected: true },
{ actua... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_76_is_simple_power | go_test.go | package is_simple_power_test
import (
"testing"
"fmt"
)
// Your task is to write a function that returns true if a number x is a simple
// power of n and false in other cases.
// x is a simple power of n if n**int=x
// For example:
// >>> is_simple_power(1, 4)
// true
// >>> is_simple_power(2, 2)
// true
// >... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_76_is_simple_power.py | reworded | func TestIs_Simple_Power(t *testing.T) {
candidate := is_simple_power
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(16, 2), expected: true },
{ actual: candidate(143214, 16), expected: false },
{ actual: candidate(4, 2), expected: true },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_77_iscube | go_test.go | package iscube_test
import (
"testing"
"fmt"
)
// Write a function that takes an integer a and returns true
// if this ingeger is a cube of some integer number.
// Note: you may assume the input is always valid.
// Examples:
// >>> iscube(1)
// true
// >>> iscube(2)
// false
// >>> iscube(-1)
// true
// >>> ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_77_iscube.py | reworded | func TestIscube(t *testing.T) {
candidate := iscube
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(1), expected: true },
{ actual: candidate(2), expected: false },
{ actual: candidate(-1), expected: true },
{ actual: candidate(64), expe... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_78_hex_key | go_test.go | package hex_key_test
import (
"testing"
"fmt"
)
// 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 ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_78_hex_key.py | reworded | func TestHex_Key(t *testing.T) {
candidate := hex_key
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("AB"), expected: 1 },
{ actual: candidate("1077E"), expected: 2 },
{ actual: candidate("ABED1A33"), expected: 4 },
{ actual: candidate(... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_79_decimal_to_binary | go_test.go | package decimal_to_binary_test
import (
"testing"
"fmt"
)
// 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 b... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_79_decimal_to_binary.py | reworded | func TestDecimal_To_Binary(t *testing.T) {
candidate := decimal_to_binary
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(0), expected: "db0db" },
{ actual: candidate(32), expected: "db100000db" },
{ actual: candidate(103), expected: "db11001... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_7_filter_by_substring | go_test.go | package filter_by_substring_test
import (
"testing"
"fmt"
)
// Filter an input list of strings only for ones that contain given substring
// >>> filter_by_substring([]string{}, "a")
// []string{}
// >>> filter_by_substring([]string{"abc", "bacd", "cde", "array"}, "a")
// []string{"abc", "bacd", "array"}
func ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_7_filter_by_substring.py | reworded | func TestFilter_By_Substring(t *testing.T) {
candidate := filter_by_substring
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{}, "john"), expected: []string{} },
{ actual: candidate([]string{"xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_80_is_happy | go_test.go | package is_happy_test
import (
"testing"
"fmt"
)
// You are given a string s.
// Your task is to check if the string is hapgo or not.
// A string is hapgo if its length is at least 3 and every 3 consecutive letters are distinct
// For example:
// >>> is_happy("a")
// false
// >>> is_happy("aa")
// false
// >>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_80_is_happy.py | reworded | func TestIs_Happy(t *testing.T) {
candidate := is_happy
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("a"), expected: false },
{ actual: candidate("aa"), expected: false },
{ actual: candidate("abcd"), expected: true },
{ actual: candi... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_81_numerical_letter_grade | go_test.go | package numerical_letter_grade_test
import (
"testing"
"fmt"
)
// 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 lis... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_81_numerical_letter_grade.py | reworded | func TestNumerical_Letter_Grade(t *testing.T) {
candidate := numerical_letter_grade
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]float64{4.0, 3, 1.7, 2, 3.5}), expected: []string{"A+", "B", "C-", "C", "A-"} },
{ actual: candidate([]float64{1.... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_82_prime_length | go_test.go | package prime_length_test
import (
"testing"
"fmt"
)
// Write a function that takes a string and returns true if the string
// length is a prime number or false otherwise
// Examples
// >>> prime_length("Hello")
// true
// >>> prime_length("abcdcba")
// true
// >>> prime_length("kittens")
// true
// >>> prime... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_82_prime_length.py | reworded | func TestPrime_Length(t *testing.T) {
candidate := prime_length
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Hello"), expected: true },
{ actual: candidate("abcdcba"), expected: true },
{ actual: candidate("kittens"), expected: true },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_83_starts_one_ends | go_test.go | package starts_one_ends_test
import (
"testing"
"fmt"
)
// Given a positive integer n, return the count of the numbers of n-digit
// positive integers that start or end with 1.
func starts_one_ends(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_83_starts_one_ends.py | reworded | func TestStarts_One_Ends(t *testing.T) {
candidate := starts_one_ends
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(1), expected: 1 },
{ actual: candidate(2), expected: 18 },
{ actual: candidate(3), expected: 180 },
{ actual: candidate... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_84_solve | go_test.go | package solve_test
import (
"testing"
"fmt"
)
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// >>> solve(1000)
// "1"
// >>> solve(150)
// "110"
// >>> solve(147)
// "1100"
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary num... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_84_solve.py | reworded | func TestSolve(t *testing.T) {
candidate := solve
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(1000), expected: "1" },
{ actual: candidate(150), expected: "110" },
{ actual: candidate(147), expected: "1100" },
{ actual: candidate(333)... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_85_add | go_test.go | package add_test
import (
"testing"
"fmt"
)
// Given a non-empty list of integers lst. add the even elements that are at odd indices..
// Examples:
// >>> add([]int{4, 2, 6, 7})
// 2
func add(lst []int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_85_add.py | reworded | func TestAdd(t *testing.T) {
candidate := add
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{4, 88}), expected: 88 },
{ actual: candidate([]int{4, 5, 6, 7, 2, 122}), expected: 122 },
{ actual: candidate([]int{4, 0, 6, 7}), expected: 0 ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_86_anti_shuffle | go_test.go | package anti_shuffle_test
import (
"testing"
"fmt"
)
// 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_86_anti_shuffle.py | reworded | func TestAnti_Shuffle(t *testing.T) {
candidate := anti_shuffle
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Hi"), expected: "Hi" },
{ actual: candidate("hello"), expected: "ehllo" },
{ actual: candidate("number"), expected: "bemnru" },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_87_get_row | go_test.go | package get_row_test
import (
"testing"
"fmt"
)
// 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 lists, [(x1,... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_87_get_row.py | reworded | func TestGet_Row(t *testing.T) {
candidate := get_row
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([][]int{[]int{1, 2, 3, 4, 5, 6}, []int{1, 2, 3, 4, 1, 6}, []int{1, 2, 3, 4, 5, 1}}, 1), expected: [][]int{[]interface{}{0, 0}, []interface{}{1, 4}, []... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_88_sort_array | go_test.go | package sort_array_test
import (
"testing"
"fmt"
)
// Given a list of non-negative integers, return a cogo of the given list after sorting,
// you will sort the given list in ascending order if the sum( first index value, last index value) is odd,
// or sort it in descending order if the sum( first index valu... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_88_sort_array.py | reworded | func TestSort_Array(t *testing.T) {
candidate := sort_array
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}), expected: []int{} },
{ actual: candidate([]int{5}), expected: []int{5} },
{ actual: candidate([]int{2, 4, 3, 0, 1, 5}), expe... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_89_encrypt | go_test.go | package encrypt_test
import (
"testing"
"fmt"
)
// 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_89_encrypt.py | reworded | func TestEncrypt(t *testing.T) {
candidate := encrypt
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("hi"), expected: "lm" },
{ actual: candidate("asdfghjkl"), expected: "ewhjklnop" },
{ actual: candidate("gf"), expected: "kj" },
{ actu... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_8_sum_product | go_test.go | package sum_product_test
import (
"testing"
"fmt"
)
// For a given list of integers, return a list consisting of a sum and a product of all the integers in a list.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// >>> sum_product([]int{})
// []interface{}{0, 1}
// >>> sum_product([]... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_8_sum_product.py | reworded | func TestSum_Product(t *testing.T) {
candidate := sum_product
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}), expected: []interface{}{0, 1} },
{ actual: candidate([]int{1, 1, 1}), expected: []interface{}{3, 1} },
{ actual: candidate... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_91_is_bored | go_test.go | package is_bored_test
import (
"testing"
"fmt"
)
// You'll be given a string of words, and your task is to count the number
// of boredoms. A boredom is a sentence that starts with the word "I".
// Sentences are delimited by '.', '?' or '!'.
// For example:
// >>> is_bored("Hello world")
// 0
// >>> is_bored(... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_91_is_bored.py | reworded | func TestIs_Bored(t *testing.T) {
candidate := is_bored
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Hello world"), expected: 0 },
{ actual: candidate("Is the sky blue?"), expected: 0 },
{ actual: candidate("I love It !"), expected: 1 },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_92_any_int | go_test.go | package any_int_test
import (
"testing"
"fmt"
)
// Create a function that takes 3 numbers.
// Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
// Returns false in any other cases.
// Examples
// >>> any_int(5, 2, 7)
// true
// >>> any_int(3, 2, 2)
// false... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_92_any_int.py | reworded | func TestAny_Int(t *testing.T) {
candidate := any_int
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(2, 3, 1), expected: true },
{ actual: candidate(2.5, 2, 3), expected: false },
{ actual: candidate(1.5, 5, 3.5), expected: false },
{ a... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_93_encode | go_test.go | package encode_test
import (
"testing"
"fmt"
)
// 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.
// E... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_93_encode.py | reworded | func TestEncode(t *testing.T) {
candidate := encode
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("TEST"), expected: "tgst" },
{ actual: candidate("Mudasir"), expected: "mWDCSKR" },
{ actual: candidate("YES"), expected: "ygs" },
{ actu... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_94_skjkasdkd | go_test.go | package skjkasdkd_test
import (
"testing"
"fmt"
)
// You are given a list of integers.
// You need to find the largest prime value and return the sum of its digits.
// Examples:
// >>> skjkasdkd([]int{0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3})
// 10
// >>> skjkasdkd([]int{1, 0, ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_94_skjkasdkd.py | reworded | func TestSkjkasdkd(t *testing.T) {
candidate := skjkasdkd
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3}), expected: 10 },
{ actual: candidate([]int{1, 0, 1, 8, 2, 459... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_95_check_dict_case | go_test.go | package check_dict_case_test
import (
"testing"
"fmt"
)
// Given a map, 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 map is empty.
// Examples:
// >>> check_dict_case(map[string]string{"a": "app... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_95_check_dict_case.py | reworded | func TestCheck_Dict_Case(t *testing.T) {
candidate := check_dict_case
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(map[string]string{"p": "pineapple", "b": "banana"}), expected: true },
{ actual: candidate(map[string]string{"p": "pineapple", "A... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_96_count_up_to | go_test.go | package count_up_to_test
import (
"testing"
"fmt"
)
// Implement a function that takes an non-negative integer and returns a list of the first n
// integers that are prime numbers and less than n.
// for example:
// >>> count_up_to(5)
// []int{2, 3}
// >>> count_up_to(11)
// []int{2, 3, 5, 7}
// >>> count_up_... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_96_count_up_to.py | reworded | func TestCount_Up_To(t *testing.T) {
candidate := count_up_to
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5), expected: []int{2, 3} },
{ actual: candidate(6), expected: []int{2, 3, 5} },
{ actual: candidate(7), expected: []int{2, 3, 5} },... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_97_multiply | go_test.go | package multiply_test
import (
"testing"
"fmt"
)
// Complete the function that takes two integers and returns
// the product of their unit digits.
// Assume the input is always valid.
// Examples:
// >>> multiply(148, 412)
// 16
// >>> multiply(19, 28)
// 72
// >>> multiply(2020, 1851)
// 0
// >>> multiply(1... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_97_multiply.py | reworded | func TestMultiply(t *testing.T) {
candidate := multiply
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(148, 412), expected: 16 },
{ actual: candidate(19, 28), expected: 72 },
{ actual: candidate(2020, 1851), expected: 0 },
{ actual: can... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_98_count_upper | go_test.go | package count_upper_test
import (
"testing"
"fmt"
)
// Given a string s, count the number of uppercase vowels in even indices.
// For example:
// >>> count_upper("aBCdEf")
// 1
// >>> count_upper("abcdefg")
// 0
// >>> count_upper("dBBE")
// 0
func count_upper(s string) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_98_count_upper.py | reworded | func TestCount_Upper(t *testing.T) {
candidate := count_upper
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("aBCdEf"), expected: 1 },
{ actual: candidate("abcdefg"), expected: 0 },
{ actual: candidate("dBBE"), expected: 0 },
{ actual: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_99_closest_integer | go_test.go | package closest_integer_test
import (
"testing"
"fmt"
)
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// >>> closest_integer("10")
// 10
// >>> closest_int... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_99_closest_integer.py | reworded | func TestClosest_Integer(t *testing.T) {
candidate := closest_integer
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("10"), expected: 10 },
{ actual: candidate("14.5"), expected: 15 },
{ actual: candidate("-15.5"), expected: -16 },
{ ac... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_9_rolling_max | go_test.go | package rolling_max_test
import (
"testing"
"fmt"
)
// From a given list of integers, generate a list of rolling maximum element found until given moment
// in the sequence.
// >>> rolling_max([]int{1, 2, 3, 2, 3, 4, 2})
// []int{1, 2, 3, 3, 3, 4, 4}
func rolling_max(numbers []int) []int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_9_rolling_max.py | reworded | func TestRolling_Max(t *testing.T) {
candidate := rolling_max
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}), expected: []int{} },
{ actual: candidate([]int{1, 2, 3, 4}), expected: []int{1, 2, 3, 4} },
{ actual: candidate([]int{4, 3... | [
"\nfunc",
"struct",
"\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([]float64{1.0, 2.0, 3.0}, 0.5)
// false
// >>> has_close_elements([]float64{1.0, 2.8, 3.0, 4.0, 5.0, 2.0}, 0.3)
// true
f... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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")
// []string{"Hi", "my", "name", "is", "John"}
/... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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
// >>>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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([]int{15, 33, 1422, 1})
// []int{1, 15, 33}
// >>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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 ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
// >>> even_odd_palindrome(3)
// []interface{}{1, 2}
// Explanation:
// Integer palind... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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.
// >>> ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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// "
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.