Prompt:
# Input is a space-delimited string of numberals from 'zero' to 'nine'.
# Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
# Return the string with numbers sorted from smallest to largest
# >>> sort_numbers('three one five')
# 'one three five'
sub sort_numbers {
    my($numbers) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&sort_numbers;
        if(eq_deeply($candidate->(""),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("three"),"three")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("three five nine"),"three five nine")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("five zero four seven nine eight"),"zero four five seven eight nine")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("six five four three two one zero"),"zero one two three four five six")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
# separate those group into separate strings and return the list of those.
# Separate groups are balanced (each open brace is properly closed) and not nested within each other
# Ignore any spaces in the input string.
# >>> separate_paren_groups('( ) (( )) (( )( ))')
# ['()', '(())', '(()())']
sub separate_paren_groups {
    my($paren_string) = @_;


Prompt:
# From a supplied list of numbers (of length at least two) select and return two that are the closest to each
# other and return them in order (smaller number, larger number).
# >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
# (2.0, 2.2)
# >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
# (2.0, 2.0)
sub find_closest_elements {
    my($numbers) = @_;


Prompt:
# Given list of numbers (of at least two elements), apply a linear transform to that list,
# such that the smallest number will become 0 and the largest will become 1
# >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
# [0.0, 0.25, 0.5, 0.75, 1.0]
sub rescale_to_unit {
    my($numbers) = @_;


Prompt:
# Filter given list of any python values only for integers
# >>> filter_integers(['a', 3.14, 5])
# [5]
# >>> filter_integers([1, 2, 3, 'abc', {}, []])
# [1, 2, 3]
sub filter_integers {
    my($values) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&filter_integers;
        if(eq_deeply($candidate->([]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([4, {}, [], 23.2, 9, "adasd"]),[4, 9])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, "c", 3, 3, "a", "b"]),[3, 3, 3])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Return length of given string
# >>> strlen('')
# 0
# >>> strlen('abc')
# 3
sub strlen {
    my($string) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&strlen;
        if(eq_deeply($candidate->(""),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("x"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("asdasnakj"),9)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# For a given number n, find the largest number that divides n evenly, smaller than n
# >>> largest_divisor(15)
# 5
sub largest_divisor {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&largest_divisor;
        if(eq_deeply($candidate->(3),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(100),50)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(49),7)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Return list of prime factors of given integer in the order from smallest to largest.
# Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
# Input number should be equal to the product of all factors
# >>> factorize(8)
# [2, 2, 2]
# >>> factorize(25)
# [5, 5]
# >>> factorize(70)
# [2, 5, 7]
sub factorize {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&factorize;
        if(eq_deeply($candidate->(2),[2])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4),[2, 2])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8),[2, 2, 2])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(57),[3, 19])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3249),[3, 3, 19, 19])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(185193),[3, 3, 3, 19, 19, 19])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(20577),[3, 19, 19, 19])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(18),[2, 3, 3])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# From a list of integers, remove all elements that occur more than once.
# Keep order of elements left the same as in the input.
# >>> remove_duplicates([1, 2, 3, 2, 4])
# [1, 3, 4]
sub remove_duplicates {
    my($numbers) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&remove_duplicates;
        if(eq_deeply($candidate->([]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 4]),[1, 2, 3, 4])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 2, 4, 3, 5]),[1, 4, 5])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
