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_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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_19_sort_numbers.py | verbatim | 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)... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_1_separate_paren_groups.py | verbatim | 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([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
// (2.0, ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_20_find_closest_elements.py | verbatim | 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([1.0, 2.0, 3.0, 4.0, 5.0])
// [0.0, 0.25, 0.5, 0.75, 1.0]
func... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_21_rescale_to_unit.py | verbatim | 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 python values only for integers
// >>> filter_integers(['a', 3.14, 5])
// [5]
// >>> filter_integers([1, 2, 3, 'abc', {}, []])
// [1, 2, 3]
func filter_integers(values []interface{}) []int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_22_filter_integers.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_23_strlen.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_24_largest_divisor.py | verbatim | 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_25_factorize.py | verbatim | 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([1, 2, 3, 2, 4])
// [1, 3, 4]
func remove_duplicates(numbers []int) []int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_26_remove_duplicates.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_27_flip_case.py | verbatim | 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([])
// ''
// >>> concatenate(['a', 'b', 'c'])
// 'abc'
func concatenate(strings []string) string {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_28_concatenate.py | verbatim | 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([], 'a')
// []
// >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
// ['abc', 'array']
func filter_by_prefix(strings []string, prefix strin... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_29_filter_by_prefix.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_2_truncate_number.py | verbatim | 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([-1, 2, -4, 5, 6])
// [2, 5, 6]
// >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
// [5, 3, 2, 3, 9, 123, 1]
func get_positive(l []int) []int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_30_get_positive.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_31_is_prime.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_33_sort_third.py | verbatim | 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([5, 3, 5, 2, 3, 3, 9, 0, 123])
// [0, 2, 3, 5, 9, 123]
func unique(l []int) []int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_34_unique.py | verbatim | 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([1, 2, 3])
// 3
// >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
// 123
func max_element(l []int) int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_35_max_element.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_36_fizz_buzz.py | verbatim | 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([1, 2, 3])
// [1, 2, 3]
// >>>... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_37_sort_even.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_39_prime_fib.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_3_below_zero.py | verbatim | 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([1, 3, 5, 0])
// False
// >>> triples_sum_to_zero([1... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_40_triples_sum_to_zero.py | verbatim | 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_41_car_race_collision.py | verbatim | 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([1, 2, 3])
// [2, 3, 4]
// >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
// [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incr_list(l []int) []int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_42_incr_list.py | verbatim | 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([1, 3, 5, 0])
// False
// >>> pairs_sum_to_zero([1, 3, -2, 1... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_43_pairs_sum_to_zero.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_44_change_base.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_45_triangle_area.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_46_fib4.py | verbatim | 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([3, 1, 2, 4, 5])
// 3
// >>> median([-10, 4, 6, 1000, 10, 20])
// 15.0
func median(l []int) float64 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_47_median.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_48_is_palindrome.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_49_modp.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_4_mean_absolute_deviation.py | verbatim | 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'... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_51_remove_vowels.py | verbatim | 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([1, 2, 4, 10], 100)
// True
// >>> below_threshold([1, 20, 4, 10], 5)
// False
func below_threshold(l []int, t int) bool {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_52_below_threshold.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_53_add.py | verbatim | 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
// >... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_54_same_chars.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_55_fib.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_56_correct_bracketing.py | verbatim | 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([1, 2, 4, 20])
// True
// >>> monotonic([1, 20, 4, 10])
// False
// >>> monotonic([4, 1, 0, -10])
// True
func monotonic(l []int) bool {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_57_monotonic.py | verbatim | 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([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
// [1, 5, 653]
// >>> common([5, 3, 2, 8], [3, 2])
// [2, 3]
func common(l1 []int, l2 []int) []int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_58_common.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_59_largest_prime_factor.py | verbatim | 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([], 4)
// []
// >>> intersperse([1, 2, 3], 4)
// [1, 4, 2, 4, 3]
func intersperse(numbers []int, delimeter int) []int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_5_intersperse.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_60_sum_to_n.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_61_correct_bracketing.py | verbatim | 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([3, 1, 2, 4, 5])
// [1, 4, 12, 20]
// >>> derivative([1, 2, 3])
// [2, 6]
func derivative(xs []... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_62_derivative.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_63_fibfib.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_64_vowels_count.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_65_circular_shift.py | verbatim | 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
// digitSum("woArBld")... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_66_digitSum.py | verbatim | 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
... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_67_fruit_distribution.py | verbatim | 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 an array representing a branch of a tree that has non-negative integer nodes
// your task is to pluck one of the nodes and return it.
// The plucked node should be the node with the smallest even value.
// If multiple nodes with the same smallest even va... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_68_pluck.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_69_search.py | verbatim | 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 ((())) ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_6_parse_nested_parens.py | verbatim | 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([1, 2, 3, 4]) == [1, 4, 2, 3]
//... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_70_strange_sort_list.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_71_triangle_area.py | verbatim | 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_it_... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_72_will_it_fly.py | verbatim | 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 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_73_smallest_change.py | verbatim | 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
// to... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_74_total_match.py | verbatim | 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(a in... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_75_is_multiply_prime.py | verbatim | 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
// is_simple... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_76_is_simple_power.py | verbatim | 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
// iscube(64) ==... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_77_iscube.py | verbatim | 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_78_hex_key.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_79_decimal_to_binary.py | verbatim | 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([], 'a')
// []
// >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
// ['abc', 'bacd', 'array']
func filter_by_substring(strings []st... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_7_filter_by_substring.py | verbatim | 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 happy or not.
// A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
// For example:
// is_happy(a) => False
// is_happy(aa) => False
// is_happy(abcd)... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_80_is_happy.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_81_numerical_letter_grade.py | verbatim | 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_length('orange'... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_82_prime_length.py | verbatim | 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 {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_83_starts_one_ends.py | verbatim | 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
// For N = 1000, the sum of digits will be 1 the output should be "1".
// For N = 150, the sum of digits will be 6 the output should be "110".
// For N = 147, the sum of digits... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_84_solve.py | verbatim | 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([4, 2, 6, 7]) ==> 2
func add(lst []int) int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_85_add.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_86_anti_shuffle.py | verbatim | 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 tuples, [(x1... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_87_get_row.py | verbatim | 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 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 ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_88_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{}), 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_89_encrypt.py | verbatim | 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 tuple consisting of a sum and a product of all the integers in a list.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// >>> sum_product([])
// (0, 1)
// >>> sum_product([1, 2, 3, 4])
// (1... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_8_sum_product.py | verbatim | 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(... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_91_is_bored.py | verbatim | 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
// any_in... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_92_any_int.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_93_encode.py | verbatim | 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:
// For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
// For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_94_skjkasdkd.py | verbatim | 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 dictionary, return True if all keys are strings in lower
// case or all keys are strings in upper case, else return False.
// The function should return False is the given dictionary is empty.
// Examples:
// check_dict_case({"a":"apple", "b"... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_95_check_dict_case.py | verbatim | 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 an array of the first n
// integers that are prime numbers and less than n.
// for example:
// count_up_to(5) => [2,3]
// count_up_to(11) => [2,3,5,7]
// count_up_to(0) => []
// count_up_... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_96_count_up_to.py | verbatim | 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) should return 16.
// multiply(19, 28) should return 72.
// multiply(2020, 1851) should ret... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_97_multiply.py | verbatim | 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') returns 1
// count_upper('abcdefg') returns 0
// count_upper('dBBE') returns 0
func count_upper(s string) int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_98_count_upper.py | verbatim | 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... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_99_closest_integer.py | verbatim | 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([1, 2, 3, 2, 3, 4, 2])
// [1, 2, 3, 3, 3, 4, 4]
func rolling_max(numbers []int) []int {
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_9_rolling_max.py | verbatim | 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.
func has_close_elements(numbers []float64, threshold float64) bool {
| remove | /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... | remove | /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:
func words_string(s string) []string {
| remove | /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:
func choose_num(x int, y int) int {
| remove | /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:
func unique_digits(x []int) []int {
| remove | /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... | remove | /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 ... | remove | /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:
// Explanation:
// Integer palindrome are 1, 2, 3. one of them is even, and two of the... | remove | /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.
func co... | remove | /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// "
] |
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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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 ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func histo... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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// "
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.