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_36_fizz_buzz | js | //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
function fizz_buzz(n){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_36_fizz_buzz.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = fizz_buzz;
assert.deepEqual(candidate(50),0);
assert.deepEqual(candidate(78),2);
assert.deepEqual(candidate(79),3);
assert.deepEqual(candidate(100),3);
assert.deepEqual(candidate(200),6);
assert.deepEqual(candidate(4000),192);
as... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_37_sort_even | js | //This function takes a list l and returns a list l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// >>> sort_even([1, 2, 3])
// [1, 2, 3]
// >>> sort_even([5, 6, 3, 4])
// [3, 6, 5, 4]
function sort_even(l... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_37_sort_even.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = sort_even;
assert.deepEqual(candidate([1, 2, 3]),[1, 2, 3]);
assert.deepEqual(candidate([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]),[-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123]);
assert.deepEqual(candidate([5, 8, -12, 4, 23, 2, 3, 11, 12, -10]),... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_39_prime_fib | js | //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
function prime_fib(n){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_39_prime_fib.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = prime_fib;
assert.deepEqual(candidate(1),2);
assert.deepEqual(candidate(2),3);
assert.deepEqual(candidate(3),5);
assert.deepEqual(candidate(4),13);
assert.deepEqual(candidate(5),89);
assert.deepEqual(candidate(6),233);
assert.dee... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_3_below_zero | js | //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 should return False.
// >>> below_zero([1, 2, 3])
// false
// >>>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_3_below_zero.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = below_zero;
assert.deepEqual(candidate([]),false);
assert.deepEqual(candidate([1, 2, -3, 1, 2, -3]),false);
assert.deepEqual(candidate([1, 2, -4, 5, 6]),true);
assert.deepEqual(candidate([1, -1, 2, -2, 5, -5, 4, -4]),false);
assert.d... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_40_triples_sum_to_zero | js | //triples_sum_to_zero takes a list of integers as an input.
// it returns True if there are three distinct elements in the list that
// sum to zero, and False otherwise.
// >>> triples_sum_to_zero([1, 3, 5, 0])
// false
// >>> triples_sum_to_zero([1, 3, -2, 1])
// true
// >>> triples_sum_to_zero([1, 2, 3, 7])
// false
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_40_triples_sum_to_zero.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = triples_sum_to_zero;
assert.deepEqual(candidate([1, 3, 5, 0]),false);
assert.deepEqual(candidate([1, 3, 5, -1]),false);
assert.deepEqual(candidate([1, 3, -2, 1]),true);
assert.deepEqual(candidate([1, 2, 3, 7]),false);
assert.deepEqua... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_41_car_race_collision | js | //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 cars move in the same speed. Two cars are said to collide
// when a c... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_41_car_race_collision.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = car_race_collision;
assert.deepEqual(candidate(2),4);
assert.deepEqual(candidate(3),9);
assert.deepEqual(candidate(4),16);
assert.deepEqual(candidate(8),64);
assert.deepEqual(candidate(10),100);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_42_incr_list | js | //Return list with elements incremented by 1.
// >>> incr_list([1, 2, 3])
// [2, 3, 4]
// >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
// [6, 4, 6, 3, 4, 4, 10, 1, 124]
function incr_list(l){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_42_incr_list.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = incr_list;
assert.deepEqual(candidate([]),[]);
assert.deepEqual(candidate([3, 2, 1]),[4, 3, 2]);
assert.deepEqual(candidate([5, 2, 5, 2, 3, 3, 9, 0, 123]),[6, 3, 6, 3, 4, 4, 10, 1, 124]);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_43_pairs_sum_to_zero | js | //pairs_sum_to_zero takes a list of integers as an input.
// it returns True if there are two distinct elements in the list that
// sum to zero, and False otherwise.
// >>> pairs_sum_to_zero([1, 3, 5, 0])
// false
// >>> pairs_sum_to_zero([1, 3, -2, 1])
// false
// >>> pairs_sum_to_zero([1, 2, 3, 7])
// false
// >>> pa... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_43_pairs_sum_to_zero.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = pairs_sum_to_zero;
assert.deepEqual(candidate([1, 3, 5, 0]),false);
assert.deepEqual(candidate([1, 3, -2, 1]),false);
assert.deepEqual(candidate([1, 2, 3, 7]),false);
assert.deepEqual(candidate([2, 4, -5, 3, 5, 7]),true);
assert.deep... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_44_change_base | js | //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"
function change_base(x, base){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_44_change_base.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = change_base;
assert.deepEqual(candidate(8, 3),"22");
assert.deepEqual(candidate(9, 3),"100");
assert.deepEqual(candidate(234, 2),"11101010");
assert.deepEqual(candidate(16, 2),"10000");
assert.deepEqual(candidate(8, 2),"1000");
ass... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_45_triangle_area | js | //Given length of a side and high return area for a triangle.
// >>> triangle_area(5, 3)
// 7.5
function triangle_area(a, h){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_45_triangle_area.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = triangle_area;
assert.deepEqual(candidate(5, 3),7.5);
assert.deepEqual(candidate(2, 2),2.0);
assert.deepEqual(candidate(10, 8),40.0);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_46_fib4 | js | //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 efficiently compute the n-th element of the fib4 number sequen... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_46_fib4.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = fib4;
assert.deepEqual(candidate(5),4);
assert.deepEqual(candidate(8),28);
assert.deepEqual(candidate(10),104);
assert.deepEqual(candidate(12),386);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_47_median | js | //Return median of elements in the list l.
// >>> median([3, 1, 2, 4, 5])
// 3
// >>> median([-10, 4, 6, 1000, 10, 20])
// 15.0
function median(l){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_47_median.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = median;
assert.deepEqual(candidate([3, 1, 2, 4, 5]),3);
assert.deepEqual(candidate([-10, 4, 6, 1000, 10, 20]),8.0);
assert.deepEqual(candidate([5]),5);
assert.deepEqual(candidate([6, 5]),5.5);
assert.deepEqual(candidate([8, 1, 3, 9, ... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_48_is_palindrome | js | //Checks if given string is a palindrome
// >>> is_palindrome("")
// true
// >>> is_palindrome("aba")
// true
// >>> is_palindrome("aaaaa")
// true
// >>> is_palindrome("zbcd")
// false
function is_palindrome(text){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_48_is_palindrome.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = is_palindrome;
assert.deepEqual(candidate(""),true);
assert.deepEqual(candidate("aba"),true);
assert.deepEqual(candidate("aaaaa"),true);
assert.deepEqual(candidate("zbcd"),false);
assert.deepEqual(candidate("xywyx"),true);
assert.d... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_49_modp | js | //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
function modp(n, p){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_49_modp.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = modp;
assert.deepEqual(candidate(3, 5),3);
assert.deepEqual(candidate(1101, 101),2);
assert.deepEqual(candidate(0, 101),1);
assert.deepEqual(candidate(3, 11),8);
assert.deepEqual(candidate(100, 101),1);
assert.deepEqual(candidate(3... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_4_mean_absolute_deviation | js | //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 = average | x - x_mean |
// >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
// ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_4_mean_absolute_deviation.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = mean_absolute_deviation;
assert.deepEqual(candidate([1.0, 2.0]),0.5);
assert.deepEqual(candidate([1.0, 2.0, 3.0, 4.0]),1.0);
assert.deepEqual(candidate([1.0, 2.0, 3.0, 4.0, 5.0]),1.2);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_51_remove_vowels | js | //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")
// "zbcd"
function remove_vowels(text){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_51_remove_vowels.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = remove_vowels;
assert.deepEqual(candidate(""),"");
assert.deepEqual(candidate("abcdef
ghijklm"),"bcdf
ghjklm");
assert.deepEqual(candidate("fedcba"),"fdcb");
assert.deepEqual(candidate("eeeee"),"");
assert.deepEqual(candidate("acBAA"... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_52_below_threshold | js | //Return True if all numbers in the list l are below threshold t.
// >>> below_threshold([1, 2, 4, 10], 100)
// true
// >>> below_threshold([1, 20, 4, 10], 5)
// false
function below_threshold(l, t){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_52_below_threshold.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = below_threshold;
assert.deepEqual(candidate([1, 2, 4, 10], 100),true);
assert.deepEqual(candidate([1, 20, 4, 10], 5),false);
assert.deepEqual(candidate([1, 20, 4, 10], 21),true);
assert.deepEqual(candidate([1, 20, 4, 10], 22),true);
... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_53_add | js | //Add two numbers x and y
// >>> add(2, 3)
// 5
// >>> add(5, 7)
// 12
function add(x, y){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_53_add.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = add;
assert.deepEqual(candidate(0, 1),1);
assert.deepEqual(candidate(1, 0),1);
assert.deepEqual(candidate(2, 3),5);
assert.deepEqual(candidate(5, 7),12);
assert.deepEqual(candidate(7, 5),12);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_54_same_chars | js | //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
// >>> same_chars("abcd", "dddddddabce")
// false
// >>> same_char... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_54_same_chars.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = same_chars;
assert.deepEqual(candidate("eabcdzzzz", "dddzzzzzzzddeddabc"),true);
assert.deepEqual(candidate("abcd", "dddddddabc"),true);
assert.deepEqual(candidate("dddddddabc", "abcd"),true);
assert.deepEqual(candidate("eabcd", "ddddd... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_55_fib | js | //Return n-th Fibonacci number.
// >>> fib(10)
// 55
// >>> fib(1)
// 1
// >>> fib(8)
// 21
function fib(n){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_55_fib.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = fib;
assert.deepEqual(candidate(10),55);
assert.deepEqual(candidate(1),1);
assert.deepEqual(candidate(8),21);
assert.deepEqual(candidate(11),89);
assert.deepEqual(candidate(12),144);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_56_correct_bracketing | js | //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
// >>> correct_bracketing("><<>")
// false
function correct_bracketing(brackets)... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_56_correct_bracketing.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = correct_bracketing;
assert.deepEqual(candidate("<>"),true);
assert.deepEqual(candidate("<<><>>"),true);
assert.deepEqual(candidate("<><><<><>><>"),true);
assert.deepEqual(candidate("<><><<<><><>><>><<><><<>>>"),true);
assert.deepEqua... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_57_monotonic | js | //Return True is list elements are monotonically increasing or decreasing.
// >>> monotonic([1, 2, 4, 20])
// true
// >>> monotonic([1, 20, 4, 10])
// false
// >>> monotonic([4, 1, 0, -10])
// true
function monotonic(l){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_57_monotonic.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = monotonic;
assert.deepEqual(candidate([1, 2, 4, 10]),true);
assert.deepEqual(candidate([1, 2, 4, 20]),true);
assert.deepEqual(candidate([1, 20, 4, 10]),false);
assert.deepEqual(candidate([4, 1, 0, -10]),true);
assert.deepEqual(candid... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_58_common | js | //Return sorted unique common elements for two lists.
// >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
// [1, 5, 653]
// >>> common([5, 3, 2, 8], [3, 2])
// [2, 3]
function common(l1, l2){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_58_common.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = common;
assert.deepEqual(candidate([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121]),[1, 5, 653]);
assert.deepEqual(candidate([5, 3, 2, 8], [3, 2]),[2, 3]);
assert.deepEqual(candidate([4, 3, 2, 8], [3, 2, 4]),[2, 3, 4]);
assert.deep... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_59_largest_prime_factor | js | //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
function largest_prime_factor(n){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_59_largest_prime_factor.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = largest_prime_factor;
assert.deepEqual(candidate(15),5);
assert.deepEqual(candidate(27),3);
assert.deepEqual(candidate(63),7);
assert.deepEqual(candidate(330),11);
assert.deepEqual(candidate(13195),29);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_5_intersperse | js | //Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
// >>> intersperse([], 4)
// []
// >>> intersperse([1, 2, 3], 4)
// [1, 4, 2, 4, 3]
function intersperse(numbers, delimeter){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_5_intersperse.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = intersperse;
assert.deepEqual(candidate([], 7),[]);
assert.deepEqual(candidate([5, 6, 3, 2], 8),[5, 8, 6, 8, 3, 8, 2]);
assert.deepEqual(candidate([2, 2, 2], 2),[2, 2, 2, 2, 2]);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_60_sum_to_n | js | //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
function sum_to_n(n){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_60_sum_to_n.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = sum_to_n;
assert.deepEqual(candidate(1),1);
assert.deepEqual(candidate(6),21);
assert.deepEqual(candidate(11),66);
assert.deepEqual(candidate(30),465);
assert.deepEqual(candidate(100),5050);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_61_correct_bracketing | js | //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
// >>> correct_bracketing(")(()")
// false
function correct_bracketing(brackets)... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_61_correct_bracketing.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = correct_bracketing;
assert.deepEqual(candidate("()"),true);
assert.deepEqual(candidate("(()())"),true);
assert.deepEqual(candidate("()()(()())()"),true);
assert.deepEqual(candidate("()()((()()())())(()()(()))"),true);
assert.deepEqua... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_62_derivative | js | //xs represent coefficients of a polynomial.
// xs[0] + xs[1] * x + xs[2] * x^2 + ....
// Return derivative of this polynomial in the same form.
// >>> derivative([3, 1, 2, 4, 5])
// [1, 4, 12, 20]
// >>> derivative([1, 2, 3])
// [2, 6]
function derivative(xs){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_62_derivative.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = derivative;
assert.deepEqual(candidate([3, 1, 2, 4, 5]),[1, 4, 12, 20]);
assert.deepEqual(candidate([1, 2, 3]),[2, 6]);
assert.deepEqual(candidate([3, 2, 1]),[2, 2]);
assert.deepEqual(candidate([3, 2, 1, 0, 4]),[2, 2, 0, 16]);
assert... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_63_fibfib | js | //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 compute the n-th element of the fibfib number sequence.
// >>>... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_63_fibfib.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = fibfib;
assert.deepEqual(candidate(2),1);
assert.deepEqual(candidate(1),0);
assert.deepEqual(candidate(5),4);
assert.deepEqual(candidate(8),24);
assert.deepEqual(candidate(10),81);
assert.deepEqual(candidate(12),274);
assert.deep... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_64_vowels_count | js | //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 given word.
// Example:
// >>> vowels_count("abcde")
// 2
// >>> vo... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_64_vowels_count.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = vowels_count;
assert.deepEqual(candidate("abcde"),2);
assert.deepEqual(candidate("Alone"),3);
assert.deepEqual(candidate("key"),2);
assert.deepEqual(candidate("bye"),1);
assert.deepEqual(candidate("keY"),2);
assert.deepEqual(candid... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_65_circular_shift | js | //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"
function circular_shift(x, shift){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_65_circular_shift.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = circular_shift;
assert.deepEqual(candidate(100, 2),"001");
assert.deepEqual(candidate(12, 2),"12");
assert.deepEqual(candidate(97, 8),"79");
assert.deepEqual(candidate(12, 1),"21");
assert.deepEqual(candidate(11, 101),"11");
}
test(... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_66_digitSum | js | //Task
// Write a function that takes a string as input and returns the sum of the upper characters only'
// ASCII codes.
// Examples:
// >>> digitSum("")
// 0
// >>> digitSum("abAB")
// 131
// >>> digitSum("abcCd")
// 67
// >>> digitSum("helloE")
// 69
// >>> digitSum("woArBld")
// 131
// >>> digitSum("aAaaaXa")
// 15... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_66_digitSum.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = digitSum;
assert.deepEqual(candidate(""),0);
assert.deepEqual(candidate("abAB"),131);
assert.deepEqual(candidate("abcCd"),67);
assert.deepEqual(candidate("helloE"),69);
assert.deepEqual(candidate("woArBld"),131);
assert.deepEqual(c... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_67_fruit_distribution | js | //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
// the oranges and apples and an integer that represent the total numb... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_67_fruit_distribution.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = fruit_distribution;
assert.deepEqual(candidate("5 apples and 6 oranges", 19),8);
assert.deepEqual(candidate("5 apples and 6 oranges", 21),10);
assert.deepEqual(candidate("0 apples and 1 oranges", 3),2);
assert.deepEqual(candidate("1 ap... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_68_pluck | js | //"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 value are found return the node that has smallest index.
//... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_68_pluck.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = pluck;
assert.deepEqual(candidate([4, 2, 3]),[2, 1]);
assert.deepEqual(candidate([1, 2, 3]),[2, 1]);
assert.deepEqual(candidate([]),[]);
assert.deepEqual(candidate([5, 0, 3, 0, 4, 2]),[0, 1]);
assert.deepEqual(candidate([1, 2, 3, 0, ... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_69_search | js | //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 the list.
// If no such a value exist, return -1.
// Exampl... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_69_search.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = search;
assert.deepEqual(candidate([5, 5, 5, 5, 1]),1);
assert.deepEqual(candidate([4, 1, 4, 1, 4, 4]),4);
assert.deepEqual(candidate([3, 3]),-1);
assert.deepEqual(candidate([8, 8, 8, 8, 8, 8, 8, 8]),8);
assert.deepEqual(candidate([2... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_6_parse_nested_parens | js | //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 ((())) has three.
// >>> parse_nested_parens("(()()) ((())) () ((())()())")
//... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_6_parse_nested_parens.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = parse_nested_parens;
assert.deepEqual(candidate("(()()) ((())) () ((())()())"),[2, 3, 1, 3]);
assert.deepEqual(candidate("() (()) ((())) (((())))"),[1, 2, 3, 4]);
assert.deepEqual(candidate("(()(())((())))"),[4]);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_70_strange_sort_list | js | //Given list of integers, return list in strange order.
// Strange sorting, is when you start with the minimum value,
// then maximum of the remaining integers, then minimum and so on.
// Examples:
// >>> strange_sort_list([1, 2, 3, 4])
// [1, 4, 2, 3]
// >>> strange_sort_list([5, 5, 5, 5])
// [5, 5, 5, 5]
// >>> stran... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_70_strange_sort_list.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = strange_sort_list;
assert.deepEqual(candidate([1, 2, 3, 4]),[1, 4, 2, 3]);
assert.deepEqual(candidate([5, 6, 7, 8, 9]),[5, 9, 6, 8, 7]);
assert.deepEqual(candidate([1, 2, 3, 4, 5]),[1, 5, 2, 4, 3]);
assert.deepEqual(candidate([5, 6, 7,... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_71_triangle_area | js | //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 greater
// than the third side.
// Example:
// >>> triangle_area(3... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_71_triangle_area.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = triangle_area;
assert.deepEqual(candidate(3, 4, 5),6.0);
assert.deepEqual(candidate(1, 2, 10),-1);
assert.deepEqual(candidate(4, 8, 5),8.18);
assert.deepEqual(candidate(2, 2, 2),1.73);
assert.deepEqual(candidate(1, 2, 3),-1);
asser... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_72_will_it_fly | js | //Write a function that returns True if the object q will fly, and False otherwise.
// The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.
// Example:
// >>> will_it_fly([1, 2], 5)
// false
// # 1+2 is less than the maximum p... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_72_will_it_fly.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = will_it_fly;
assert.deepEqual(candidate([3, 2, 3], 9),true);
assert.deepEqual(candidate([1, 2], 5),false);
assert.deepEqual(candidate([3], 5),true);
assert.deepEqual(candidate([3, 2, 3], 1),false);
assert.deepEqual(candidate([1, 2, 3... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_73_smallest_change | js | //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 any other element.
// For example:
// >>> smallest_change([1, 2, 3... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_73_smallest_change.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = smallest_change;
assert.deepEqual(candidate([1, 2, 3, 5, 4, 7, 9, 6]),4);
assert.deepEqual(candidate([1, 2, 3, 4, 3, 2, 2]),1);
assert.deepEqual(candidate([1, 4, 2]),1);
assert.deepEqual(candidate([1, 4, 4, 2]),1);
assert.deepEqual(c... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_74_total_match | js | //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
// >>> total_match([], [])
// []
// >>> total_match(["hi", "admin"],... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_74_total_match.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = total_match;
assert.deepEqual(candidate([], []),[]);
assert.deepEqual(candidate(["hi", "admin"], ["hi", "hi"]),["hi", "hi"]);
assert.deepEqual(candidate(["hi", "admin"], ["hi", "hi", "admin", "project"]),["hi", "admin"]);
assert.deepEq... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_75_is_multiply_prime | js | //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
function is_multiply_prime(a){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_75_is_multiply_prime.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = is_multiply_prime;
assert.deepEqual(candidate(5),false);
assert.deepEqual(candidate(30),true);
assert.deepEqual(candidate(8),true);
assert.deepEqual(candidate(10),false);
assert.deepEqual(candidate(125),true);
assert.deepEqual(cand... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_76_is_simple_power | js | //Your task is to write a function that returns true if a number x is a simple
// power of n and false in other cases.
// x is a simple power of n if n**int=x
// For example:
// >>> is_simple_power(1, 4)
// true
// >>> is_simple_power(2, 2)
// true
// >>> is_simple_power(8, 2)
// true
// >>> is_simple_power(3, 2)
// fa... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_76_is_simple_power.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = is_simple_power;
assert.deepEqual(candidate(16, 2),true);
assert.deepEqual(candidate(143214, 16),false);
assert.deepEqual(candidate(4, 2),true);
assert.deepEqual(candidate(9, 3),true);
assert.deepEqual(candidate(16, 4),true);
asser... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_77_iscube | js | //Write a function that takes an integer a and returns True
// if this ingeger is a cube of some integer number.
// Note: you may assume the input is always valid.
// Examples:
// >>> iscube(1)
// true
// >>> iscube(2)
// false
// >>> iscube(-1)
// true
// >>> iscube(64)
// true
// >>> iscube(0)
// true
// >>> iscube(... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_77_iscube.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = iscube;
assert.deepEqual(candidate(1),true);
assert.deepEqual(candidate(2),false);
assert.deepEqual(candidate(-1),true);
assert.deepEqual(candidate(64),true);
assert.deepEqual(candidate(180),false);
assert.deepEqual(candidate(1000)... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_78_hex_key | js | //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 natural numbers).
// Hexadecimal digits are 0, 1, 2, 3, 4, ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_78_hex_key.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = hex_key;
assert.deepEqual(candidate("AB"),1);
assert.deepEqual(candidate("1077E"),2);
assert.deepEqual(candidate("ABED1A33"),4);
assert.deepEqual(candidate("2020"),2);
assert.deepEqual(candidate("123456789ABCDEF0"),6);
assert.deepE... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_79_decimal_to_binary | js | //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 be an extra couple of characters 'db' at the beginning and at the end ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_79_decimal_to_binary.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = decimal_to_binary;
assert.deepEqual(candidate(0),"db0db");
assert.deepEqual(candidate(32),"db100000db");
assert.deepEqual(candidate(103),"db1100111db");
assert.deepEqual(candidate(15),"db1111db");
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_7_filter_by_substring | js | //Filter an input list of strings only for ones that contain given substring
// >>> filter_by_substring([], "a")
// []
// >>> filter_by_substring(["abc", "bacd", "cde", "array"], "a")
// ["abc", "bacd", "array"]
function filter_by_substring(strings, substring){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_7_filter_by_substring.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = filter_by_substring;
assert.deepEqual(candidate([], "john"),[]);
assert.deepEqual(candidate(["xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"], "xxx"),["xxx", "xxxAAA", "xxx"]);
assert.deepEqual(candidate(["xxx", "asd", "aaaxxy", "john d... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_80_is_happy | js | //You are given a string s.
// Your task is to check if the string is happy or not.
// A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
// For example:
// >>> is_happy("a")
// false
// >>> is_happy("aa")
// false
// >>> is_happy("abcd")
// true
// >>> is_happy("aabb")
// false
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_80_is_happy.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = is_happy;
assert.deepEqual(candidate("a"),false);
assert.deepEqual(candidate("aa"),false);
assert.deepEqual(candidate("abcd"),true);
assert.deepEqual(candidate("aabb"),false);
assert.deepEqual(candidate("adb"),true);
assert.deepEqu... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_81_numerical_letter_grade | js | //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 list of GPAs for some students and you have to write
// a function that can ... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_81_numerical_letter_grade.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = numerical_letter_grade;
assert.deepEqual(candidate([4.0, 3, 1.7, 2, 3.5]),["A+", "B", "C-", "C", "A-"]);
assert.deepEqual(candidate([1.2]),["D+"]);
assert.deepEqual(candidate([0.5]),["D-"]);
assert.deepEqual(candidate([0.0]),["E"]);
... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_82_prime_length | js | //Write a function that takes a string and returns True if the string
// length is a prime number or False otherwise
// Examples
// >>> prime_length("Hello")
// true
// >>> prime_length("abcdcba")
// true
// >>> prime_length("kittens")
// true
// >>> prime_length("orange")
// false
function prime_length(string){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_82_prime_length.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = prime_length;
assert.deepEqual(candidate("Hello"),true);
assert.deepEqual(candidate("abcdcba"),true);
assert.deepEqual(candidate("kittens"),true);
assert.deepEqual(candidate("orange"),false);
assert.deepEqual(candidate("wow"),true);
... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_83_starts_one_ends | js | //Given a positive integer n, return the count of the numbers of n-digit
// positive integers that start or end with 1.
function starts_one_ends(n){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_83_starts_one_ends.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = starts_one_ends;
assert.deepEqual(candidate(1),1);
assert.deepEqual(candidate(2),18);
assert.deepEqual(candidate(3),180);
assert.deepEqual(candidate(4),1800);
assert.deepEqual(candidate(5),18000);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_84_solve | js | //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 number
function solve(N){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_84_solve.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = solve;
assert.deepEqual(candidate(1000),"1");
assert.deepEqual(candidate(150),"110");
assert.deepEqual(candidate(147),"1100");
assert.deepEqual(candidate(333),"1001");
assert.deepEqual(candidate(963),"10010");
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_85_add | js | //Given a non-empty list of integers lst. add the even elements that are at odd indices..
// Examples:
// >>> add([4, 2, 6, 7])
// 2
function add(lst){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_85_add.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = add;
assert.deepEqual(candidate([4, 88]),88);
assert.deepEqual(candidate([4, 5, 6, 7, 2, 122]),122);
assert.deepEqual(candidate([4, 0, 6, 7]),0);
assert.deepEqual(candidate([4, 4, 6, 8]),12);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_86_anti_shuffle | js | //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 value.
// Note: You should keep the order of words and blank sp... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_86_anti_shuffle.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = anti_shuffle;
assert.deepEqual(candidate("Hi"),"Hi");
assert.deepEqual(candidate("hello"),"ehllo");
assert.deepEqual(candidate("number"),"bemnru");
assert.deepEqual(candidate("abcd"),"abcd");
assert.deepEqual(candidate("Hello World!!... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_87_get_row | js | //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, y1), (x2, y2) ...] such that
// each tuple is a coordinat... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_87_get_row.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = get_row;
assert.deepEqual(candidate([[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 1, 6], [1, 2, 3, 4, 5, 1]], 1),[[0, 0], [1, 4], [1, 0], [2, 5], [2, 0]]);
assert.deepEqual(candidate([[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [1, 2, ... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_88_sort_array | js | //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 value, last index value) is even.
// Note:
// * don't change t... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_88_sort_array.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = sort_array;
assert.deepEqual(candidate([]),[]);
assert.deepEqual(candidate([5]),[5]);
assert.deepEqual(candidate([2, 4, 3, 0, 1, 5]),[0, 1, 2, 3, 4, 5]);
assert.deepEqual(candidate([2, 4, 3, 0, 1, 5, 6]),[6, 5, 4, 3, 2, 1, 0]);
asser... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_89_encrypt | js | //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:
// >>> encrypt("hi")
// "lm"
// >>> encrypt("asdfghjkl")
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_89_encrypt.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = encrypt;
assert.deepEqual(candidate("hi"),"lm");
assert.deepEqual(candidate("asdfghjkl"),"ewhjklnop");
assert.deepEqual(candidate("gf"),"kj");
assert.deepEqual(candidate("et"),"ix");
assert.deepEqual(candidate("faewfawefaewg"),"jeiaj... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_8_sum_product | js | //For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// >>> sum_product([])
// [0, 1]
// >>> sum_product([1, 2, 3, 4])
// [10, 24]
function sum_product(numbers){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_8_sum_product.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = sum_product;
assert.deepEqual(candidate([]),[0, 1]);
assert.deepEqual(candidate([1, 1, 1]),[3, 1]);
assert.deepEqual(candidate([100, 0]),[100, 0]);
assert.deepEqual(candidate([3, 5, 7]),[15, 105]);
assert.deepEqual(candidate([10]),[1... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_90_next_smallest | js | //You are given a list of integers.
// Write a function next_smallest() that returns the 2nd smallest element of the list.
// Return None if there is no such element.
// >>> next_smallest([1, 2, 3, 4, 5])
// 2
// >>> next_smallest([5, 1, 4, 3, 2])
// 2
// >>> next_smallest([])
// undefined
// >>> next_smallest([1, 1])
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_90_next_smallest.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = next_smallest;
assert.deepEqual(candidate([1, 2, 3, 4, 5]),2);
assert.deepEqual(candidate([5, 1, 4, 3, 2]),2);
assert.deepEqual(candidate([]),undefined);
assert.deepEqual(candidate([1, 1]),undefined);
assert.deepEqual(candidate([1, 1... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_91_is_bored | js | //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("The sky is blue. The sun is shining. I love this weather")
... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_91_is_bored.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = is_bored;
assert.deepEqual(candidate("Hello world"),0);
assert.deepEqual(candidate("Is the sky blue?"),0);
assert.deepEqual(candidate("I love It !"),1);
assert.deepEqual(candidate("bIt"),0);
assert.deepEqual(candidate("I feel good to... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_92_any_int | js | //Create a function that takes 3 numbers.
// Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
// Returns false in any other cases.
// Examples
// >>> any_int(5, 2, 7)
// true
// >>> any_int(3, 2, 2)
// false
// >>> any_int(3, -2, 1)
// true
// >>> any_int(3.6, -2.2,... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_92_any_int.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = any_int;
assert.deepEqual(candidate(2, 3, 1),true);
assert.deepEqual(candidate(2.5, 2, 3),false);
assert.deepEqual(candidate(1.5, 5, 3.5),false);
assert.deepEqual(candidate(2, 6, 2),false);
assert.deepEqual(candidate(4, 2, 2),true);
... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_93_encode | js | //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.
// Examples:
// >>> encode("test")
// "TGST"
// >>> encode("Th... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_93_encode.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = encode;
assert.deepEqual(candidate("TEST"),"tgst");
assert.deepEqual(candidate("Mudasir"),"mWDCSKR");
assert.deepEqual(candidate("YES"),"ygs");
assert.deepEqual(candidate("This is a message"),"tHKS KS C MGSSCGG");
assert.deepEqual(ca... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_94_skjkasdkd | js | //You are given a list of integers.
// You need to find the largest prime value and return the sum of its digits.
// Examples:
// >>> skjkasdkd([0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3])
// 10
// >>> skjkasdkd([1, 0, 1, 8, 2, 4597, 2, 1, 3, 40, 1, 2, 1, 2, 4, 2, 5, 1])
// 25
// >>> skjka... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_94_skjkasdkd.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = skjkasdkd;
assert.deepEqual(candidate([0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3]),10);
assert.deepEqual(candidate([1, 0, 1, 8, 2, 4597, 2, 1, 3, 40, 1, 2, 1, 2, 4, 2, 5, 1]),25);
assert.deepEqual(candidate(... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_95_check_dict_case | js | //Given a dictionary, return True if all keys are strings in lower
// case or all keys are strings in upper case, else return False.
// The function should return False is the given dictionary is empty.
// Examples:
// >>> check_dict_case({"a": "apple", "b": "banana"})
// true
// >>> check_dict_case({"a": "apple", "A"... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_95_check_dict_case.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = check_dict_case;
assert.deepEqual(candidate({"p": "pineapple", "b": "banana"}),true);
assert.deepEqual(candidate({"p": "pineapple", "A": "banana", "B": "banana"}),false);
assert.deepEqual(candidate({"p": "pineapple", "5": "banana", "a": ... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_96_count_up_to | js | //Implement a function that takes an non-negative integer and returns an array of the first n
// integers that are prime numbers and less than n.
// for example:
// >>> count_up_to(5)
// [2, 3]
// >>> count_up_to(11)
// [2, 3, 5, 7]
// >>> count_up_to(0)
// []
// >>> count_up_to(20)
// [2, 3, 5, 7, 11, 13, 17, 19]
// >... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_96_count_up_to.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = count_up_to;
assert.deepEqual(candidate(5),[2, 3]);
assert.deepEqual(candidate(6),[2, 3, 5]);
assert.deepEqual(candidate(7),[2, 3, 5]);
assert.deepEqual(candidate(10),[2, 3, 5, 7]);
assert.deepEqual(candidate(0),[]);
assert.deepEqu... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_97_multiply | js | //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(14, -15)
// 20
function multiply(a, b){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_97_multiply.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = multiply;
assert.deepEqual(candidate(148, 412),16);
assert.deepEqual(candidate(19, 28),72);
assert.deepEqual(candidate(2020, 1851),0);
assert.deepEqual(candidate(14, -15),20);
assert.deepEqual(candidate(76, 67),42);
assert.deepEqua... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_98_count_upper | js | //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
function count_upper(s){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_98_count_upper.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = count_upper;
assert.deepEqual(candidate("aBCdEf"),1);
assert.deepEqual(candidate("abcdefg"),0);
assert.deepEqual(candidate("dBBE"),0);
assert.deepEqual(candidate("B"),0);
assert.deepEqual(candidate("U"),1);
assert.deepEqual(candida... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_99_closest_integer | js | //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_integer("15.3")
// 15
// Note:
// Rounding away from zero means that i... | transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_99_closest_integer.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = closest_integer;
assert.deepEqual(candidate("10"),10);
assert.deepEqual(candidate("14.5"),15);
assert.deepEqual(candidate("-15.5"),-16);
assert.deepEqual(candidate("15.3"),15);
assert.deepEqual(candidate("0"),0);
}
test(); | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_9_rolling_max | js | //From a given list of integers, generate a list of rolling maximum element found until given moment
// in the sequence.
// >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
// [1, 2, 3, 3, 3, 4, 4]
function rolling_max(numbers){
| transform | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals-with-cleaned-doctests/HumanEval_9_rolling_max.py | verbatim | const assert = require('node:assert');
function test() {
let candidate = rolling_max;
assert.deepEqual(candidate([]),[]);
assert.deepEqual(candidate([1, 2, 3, 4]),[1, 2, 3, 4]);
assert.deepEqual(candidate([4, 3, 2, 1]),[4, 4, 4, 4]);
assert.deepEqual(candidate([3, 2, 3, 100, 3]),[3, 3, 3, 100, 100]);
}
tes... | [
"\nfunction ",
"\n/*",
"\n//",
"\nconsole.log"
] |
HumanEval_0_has_close_elements | lua | -- 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
local function has_close_elements(numbers, threshold)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_0_has_close_elements.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = has_close_elements
lu.assertEquals(candidate({1.0, 2.0, 3.9, 4.0, 5.0, 2.2}, 0.3), true)
lu.assertEquals(candidate({1.0, 2.0, 3.9, 4.0, 5.0, 2.2}, 0.05), false)
lu.assertEquals(candidate({1.0, 2.0, 5.9, 4.0, 5.0}, 0.95), true)
lu.asser... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_100_make_a_pile | lua | -- 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 inde... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_100_make_a_pile.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = make_a_pile
lu.assertEquals(candidate(3), {3, 5, 7})
lu.assertEquals(candidate(4), {4, 6, 8, 10})
lu.assertEquals(candidate(5), {5, 7, 9, 11, 13})
lu.assertEquals(candidate(6), {6, 8, 10, 12, 14, 16})
lu.assertEquals(candidate(8), ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_101_words_string | lua | -- 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", "three... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_101_words_string.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = words_string
lu.assertEquals(candidate('Hi, my name is John'), {'Hi', 'my', 'name', 'is', 'John'})
lu.assertEquals(candidate('One, two, three, four, five, six'), {'One', 'two', 'three', 'four', 'five', 'six'})
lu.assertEquals(candidate('Hi... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_102_choose_num | lua | -- 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
local function choose_num(x, y)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_102_choose_num.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = choose_num
lu.assertEquals(candidate(12, 15), 14)
lu.assertEquals(candidate(13, 12), -1)
lu.assertEquals(candidate(33, 12354), 12354)
lu.assertEquals(candidate(5234, 5233), -1)
lu.assertEquals(candidate(6, 29), 28)
lu.assertEqu... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_103_rounded_avg | lua | -- You are given two positive integers n and m, and your task is to compute the
-- average of the integers from n through m (including n and m).
-- Round the answer to the nearest integer and convert that to binary.
-- If n is greater than m, return -1.
-- Example:
-- rounded_avg(1, 5) => "0b11"
-- rounded_avg(7, 5) =... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_103_rounded_avg.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = rounded_avg
lu.assertEquals(candidate(1, 5), '0b11')
lu.assertEquals(candidate(7, 13), '0b1010')
lu.assertEquals(candidate(964, 977), '0b1111001010')
lu.assertEquals(candidate(996, 997), '0b1111100100')
lu.assertEquals(candidate(56... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_104_unique_digits | lua | -- 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])
-- []
local function unique_digits(x... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_104_unique_digits.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = unique_digits
lu.assertEquals(candidate({15, 33, 1422, 1}), {1, 15, 33})
lu.assertEquals(candidate({152, 323, 1422, 10}), {})
lu.assertEquals(candidate({12345, 2033, 111, 151}), {111, 151})
lu.assertEquals(candidate({135, 103, 31}), {3... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_105_by_length | lua | -- 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]
-- -> ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_105_by_length.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = by_length
lu.assertEquals(candidate({2, 1, 1, 4, 5, 8, 2, 3}), {'Eight', 'Five', 'Four', 'Three', 'Two', 'Two', 'One', 'One'})
lu.assertEquals(candidate({}), {})
lu.assertEquals(candidate({1, -1, 55}), {'One'})
lu.assertEquals(candidat... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_106_f | lua | -- 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 * 2 * ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_106_f.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = f
lu.assertEquals(candidate(5), {1, 2, 6, 24, 15})
lu.assertEquals(candidate(7), {1, 2, 6, 24, 15, 720, 28})
lu.assertEquals(candidate(1), {1})
lu.assertEquals(candidate(3), {1, 2, 6})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_107_even_odd_palindrome | lua | -- 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:... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_107_even_odd_palindrome.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = even_odd_palindrome
lu.assertEquals(candidate(123), {8, 13})
lu.assertEquals(candidate(12), {4, 6})
lu.assertEquals(candidate(3), {1, 2})
lu.assertEquals(candidate(63), {6, 8})
lu.assertEquals(candidate(25), {5, 6})
lu.assertEq... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_108_count_nums | lua | -- 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]) == 1
-- ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_108_count_nums.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = count_nums
lu.assertEquals(candidate({}), 0)
lu.assertEquals(candidate({-1, -2, 0}), 0)
lu.assertEquals(candidate({1, 1, 2, -2, 3, 4, 5}), 6)
lu.assertEquals(candidate({1, 6, 9, -6, 0, 1, 5}), 5)
lu.assertEquals(candidate({1, 100, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_109_move_one_ball | lua | -- 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 sh... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_109_move_one_ball.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = move_one_ball
lu.assertEquals(candidate({3, 4, 5, 1, 2}), true)
lu.assertEquals(candidate({3, 5, 10, 1, 2}), true)
lu.assertEquals(candidate({4, 3, 1, 2}), false)
lu.assertEquals(candidate({3, 5, 4, 1, 2}), false)
lu.assertEquals(c... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_10_make_palindrome | lua | -- 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('')
-- ''
-- >>> make_... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_10_make_palindrome.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = make_palindrome
lu.assertEquals(candidate(''), '')
lu.assertEquals(candidate('x'), 'x')
lu.assertEquals(candidate('xyz'), 'xyzyx')
lu.assertEquals(candidate('xyx'), 'xyx')
lu.assertEquals(candidate('jerry'), 'jerryrrej')
end
os.ex... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_110_exchange | lua | -- 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 possible to... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_110_exchange.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = exchange
lu.assertEquals(candidate({1, 2, 3, 4}, {1, 2, 3, 4}), 'YES')
lu.assertEquals(candidate({1, 2, 3, 4}, {1, 5, 3, 4}), 'NO')
lu.assertEquals(candidate({1, 2, 3, 4}, {2, 1, 4, 3}), 'YES')
lu.assertEquals(candidate({5, 7, 3}, {2, ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_111_histogram | lua | -- 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('a b b ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_111_histogram.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = histogram
lu.assertEquals(candidate('a b b a'), {['a'] = 2, ['b'] = 2})
lu.assertEquals(candidate('a b c a b'), {['a'] = 2, ['b'] = 2})
lu.assertEquals(candidate('a b c d g'), {['a'] = 1, ['b'] = 1, ['c'] = 1, ['d'] = 1, ['g'] = 1})
lu... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_112_reverse_delete | lua | -- 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 True/Fa... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_112_reverse_delete.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = reverse_delete
lu.assertEquals(candidate('abcde', 'ae'), {'bcd', false})
lu.assertEquals(candidate('abcdef', 'b'), {'acdef', false})
lu.assertEquals(candidate('abcdedcba', 'ab'), {'cdedc', true})
lu.assertEquals(candidate('dwik', 'w'),... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_113_odd_count | lua | -- 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(['1234567'])... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_113_odd_count.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = odd_count
lu.assertEquals(candidate({'1234567'}), {'the number of odd elements 4n the str4ng 4 of the 4nput.'})
lu.assertEquals(candidate({'3', '11111111'}), {'the number of odd elements 1n the str1ng 1 of the 1nput.', 'the number of odd eleme... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_114_minSubArraySum | lua | -- 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
local function minSubArraySum(nums)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_114_minSubArraySum.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = minSubArraySum
lu.assertEquals(candidate({2, 3, 4, 1, 2, 4}), 1)
lu.assertEquals(candidate({-1, -2, -3}), -6)
lu.assertEquals(candidate({-1, -2, -3, 2, -10}), -14)
lu.assertEquals(candidate({-9999999999999999}), -9999999999999999)
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_115_max_fill | lua | -- 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 wells.... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_115_max_fill.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = max_fill
lu.assertEquals(candidate({{0, 0, 1, 0}, {0, 1, 0, 0}, {1, 1, 1, 1}}, 1), 6)
lu.assertEquals(candidate({{0, 0, 1, 1}, {0, 0, 0, 0}, {1, 1, 1, 1}, {0, 1, 1, 1}}, 2), 5)
lu.assertEquals(candidate({{0, 0, 0}, {0, 0, 0}}, 5), 0)
l... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_116_sort_array | lua | -- 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_array([... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_116_sort_array.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = sort_array
lu.assertEquals(candidate({1, 5, 2, 3, 4}), {1, 2, 4, 3, 5})
lu.assertEquals(candidate({-2, -3, -4, -5, -6}), {-4, -2, -6, -5, -3})
lu.assertEquals(candidate({1, 0, 2, 3, 4}), {0, 1, 2, 4, 3})
lu.assertEquals(candidate({}), ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_117_select_words | lua | -- 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 may assu... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_117_select_words.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = select_words
lu.assertEquals(candidate('Mary had a little lamb', 4), {'little'})
lu.assertEquals(candidate('Mary had a little lamb', 3), {'Mary', 'lamb'})
lu.assertEquals(candidate('simple white space', 2), {})
lu.assertEquals(candidat... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_118_get_closest_vowel | lua | -- 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 given str... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_118_get_closest_vowel.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = get_closest_vowel
lu.assertEquals(candidate('yogurt'), 'u')
lu.assertEquals(candidate('full'), 'u')
lu.assertEquals(candidate('easy'), '')
lu.assertEquals(candidate('eAsy'), '')
lu.assertEquals(candidate('ali'), '')
lu.assertEq... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_119_match_parens | lua | -- 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 parentheses ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_119_match_parens.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = match_parens
lu.assertEquals(candidate({'()(', ')'}), 'Yes')
lu.assertEquals(candidate({')', ')'}), 'No')
lu.assertEquals(candidate({'(()(())', '())())'}), 'No')
lu.assertEquals(candidate({')())', '(()()('}), 'Yes')
lu.assertEquals... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_11_string_xor | lua | -- 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'
local function string_xor(a, b)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_11_string_xor.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = string_xor
lu.assertEquals(candidate('111000', '101010'), '010010')
lu.assertEquals(candidate('1', '1'), '0')
lu.assertEquals(candidate('0101', '0000'), '0101')
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_120_maximum | lua | -- 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 = ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_120_maximum.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = maximum
lu.assertEquals(candidate({-3, -4, 5}, 3), {-4, -3, 5})
lu.assertEquals(candidate({4, -4, 4}, 2), {4, 4})
lu.assertEquals(candidate({-3, 2, 1, 2, -1, -2, 1}, 1), {2})
lu.assertEquals(candidate({123, -123, 20, 0, 1, 2, -3}, 3), ... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_121_solution | lua | -- 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
local function solution(lst)
| keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_121_solution.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = solution
lu.assertEquals(candidate({5, 8, 7, 1}), 12)
lu.assertEquals(candidate({3, 3, 3, 3, 3}), 9)
lu.assertEquals(candidate({30, 13, 24, 321}), 0)
lu.assertEquals(candidate({5, 9}), 5)
lu.assertEquals(candidate({2, 4, 8}), 0)
... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_122_add_elements | lua | -- 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 <= l... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_122_add_elements.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = add_elements
lu.assertEquals(candidate({1, -2, -3, 41, 57, 76, 87, 88, 99}, 3), -4)
lu.assertEquals(candidate({111, 121, 3, 4000, 5, 6}, 2), 0)
lu.assertEquals(candidate({11, 21, 3, 90, 5, 6, 7, 8, 9}, 4), 125)
lu.assertEquals(candidat... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_123_get_odd_collatz | lua | -- 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 previous ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_123_get_odd_collatz.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = get_odd_collatz
lu.assertEquals(candidate(14), {1, 5, 7, 11, 13, 17})
lu.assertEquals(candidate(5), {1, 5})
lu.assertEquals(candidate(12), {1, 3, 5})
lu.assertEquals(candidate(1), {1})
end
os.exit(lu.LuaUnit.run()) | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_124_valid_date | lua | -- 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,8,10,1... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_124_valid_date.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = valid_date
lu.assertEquals(candidate('03-11-2000'), true)
lu.assertEquals(candidate('15-01-2012'), false)
lu.assertEquals(candidate('04-0-2040'), false)
lu.assertEquals(candidate('06-04-2020'), true)
lu.assertEquals(candidate('01-0... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_125_split_words | lua | -- Given a string of words, return a list of words split on whitespace, if no whitespaces exists in the text you
-- should split on commas ',' if no commas exists you should return the number of lower-case letters with odd order in the
-- alphabet, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
-- Examples
-- split_word... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_125_split_words.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = split_words
lu.assertEquals(candidate('Hello world!'), {'Hello', 'world!'})
lu.assertEquals(candidate('Hello,world!'), {'Hello', 'world!'})
lu.assertEquals(candidate('Hello world,!'), {'Hello', 'world,!'})
lu.assertEquals(candidate('He... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_126_is_sorted | lua | -- 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]) ➞ False
--... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_126_is_sorted.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = is_sorted
lu.assertEquals(candidate({5}), true)
lu.assertEquals(candidate({1, 2, 3, 4, 5}), true)
lu.assertEquals(candidate({1, 3, 2, 4, 5}), false)
lu.assertEquals(candidate({1, 2, 3, 4, 5, 6}), true)
lu.assertEquals(candidate({1,... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
HumanEval_127_intersection | lua | -- 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 end.
-- ... | keep | /home/arjun/repos/nuprl/MultiPL-E/datasets/../datasets/originals/HumanEval_127_intersection.py | verbatim | lu = require('luaunit')
function test_humaneval()
local candidate = intersection
lu.assertEquals(candidate({1, 2}, {2, 3}), 'NO')
lu.assertEquals(candidate({-1, 1}, {0, 4}), 'NO')
lu.assertEquals(candidate({-3, -1}, {-5, 5}), 'YES')
lu.assertEquals(candidate({-2, 2}, {-4, 0}), 'YES')
lu.assertEqual... | [
"\nlocal",
"\nfunction",
"\n--",
"\n\n"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.