# >>> flip_case('Hello')
# 'hELLO'
sub flip_case {
    my($string) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&flip_case;
        if(eq_deeply($candidate->(""),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Hello!"),"hELLO!")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("These violent delights have violent ends"),"tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Concatenate list of strings into a single string
# >>> concatenate([])
# ''
# >>> concatenate(['a', 'b', 'c'])
# 'abc'
sub concatenate {
    my($strings) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&concatenate;
        if(eq_deeply($candidate->([]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["x", "y", "z"]),"xyz")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["x", "y", "z", "w", "k"]),"xyzwk")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Filter an input list of strings only for ones that start with a given prefix.
# >>> filter_by_prefix([], 'a')
# []
# >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
# ['abc', 'array']
sub filter_by_prefix {
    my($strings, $prefix) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&filter_by_prefix;
        if(eq_deeply($candidate->([], "john"),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"], "xxx"),["xxx", "xxxAAA", "xxx"])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a positive floating point number, it can be decomposed into
# and integer part (largest integer smaller than given number) and decimals
# (leftover part always smaller than 1).
# Return the decimal part of the number.
# >>> truncate_number(3.5)
# 0.5
sub truncate_number {
    my($number) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&truncate_number;
        if(eq_deeply($candidate->(3.5),0.5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1.25),0.25)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(123.0),0.0)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Return only positive numbers in the list.
# >>> get_positive([-1, 2, -4, 5, 6])
# [2, 5, 6]
# >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
# [5, 3, 2, 3, 9, 123, 1]
sub get_positive {
    my($l) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&get_positive;
        if(eq_deeply($candidate->([-1, -2, 4, 5, 6]),[4, 5, 6])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]),[5, 3, 2, 3, 3, 9, 123, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1, -2]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([]),[])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Return true if a given number is prime, and false otherwise.
# >>> is_prime(6)
# False
# >>> is_prime(101)
# True
# >>> is_prime(11)
# True
# >>> is_prime(13441)
# True
# >>> is_prime(61)
# True
# >>> is_prime(4)
# False
# >>> is_prime(1)
# False
sub is_prime {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&is_prime;
        if(eq_deeply($candidate->(6),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(101),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(11),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(13441),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(61),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(11),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(17),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(85),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(77),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(255379),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# This function takes a list l and returns a list l' such that
# l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
# to the values of the corresponding indicies of l, but sorted.
# >>> sort_third([1, 2, 3])
# [1, 2, 3]
# >>> sort_third([5, 6, 3, 4, 8, 9, 2])
# [2, 6, 3, 4, 8, 9, 5]
sub sort_third {
    my($l) = @_;


Prompt:
# Return sorted unique elements in a list
# >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
# [0, 2, 3, 5, 9, 123]
sub unique {
    my($l) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&unique;
        if(eq_deeply($candidate->([5, 3, 5, 2, 3, 3, 9, 0, 123]),[0, 2, 3, 5, 9, 123])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Return maximum element in the list.
# >>> max_element([1, 2, 3])
# 3
# >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
# 123
sub max_element {
    my($l) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&max_element;
        if(eq_deeply($candidate->([1, 2, 3]),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]),124)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
sub fizz_buzz {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&fizz_buzz;
        if(eq_deeply($candidate->(50),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(78),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(79),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(100),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(200),6)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4000),192)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10000),639)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(100000),8026)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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]
sub sort_even {
    my($l) = @_;


Prompt:
# 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
sub prime_fib {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&prime_fib;
        if(eq_deeply($candidate->(1),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4),13)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5),89)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(6),233)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7),1597)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8),28657)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(9),514229)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10),433494437)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
# >>> below_zero([1, 2, -4, 5])
# True
sub below_zero {
    my($operations) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&below_zero;
        if(eq_deeply($candidate->([]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, -3, 1, 2, -3]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, -4, 5, 6]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, -1, 2, -2, 5, -5, 4, -4]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, -1, 2, -2, 5, -5, 4, -5]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, -2, 2, -2, 5, -5, 4, -4]),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
# >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
# True
# >>> triples_sum_to_zero([1])
# False
sub triples_sum_to_zero {
    my($l) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&triples_sum_to_zero;
        if(eq_deeply($candidate->([1, 3, 5, 0]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 3, 5, -1]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 3, -2, 1]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 7]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 5, 7]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([2, 4, -5, 3, 9, 7]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 3, 5, -100]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([100, 3, 5, -100]),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 car that's moving left to right hits a car that's moving right to left.
# However, the cars are infinitely sturdy and strong; as a result, they continue moving
# in their trajectory as if they did not collide.
# This function outputs the number of such collisions.
sub car_race_collision {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&car_race_collision;
        if(eq_deeply($candidate->(2),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3),9)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4),16)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8),64)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10),100)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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]
