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_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.
func circular_shift(x int, shift int) string {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func digitSum(s string) int {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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
... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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 ((())) ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func strange_sort_list(lst []int) []int {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
// # 1+2 is... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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
func ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
// 30 = 2 * 3 * 5
func is_multiply_prime(a int) bool {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func is_simple_power(x int, n int) bool {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func iscube(a int) bool {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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 ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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
func filter_by_substring(strings []string, substring string) []string {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func is_happy(s string) bool {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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
func prime_length(myString string) bool {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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_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
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
func solve(N int) string {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func add(lst []int) int {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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 ... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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.
func sum_product(numbers []int) []interface{} {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func is_bored(S string) int {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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
func any_int(x float64, y float64, z float64) bool {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func skjkasdkd(lst []int) int {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func check_dict_case(dict map[string... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func count_up_to(n int) []int {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func multiply(a int, b int) int {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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:
func count_upper(s string) int {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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
// Note:
// Rounding away from zero means that if the... | remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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.
func rolling_max(numbers []int) []int {
| remove | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/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.
// >>> 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 | reworded | 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 | reworded | 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 a list 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 | reworded | 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 | reworded | 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 | reworded | 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 a list of integers, sort the integers that are between 1 and 9 inclusive,
// reverse the resulting list, and then replace each digit by its corresponding name from
// "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
// For examp... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_105_by_length.py | reworded | 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 | reworded | 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 list 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 palindr... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_107_even_odd_palindrome.py | reworded | 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 a list of integers and returns
// the number of elements which has a sum of digits > 0.
// If a number is negative, then its first signed digit will be negative:
// e.g. -123 has signed digits -1, 2, and 3.
// >>> co... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_108_count_nums.py | reworded | 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 a list 'arr' of N integers arr[1], arr[2], ..., arr[N].The
// numbers in the list will be randomly ordered. Your task is to determine if
// it is possible to get a list sorted in non-decreasing order by performing
// the following operation on ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_109_move_one_ball.py | reworded | 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 ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_10_make_palindrome.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_110_exchange.py | reworded | 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 map
// of the letter with the most repetition and containing the corresponding count.
// If several letters have the same occurrence, return all of them.
// Example:
// >>> histogram(... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_111_histogram.py | reworded | 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... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_112_reverse_delete.py | reworded | func TestReverse_Delete(t *testing.T) {
candidate := reverse_delete
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("abcde", "ae"), expected: []interface{}{"bcd", false} },
{ actual: candidate("abcdef", "b"), expected: []interface{}{"acdef", false... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_113_odd_count | go_test.go | package odd_count_test
import (
"testing"
"fmt"
)
// Given a list of strings, where each string consists of only digits, return a list.
// Each element i of the output should be "the number of odd elements in the
// string i of the input." where all the i's should be replaced by the number
// of odd digits in... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_113_odd_count.py | reworded | func TestOdd_Count(t *testing.T) {
candidate := odd_count
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"1234567"}), expected: []string{"the number of odd elements 4n the str4ng 4 of the 4nput."} },
{ actual: candidate([]string{"3", "11... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_114_minSubArraySum | go_test.go | package minSubArraySum_test
import (
"testing"
"fmt"
)
// Given a list of integers nums, find the minimum sum of any non-empty sub-list
// of nums.
// Example
// >>> minSubArraySum([]int{2, 3, 4, 1, 2, 4})
// 1
// >>> minSubArraySum([]int{-1, -2, -3})
// -6
func minSubArraySum(nums []int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_114_minSubArraySum.py | reworded | func TestMinsubarraysum(t *testing.T) {
candidate := minSubArraySum
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{2, 3, 4, 1, 2, 4}), expected: 1 },
{ actual: candidate([]int{-1, -2, -3}), expected: -6 },
{ actual: candidate([]int{-1,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_115_max_fill | go_test.go | package max_fill_test
import (
"testing"
"fmt"
)
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it,
// and all buckets have the same capac... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_115_max_fill.py | reworded | func TestMax_Fill(t *testing.T) {
candidate := max_fill
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([][]int{[]int{0, 0, 1, 0}, []int{0, 1, 0, 0}, []int{1, 1, 1, 1}}, 1), expected: 6 },
{ actual: candidate([][]int{[]int{0, 0, 1, 1}, []int{0, 0,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_116_sort_array | go_test.go | package sort_array_test
import (
"testing"
"fmt"
)
// In this Kata, you have to sort a list of non-negative integers according to
// number of ones in their binary representation in ascending order.
// For similar number of ones, sort based on decimal value.
// It must be implemented like this:
// >>> sort_ar... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_116_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{1, 5, 2, 3, 4}), expected: []int{1, 2, 4, 3, 5} },
{ actual: candidate([]int{-2, -3, -4, -5, -6}), expected: []int{-4, -2, -6, -5, -3... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_117_select_words | go_test.go | package select_words_test
import (
"testing"
"fmt"
)
// Given a string s and a natural number n, you have been tasked to implement
// a function that returns a list of all words from string s that contain exactly
// n consonants, in order these words appear in the string s.
// If the string s is empty then ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_117_select_words.py | reworded | func TestSelect_Words(t *testing.T) {
candidate := select_words
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Mary had a little lamb", 4), expected: []string{"little"} },
{ actual: candidate("Mary had a little lamb", 3), expected: []string{"Mar... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_118_get_closest_vowel | go_test.go | package get_closest_vowel_test
import (
"testing"
"fmt"
)
// You are given a word. Your task is to find the closest vowel that stands between
// two consonants from the right side of the word (case sensitive).
// Vowels in the beginning and ending doesn't count. Return empty string if you didn't
// find any ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_118_get_closest_vowel.py | reworded | func TestGet_Closest_Vowel(t *testing.T) {
candidate := get_closest_vowel
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("yogurt"), expected: "u" },
{ actual: candidate("full"), expected: "u" },
{ actual: candidate("easy"), expected: "" },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_119_match_parens | go_test.go | package match_parens_test
import (
"testing"
"fmt"
)
// You are given a list of two strings, both strings consist of open
// parentheses '(' or close parentheses ')' only.
// Your job is to check if it is possible to concatenate the two strings in
// some order, that the resulting string will be good.
// A st... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_119_match_parens.py | reworded | func TestMatch_Parens(t *testing.T) {
candidate := match_parens
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"()(", ")"}), expected: "Yes" },
{ actual: candidate([]string{")", ")"}), expected: "No" },
{ actual: candidate([]string{... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_11_string_xor | go_test.go | package string_xor_test
import (
"testing"
"fmt"
)
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// >>> string_xor("010", "110")
// "100"
func string_xor(a string, b string) string {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_11_string_xor.py | reworded | func TestString_Xor(t *testing.T) {
candidate := string_xor
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("111000", "101010"), expected: "010010" },
{ actual: candidate("1", "1"), expected: "0" },
{ actual: candidate("0101", "0000"), expect... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_120_maximum | go_test.go | package maximum_test
import (
"testing"
"fmt"
)
// Given a list arr of integers and a positive integer k, return a sorted list
// of length k with the maximum k numbers in arr.
// Example 1:
// >>> maximum([]int{-3, -4, 5}, 3)
// []int{-4, -3, 5}
// Example 2:
// >>> maximum([]int{4, -4, 4}, 2)
// []int{4, 4... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_120_maximum.py | reworded | func TestMaximum(t *testing.T) {
candidate := maximum
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{-3, -4, 5}, 3), expected: []int{-4, -3, 5} },
{ actual: candidate([]int{4, -4, 4}, 2), expected: []int{4, 4} },
{ actual: candidate([]... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_121_solution | go_test.go | package solution_test
import (
"testing"
"fmt"
)
// Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
// Examples
// >>> solution([]int{5, 8, 7, 1})
// 12
// >>> solution([]int{3, 3, 3, 3, 3})
// 9
// >>> solution([]int{30, 13, 24, 321})
// 0
func soluti... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_121_solution.py | reworded | func TestSolution(t *testing.T) {
candidate := solution
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{5, 8, 7, 1}), expected: 12 },
{ actual: candidate([]int{3, 3, 3, 3, 3}), expected: 9 },
{ actual: candidate([]int{30, 13, 24, 321}),... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_122_add_elements | go_test.go | package add_elements_test
import (
"testing"
"fmt"
)
// Given a non-empty list of integers arr and an integer k, return
// the sum of the elements with at most two digits from the first k elements of arr.
// Example:
// >>> add_elements([]int{111, 21, 3, 4000, 5, 6, 7, 8, 9}, 4)
// 24
// Constraints:
// 1. 1 ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_122_add_elements.py | reworded | func TestAdd_Elements(t *testing.T) {
candidate := add_elements
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, -2, -3, 41, 57, 76, 87, 88, 99}, 3), expected: -4 },
{ actual: candidate([]int{111, 121, 3, 4000, 5, 6}, 2), expected: 0 },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_123_get_odd_collatz | go_test.go | package get_odd_collatz_test
import (
"testing"
"fmt"
)
// Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.
// The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
// as follows: start with any positive integer n. Then each term i... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_123_get_odd_collatz.py | reworded | func TestGet_Odd_Collatz(t *testing.T) {
candidate := get_odd_collatz
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(14), expected: []int{1, 5, 7, 11, 13, 17} },
{ actual: candidate(5), expected: []int{1, 5} },
{ actual: candidate(12), expec... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_124_valid_date | go_test.go | package valid_date_test
import (
"testing"
"fmt"
)
// You have to write a function which validates a given date string and
// returns true if the date is valid otherwise false.
// The date is valid if all of the following rules are satisfied:
// 1. The date string is not empty.
// 2. The number of days is not... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_124_valid_date.py | reworded | func TestValid_Date(t *testing.T) {
candidate := valid_date
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("03-11-2000"), expected: true },
{ actual: candidate("15-01-2012"), expected: false },
{ actual: candidate("04-0-2040"), expected: fal... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_126_is_sorted | go_test.go | package is_sorted_test
import (
"testing"
"fmt"
)
// Given a list of numbers, return whether or not they are sorted
// in ascending order. If list has more than 1 duplicate of the same
// number, return false. Assume no negative numbers and only integers.
// Examples
// >>> is_sorted([]int{5})
// true
// >>> ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_126_is_sorted.py | reworded | func TestIs_Sorted(t *testing.T) {
candidate := is_sorted
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{5}), expected: true },
{ actual: candidate([]int{1, 2, 3, 4, 5}), expected: true },
{ actual: candidate([]int{1, 3, 2, 4, 5}), exp... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_127_intersection | go_test.go | package intersection_test
import (
"testing"
"fmt"
)
// You are given two intervals,
// where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
// The given intervals are closed which means that the interval (start, end)
// includes both start and end.
// For each given inter... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_127_intersection.py | reworded | func TestIntersection(t *testing.T) {
candidate := intersection
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]interface{}{1, 2}, []interface{}{2, 3}), expected: "NO" },
{ actual: candidate([]interface{}{-1, 1}, []interface{}{0, 4}), expected: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_129_minPath | go_test.go | package minPath_test
import (
"testing"
"fmt"
)
// Given a grid with N rows and N columns (N >= 2) and a positive integer k,
// each cell of the grid contains a value. Every integer in the range [1, N * N]
// inclusive appears exactly once on the cells of the grid.
// You have to find the minimum path of len... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_129_minPath.py | reworded | func TestMinpath(t *testing.T) {
candidate := minPath
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([][]int{[]int{1, 2, 3}, []int{4, 5, 6}, []int{7, 8, 9}}, 3), expected: []int{1, 2, 1} },
{ actual: candidate([][]int{[]int{5, 9, 3}, []int{4, 1, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_130_tri | go_test.go | package tri_test
import (
"testing"
"fmt"
)
// Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in
// the last couple centuries. However, what people don't know is Tribonacci sequence.
// Tribonacci sequence is defined by the recurrence:
// tri(1) = 3
// tri(n) = 1 + n / 2, if n is ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_130_tri.py | reworded | func TestTri(t *testing.T) {
candidate := tri
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3), expected: []int{1, 3, 2, 8} },
{ actual: candidate(4), expected: []int{1, 3, 2, 8, 3} },
{ actual: candidate(5), expected: []int{1, 3, 2, 8, 3, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_131_digits | go_test.go | package digits_test
import (
"testing"
"fmt"
)
// Given a positive integer n, return the product of the odd digits.
// Return 0 if all digits are even.
// For example:
// >>> digits(1)
// 1
// >>> digits(4)
// 0
// >>> digits(235)
// 15
func digits(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_131_digits.py | reworded | func TestDigits(t *testing.T) {
candidate := digits
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5), expected: 5 },
{ actual: candidate(54), expected: 5 },
{ actual: candidate(120), expected: 1 },
{ actual: candidate(5014), expected: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_132_is_nested | go_test.go | package is_nested_test
import (
"testing"
"fmt"
)
// Create a function that takes a string as input which contains only square brackets.
// The function should return true if and only if there is a valid subsequence of brackets
// where at least one bracket in the subsequence is nested.
// >>> is_nested("[[]... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_132_is_nested.py | reworded | func TestIs_Nested(t *testing.T) {
candidate := is_nested
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("[[]]"), expected: true },
{ actual: candidate("[]]]]]]][[[[[]"), expected: false },
{ actual: candidate("[][]"), expected: false },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_133_sum_squares | go_test.go | package sum_squares_test
import (
"testing"
"fmt"
)
// You are given a list of numbers.
// You need to return the sum of squared numbers in the given list,
// round each element in the list to the upper int(Ceiling) first.
// Examples:
// >>> lst([]float64{1.0, 2.0, 3.0})
// 14
// >>> lst([]float64{1.0, 4.0, ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_133_sum_squares.py | reworded | func TestSum_Squares(t *testing.T) {
candidate := sum_squares
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]float64{1.0, 2.0, 3.0}), expected: 14 },
{ actual: candidate([]float64{1.0, 2.0, 3.0}), expected: 14 },
{ actual: candidate([]floa... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_134_check_if_last_char_is_a_letter | go_test.go | package check_if_last_char_is_a_letter_test
import (
"testing"
"fmt"
)
// Create a function that returns true if the last character
// of a given string is an alphabetical character and is not
// a part of a word, and false otherwise.
// Note: "word" is a group of characters separated by space.
// Examples:
/... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_134_check_if_last_char_is_a_letter.py | reworded | func TestCheck_If_Last_Char_Is_A_Letter(t *testing.T) {
candidate := check_if_last_char_is_a_letter
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("apple"), expected: false },
{ actual: candidate("apple pi e"), expected: true },
{ actual: ca... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_135_can_arrange | go_test.go | package can_arrange_test
import (
"testing"
"fmt"
)
// Create a function which returns the largest index of an element which
// is not greater than or equal to the element immediately preceding it. If
// no such element exists then return -1. The given list will not contain
// duplicate values.
// Examples:
/... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_135_can_arrange.py | reworded | func TestCan_Arrange(t *testing.T) {
candidate := can_arrange
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 4, 3, 5}), expected: 3 },
{ actual: candidate([]int{1, 2, 4, 5}), expected: -1 },
{ actual: candidate([]int{1, 4, 2, 5, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_136_largest_smallest_integers | go_test.go | package largest_smallest_integers_test
import (
"testing"
"fmt"
)
// Create a function that returns a list (a, b), where 'a' is
// the largest of negative integers, and 'b' is the smallest
// of positive integers in a list.
// If there is no negative or positive integers, return them as nil.
// Examples:
// >... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_136_largest_smallest_integers.py | reworded | func TestLargest_Smallest_Integers(t *testing.T) {
candidate := largest_smallest_integers
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{2, 4, 1, 3, 5, 7}), expected: []interface{}{nil, 1} },
{ actual: candidate([]int{2, 4, 1, 3, 5, 7, 0}),... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_138_is_equal_to_sum_even | go_test.go | package is_equal_to_sum_even_test
import (
"testing"
"fmt"
)
// Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
// Example
// >>> is_equal_to_sum_even(4)
// false
// >>> is_equal_to_sum_even(6)
// false
// >>> is_equal_to_sum_even(8)
// true
func is_equal_to_su... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_138_is_equal_to_sum_even.py | reworded | func TestIs_Equal_To_Sum_Even(t *testing.T) {
candidate := is_equal_to_sum_even
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(4), expected: false },
{ actual: candidate(6), expected: false },
{ actual: candidate(8), expected: true },
{... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_139_special_factorial | go_test.go | package special_factorial_test
import (
"testing"
"fmt"
)
// The Brazilian factorial is defined as:
// brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
// where n > 0
// For example:
// >>> special_factorial(4)
// 288
// The function will receive an integer as input and should return the special
// fa... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_139_special_factorial.py | reworded | func TestSpecial_Factorial(t *testing.T) {
candidate := special_factorial
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(4), expected: 288 },
{ actual: candidate(5), expected: 34560 },
{ actual: candidate(7), expected: 125411328000 },
{... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_13_greatest_common_divisor | go_test.go | package greatest_common_divisor_test
import (
"testing"
"fmt"
)
// Return a greatest common divisor of two integers a and b
// >>> greatest_common_divisor(3, 5)
// 1
// >>> greatest_common_divisor(25, 15)
// 5
func greatest_common_divisor(a int, b int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_13_greatest_common_divisor.py | reworded | func TestGreatest_Common_Divisor(t *testing.T) {
candidate := greatest_common_divisor
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3, 7), expected: 1 },
{ actual: candidate(10, 15), expected: 5 },
{ actual: candidate(49, 14), expected: 7 }... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_140_fix_spaces | go_test.go | package fix_spaces_test
import (
"testing"
"fmt"
)
// Given a string text, replace all spaces in it with underscores,
// and if a string has more than 2 consecutive spaces,
// then replace all consecutive spaces with -
// >>> fix_spaces(" Example")
// "Example"
// >>> fix_spaces(" Example 1")
// "Example_1... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_140_fix_spaces.py | reworded | func TestFix_Spaces(t *testing.T) {
candidate := fix_spaces
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Example"), expected: "Example" },
{ actual: candidate("Mudasir Hanif "), expected: "Mudasir_Hanif_" },
{ actual: candidate("Yellow Ye... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_141_file_name_check | go_test.go | package file_name_check_test
import (
"testing"
"fmt"
)
// Create a function which takes a string representing a file's name, and returns
// 'Yes' if the the file's name is valid, and returns 'No' otherwise.
// A file's name is considered to be valid if and only if all the following conditions
// are met:
//... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_141_file_name_check.py | reworded | func TestFile_Name_Check(t *testing.T) {
candidate := file_name_check
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("example.txt"), expected: "Yes" },
{ actual: candidate("1example.dll"), expected: "No" },
{ actual: candidate("s1sdf3.asd"),... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_142_sum_squares | go_test.go | package sum_squares_test
import (
"testing"
"fmt"
)
// "
// This function will take a list of integers. For all entries in the list, the function shall square the integer entry if its index is a
// multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The func... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_142_sum_squares.py | reworded | func TestSum_Squares(t *testing.T) {
candidate := sum_squares
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 3}), expected: 6 },
{ actual: candidate([]int{1, 4, 9}), expected: 14 },
{ actual: candidate([]int{}), expected: 0 },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_143_words_in_sentence | go_test.go | package words_in_sentence_test
import (
"testing"
"fmt"
)
// You are given a string representing a sentence,
// the sentence contains some words separated by a space,
// and you have to return a string that contains the words from the original sentence,
// whose lengths are prime numbers,
// the order of the ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_143_words_in_sentence.py | reworded | func TestWords_In_Sentence(t *testing.T) {
candidate := words_in_sentence
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("This is a test"), expected: "is" },
{ actual: candidate("lets go for swimming"), expected: "go for" },
{ actual: candid... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_144_simplify | go_test.go | package simplify_test
import (
"testing"
"fmt"
)
// Your task is to implement a function that will simplify the expression
// x * n. The function returns true if x * n evaluates to a whole number and false
// otherwise. Both x and n, are string representation of a fraction, and have the following format,
// <... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_144_simplify.py | reworded | func TestSimplify(t *testing.T) {
candidate := simplify
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("1/5", "5/1"), expected: true },
{ actual: candidate("1/6", "2/1"), expected: false },
{ actual: candidate("5/1", "3/1"), expected: true }... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_145_order_by_points | go_test.go | package order_by_points_test
import (
"testing"
"fmt"
)
// Write a function which sorts the given list of integers
// in ascending order according to the sum of their digits.
// Note: if there are several items with similar sum of their digits,
// order them based on their index in original list.
// For examp... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_145_order_by_points.py | reworded | func TestOrder_By_Points(t *testing.T) {
candidate := order_by_points
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 11, -1, -11, -12}), expected: []int{-1, -11, 1, -12, 11} },
{ actual: candidate([]int{1234, 423, 463, 145, 2, 423, 423, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_146_specialFilter | go_test.go | package specialFilter_test
import (
"testing"
"fmt"
)
// Write a function that takes a list of numbers as input and returns
// the number of elements in the list that are greater than 10 and both
// first and last digits of a number are odd (1, 3, 5, 7, 9).
// For example:
// >>> specialFilter([]int{15, -73... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_146_specialFilter.py | reworded | func TestSpecialfilter(t *testing.T) {
candidate := specialFilter
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{5, -2, 1, -5}), expected: 0 },
{ actual: candidate([]int{15, -73, 14, -15}), expected: 1 },
{ actual: candidate([]int{33, ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_147_get_max_triples | go_test.go | package get_max_triples_test
import (
"testing"
"fmt"
)
// You are given a positive integer n. You have to create an integer list a of length n.
// For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
// Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
// and a[i] + a[j] + a[k] is ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_147_get_max_triples.py | reworded | func TestGet_Max_Triples(t *testing.T) {
candidate := get_max_triples
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5), expected: 1 },
{ actual: candidate(6), expected: 4 },
{ actual: candidate(10), expected: 36 },
{ actual: candidate(... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_148_bf | go_test.go | package bf_test
import (
"testing"
"fmt"
)
// There are eight planets in our solar system: the closerst to the Sun
// is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
// Uranus, Neptune.
// Write a function that takes two planet names as strings planet1 and planet2.
// The function sho... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_148_bf.py | reworded | func TestBf(t *testing.T) {
candidate := bf
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Jupiter", "Neptune"), expected: []interface{}{"Saturn", "Uranus"} },
{ actual: candidate("Earth", "Mercury"), expected: []interface{}{"Venus"} },
{ a... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_149_sorted_list_sum | go_test.go | package sorted_list_sum_test
import (
"testing"
"fmt"
)
// Write a function that accepts a list of strings as a parameter,
// deletes the strings that have odd lengths from it,
// and returns the resulted list with a sorted order,
// The list is always a list of strings and never a list of numbers,
// and it ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_149_sorted_list_sum.py | reworded | func TestSorted_List_Sum(t *testing.T) {
candidate := sorted_list_sum
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"aa", "a", "aaa"}), expected: []string{"aa"} },
{ actual: candidate([]string{"school", "AI", "asdf", "b"}), expected: []... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_14_all_prefixes | go_test.go | package all_prefixes_test
import (
"testing"
"fmt"
)
// Return list of all prefixes from shortest to longest of the input string
// >>> all_prefixes("abc")
// []string{"a", "ab", "abc"}
func all_prefixes(myString string) []string {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_14_all_prefixes.py | reworded | func TestAll_Prefixes(t *testing.T) {
candidate := all_prefixes
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(""), expected: []string{} },
{ actual: candidate("asdfgh"), expected: []string{"a", "as", "asd", "asdf", "asdfg", "asdfgh"} },
{ a... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_150_x_or_y | go_test.go | package x_or_y_test
import (
"testing"
"fmt"
)
// A simple program which should return the value of x if n is
// a prime number and should return the value of y otherwise.
// Examples:
// >>> x_or_y(7, 34, 12)
// 34
// >>> x_or_y(15, 8, 5)
// 5
func x_or_y(n int, x int, y int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_150_x_or_y.py | reworded | func TestX_Or_Y(t *testing.T) {
candidate := x_or_y
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(7, 34, 12), expected: 34 },
{ actual: candidate(15, 8, 5), expected: 5 },
{ actual: candidate(3, 33, 5212), expected: 33 },
{ actual: can... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_151_double_the_difference | go_test.go | package double_the_difference_test
import (
"testing"
"fmt"
)
// Given a list of numbers, return the sum of squares of the numbers
// in the list that are odd. Ignore numbers that are negative or not integers.
// >>> double_the_difference([]int{1, 3, 2, 0})
// 10
// >>> double_the_difference([]int{-1, -2, 0})... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_151_double_the_difference.py | reworded | func TestDouble_The_Difference(t *testing.T) {
candidate := double_the_difference
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]float64{}), expected: 0 },
{ actual: candidate([]float64{5.0, 4.0}), expected: 25 },
{ actual: candidate([]flo... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_152_compare | go_test.go | package compare_test
import (
"testing"
"fmt"
)
// I think we all remember that feeling when the result of some long-awaited
// event is finally known. The feelings and thoughts you have at that moment are
// definitely worth noting down and comparing.
// Your task is to determine if a person correctly guesse... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_152_compare.py | reworded | func TestCompare(t *testing.T) {
candidate := compare
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{1, 2, 3, 4, 5, 1}, []int{1, 2, 3, 4, 2, -2}), expected: []int{0, 0, 0, 0, 3, 3} },
{ actual: candidate([]int{0, 0, 0, 0, 0, 0}, []int{0, 0,... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_153_Strongest_Extension | go_test.go | package Strongest_Extension_test
import (
"testing"
"fmt"
)
// You will be given the name of a class (a string) and a list of extensions.
// The extensions are to be used to load additional classes to the class. The
// strength of the extension is as follows: Let CAP be the number of the uppercase
// letters ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_153_Strongest_Extension.py | reworded | func TestStrongest_Extension(t *testing.T) {
candidate := Strongest_Extension
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Watashi", []string{"tEN", "niNE", "eIGHt8OKe"}), expected: "Watashi.eIGHt8OKe" },
{ actual: candidate("Boku123", []strin... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_154_cycpattern_check | go_test.go | package cycpattern_check_test
import (
"testing"
"fmt"
)
// You are given 2 words. You need to return true if the second word or any of its rotations is a substring in the first word
// >>> cycpattern_check("abcd", "abd")
// false
// >>> cycpattern_check("hello", "ell")
// true
// >>> cycpattern_check("whassu... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_154_cycpattern_check.py | reworded | func TestCycpattern_Check(t *testing.T) {
candidate := cycpattern_check
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("xyzw", "xyw"), expected: false },
{ actual: candidate("yello", "ell"), expected: true },
{ actual: candidate("whattup", "... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_155_even_odd_count | go_test.go | package even_odd_count_test
import (
"testing"
"fmt"
)
// Given an integer. return a list that has the number of even and odd digits respectively.
// Example:
// >>> even_odd_count(-12)
// []interface{}{1, 1}
// >>> even_odd_count(123)
// []interface{}{1, 2}
func even_odd_count(num int) []interface{} {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_155_even_odd_count.py | reworded | func TestEven_Odd_Count(t *testing.T) {
candidate := even_odd_count
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(7), expected: []interface{}{0, 1} },
{ actual: candidate(-78), expected: []interface{}{1, 1} },
{ actual: candidate(3452), exp... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_156_int_to_mini_roman | go_test.go | package int_to_mini_roman_test
import (
"testing"
"fmt"
)
// Given a positive integer, obtain its roman numeral equivalent as a string,
// and return it in lowercase.
// Restrictions: 1 <= num <= 1000
// Examples:
// >>> int_to_mini_roman(19)
// "xix"
// >>> int_to_mini_roman(152)
// "clii"
// >>> int_to_mini... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_156_int_to_mini_roman.py | reworded | func TestInt_To_Mini_Roman(t *testing.T) {
candidate := int_to_mini_roman
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(19), expected: "xix" },
{ actual: candidate(152), expected: "clii" },
{ actual: candidate(251), expected: "ccli" },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_157_right_angle_triangle | go_test.go | package right_angle_triangle_test
import (
"testing"
"fmt"
)
// Given the lengths of the three sides of a triangle. Return true if the three
// sides form a right-angled triangle, false otherwise.
// A right-angled triangle is a triangle in which one angle is right angle or
// 90 degree.
// Example:
// >>> r... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_157_right_angle_triangle.py | reworded | func TestRight_Angle_Triangle(t *testing.T) {
candidate := right_angle_triangle
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(3, 4, 5), expected: true },
{ actual: candidate(1, 2, 3), expected: false },
{ actual: candidate(10, 6, 8), expect... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_158_find_max | go_test.go | package find_max_test
import (
"testing"
"fmt"
)
// Write a function that accepts a list of strings.
// The list contains different words. Return the word with maximum number
// of unique characters. If multiple strings have maximum number of unique
// characters, return the one which comes first in lexicogra... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_158_find_max.py | reworded | func TestFind_Max(t *testing.T) {
candidate := find_max
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"name", "of", "string"}), expected: "string" },
{ actual: candidate([]string{"name", "enam", "game"}), expected: "enam" },
{ actu... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_159_eat | go_test.go | package eat_test
import (
"testing"
"fmt"
)
// You're a hungry rabbit, and you already have eaten a certain number of carrots,
// but now you need to eat more carrots to complete the day's meals.
// you should return a list of [ total number of eaten carrots after your meals,
// the number of carrots left aft... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_159_eat.py | reworded | func TestEat(t *testing.T) {
candidate := eat
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5, 6, 10), expected: []int{11, 4} },
{ actual: candidate(4, 8, 9), expected: []int{12, 1} },
{ actual: candidate(1, 10, 10), expected: []int{11, 0} ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_15_string_sequence | go_test.go | package string_sequence_test
import (
"testing"
"fmt"
)
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// >>> string_sequence(0)
// "0"
// >>> string_sequence(5)
// "0 1 2 3 4 5"
func string_sequence(n int) string {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_15_string_sequence.py | reworded | func TestString_Sequence(t *testing.T) {
candidate := string_sequence
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(0), expected: "0" },
{ actual: candidate(3), expected: "0 1 2 3" },
{ actual: candidate(10), expected: "0 1 2 3 4 5 6 7 8 9 ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_160_do_algebra | go_test.go | package do_algebra_test
import (
"testing"
"fmt"
)
// Given two lists operator, and operand. The first list has basic algebra operations, and
// the second list is a list of integers. Use the two given lists to build the algebric
// expression and return the evaluation of this expression.
// The basic algeb... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_160_do_algebra.py | reworded | func TestDo_Algebra(t *testing.T) {
candidate := do_algebra
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{"**", "*", "+"}, []int{2, 3, 4, 5}), expected: 37 },
{ actual: candidate([]string{"+", "*", "-"}, []int{2, 3, 4, 5}), expected: 9 ... | [
"\nfunc",
"struct",
"\n// "
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.