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