sub incr_list {
    my($l) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&incr_list;
        if(eq_deeply($candidate->([]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, 2, 1]),[4, 3, 2])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5, 2, 5, 2, 3, 3, 9, 0, 123]),[6, 3, 6, 3, 4, 4, 10, 1, 124])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
# >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
# True
# >>> pairs_sum_to_zero([1])
# False
sub pairs_sum_to_zero {
    my($l) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&pairs_sum_to_zero;
        if(eq_deeply($candidate->([1, 3, 5, 0]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 3, -2, 1]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 7]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([2, 4, -5, 3, 5, 7]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-3, 9, -1, 3, 2, 30]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-3, 9, -1, 3, 2, 31]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-3, 9, -1, 4, 2, 30]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-3, 9, -1, 4, 2, 31]),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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'
sub change_base {
    my($x, $base) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&change_base;
        if(eq_deeply($candidate->(8, 3),"22")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(9, 3),"100")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(234, 2),"11101010")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(16, 2),"10000")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8, 2),"1000")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7, 2),"111")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 3),"2")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3, 4),"3")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4, 5),"4")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5, 6),"5")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(6, 7),"6")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7, 8),"7")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given length of a side and high return area for a triangle.
# >>> triangle_area(5, 3)
# 7.5
sub triangle_area {
    my($a, $h) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&triangle_area;
        if(eq_deeply($candidate->(5, 3),7.5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 2),2.0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10, 8),40.0)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 sequence.  Do not use recursion.
# >>> fib4(5)
# 4
# >>> fib4(6)
# 8
# >>> fib4(7)
# 14
sub fib4 {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&fib4;
        if(eq_deeply($candidate->(5),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8),28)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10),104)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(12),386)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Return median of elements in the list l.
# >>> median([3, 1, 2, 4, 5])
# 3
# >>> median([-10, 4, 6, 1000, 10, 20])
# 15.0
sub median {
    my($l) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&median;
        if(eq_deeply($candidate->([3, 1, 2, 4, 5]),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-10, 4, 6, 1000, 10, 20]),8.0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5]),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([6, 5]),5.5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([8, 1, 3, 9, 9, 2, 7]),7)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Checks if given string is a palindrome
# >>> is_palindrome('')
# True
# >>> is_palindrome('aba')
# True
# >>> is_palindrome('aaaaa')
# True
# >>> is_palindrome('zbcd')
# False
sub is_palindrome {
    my($text) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&is_palindrome;
        if(eq_deeply($candidate->(""),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aba"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aaaaa"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("zbcd"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("xywyx"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("xywyz"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("xywzx"),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
sub modp {
    my($n, $p) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&modp;
        if(eq_deeply($candidate->(3, 5),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1101, 101),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(0, 101),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3, 11),8)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(100, 101),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(30, 5),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(31, 5),3)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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])
# 1.0
sub mean_absolute_deviation {
    my($numbers) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&mean_absolute_deviation;
        if(eq_deeply($candidate->([1.0, 2.0]),0.5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1.0, 2.0, 3.0, 4.0]),1.0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1.0, 2.0, 3.0, 4.0, 5.0]),1.2)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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'
sub remove_vowels {
    my($text) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&remove_vowels;
        if(eq_deeply($candidate->(""),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcdef
ghijklm"),"bcdf
ghjklm")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("fedcba"),"fdcb")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("eeeee"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("acBAA"),"cB")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("EcBOO"),"cB")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("ybcd"),"ybcd")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
sub below_threshold {
    my($l, $t) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&below_threshold;
        if(eq_deeply($candidate->([1, 2, 4, 10], 100),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 20, 4, 10], 5),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 20, 4, 10], 21),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 20, 4, 10], 22),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 8, 4, 10], 11),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 8, 4, 10], 10),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Add two numbers x and y
# >>> add(2, 3)
# 5
# >>> add(5, 7)
# 12
sub add {
    my($x, $y) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&add;
        if(eq_deeply($candidate->(0, 1),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1, 0),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 3),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5, 7),12)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7, 5),12)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
