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_59_largest_prime_factor | go_test.go | package largest_prime_factor_test
import (
"testing"
"fmt"
)
// Return the largest prime factor of n. Assume n > 1 and is not a prime.
// >>> largest_prime_factor(13195)
// 29
// >>> largest_prime_factor(2048)
// 2
func largest_prime_factor(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_59_largest_prime_factor.py | verbatim | func TestLargest_Prime_Factor(t *testing.T) {
candidate := largest_prime_factor
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(15), expected: 5 },
{ actual: candidate(27), expected: 3 },
{ actual: candidate(63), expected: 7 },
{ actual:... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_5_intersperse | go_test.go | package intersperse_test
import (
"testing"
"fmt"
)
// Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
// >>> intersperse([]int{}, 4)
// []int{}
// >>> intersperse([]int{1, 2, 3}, 4)
// []int{1, 4, 2, 4, 3}
func intersperse(numbers []int, delimeter int) []int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_5_intersperse.py | verbatim | func TestIntersperse(t *testing.T) {
candidate := intersperse
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}, 7), expected: []int{} },
{ actual: candidate([]int{5, 6, 3, 2}, 8), expected: []int{5, 8, 6, 8, 3, 8, 2} },
{ actual: candi... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_60_sum_to_n | go_test.go | package sum_to_n_test
import (
"testing"
"fmt"
)
// sum_to_n is a function that sums numbers from 1 to n.
// >>> sum_to_n(30)
// 465
// >>> sum_to_n(100)
// 5050
// >>> sum_to_n(5)
// 15
// >>> sum_to_n(10)
// 55
// >>> sum_to_n(1)
// 1
func sum_to_n(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_60_sum_to_n.py | verbatim | func TestSum_To_N(t *testing.T) {
candidate := sum_to_n
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(1), expected: 1 },
{ actual: candidate(6), expected: 21 },
{ actual: candidate(11), expected: 66 },
{ actual: candidate(30), expected... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_61_correct_bracketing | go_test.go | package correct_bracketing_test
import (
"testing"
"fmt"
)
// brackets is a string of "(" and ")".
// return True if every opening bracket has a corresponding closing bracket.
// >>> correct_bracketing("(")
// false
// >>> correct_bracketing("()")
// true
// >>> correct_bracketing("(()())")
// true
// >>> cor... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_61_correct_bracketing.py | verbatim | func TestCorrect_Bracketing(t *testing.T) {
candidate := correct_bracketing
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("()"), expected: true },
{ actual: candidate("(()())"), expected: true },
{ actual: candidate("()()(()())()"), expecte... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_62_derivative | go_test.go | package derivative_test
import (
"testing"
"fmt"
)
// xs represent coefficients of a polynomial.
// xs[0] + xs[1] * x + xs[2] * x^2 + ....
// Return derivative of this polynomial in the same form.
// >>> derivative([]int{3, 1, 2, 4, 5})
// []int{1, 4, 12, 20}
// >>> derivative([]int{1, 2, 3})
// []int{2, 6}
f... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_62_derivative.py | verbatim | func TestDerivative(t *testing.T) {
candidate := derivative
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{3, 1, 2, 4, 5}), expected: []int{1, 4, 12, 20} },
{ actual: candidate([]int{1, 2, 3}), expected: []int{2, 6} },
{ actual: candid... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_63_fibfib | go_test.go | package fibfib_test
import (
"testing"
"fmt"
)
// The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fibfib(0) == 0
// fibfib(1) == 0
// fibfib(2) == 1
// fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
// Please write a function to efficiently comp... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_63_fibfib.py | verbatim | func TestFibfib(t *testing.T) {
candidate := fibfib
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(2), expected: 1 },
{ actual: candidate(1), expected: 0 },
{ actual: candidate(5), expected: 4 },
{ actual: candidate(8), expected: 24 },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_64_vowels_count | go_test.go | package vowels_count_test
import (
"testing"
"fmt"
)
// Write a function vowels_count which takes a string representing
// a word as input and returns the number of vowels in the string.
// Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
// vowel, but only when it is at the end of the giv... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_64_vowels_count.py | verbatim | func TestVowels_Count(t *testing.T) {
candidate := vowels_count
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("abcde"), expected: 2 },
{ actual: candidate("Alone"), expected: 3 },
{ actual: candidate("key"), expected: 2 },
{ actual: ca... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_65_circular_shift | go_test.go | package circular_shift_test
import (
"testing"
"fmt"
)
// Circular shift the digits of the integer x, shift the digits right by shift
// and return the result as a string.
// If shift > number of digits, return digits reversed.
// >>> circular_shift(12, 1)
// "21"
// >>> circular_shift(12, 2)
// "12"
func cir... | transform | /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:
// >>> digitSum("")
// 0
// >>> digitSum("abAB")
// 131
// >>> digitSum("abcCd")
// 67
// >>> digitSum("helloE")
// 69
// >>>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_66_digitSum.py | 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
... | transform | /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... | transform | /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... | transform | /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 ((())) ... | transform | /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:
// >>> strange_sort_list([]int{1, 2, 3, 4})
// []int{... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_70_strange_sort_list.py | 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... | transform | /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:
// >>> will... | transform | /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... | transform | /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
// >>... | transform | /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:
// >>> is_multiply_prime(30)
// true
// 30 = 2 * 3 * 5
func is_multiply_prime(... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_75_is_multiply_prime.py | verbatim | func TestIs_Multiply_Prime(t *testing.T) {
candidate := is_multiply_prime
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(5), expected: false },
{ actual: candidate(30), expected: true },
{ actual: candidate(8), expected: true },
{ actua... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_76_is_simple_power | go_test.go | package is_simple_power_test
import (
"testing"
"fmt"
)
// Your task is to write a function that returns true if a number x is a simple
// power of n and false in other cases.
// x is a simple power of n if n**int=x
// For example:
// >>> is_simple_power(1, 4)
// true
// >>> is_simple_power(2, 2)
// true
// >... | transform | /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:
// >>> iscube(1)
// true
// >>> iscube(2)
// false
// >>> iscube(-1)
// true
// >>> ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_77_iscube.py | 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 ... | transform | /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... | transform | /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
// >>> filter_by_substring([]string{}, "a")
// []string{}
// >>> filter_by_substring([]string{"abc", "bacd", "cde", "array"}, "a")
// []string{"abc", "bacd", "array"}
func ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_7_filter_by_substring.py | verbatim | func TestFilter_By_Substring(t *testing.T) {
candidate := filter_by_substring
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]string{}, "john"), expected: []string{} },
{ actual: candidate([]string{"xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_80_is_happy | go_test.go | package is_happy_test
import (
"testing"
"fmt"
)
// You are given a string s.
// Your task is to check if the string is happy or not.
// A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
// For example:
// >>> is_happy("a")
// false
// >>> is_happy("aa")
// false
// >>... | transform | /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... | transform | /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
// >>> prime_length("Hello")
// true
// >>> prime_length("abcdcba")
// true
// >>> prime_length("kittens")
// true
// >>> prime... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_82_prime_length.py | verbatim | func TestPrime_Length(t *testing.T) {
candidate := prime_length
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("Hello"), expected: true },
{ actual: candidate("abcdcba"), expected: true },
{ actual: candidate("kittens"), expected: true },
... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_83_starts_one_ends | go_test.go | package starts_one_ends_test
import (
"testing"
"fmt"
)
// Given a positive integer n, return the count of the numbers of n-digit
// positive integers that start or end with 1.
func starts_one_ends(n int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_83_starts_one_ends.py | verbatim | func TestStarts_One_Ends(t *testing.T) {
candidate := starts_one_ends
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(1), expected: 1 },
{ actual: candidate(2), expected: 18 },
{ actual: candidate(3), expected: 180 },
{ actual: candidate... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_84_solve | go_test.go | package solve_test
import (
"testing"
"fmt"
)
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// >>> solve(1000)
// "1"
// >>> solve(150)
// "110"
// >>> solve(147)
// "1100"
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary num... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_84_solve.py | verbatim | func TestSolve(t *testing.T) {
candidate := solve
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(1000), expected: "1" },
{ actual: candidate(150), expected: "110" },
{ actual: candidate(147), expected: "1100" },
{ actual: candidate(333)... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_85_add | go_test.go | package add_test
import (
"testing"
"fmt"
)
// Given a non-empty list of integers lst. add the even elements that are at odd indices..
// Examples:
// >>> add([]int{4, 2, 6, 7})
// 2
func add(lst []int) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_85_add.py | 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... | transform | /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... | transform | /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 ... | transform | /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... | transform | /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.
// >>> sum_product([]int{})
// []interface{}{0, 1}
// >>> sum_product([... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_8_sum_product.py | verbatim | func TestSum_Product(t *testing.T) {
candidate := sum_product
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{}), expected: []interface{}{0, 1} },
{ actual: candidate([]int{1, 1, 1}), expected: []interface{}{3, 1} },
{ actual: candidate... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_91_is_bored | go_test.go | package is_bored_test
import (
"testing"
"fmt"
)
// You'll be given a string of words, and your task is to count the number
// of boredoms. A boredom is a sentence that starts with the word "I".
// Sentences are delimited by '.', '?' or '!'.
// For example:
// >>> is_bored("Hello world")
// 0
// >>> is_bored(... | transform | /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
// >>> any_int(5, 2, 7)
// true
// >>> any_int(3, 2, 2)
// false... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_92_any_int.py | 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... | transform | /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:
// >>> skjkasdkd([]int{0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3})
// 10
// >>> skjkasdkd([]int{1, 0, ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_94_skjkasdkd.py | verbatim | func TestSkjkasdkd(t *testing.T) {
candidate := skjkasdkd
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate([]int{0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3}), expected: 10 },
{ actual: candidate([]int{1, 0, 1, 8, 2, 459... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_95_check_dict_case | go_test.go | package check_dict_case_test
import (
"testing"
"fmt"
)
// Given a dictionary, return True if all keys are strings in lower
// case or all keys are strings in upper case, else return False.
// The function should return False is the given dictionary is empty.
// Examples:
// >>> check_dict_case(map[string]st... | transform | /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:
// >>> count_up_to(5)
// []int{2, 3}
// >>> count_up_to(11)
// []int{2, 3, 5, 7}
// >>> count_u... | transform | /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:
// >>> multiply(148, 412)
// 16
// >>> multiply(19, 28)
// 72
// >>> multiply(2020, 1851)
// 0
// >>> multiply(1... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_97_multiply.py | verbatim | func TestMultiply(t *testing.T) {
candidate := multiply
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate(148, 412), expected: 16 },
{ actual: candidate(19, 28), expected: 72 },
{ actual: candidate(2020, 1851), expected: 0 },
{ actual: can... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_98_count_upper | go_test.go | package count_upper_test
import (
"testing"
"fmt"
)
// Given a string s, count the number of uppercase vowels in even indices.
// For example:
// >>> count_upper("aBCdEf")
// 1
// >>> count_upper("abcdefg")
// 0
// >>> count_upper("dBBE")
// 0
func count_upper(s string) int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_98_count_upper.py | verbatim | func TestCount_Upper(t *testing.T) {
candidate := count_upper
type test struct {
actual interface{}
expected interface{}
}
tests := []test{
{ actual: candidate("aBCdEf"), expected: 1 },
{ actual: candidate("abcdefg"), expected: 0 },
{ actual: candidate("dBBE"), expected: 0 },
{ actual: ... | [
"\nfunc",
"struct",
"\n// "
] |
HumanEval_99_closest_integer | go_test.go | package closest_integer_test
import (
"testing"
"fmt"
)
// Create a function that takes a value (string) representing a number
// and returns the closest integer to it. If the number is equidistant
// from two integers, round it away from zero.
// Examples
// >>> closest_integer("10")
// 10
// >>> closest_int... | transform | /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.
// >>> rolling_max([]int{1, 2, 3, 2, 3, 4, 2})
// []int{1, 2, 3, 3, 3, 4, 4}
func rolling_max(numbers []int) []int {
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_9_rolling_max.py | 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 | hs | -- | Check if in given list of numbers, are any two numbers closer to each other than
-- given threshold.
-- >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
-- False
-- >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
-- True
hasCloseElements :: [Float] -> Float -> Bool
hasCloseElements numbers threshold = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_0_has_close_elements.py | verbatim |
main :: IO ()
main = do
let candidate = hasCloseElements
if candidate [1.0,2.0,3.9,4.0,5.0,2.2] 0.3 == True then pure () else error "assertion failed"
if candidate [1.0,2.0,3.9,4.0,5.0,2.2] 0.05 == False then pure () else error "assertion failed"
if candidate [1.0,2.0,5.9,4.0,5.0] 0.95 == True then pure () els... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_100_make_a_pile | hs | -- | 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 stones in each level in a list, where element at index... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_100_make_a_pile.py | verbatim |
main :: IO ()
main = do
let candidate = makeAPile
if candidate 3 == [3,5,7] then pure () else error "assertion failed"
if candidate 4 == [4,6,8,10] then pure () else error "assertion failed"
if candidate 5 == [5,7,9,11,13] then pure () else error "assertion failed"
if candidate 6 == [6,8,10,12,14,16] then pu... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_101_words_string | hs | -- | You will be given a string of words separated by commas or spaces. Your task is
-- to split the string into words and return an array of the words.
-- For example:
-- words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
-- words_string("One, two, three, four, five, six") == ["One", "two", ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_101_words_string.py | verbatim |
main :: IO ()
main = do
let candidate = wordsString
if candidate "Hi, my name is John" == ["Hi","my","name","is","John"] then pure () else error "assertion failed"
if candidate "One, two, three, four, five, six" == ["One","two","three","four","five","six"] then pure () else error "assertion failed"
if candidat... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_102_choose_num | hs | -- | This function takes two positive numbers x and y and returns the
-- biggest even integer number that is in the range [x, y] inclusive. If
-- there's no such number, then the function should return -1.
-- For example:
-- choose_num(12, 15) = 14
-- choose_num(13, 12) = -1
chooseNum :: Int -> Int -> Int
chooseN... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_102_choose_num.py | verbatim |
main :: IO ()
main = do
let candidate = chooseNum
if candidate 12 15 == 14 then pure () else error "assertion failed"
if candidate 13 12 == (-1) then pure () else error "assertion failed"
if candidate 33 12354 == 12354 then pure () else error "assertion failed"
if candidate 5234 5233 == (-1) then pure () els... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_104_unique_digits | hs | -- | Given a list of positive integers x. return a sorted list of all
-- elements that hasn't any even digit.
-- Note: Returned list should be sorted in increasing order.
-- For example:
-- >>> unique_digits([15, 33, 1422, 1])
-- [1, 15, 33]
-- >>> unique_digits([152, 323, 1422, 10])
-- []
uniqueDigits :: [Int]... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_104_unique_digits.py | verbatim |
main :: IO ()
main = do
let candidate = uniqueDigits
if candidate [15,33,1422,1] == [1,15,33] then pure () else error "assertion failed"
if candidate [152,323,1422,10] == [] then pure () else error "assertion failed"
if candidate [12345,2033,111,151] == [111,151] then pure () else error "assertion failed"
if... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_105_by_length | hs | -- | Given an array of integers, sort the integers that are between 1 and 9 inclusive,
-- reverse the resulting array, and then replace each digit by its corresponding name from
-- "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
-- For example:
-- arr = [2, 1, 1, 4, 5, 8, 2, 3]
-- -> sor... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_105_by_length.py | verbatim |
main :: IO ()
main = do
let candidate = byLength
if candidate [2,1,1,4,5,8,2,3] == ["Eight","Five","Four","Three","Two","Two","One","One"] then pure () else error "assertion failed"
if candidate [] == [] then pure () else error "assertion failed"
if candidate [1,(-1),55] == ["One"] then pure () else error "ass... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_106_f | hs | -- | 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 multiplication of the numbers from 1 to i (1 *... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_106_f.py | verbatim |
main :: IO ()
main = do
let candidate = f
if candidate 5 == [1,2,6,24,15] then pure () else error "assertion failed"
if candidate 7 == [1,2,6,24,15,720,28] then pure () else error "assertion failed"
if candidate 1 == [1] then pure () else error "assertion failed"
if candidate 3 == [1,2,6] then pure () else e... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_107_even_odd_palindrome | hs | -- | Given a positive integer n, return a tuple that has the number of even and odd
-- integer palindromes that fall within the range(1, n), inclusive.
-- Example 1:
-- Input: 3
-- Output: (1, 2)
-- Explanation:
-- Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
-- Example 2:
-- In... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_107_even_odd_palindrome.py | verbatim |
main :: IO ()
main = do
let candidate = evenOddPalindrome
if candidate 123 == (8, 13) then pure () else error "assertion failed"
if candidate 12 == (4, 6) then pure () else error "assertion failed"
if candidate 3 == (1, 2) then pure () else error "assertion failed"
if candidate 63 == (6, 8) then pure () else... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_108_count_nums | hs | -- | Write a function count_nums which takes an array of integers and returns
-- the number of elements which has a sum of digits > 0.
-- If a number is negative, then its first signed digit will be negative:
-- e.g. -123 has signed digits -1, 2, and 3.
-- >>> count_nums([]) == 0
-- >>> count_nums([-1, 11, -11]) =... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_108_count_nums.py | verbatim |
main :: IO ()
main = do
let candidate = countNums
if candidate [] == 0 then pure () else error "assertion failed"
if candidate [(-1),(-2),0] == 0 then pure () else error "assertion failed"
if candidate [1,1,2,(-2),3,4,5] == 6 then pure () else error "assertion failed"
if candidate [1,6,9,(-6),0,1,5] == 5 the... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_109_move_one_ball | hs | -- | 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 operation on the given array:
-- You are allowed to perform right ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_109_move_one_ball.py | verbatim |
main :: IO ()
main = do
let candidate = moveOneBall
if candidate [3,4,5,1,2] == True then pure () else error "assertion failed"
if candidate [3,5,10,1,2] == True then pure () else error "assertion failed"
if candidate [4,3,1,2] == False then pure () else error "assertion failed"
if candidate [3,5,4,1,2] == F... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_10_make_palindrome | hs | -- | 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 palindromic suffix.
-- >>> make_palindrome('')
-- ''
-- >>... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_10_make_palindrome.py | verbatim |
main :: IO ()
main = do
let candidate = makePalindrome
if candidate "" == "" then pure () else error "assertion failed"
if candidate "x" == "x" then pure () else error "assertion failed"
if candidate "xyz" == "xyzyx" then pure () else error "assertion failed"
if candidate "xyx" == "xyx" then pure () else err... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_110_exchange | hs | -- | 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 exchanged elements between lst1 and lst2.
-- If it is possi... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_110_exchange.py | verbatim |
main :: IO ()
main = do
let candidate = exchange
if candidate [1,2,3,4] [1,2,3,4] == "YES" then pure () else error "assertion failed"
if candidate [1,2,3,4] [1,5,3,4] == "NO" then pure () else error "assertion failed"
if candidate [1,2,3,4] [2,1,4,3] == "YES" then pure () else error "assertion failed"
if can... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_111_histogram | hs | -- | 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:
-- histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
-- histogram(... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_111_histogram.py | verbatim |
main :: IO ()
main = do
let candidate = histogram
if candidate "a b b a" == [("a", 2), ("b", 2)] then pure () else error "assertion failed"
if candidate "a b c a b" == [("a", 2), ("b", 2)] then pure () else error "assertion failed"
if candidate "a b c d g" == [("a", 1), ("b", 1), ("c", 1), ("d", 1), ("g", 1)] ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_112_reverse_delete | hs | -- | 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.
-- You should return a tuple containing the result string and T... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_112_reverse_delete.py | verbatim |
main :: IO ()
main = do
let candidate = reverseDelete
if candidate "abcde" "ae" == ("bcd", False) then pure () else error "assertion failed"
if candidate "abcdef" "b" == ("acdef", False) then pure () else error "assertion failed"
if candidate "abcdedcba" "ab" == ("cdedc", True) then pure () else error "asserti... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_113_odd_count | hs | -- | 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 the i'th string of the input.
-- >>> odd_count(['1234... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_113_odd_count.py | verbatim |
main :: IO ()
main = do
let candidate = oddCount
if candidate ["1234567"] == ["the number of odd elements 4n the str4ng 4 of the 4nput."] then pure () else error "assertion failed"
if candidate ["3","11111111"] == ["the number of odd elements 1n the str1ng 1 of the 1nput.","the number of odd elements 8n the str8... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_114_minSubArraySum | hs | -- | Given an array of integers nums, find the minimum sum of any non-empty sub-array
-- of nums.
-- Example
-- minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
-- minSubArraySum([-1, -2, -3]) == -6
minsubarraysum :: [Int] -> Int
minsubarraysum nums = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_114_minSubArraySum.py | verbatim |
main :: IO ()
main = do
let candidate = minsubarraysum
if candidate [2,3,4,1,2,4] == 1 then pure () else error "assertion failed"
if candidate [(-1),(-2),(-3)] == (-6) then pure () else error "assertion failed"
if candidate [(-1),(-2),(-3),2,(-10)] == (-14) then pure () else error "assertion failed"
if candi... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_115_max_fill | hs | -- | 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 capacity.
-- Your task is to use the buckets to empty the ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_115_max_fill.py | verbatim |
main :: IO ()
main = do
let candidate = maxFill
if candidate [[0,0,1,0],[0,1,0,0],[1,1,1,1]] 1 == 6 then pure () else error "assertion failed"
if candidate [[0,0,1,1],[0,0,0,0],[1,1,1,1],[0,1,1,1]] 2 == 5 then pure () else error "assertion failed"
if candidate [[0,0,0],[0,0,0]] 5 == 0 then pure () else error "... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_116_sort_array | hs | -- | 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_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
-- >>> sort_... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_116_sort_array.py | verbatim |
main :: IO ()
main = do
let candidate = sortArray
if candidate [1,5,2,3,4] == [1,2,4,3,5] then pure () else error "assertion failed"
if candidate [(-2),(-3),(-4),(-5),(-6)] == [(-4),(-2),(-6),(-5),(-3)] then pure () else error "assertion failed"
if candidate [1,0,2,3,4] == [0,1,2,4,3] then pure () else error "... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_117_select_words | hs | -- | 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 the function should return an empty list.
-- Note: you ma... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_117_select_words.py | verbatim |
main :: IO ()
main = do
let candidate = selectWords
if candidate "Mary had a little lamb" 4 == ["little"] then pure () else error "assertion failed"
if candidate "Mary had a little lamb" 3 == ["Mary","lamb"] then pure () else error "assertion failed"
if candidate "simple white space" 2 == [] then pure () else ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_118_get_closest_vowel | hs | -- | 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 vowel met the above condition.
-- You may assume that the giv... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_118_get_closest_vowel.py | verbatim |
main :: IO ()
main = do
let candidate = getClosestVowel
if candidate "yogurt" == "u" then pure () else error "assertion failed"
if candidate "full" == "u" then pure () else error "assertion failed"
if candidate "easy" == "" then pure () else error "assertion failed"
if candidate "eAsy" == "" then pure () els... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_119_match_parens | hs | -- | 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 string S is considered to be good if and only if all parent... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_119_match_parens.py | verbatim |
main :: IO ()
main = do
let candidate = matchParens
if candidate ["()(",")"] == "Yes" then pure () else error "assertion failed"
if candidate [")",")"] == "No" then pure () else error "assertion failed"
if candidate ["(()(())","())())"] == "No" then pure () else error "assertion failed"
if candidate [")())",... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_11_string_xor | hs | -- | 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'
stringXor :: String -> String -> String
stringXor a b = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_11_string_xor.py | verbatim |
main :: IO ()
main = do
let candidate = stringXor
if candidate "111000" "101010" == "010010" then pure () else error "assertion failed"
if candidate "1" "1" == "0" then pure () else error "assertion failed"
if candidate "0101" "0000" == "0101" then pure () else error "assertion failed"
pure () | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_120_maximum | hs | -- | Given an array arr of integers and a positive integer k, return a sorted list
-- of length k with the maximum k numbers in arr.
-- Example 1:
-- Input: arr = [-3, -4, 5], k = 3
-- Output: [-4, -3, 5]
-- Example 2:
-- Input: arr = [4, -4, 4], k = 2
-- Output: [4, 4]
-- Example 3:
-- Input: arr = [-3, 2, 1... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_120_maximum.py | verbatim |
main :: IO ()
main = do
let candidate = maximum
if candidate [(-3),(-4),5] 3 == [(-4),(-3),5] then pure () else error "assertion failed"
if candidate [4,(-4),4] 2 == [4,4] then pure () else error "assertion failed"
if candidate [(-3),2,1,2,(-1),(-2),1] 1 == [2] then pure () else error "assertion failed"
if c... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_121_solution | hs | -- | Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
-- Examples
-- solution([5, 8, 7, 1]) ==> 12
-- solution([3, 3, 3, 3, 3]) ==> 9
-- solution([30, 13, 24, 321]) ==>0
solution :: [Int] -> Int
solution lst = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_121_solution.py | verbatim |
main :: IO ()
main = do
let candidate = solution
if candidate [5,8,7,1] == 12 then pure () else error "assertion failed"
if candidate [3,3,3,3,3] == 9 then pure () else error "assertion failed"
if candidate [30,13,24,321] == 0 then pure () else error "assertion failed"
if candidate [5,9] == 5 then pure () el... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_122_add_elements | hs | -- | Given a non-empty array of integers arr and an integer k, return
-- the sum of the elements with at most two digits from the first k elements of arr.
-- Example:
-- Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
-- Output: 24 # sum of 21 + 3
-- Constraints:
-- 1. 1 <= len(arr) <= 100
-- 2. 1 <= k <= len(arr)... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_122_add_elements.py | verbatim |
main :: IO ()
main = do
let candidate = addElements
if candidate [1,(-2),(-3),41,57,76,87,88,99] 3 == (-4) then pure () else error "assertion failed"
if candidate [111,121,3,4000,5,6] 2 == 0 then pure () else error "assertion failed"
if candidate [11,21,3,90,5,6,7,8,9] 4 == 125 then pure () else error "asserti... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_123_get_odd_collatz | hs | -- | 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 is obtained from the
-- previous term as follows: if the prev... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_123_get_odd_collatz.py | verbatim |
main :: IO ()
main = do
let candidate = getOddCollatz
if candidate 14 == [1,5,7,11,13,17] then pure () else error "assertion failed"
if candidate 5 == [1,5] then pure () else error "assertion failed"
if candidate 12 == [1,3,5] then pure () else error "assertion failed"
if candidate 1 == [1] then pure () else... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_124_valid_date | hs | -- | 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 less than 1 or higher than 31 days for months 1,3,5,7,... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_124_valid_date.py | verbatim |
main :: IO ()
main = do
let candidate = validDate
if candidate "03-11-2000" == True then pure () else error "assertion failed"
if candidate "15-01-2012" == False then pure () else error "assertion failed"
if candidate "04-0-2040" == False then pure () else error "assertion failed"
if candidate "06-04-2020" =... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_126_is_sorted | hs | -- | Given a list of numbers, return whether or not they are sorted
-- in ascending order. If list has more than 1 duplicate of the same
-- number, return False. Assume no negative numbers and only integers.
-- Examples
-- is_sorted([5]) âžž True
-- is_sorted([1, 2, 3, 4, 5]) âžž True
-- is_sorted([1, 3, 2, 4, 5]... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_126_is_sorted.py | verbatim |
main :: IO ()
main = do
let candidate = isSorted
if candidate [5] == True then pure () else error "assertion failed"
if candidate [1,2,3,4,5] == True then pure () else error "assertion failed"
if candidate [1,3,2,4,5] == False then pure () else error "assertion failed"
if candidate [1,2,3,4,5,6] == True then... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_127_intersection | hs | -- | 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 interval, it is assumed that its start is less or equal its en... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_127_intersection.py | verbatim |
main :: IO ()
main = do
let candidate = intersection
if candidate (1, 2) (2, 3) == "NO" then pure () else error "assertion failed"
if candidate ((-1), 1) (0, 4) == "NO" then pure () else error "assertion failed"
if candidate ((-3), (-1)) ((-5), 5) == "YES" then pure () else error "assertion failed"
if candid... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_128_prod_signs | hs | -- | You are given an array arr of integers and you need to return
-- sum of magnitudes of integers multiplied by product of all signs
-- of each number in the array, represented by 1, -1 or 0.
-- Note: return None for empty arr.
-- Example:
-- >>> prod_signs([1, 2, 2, -4]) == -9
-- >>> prod_signs([0, 1]) == 0
--... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_128_prod_signs.py | verbatim |
main :: IO ()
main = do
let candidate = prodSigns
if candidate [1,2,2,(-4)] == Just ((-9)) then pure () else error "assertion failed"
if candidate [0,1] == Just (0) then pure () else error "assertion failed"
if candidate [1,1,1,2,3,(-1),1] == Just ((-10)) then pure () else error "assertion failed"
if candida... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_129_minPath | hs | -- | 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 length k in the grid. You can start
-- from any cell, a... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_129_minPath.py | verbatim |
main :: IO ()
main = do
let candidate = minpath
if candidate [[1,2,3],[4,5,6],[7,8,9]] 3 == [1,2,1] then pure () else error "assertion failed"
if candidate [[5,9,3],[4,1,6],[7,8,2]] 1 == [1] then pure () else error "assertion failed"
if candidate [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]] 4 == [1,2,1,2] ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_12_longest | hs | -- | Out of list of strings, return the longest one. Return the first one in case of multiple
-- strings of the same length. Return None in case the input list is empty.
-- >>> longest([])
-- >>> longest(['a', 'b', 'c'])
-- 'a'
-- >>> longest(['a', 'bb', 'ccc'])
-- 'ccc'
longest :: [String] -> Maybe String
longes... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_12_longest.py | verbatim |
main :: IO ()
main = do
let candidate = longest
if candidate [] == Just (Nothing) then pure () else error "assertion failed"
if candidate ["x","y","z"] == Just ("x") then pure () else error "assertion failed"
if candidate ["x","yyy","zzzz","www","kkkk","abc"] == Just ("zzzz") then pure () else error "assertion... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_130_tri | hs | -- | 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 even.
-- tri(n) = tri(n - 1) + tri(n - 2) + tr... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_130_tri.py | verbatim |
main :: IO ()
main = do
let candidate = tri
if candidate 3 == [1,3,2,8] then pure () else error "assertion failed"
if candidate 4 == [1,3,2,8,3] then pure () else error "assertion failed"
if candidate 5 == [1,3,2,8,3,15] then pure () else error "assertion failed"
if candidate 6 == [1,3,2,8,3,15,4] then pure ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_131_digits | hs | -- | 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
digits :: Int -> Int
digits n = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_131_digits.py | verbatim |
main :: IO ()
main = do
let candidate = digits
if candidate 5 == 5 then pure () else error "assertion failed"
if candidate 54 == 5 then pure () else error "assertion failed"
if candidate 120 == 1 then pure () else error "assertion failed"
if candidate 5014 == 5 then pure () else error "assertion failed"
if... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_132_is_nested | hs | -- | 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('[[]]') âžž True
-- is_nested('[]]]]]]][[[[[]') âžž False
-- ... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_132_is_nested.py | verbatim |
main :: IO ()
main = do
let candidate = isNested
if candidate "[[]]" == True then pure () else error "assertion failed"
if candidate "[]]]]]]][[[[[]" == False then pure () else error "assertion failed"
if candidate "[][]" == False then pure () else error "assertion failed"
if candidate "[]" == False then pur... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_133_sum_squares | hs | -- | You are given a list of numbers.
-- You need to return the sum of squared numbers in the given list,
-- round each element in the list to the upper int(Ceiling) first.
-- Examples:
-- For lst = [1,2,3] the output should be 14
-- For lst = [1,4,9] the output should be 98
-- For lst = [1,3,5,7] the output shou... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_133_sum_squares.py | verbatim |
main :: IO ()
main = do
let candidate = sumSquares
if candidate [1.0,2.0,3.0] == 14 then pure () else error "assertion failed"
if candidate [1.0,2.0,3.0] == 14 then pure () else error "assertion failed"
if candidate [1.0,3.0,5.0,7.0] == 84 then pure () else error "assertion failed"
if candidate [1.4,4.2,0.0]... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_134_check_if_last_char_is_a_letter | hs | -- | 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:
-- check_if_last_char_is_a_letter("apple pie") âžž False
-- check_if_last_... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_134_check_if_last_char_is_a_letter.py | verbatim |
main :: IO ()
main = do
let candidate = checkIfLastCharIsALetter
if candidate "apple" == False then pure () else error "assertion failed"
if candidate "apple pi e" == True then pure () else error "assertion failed"
if candidate "eeeee" == False then pure () else error "assertion failed"
if candidate "A" == T... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_135_can_arrange | hs | -- | 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:
-- can_arrange([1,2,4,3,5]) = 3
-- can_arrange([1,2,3]... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_135_can_arrange.py | verbatim |
main :: IO ()
main = do
let candidate = canArrange
if candidate [1,2,4,3,5] == 3 then pure () else error "assertion failed"
if candidate [1,2,4,5] == (-1) then pure () else error "assertion failed"
if candidate [1,4,2,5,6,7,8,9,10] == 2 then pure () else error "assertion failed"
if candidate [4,8,5,7,3] == 4... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_136_largest_smallest_integers | hs | -- | 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:
-- largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
-- large... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_136_largest_smallest_integers.py | verbatim |
main :: IO ()
main = do
let candidate = largestSmallestIntegers
if candidate [2,4,1,3,5,7] == (Nothing, 1) then pure () else error "assertion failed"
if candidate [2,4,1,3,5,7,0] == (Nothing, 1) then pure () else error "assertion failed"
if candidate [1,3,2,4,5,6,(-2)] == ((-2), 1) then pure () else error "ass... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_138_is_equal_to_sum_even | hs | -- | 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
isEqualToSumEven :: Int -> Bool
isEqualToSumEven n = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_138_is_equal_to_sum_even.py | verbatim |
main :: IO ()
main = do
let candidate = isEqualToSumEven
if candidate 4 == False then pure () else error "assertion failed"
if candidate 6 == False then pure () else error "assertion failed"
if candidate 8 == True then pure () else error "assertion failed"
if candidate 10 == True then pure () else error "ass... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_139_special_factorial | hs | -- | 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
-- factorial of this integer.
specialFactorial :: Int -> Int
spe... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_139_special_factorial.py | verbatim |
main :: IO ()
main = do
let candidate = specialFactorial
if candidate 4 == 288 then pure () else error "assertion failed"
if candidate 5 == 34560 then pure () else error "assertion failed"
if candidate 7 == 125411328000 then pure () else error "assertion failed"
if candidate 1 == 1 then pure () else error "a... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_13_greatest_common_divisor | hs | -- | Return a greatest common divisor of two integers a and b
-- >>> greatest_common_divisor(3, 5)
-- 1
-- >>> greatest_common_divisor(25, 15)
-- 5
greatestCommonDivisor :: Int -> Int -> Int
greatestCommonDivisor a b = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_13_greatest_common_divisor.py | verbatim |
main :: IO ()
main = do
let candidate = greatestCommonDivisor
if candidate 3 7 == 1 then pure () else error "assertion failed"
if candidate 10 15 == 5 then pure () else error "assertion failed"
if candidate 49 14 == 7 then pure () else error "assertion failed"
if candidate 144 60 == 12 then pure () else erro... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_140_fix_spaces | hs | -- | Given a string text, replace all spaces in it with underscores,
-- and if a string has more than 2 consecutive spaces,
-- then replace all consecutive spaces with -
-- fix_spaces("Example") == "Example"
-- fix_spaces("Example 1") == "Example_1"
-- fix_spaces(" Example 2") == "_Example_2"
-- fix_spaces(" E... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_140_fix_spaces.py | verbatim |
main :: IO ()
main = do
let candidate = fixSpaces
if candidate "Example" == "Example" then pure () else error "assertion failed"
if candidate "Mudasir Hanif " == "Mudasir_Hanif_" then pure () else error "assertion failed"
if candidate "Yellow Yellow Dirty Fellow" == "Yellow_Yellow__Dirty__Fellow" then pure (... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_141_file_name_check | hs | -- | 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:
-- - There should not be more than three digits ('0'-'9') in t... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_141_file_name_check.py | verbatim |
main :: IO ()
main = do
let candidate = fileNameCheck
if candidate "example.txt" == "Yes" then pure () else error "assertion failed"
if candidate "1example.dll" == "No" then pure () else error "assertion failed"
if candidate "s1sdf3.asd" == "No" then pure () else error "assertion failed"
if candidate "K.dll"... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_142_sum_squares | hs | -- | "
-- 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 function will not
-- change the entries in the list whose in... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_142_sum_squares.py | verbatim |
main :: IO ()
main = do
let candidate = sumSquares
if candidate [1,2,3] == 6 then pure () else error "assertion failed"
if candidate [1,4,9] == 14 then pure () else error "assertion failed"
if candidate [] == 0 then pure () else error "assertion failed"
if candidate [1,1,1,1,1,1,1,1,1] == 9 then pure () else... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_143_words_in_sentence | hs | -- | 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 words in the new string should be the same as the original one... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_143_words_in_sentence.py | verbatim |
main :: IO ()
main = do
let candidate = wordsInSentence
if candidate "This is a test" == "is" then pure () else error "assertion failed"
if candidate "lets go for swimming" == "go for" then pure () else error "assertion failed"
if candidate "there is no place available here" == "there is no place" then pure ()... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_144_simplify | hs | -- | 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,
-- <numerator>/<denominator> where both numerator and deno... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_144_simplify.py | verbatim |
main :: IO ()
main = do
let candidate = simplify
if candidate "1/5" "5/1" == True then pure () else error "assertion failed"
if candidate "1/6" "2/1" == False then pure () else error "assertion failed"
if candidate "5/1" "3/1" == True then pure () else error "assertion failed"
if candidate "7/10" "10/2" == F... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_145_order_by_points | hs | -- | 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 example:
-- >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_145_order_by_points.py | verbatim |
main :: IO ()
main = do
let candidate = orderByPoints
if candidate [1,11,(-1),(-11),(-12)] == [(-1),(-11),1,(-12),11] then pure () else error "assertion failed"
if candidate [1234,423,463,145,2,423,423,53,6,37,3457,3,56,0,46] == [0,2,3,6,53,423,423,423,1234,145,37,46,56,463,3457] then pure () else error "asserti... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_146_specialFilter | hs | -- | Write a function that takes an array of numbers as input and returns
-- the number of elements in the array that are greater than 10 and both
-- first and last digits of a number are odd (1, 3, 5, 7, 9).
-- For example:
-- specialFilter([15, -73, 14, -15]) => 1
-- specialFilter([33, -2, -3, 45, 21, 109]) =... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_146_specialFilter.py | verbatim |
main :: IO ()
main = do
let candidate = specialfilter
if candidate [5,(-2),1,(-5)] == 0 then pure () else error "assertion failed"
if candidate [15,(-73),14,(-15)] == 1 then pure () else error "assertion failed"
if candidate [33,(-2),(-3),45,21,109] == 2 then pure () else error "assertion failed"
if candidat... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_147_get_max_triples | hs | -- | 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 a multiple of 3.
-- Example :
-- Input: n = 5
-- Outp... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_147_get_max_triples.py | verbatim |
main :: IO ()
main = do
let candidate = getMaxTriples
if candidate 5 == 1 then pure () else error "assertion failed"
if candidate 6 == 4 then pure () else error "assertion failed"
if candidate 10 == 36 then pure () else error "assertion failed"
if candidate 100 == 53361 then pure () else error "assertion fai... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_149_sorted_list_sum | hs | -- | 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 it may contain duplicates.
-- The order of the list should b... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_149_sorted_list_sum.py | verbatim |
main :: IO ()
main = do
let candidate = sortedListSum
if candidate ["aa","a","aaa"] == ["aa"] then pure () else error "assertion failed"
if candidate ["school","AI","asdf","b"] == ["AI","asdf","school"] then pure () else error "assertion failed"
if candidate ["d","b","c","a"] == [] then pure () else error "ass... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_14_all_prefixes | hs | -- | Return list of all prefixes from shortest to longest of the input string
-- >>> all_prefixes('abc')
-- ['a', 'ab', 'abc']
allPrefixes :: String -> [String]
allPrefixes string = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_14_all_prefixes.py | verbatim |
main :: IO ()
main = do
let candidate = allPrefixes
if candidate "" == [] then pure () else error "assertion failed"
if candidate "asdfgh" == ["a","as","asd","asdf","asdfg","asdfgh"] then pure () else error "assertion failed"
if candidate "WWW" == ["W","WW","WWW"] then pure () else error "assertion failed"
p... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_150_x_or_y | hs | -- | A simple program which should return the value of x if n is
-- a prime number and should return the value of y otherwise.
-- Examples:
-- for x_or_y(7, 34, 12) == 34
-- for x_or_y(15, 8, 5) == 5
xOrY :: Int -> Int -> Int -> Int
xOrY n x y = | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_150_x_or_y.py | verbatim |
main :: IO ()
main = do
let candidate = xOrY
if candidate 7 34 12 == 34 then pure () else error "assertion failed"
if candidate 15 8 5 == 5 then pure () else error "assertion failed"
if candidate 3 33 5212 == 33 then pure () else error "assertion failed"
if candidate 1259 3 52 == 3 then pure () else error "a... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_151_double_the_difference | hs | -- | Given a list of numbers, return the sum of squares of the numbers
-- in the list that are odd. Ignore numbers that are negative or not integers.
-- double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
-- double_the_difference([-1, -2, 0]) == 0
-- double_the_difference([9, -2]) == 81
-- double_the_differe... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_151_double_the_difference.py | verbatim |
main :: IO ()
main = do
let candidate = doubleTheDifference
if candidate [.0] == 0 then pure () else error "assertion failed"
if candidate [5.0,4.0] == 25 then pure () else error "assertion failed"
if candidate [0.1,0.2,0.3] == 0 then pure () else error "assertion failed"
if candidate [-10.0,-20.0,-30.0] == ... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
HumanEval_152_compare | hs | -- | 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 guessed the results of a number of matches.
-- You are giv... | keep | C:\Users\Thomas\PycharmProjects\MultiPL-E\datasets\..\datasets\originals\HumanEval_152_compare.py | verbatim |
main :: IO ()
main = do
let candidate = compare
if candidate [1,2,3,4,5,1] [1,2,3,4,2,(-2)] == [0,0,0,0,3,3] then pure () else error "assertion failed"
if candidate [0,0,0,0,0,0] [0,0,0,0,0,0] == [0,0,0,0,0,0] then pure () else error "assertion failed"
if candidate [1,2,3] [(-1),(-2),(-3)] == [2,4,6] then pure... | [
"\n\n",
"\n{-",
"\n-- |",
"\n--",
"\ntype",
"\ndata",
"\nnewtype"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.