# False
sub same_chars {
    my($s0, $s1) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&same_chars;
        if(eq_deeply($candidate->("eabcdzzzz", "dddzzzzzzzddeddabc"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcd", "dddddddabc"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("dddddddabc", "abcd"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("eabcd", "dddddddabc"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcd", "dddddddabcf"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("eabcdzzzz", "dddzzzzzzzddddabc"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aabb", "aaccc"),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Return n-th Fibonacci number.
# >>> fib(10)
# 55
# >>> fib(1)
# 1
# >>> fib(8)
# 21
sub fib {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&fib;
        if(eq_deeply($candidate->(10),55)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8),21)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(11),89)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(12),144)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
sub correct_bracketing {
    my($brackets) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&correct_bracketing;
        if(eq_deeply($candidate->("<>"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("<<><>>"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("<><><<><>><>"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("<><><<<><><>><>><<><><<>>>"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("<<<><>>>>"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("><<>"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("<"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("<<<<"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(">"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("<<>"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("<><><<><>><>><<>"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("<><><<><>><>>><>"),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
sub monotonic {
    my($l) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&monotonic;
        if(eq_deeply($candidate->([1, 2, 4, 10]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 4, 20]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 20, 4, 10]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([4, 1, 0, -10]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([4, 1, 1, 0]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 2, 5, 60]),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 4, 5, 60]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([9, 9, 9, 9]),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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]
sub common {
    my($l1, $l2) = @_;


Prompt:
# 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
sub largest_prime_factor {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&largest_prime_factor;
        if(eq_deeply($candidate->(15),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(27),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(63),7)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(330),11)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(13195),29)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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]
sub intersperse {
    my($numbers, $delimeter) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&intersperse;
        if(eq_deeply($candidate->([], 7),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5, 6, 3, 2], 8),[5, 8, 6, 8, 3, 8, 2])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([2, 2, 2], 2),[2, 2, 2, 2, 2])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
sub sum_to_n {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&sum_to_n;
        if(eq_deeply($candidate->(1),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(6),21)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(11),66)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(30),465)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(100),5050)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
sub correct_bracketing {
    my($brackets) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&correct_bracketing;
        if(eq_deeply($candidate->("()"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("(()())"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("()()(()())()"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("()()((()()())())(()()(()))"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("((()())))"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(")(()"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("("),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("(((("),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(")"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("(()"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("()()(()())())(()"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("()()(()())()))()"),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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]
sub derivative {
    my($xs) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&derivative;
        if(eq_deeply($candidate->([3, 1, 2, 4, 5]),[1, 4, 12, 20])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3]),[2, 6])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, 2, 1]),[2, 2])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, 2, 1, 0, 4]),[2, 2, 0, 16])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1]),[])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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.
# >>> fibfib(1)
# 0
# >>> fibfib(5)
# 4
# >>> fibfib(8)
# 24
sub fibfib {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&fibfib;
        if(eq_deeply($candidate->(2),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8),24)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10),81)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(12),274)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(14),927)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
# >>> vowels_count("ACEDY")
# 3
sub vowels_count {
    my($s) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&vowels_count;
        if(eq_deeply($candidate->("abcde"),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Alone"),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("key"),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("bye"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("keY"),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("bYe"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("ACEDY"),3)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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"
sub circular_shift {
    my($x, $shift) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&circular_shift;
        if(eq_deeply($candidate->(100, 2),"001")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(12, 2),"12")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(97, 8),"79")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(12, 1),"21")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(11, 101),"11")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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") => 153
sub digitSum {
    my($s) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&digitSum;
        if(eq_deeply($candidate->(""),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abAB"),131)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcCd"),67)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("helloE"),69)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("woArBld"),131)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aAaaaXa"),153)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(" How are yOu?"),151)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("You arE Very Smart"),327)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 number of the fruits
# in the basket return the number of the mango fruits in the basket.
# for examble:
# fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
# fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
# fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
# fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
sub fruit_distribution {
    my($s, $n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&fruit_distribution;
        if(eq_deeply($candidate->("5 apples and 6 oranges", 19),8)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("5 apples and 6 oranges", 21),10)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("0 apples and 1 oranges", 3),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1 apples and 0 oranges", 3),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("2 apples and 3 oranges", 100),95)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("2 apples and 3 oranges", 5),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1 apples and 100 oranges", 120),19)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# "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.
# The plucked node should be returned in a list, [ smalest_value, its index ],
# If there are no even values or the given array is empty, return [].
# Example 1:
# Input: [4,2,3]
# Output: [2, 1]
# Explanation: 2 has the smallest even value, and 2 has the smallest index.
# Example 2:
# Input: [1,2,3]
# Output: [2, 1]
# Explanation: 2 has the smallest even value, and 2 has the smallest index.
# Example 3:
# Input: []
# Output: []
# Example 4:
# Input: [5, 0, 3, 0, 4, 2]
# Output: [0, 1]
# Explanation: 0 is the smallest value, but  there are two zeros,
# so we will choose the first zero, which has the smallest index.
# Constraints:
# * 1 <= nodes.length <= 10000
# * 0 <= node.value
sub pluck {
    my($arr) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&pluck;
        if(eq_deeply($candidate->([4, 2, 3]),[2, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3]),[2, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5, 0, 3, 0, 4, 2]),[0, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 0, 5, 3]),[0, 3])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5, 4, 8, 4, 8]),[4, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([7, 6, 7, 1]),[6, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([7, 9, 7, 1]),[])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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.
# Examples:
# search([4, 1, 2, 2, 3, 1]) == 2
# search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
# search([5, 5, 4, 4, 4]) == -1
sub search {
    my($lst) = @_;


Prompt:
# 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('(()()) ((())) () ((())()())')
# [2, 3, 1, 3]
sub parse_nested_parens {
    my($paren_string) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&parse_nested_parens;
        if(eq_deeply($candidate->("(()()) ((())) () ((())()())"),[2, 3, 1, 3])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("() (()) ((())) (((())))"),[1, 2, 3, 4])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("(()(())((())))"),[4])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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]
# strange_sort_list([]) == []
sub strange_sort_list {
    my($lst) = @_;


Prompt:
# 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, 4, 5) == 6.00
# triangle_area(1, 2, 10) == -1
sub triangle_area {
    my($a, $b, $c) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&triangle_area;
        if(eq_deeply($candidate->(3, 4, 5),6.0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1, 2, 10),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4, 8, 5),8.18)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 2, 2),1.73)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1, 2, 3),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10, 5, 7),16.25)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 6, 3),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1, 1, 1),0.43)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 2, 10),-1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 possible weight, but it's unbalanced.
# will_it_fly([3, 2, 3], 1) ➞ False
# # it's balanced, but 3+2+3 is more than the maximum possible weight.
# will_it_fly([3, 2, 3], 9) ➞ True
# # 3+2+3 is less than the maximum possible weight, and it's balanced.
# will_it_fly([3], 5) ➞ True
# # 3 is less than the maximum possible weight, and it's balanced.
sub will_it_fly {
    my($q, $w) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&will_it_fly;
        if(eq_deeply($candidate->([3, 2, 3], 9),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2], 5),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3], 5),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, 2, 3], 1),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3], 6),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5], 5),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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,5,4,7,9,6]) == 4
# smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
# smallest_change([1, 2, 3, 2, 1]) == 0
sub smallest_change {
    my($arr) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&smallest_change;
        if(eq_deeply($candidate->([1, 2, 3, 5, 4, 7, 9, 6]),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 4, 3, 2, 2]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 4, 2]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 4, 4, 2]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 2, 1]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, 1, 1, 3]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([0, 1]),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
# total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
# total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
# total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
sub total_match {
    my($lst1, $lst2) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&total_match;
        if(eq_deeply($candidate->([], []),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["hi", "admin"], ["hi", "hi"]),["hi", "hi"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["hi", "admin"], ["hi", "hi", "admin", "project"]),["hi", "admin"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["4"], ["1", "2", "3", "4", "5"]),["4"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["hi", "admin"], ["hI", "Hi"]),["hI", "Hi"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["hi", "admin"], ["hI", "hi", "hi"]),["hI", "hi", "hi"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["hi", "admin"], ["hI", "hi", "hii"]),["hi", "admin"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([], ["this"]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["this"], []),[])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
sub is_multiply_prime {
    my($a) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&is_multiply_prime;
        if(eq_deeply($candidate->(5),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(30),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(125),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(105),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(126),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(729),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(891),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1001),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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) => false
# is_simple_power(3, 1) => false
# is_simple_power(5, 3) => false
sub is_simple_power {
    my($x, $n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&is_simple_power;
        if(eq_deeply($candidate->(16, 2),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(143214, 16),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4, 2),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(9, 3),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(16, 4),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(24, 2),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(128, 4),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(12, 6),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1, 1),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1, 12),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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(180) ==> False
sub iscube {
    my($a) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&iscube;
        if(eq_deeply($candidate->(1),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(-1),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(64),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(180),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1000),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(0),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1729),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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, 5, 6, 7, 8, 9, A, B, C, D, E, F.
# Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
# So you have to determine a number of the following digits: 2, 3, 5, 7,
# B (=decimal 11), D (=decimal 13).
# Note: you may assume the input is always correct or empty string,
# and symbols A,B,C,D,E,F are always uppercase.
# Examples:
# For num = "AB" the output should be 1.
# For num = "1077E" the output should be 2.
# For num = "ABED1A33" the output should be 4.
# For num = "123456789ABCDEF0" the output should be 6.
# For num = "2020" the output should be 2.
sub hex_key {
    my($num) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&hex_key;
        if(eq_deeply($candidate->("AB"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1077E"),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("ABED1A33"),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("2020"),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("123456789ABCDEF0"),6)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("112233445566778899AABBCCDDEEFF00"),12)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 of the string.
# The extra characters are there to help with the format.
# Examples:
# decimal_to_binary(15)   # returns "db1111db"
# decimal_to_binary(32)   # returns "db100000db"
sub decimal_to_binary {
    my($decimal) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&decimal_to_binary;
        if(eq_deeply($candidate->(0),"db0db")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(32),"db100000db")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(103),"db1100111db")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(15),"db1111db")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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']
sub filter_by_substring {
    my($strings, $substring) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&filter_by_substring;
        if(eq_deeply($candidate->([], "john"),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["xxx", "asd", "xxy", "john doe", "xxxAAA", "xxx"], "xxx"),["xxx", "xxxAAA", "xxx"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["xxx", "asd", "aaaxxy", "john doe", "xxxAAA", "xxx"], "xx"),["xxx", "aaaxxy", "xxxAAA", "xxx"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["grunt", "trumpet", "prune", "gruesome"], "run"),["grunt", "prune"])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
# is_happy(adb) => True
# is_happy(xyy) => False
sub is_happy {
    my($s) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&is_happy;
        if(eq_deeply($candidate->("a"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aa"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcd"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aabb"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("adb"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("xyy"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("iopaxpoi"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("iopaxioi"),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 output a list of letter grades using the following table:
# GPA       |    Letter grade
# 4.0                A+
# > 3.7                A
# > 3.3                A-
# > 3.0                B+
# > 2.7                B
# > 2.3                B-
# > 2.0                C+
# > 1.7                C
# > 1.3                C-
# > 1.0                D+
# > 0.7                D
# > 0.0                D-
# 0.0                E
# Example:
# grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
sub numerical_letter_grade {
    my($grades) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&numerical_letter_grade;
        if(eq_deeply($candidate->([4.0, 3, 1.7, 2, 3.5]),["A+", "B", "C-", "C", "A-"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1.2]),["D+"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([0.5]),["D-"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([0.0]),["E"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1.0, 0.3, 1.5, 2.8, 3.3]),["D", "D-", "C-", "B", "B+"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([0.0, 0.7]),["E", "D-"])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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
sub prime_length {
    my($string) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&prime_length;
        if(eq_deeply($candidate->("Hello"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcdcba"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("kittens"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("orange"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("wow"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("world"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("MadaM"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Wow"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(""),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("HI"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("go"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("gogo"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aaaaaaaaaaaaaaa"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Madam"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("M"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("0"),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a positive integer n, return the count of the numbers of n-digit
# positive integers that start or end with 1.
sub starts_one_ends {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&starts_one_ends;
        if(eq_deeply($candidate->(1),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2),18)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3),180)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4),1800)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5),18000)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a positive integer N, return the total sum of its digits in binary.
# Example
# For N = 1000, the sum of digits will be 1 the output should be "1".
# For N = 150, the sum of digits will be 6 the output should be "110".
# For N = 147, the sum of digits will be 12 the output should be "1100".
# Variables:
# @N integer
# Constraints: 0 ≤ N ≤ 10000.
# Output:
# a string of binary number
sub solve {
    my($N) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&solve;
        if(eq_deeply($candidate->(1000),"1")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(150),"110")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(147),"1100")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(333),"1001")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(963),"10010")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a non-empty list of integers lst. add the even elements that are at odd indices..
# Examples:
# add([4, 2, 6, 7]) ==> 2
sub add {
    my($lst) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&add;
        if(eq_deeply($candidate->([4, 88]),88)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([4, 5, 6, 7, 2, 122]),122)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([4, 0, 6, 7]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([4, 4, 6, 8]),12)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 spaces in the sentence.
# For example:
# anti_shuffle('Hi') returns 'Hi'
# anti_shuffle('hello') returns 'ehllo'
# anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
sub anti_shuffle {
    my($s) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&anti_shuffle;
        if(eq_deeply($candidate->("Hi"),"Hi")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("hello"),"ehllo")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("number"),"bemnru")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcd"),"abcd")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Hello World!!!"),"Hello !!!Wdlor")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(""),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Hi. My name is Mister Robot. How are you?"),".Hi My aemn is Meirst .Rboot How aer ?ouy")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 coordinate - (row, columns), starting with 0.
# Sort coordinates initially by rows in ascending order.
# Also, sort coordinates of the row by columns in descending order.
# Examples:
# get_row([
# [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)]
# get_row([], 1) == []
# get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
sub get_row {
    my($lst, $x) = @_;


Prompt:
# 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 the given array.
# Examples:
# * sort_array([]) => []
# * sort_array([5]) => [5]
# * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
# * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
sub sort_array {
    my($array) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&sort_array;
        if(eq_deeply($candidate->([]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5]),[5])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([2, 4, 3, 0, 1, 5]),[0, 1, 2, 3, 4, 5])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([2, 4, 3, 0, 1, 5, 6]),[6, 5, 4, 3, 2, 1, 0])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([2, 1]),[1, 2])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([15, 42, 87, 32, 11, 0]),[0, 11, 15, 32, 42, 87])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([21, 14, 23, 11]),[23, 21, 14, 11])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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') returns 'lm'
# encrypt('asdfghjkl') returns 'ewhjklnop'
# encrypt('gf') returns 'kj'
# encrypt('et') returns 'ix'
sub encrypt {
    my($s) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&encrypt;
        if(eq_deeply($candidate->("hi"),"lm")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("asdfghjkl"),"ewhjklnop")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("gf"),"kj")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("et"),"ix")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("faewfawefaewg"),"jeiajeaijeiak")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("hellomyfriend"),"lippsqcjvmirh")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh"),"hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("a"),"e")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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)
sub sum_product {
    my($numbers) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&sum_product;
        if(eq_deeply($candidate->([]),[0, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 1, 1]),[3, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([100, 0]),[100, 0])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, 5, 7]),[15, 105])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([10]),[10, 10])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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([]) == None
# next_smallest([1, 1]) == None
sub next_smallest {
    my($lst) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&next_smallest;
        if(eq_deeply($candidate->([1, 2, 3, 4, 5]),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5, 1, 4, 3, 2]),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([]),undef)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 1]),undef)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 1, 1, 1, 0]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 1]),undef)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-35, 34, 12, -45]),-35)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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")
# 1
sub is_bored {
    my($S) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&is_bored;
        if(eq_deeply($candidate->("Hello world"),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Is the sky blue?"),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("I love It !"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("bIt"),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("I feel good today. I will be productive. will kill It"),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("You and I are going for a walk"),0)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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, 2) ➞ False
sub any_int {
    my($x, $y, $z) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&any_int;
        if(eq_deeply($candidate->(2, 3, 1),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2.5, 2, 3),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1.5, 5, 3.5),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 6, 2),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4, 2, 2),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2.2, 2.2, 2.2),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(-4, 6, 2),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 1, 1),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3, 4, 7),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3.0, 4, 7),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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('This is a message')
# 'tHKS KS C MGSSCGG'
sub encode {
    my($message) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&encode;
        if(eq_deeply($candidate->("TEST"),"tgst")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Mudasir"),"mWDCSKR")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("YES"),"ygs")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("This is a message"),"tHKS KS C MGSSCGG")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("I DoNt KnOw WhAt tO WrItE"),"k dQnT kNqW wHcT Tq wRkTg")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# You are given a list of integers.
# You need to find the largest prime value and return the sum of its digits.
# Examples:
# For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
# For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25
# For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
# For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
# For lst = [0,81,12,3,1,21] the output should be 3
# For lst = [0,8,1,2,1,7] the output should be 7
sub skjkasdkd {
    my($lst) = @_;


Prompt:
# 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"}) should return True.
# check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) should return False.
# check_dict_case({"a":"apple", "8":"banana", "a":"apple"}) should return False.
# check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) should return False.
# check_dict_case({"STATE":"NC", "ZIP":"12345" }) should return True.
sub check_dict_case {
    my($dict) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&check_dict_case;
        if(eq_deeply($candidate->({"p" => "pineapple", "b" => "banana"}),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->({"p" => "pineapple", "A" => "banana", "B" => "banana"}),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->({"p" => "pineapple", "5" => "banana", "a" => "apple"}),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->({"Name" => "John", "Age" => "36", "City" => "Houston"}),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->({"STATE" => "NC", "ZIP" => "12345"}),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->({"fruit" => "Orange", "taste" => "Sweet"}),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->({}),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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]
# count_up_to(1) => []
# count_up_to(18) => [2,3,5,7,11,13,17]
sub count_up_to {
    my($n) = @_;


Prompt:
# Complete the function that takes two integers and returns
# the product of their unit digits.
# Assume the input is always valid.
# Examples:
# multiply(148, 412) should return 16.
# multiply(19, 28) should return 72.
# multiply(2020, 1851) should return 0.
# multiply(14,-15) should return 20.
sub multiply {
    my($a, $b) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&multiply;
        if(eq_deeply($candidate->(148, 412),16)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(19, 28),72)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2020, 1851),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(14, -15),20)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(76, 67),42)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(17, 27),49)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(0, 1),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(0, 0),0)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a string s, count the number of uppercase vowels in even indices.
# For example:
# count_upper('aBCdEf') returns 1
# count_upper('abcdefg') returns 0
# count_upper('dBBE') returns 0
sub count_upper {
    my($s) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&count_upper;
        if(eq_deeply($candidate->("aBCdEf"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcdefg"),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("dBBE"),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("B"),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("U"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(""),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("EEEE"),2)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 if the given number is equidistant
# from two integers, the one you should return is the one that is the
# farthest from zero. For example closest_integer("14.5") should
# return 15 and closest_integer("-14.5") should return -15.
sub closest_integer {
    my($value) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&closest_integer;
        if(eq_deeply($candidate->("10"),10)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("14.5"),15)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("-15.5"),-16)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("15.3"),15)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("0"),0)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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]
sub rolling_max {
    my($numbers) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&rolling_max;
        if(eq_deeply($candidate->([]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 2, 3, 4]),[1, 2, 3, 4])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([4, 3, 2, 1]),[4, 4, 4, 4])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, 2, 3, 100, 3]),[3, 3, 3, 100, 100])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();