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


Prompt:
# Given a positive integer n, you have to make a pile of n levels of stones.
# The first level has n stones.
# The number of stones in the next level is:
# - the next odd number if n is odd.
# - the next even number if n is even.
# Return the number of stones in each level in a list, where element at index
# i represents the number of stones in the level (i+1).
# Examples:
# >>> make_a_pile(3)
# [3, 5, 7]
sub make_a_pile {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&make_a_pile;
        if(eq_deeply($candidate->(3),[3, 5, 7])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4),[4, 6, 8, 10])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5),[5, 7, 9, 11, 13])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(6),[6, 8, 10, 12, 14, 16])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8),[8, 10, 12, 14, 16, 18, 20, 22])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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", "four", "five", "six"]
sub words_string {
    my($s) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&words_string;
        if(eq_deeply($candidate->("Hi, my name is John"),["Hi", "my", "name", "is", "John"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("One, two, three, four, five, six"),["One", "two", "three", "four", "five", "six"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Hi, my name"),["Hi", "my", "name"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("One,, two, three, four, five, six,"),["One", "two", "three", "four", "five", "six"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(""),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("ahmed     , gamal"),["ahmed", "gamal"])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


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

use Test::Deep;

sub testhumaneval {
    my $candidate = \&choose_num;
        if(eq_deeply($candidate->(12, 15),14)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(13, 12),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(33, 12354),12354)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5234, 5233),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(6, 29),28)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(27, 10),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7, 7),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(546, 546),546)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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) => -1
# rounded_avg(10, 20) => "0b1111"
# rounded_avg(20, 33) => "0b11010"
sub rounded_avg {
    my($n, $m) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&rounded_avg;
        if(eq_deeply($candidate->(1, 5),"0b11")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7, 13),"0b1010")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(964, 977),"0b1111001010")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(996, 997),"0b1111100100")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(560, 851),"0b1011000010")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(185, 546),"0b101101110")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(362, 496),"0b110101101")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(350, 902),"0b1001110010")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(197, 233),"0b11010111")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7, 5),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5, 1),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5, 5),"0b101")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


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

use Test::Deep;

sub testhumaneval {
    my $candidate = \&unique_digits;
        if(eq_deeply($candidate->([15, 33, 1422, 1]),[1, 15, 33])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([152, 323, 1422, 10]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([12345, 2033, 111, 151]),[111, 151])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([135, 103, 31]),[31, 135])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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]
# -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
# -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
# return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]
# If the array is empty, return an empty array:
# arr = []
# return []
# If the array has any strange number ignore it:
# arr = [1, -1 , 55]
# -> sort arr -> [-1, 1, 55]
# -> reverse arr -> [55, 1, -1]
# return = ['One']
sub by_length {
    my($arr) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&by_length;
        if(eq_deeply($candidate->([2, 1, 1, 4, 5, 8, 2, 3]),["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, -1, 55]),["One"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, -1, 3, 2]),["Three", "Two", "One"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([9, 4, 8]),["Nine", "Eight", "Four"])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 * ... * i).
# Example:
# f(5) == [1, 2, 6, 24, 15]
sub f {
    my($n) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# 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:
# Input: 12
# Output: (4, 6)
# Explanation:
# Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
# Note:
# 1. 1 <= n <= 10^3
# 2. returned tuple has the number of even and odd integer palindromes respectively.
sub even_odd_palindrome {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&even_odd_palindrome;
        if(eq_deeply($candidate->(123),[8, 13])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(12),[4, 6])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3),[1, 2])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(63),[6, 8])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(25),[5, 6])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(19),[4, 6])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(9),[4, 5])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1),[0, 1])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


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

use Test::Deep;

sub testhumaneval {
    my $candidate = \&count_nums;
        if(eq_deeply($candidate->([]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1, -2, 0]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 1, 2, -2, 3, 4, 5]),6)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 6, 9, -6, 0, 1, 5]),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, 100, 98, -7, 1, -1]),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([12, 23, 34, -45, -56, 0]),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([0, 1]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1]),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 shift operation any number of times.
# One right shift operation means shifting all elements of the array by one
# position in the right direction. The last element of the array will be moved to
# the starting position in the array i.e. 0th index.
# If it is possible to obtain the sorted array by performing the above operation
# then return True else return False.
# If the given array is empty then return True.
# Note: The given list is guaranteed to have unique elements.
# For Example:
# move_one_ball([3, 4, 5, 1, 2])==>True
# Explanation: By performin 2 right shift operations, non-decreasing order can
# be achieved for the given array.
# move_one_ball([3, 5, 4, 1, 2])==>False
# Explanation:It is not possible to get non-decreasing order for the given
# array by performing any number of right shift operations.
sub move_one_ball {
    my($arr) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# 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_palindrome('cat')
# 'catac'
# >>> make_palindrome('cata')
# 'catac'
sub make_palindrome {
    my($string) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&make_palindrome;
        if(eq_deeply($candidate->(""),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("x"),"x")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("xyz"),"xyzyx")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("xyx"),"xyx")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("jerry"),"jerryrrej")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 exchange elements between the lst1 and lst2 to make
# all the elements of lst1 to be even, return "YES".
# Otherwise, return "NO".
# For example:
# exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
# exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
# It is assumed that the input lists will be non-empty.
sub exchange {
    my($lst1, $lst2) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# 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 a') == {'a': 2, 'b': 2}
# histogram('a b c a b') == {'a': 2, 'b': 2}
# histogram('b b b b a') == {'b': 4}
# histogram('') == {}
sub histogram {
    my($test) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&histogram;
        if(eq_deeply($candidate->("a b b a"),{"a" => 2, "b" => 2})) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("a b c a b"),{"a" => 2, "b" => 2})) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("a b c d g"),{"a" => 1, "b" => 1, "c" => 1, "d" => 1, "g" => 1})) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("r t g"),{"r" => 1, "t" => 1, "g" => 1})) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("b b b b a"),{"b" => 4})) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("r t g"),{"r" => 1, "t" => 1, "g" => 1})) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(""),{})) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("a"),{"a" => 1})) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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/False for the check.
# Example
# For s = "abcde", c = "ae", the result should be ('bcd',False)
# For s = "abcdef", c = "b"  the result should be ('acdef',False)
# For s = "abcdedcba", c = "ab", the result should be ('cdedc',True)
sub reverse_delete {
    my($s, $c) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&reverse_delete;
        if(eq_deeply($candidate->("abcde", "ae"),["bcd", ""])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcdef", "b"),["acdef", ""])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcdedcba", "ab"),["cdedc", 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("dwik", "w"),["dik", ""])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("a", "a"),["", 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcdedcba", ""),["abcdedcba", 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcdedcba", "v"),["abcdedcba", 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("vabba", "v"),["abba", 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("mamma", "mia"),["", 1])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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'])
# ["the number of odd elements 4n the str4ng 4 of the 4nput."]
# >>> odd_count(['3',"11111111"])
# ["the number of odd elements 1n the str1ng 1 of the 1nput.",
# "the number of odd elements 8n the str8ng 8 of the 8nput."]
sub odd_count {
    my($lst) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&odd_count;
        if(eq_deeply($candidate->(["1234567"]),["the number of odd elements 4n the str4ng 4 of the 4nput."])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["3", "11111111"]),["the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 of the 8nput."])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["271", "137", "314"]),["the number of odd elements 2n the str2ng 2 of the 2nput.", "the number of odd elements 3n the str3ng 3 of the 3nput.", "the number of odd elements 2n the str2ng 2 of the 2nput."])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


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

use Test::Deep;

sub testhumaneval {
    my $candidate = \&minSubArraySum;
        if(eq_deeply($candidate->([2, 3, 4, 1, 2, 4]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1, -2, -3]),-6)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1, -2, -3, 2, -10]),-14)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-9999999999999999]),-9999999999999999)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([0, 10, 20, 1000000]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1, -2, -3, 10, -5]),-6)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([100, -1, -2, -3, 10, -5]),-6)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([10, 11, 13, 8, 3, 4]),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([100, -33, 32, -1, 0, -2]),-33)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-10]),-10)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([7]),7)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1, -1]),-1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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.
# Output the number of times you need to lower the buckets.
# Example 1:
# Input:
# grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
# bucket_capacity : 1
# Output: 6
# Example 2:
# Input:
# grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
# bucket_capacity : 2
# Output: 5
# Example 3:
# Input:
# grid : [[0,0,0], [0,0,0]]
# bucket_capacity : 5
# Output: 0
# Constraints:
# * all wells have the same length
# * 1 <= grid.length <= 10^2
# * 1 <= grid[:,1].length <= 10^2
# * grid[i][j] -> 0 | 1
# * 1 <= capacity <= 10
sub max_fill {
    my($grid, $capacity) = @_;


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


Prompt:
# 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 assume the input string contains only letters and spaces.
# Examples:
# select_words("Mary had a little lamb", 4) ==> ["little"]
# select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
# select_words("simple white space", 2) ==> []
# select_words("Hello world", 4) ==> ["world"]
# select_words("Uncle sam", 3) ==> ["Uncle"]
sub select_words {
    my($s, $n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&select_words;
        if(eq_deeply($candidate->("Mary had a little lamb", 4),["little"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Mary had a little lamb", 3),["Mary", "lamb"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("simple white space", 2),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Hello world", 4),["world"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Uncle sam", 3),["Uncle"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("", 4),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("a b c d e f", 1),["b", "c", "d", "f"])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 string contains English letter only.
# Example:
# get_closest_vowel("yogurt") ==> "u"
# get_closest_vowel("FULL") ==> "U"
# get_closest_vowel("quick") ==> ""
# get_closest_vowel("ab") ==> ""
sub get_closest_vowel {
    my($word) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&get_closest_vowel;
        if(eq_deeply($candidate->("yogurt"),"u")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("full"),"u")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("easy"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("eAsy"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("ali"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("bad"),"a")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("most"),"o")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("ab"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("ba"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("quick"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("anime"),"i")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Asia"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Above"),"o")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 in S
# are balanced. For example: the string '(())()' is good, while the string
# '())' is not.
# Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
# Examples:
# match_parens(['()(', ')']) == 'Yes'
# match_parens([')', ')']) == 'No'
sub match_parens {
    my($lst) = @_;

use Test::Deep;

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

testhumaneval();


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

use Test::Deep;

sub testhumaneval {
    my $candidate = \&string_xor;
        if(eq_deeply($candidate->("111000", "101010"),"010010")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1", "1"),"0")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("0101", "0000"),"0101")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given an array arr of integers and a positive integer k, return a sorted list
# of length k with the maximum k numbers in arr.
# Example 1:
# Input: arr = [-3, -4, 5], k = 3
# Output: [-4, -3, 5]
# Example 2:
# Input: arr = [4, -4, 4], k = 2
# Output: [4, 4]
# Example 3:
# Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
# Output: [2]
# Note:
# 1. The length of the array will be in the range of [1, 1000].
# 2. The elements in the array will be in the range of [-1000, 1000].
# 3. 0 <= k <= len(arr)
sub maximum {
    my($arr, $k) = @_;


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

use Test::Deep;

sub testhumaneval {
    my $candidate = \&solution;
        if(eq_deeply($candidate->([5, 8, 7, 1]),12)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, 3, 3, 3, 3]),9)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([30, 13, 24, 321]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5, 9]),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([2, 4, 8]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([30, 13, 23, 32]),23)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([3, 13, 2, 9]),3)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a non-empty array of integers arr and an integer k, return
# the sum of the elements with at most two digits from the first k elements of arr.
# Example:
# Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
# Output: 24 # sum of 21 + 3
# Constraints:
# 1. 1 <= len(arr) <= 100
# 2. 1 <= k <= len(arr)
sub add_elements {
    my($arr, $k) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&add_elements;
        if(eq_deeply($candidate->([1, -2, -3, 41, 57, 76, 87, 88, 99], 3),-4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([111, 121, 3, 4000, 5, 6], 2),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([11, 21, 3, 90, 5, 6, 7, 8, 9], 4),125)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([111, 21, 3, 4000, 5, 6, 7, 8, 9], 4),24)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1], 1),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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 term is even, the next term is one half of
# the previous term. If the previous term is odd, the next term is 3 times the previous
# term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.
# Note:
# 1. Collatz(1) is [1].
# 2. returned list sorted in increasing order.
# For example:
# get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.
sub get_odd_collatz {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&get_odd_collatz;
        if(eq_deeply($candidate->(14),[1, 5, 7, 11, 13, 17])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5),[1, 5])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(12),[1, 3, 5])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1),[1])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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,12. And the number of days is not less than 1 or higher than 30 days for months 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.
# 3. The months should not be less than 1 or higher than 12.
# 4. The date should be in the format: mm-dd-yyyy
# for example:
# valid_date('03-11-2000') => True
# valid_date('15-01-2012') => False
# valid_date('04-0-2040') => False
# valid_date('06-04-2020') => True
# valid_date('06/04/2020') => False
sub valid_date {
    my($date) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&valid_date;
        if(eq_deeply($candidate->("03-11-2000"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("15-01-2012"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("04-0-2040"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("06-04-2020"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("01-01-2007"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("03-32-2011"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(""),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("04-31-3000"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("06-06-2005"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("21-31-2000"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("04-12-2003"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("04122003"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("20030412"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("2003-04"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("2003-04-12"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("04-2003"),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# 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_words("Hello world!") ➞ ["Hello", "world!"]
# split_words("Hello,world!") ➞ ["Hello", "world!"]
# split_words("abcdef") == 3
sub split_words {
    my($txt) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&split_words;
        if(eq_deeply($candidate->("Hello world!"),["Hello", "world!"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Hello,world!"),["Hello", "world!"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Hello world,!"),["Hello", "world,!"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Hello,Hello,world !"),["Hello,Hello,world", "!"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcdef"),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aaabb"),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aaaBb"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(""),0)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


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

use Test::Deep;

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

testhumaneval();


Prompt:
# 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.
# Your task is to determine whether the length of intersection of these two
# intervals is a prime number.
# Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)
# which its length is 1, which not a prime number.
# If the length of the intersection is a prime number, return "YES",
# otherwise, return "NO".
# If the two intervals don't intersect, return "NO".
# [input/output] samples:
# intersection((1, 2), (2, 3)) ==> "NO"
# intersection((-1, 1), (0, 4)) ==> "NO"
# intersection((-3, -1), (-5, 5)) ==> "YES"
sub intersection {
    my($interval1, $interval2) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# You are given an array arr of integers and you need to return
# sum of magnitudes of integers multiplied by product of all signs
# of each number in the array, represented by 1, -1 or 0.
# Note: return None for empty arr.
# Example:
# >>> prod_signs([1, 2, 2, -4]) == -9
# >>> prod_signs([0, 1]) == 0
# >>> prod_signs([]) == None
sub prod_signs {
    my($arr) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Given a grid with N rows and N columns (N >= 2) and a positive integer k,
# each cell of the grid contains a value. Every integer in the range [1, N * N]
# inclusive appears exactly once on the cells of the grid.
# You have to find the minimum path of length k in the grid. You can start
# from any cell, and in each step you can move to any of the neighbor cells,
# in other words, you can go to cells which share an edge with you current
# cell.
# Please note that a path of length k means visiting exactly k cells (not
# necessarily distinct).
# You CANNOT go off the grid.
# A path A (of length k) is considered less than a path B (of length k) if
# after making the ordered lists of the values on the cells that A and B go
# through (let's call them lst_A and lst_B), lst_A is lexicographically less
# than lst_B, in other words, there exist an integer index i (1 <= i <= k)
# such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
# lst_A[j] = lst_B[j].
# It is guaranteed that the answer is unique.
# Return an ordered list of the values on the cells that the minimum path go through.
# Examples:
# Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
# Output: [1, 2, 1]
# Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
# Output: [1]
sub minPath {
    my($grid, $k) = @_;


Prompt:
# Out of list of strings, return the longest one. Return the first one in case of multiple
# strings of the same length. Return None in case the input list is empty.
# >>> longest([])
# >>> longest(['a', 'b', 'c'])
# 'a'
# >>> longest(['a', 'bb', 'ccc'])
# 'ccc'
sub longest {
    my($strings) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&longest;
        if(eq_deeply($candidate->([]),undef)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["x", "y", "z"]),"x")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["x", "yyy", "zzzz", "www", "kkkk", "abc"]),"zzzz")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in
# the last couple centuries. However, what people don't know is Tribonacci sequence.
# Tribonacci sequence is defined by the recurrence:
# tri(1) = 3
# tri(n) = 1 + n / 2, if n is even.
# tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
# For example:
# tri(2) = 1 + (2 / 2) = 2
# tri(4) = 3
# tri(3) = tri(2) + tri(1) + tri(4)
# = 2 + 3 + 3 = 8
# You are given a non-negative integer number n, you have to a return a list of the
# first n + 1 numbers of the Tribonacci sequence.
# Examples:
# tri(3) = [1, 3, 2, 8]
sub tri {
    my($n) = @_;


Prompt:
# Given a positive integer n, return the product of the odd digits.
# Return 0 if all digits are even.
# For example:
# digits(1)  == 1
# digits(4)  == 0
# digits(235) == 15
sub digits {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&digits;
        if(eq_deeply($candidate->(5),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(54),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(120),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5014),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(98765),315)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5576543),2625)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2468),0)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Create a function that takes a string as input which contains only square brackets.
# The function should return True if and only if there is a valid subsequence of brackets
# where at least one bracket in the subsequence is nested.
# is_nested('[[]]') ➞ True
# is_nested('[]]]]]]][[[[[]') ➞ False
# is_nested('[][]') ➞ False
# is_nested('[]') ➞ False
# is_nested('[[][]]') ➞ True
# is_nested('[[]][[') ➞ True
sub is_nested {
    my($string) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&is_nested;
        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->("[[[[]]]]"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("[]]]]]]]]]]"),"")) {
        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->("[[]][["),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;
        }
}

testhumaneval();


Prompt:
# You are given a list of numbers.
# You need to return the sum of squared numbers in the given list,
# round each element in the list to the upper int(Ceiling) first.
# Examples:
# For lst = [1,2,3] the output should be 14
# For lst = [1,4,9] the output should be 98
# For lst = [1,3,5,7] the output should be 84
# For lst = [1.4,4.2,0] the output should be 29
# For lst = [-2.4,1,1] the output should be 6
sub sum_squares {
    my($lst) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&sum_squares;
        if(eq_deeply($candidate->([1.0, 2.0, 3.0]),14)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1.0, 2.0, 3.0]),14)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1.0, 3.0, 5.0, 7.0]),84)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1.4, 4.2, 0.0]),29)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-2.4, 1.0, 1.0]),6)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([100.0, 1.0, 15.0, 2.0]),10230)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([10000.0, 10000.0]),200000000)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1.4, 4.6, 6.3]),75)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1.4, 17.9, 18.9, 19.9]),1086)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([0.0]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1.0]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1.0, 1.0, 0.0]),2)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Create a function that returns True if the last character
# of a given string is an alphabetical character and is not
# a part of a word, and False otherwise.
# Note: "word" is a group of characters separated by space.
# Examples:
# check_if_last_char_is_a_letter("apple pie") ➞ False
# check_if_last_char_is_a_letter("apple pi e") ➞ True
# check_if_last_char_is_a_letter("apple pi e ") ➞ False
# check_if_last_char_is_a_letter("") ➞ False
sub check_if_last_char_is_a_letter {
    my($txt) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&check_if_last_char_is_a_letter;
        if(eq_deeply($candidate->("apple"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("apple pi e"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("eeeee"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("A"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Pumpkin pie "),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Pumpkin pie 1"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(""),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("eeeee e "),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("apple pie"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("apple pi e "),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Create a function which returns the largest index of an element which
# is not greater than or equal to the element immediately preceding it. If
# no such element exists then return -1. The given array will not contain
# duplicate values.
# Examples:
# can_arrange([1,2,4,3,5]) = 3
# can_arrange([1,2,3]) = -1
sub can_arrange {
    my($arr) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Create a function that returns a tuple (a, b), where 'a' is
# the largest of negative integers, and 'b' is the smallest
# of positive integers in a list.
# If there is no negative or positive integers, return them as None.
# Examples:
# largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
# largest_smallest_integers([]) == (None, None)
# largest_smallest_integers([0]) == (None, None)
sub largest_smallest_integers {
    my($lst) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Create a function that takes integers, floats, or strings representing
# real numbers, and returns the larger variable in its given variable type.
# Return None if the values are equal.
# Note: If a real number is represented as a string, the floating point might be . or ,
# compare_one(1, 2.5) ➞ 2.5
# compare_one(1, "2,3") ➞ "2,3"
# compare_one("5,1", "6") ➞ "6"
# compare_one("1", 1) ➞ None
sub compare_one {
    my($a, $b) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
# Example
# is_equal_to_sum_even(4) == False
# is_equal_to_sum_even(6) == False
# is_equal_to_sum_even(8) == True
sub is_equal_to_sum_even {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&is_equal_to_sum_even;
        if(eq_deeply($candidate->(4),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(6),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(8),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(11),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(12),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(13),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(16),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# The Brazilian factorial is defined as:
# brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
# where n > 0
# For example:
# >>> special_factorial(4)
# 288
# The function will receive an integer as input and should return the special
# factorial of this integer.
sub special_factorial {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&special_factorial;
        if(eq_deeply($candidate->(4),288)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5),34560)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7),125411328000)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Return a greatest common divisor of two integers a and b
# >>> greatest_common_divisor(3, 5)
# 1
# >>> greatest_common_divisor(25, 15)
# 5
sub greatest_common_divisor {
    my($a, $b) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&greatest_common_divisor;
        if(eq_deeply($candidate->(3, 7),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10, 15),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(49, 14),7)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(144, 60),12)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a string text, replace all spaces in it with underscores,
# and if a string has more than 2 consecutive spaces,
# then replace all consecutive spaces with -
# fix_spaces("Example") == "Example"
# fix_spaces("Example 1") == "Example_1"
# fix_spaces(" Example 2") == "_Example_2"
# fix_spaces(" Example   3") == "_Example-3"
sub fix_spaces {
    my($text) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&fix_spaces;
        if(eq_deeply($candidate->("Example"),"Example")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Mudasir Hanif "),"Mudasir_Hanif_")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Yellow Yellow  Dirty  Fellow"),"Yellow_Yellow__Dirty__Fellow")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Exa   mple"),"Exa-mple")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("   Exa 1 2 2 mple"),"-Exa_1_2_2_mple")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Create a function which takes a string representing a file's name, and returns
# 'Yes' if the the file's name is valid, and returns 'No' otherwise.
# A file's name is considered to be valid if and only if all the following conditions
# are met:
# - There should not be more than three digits ('0'-'9') in the file's name.
# - The file's name contains exactly one dot '.'
# - The substring before the dot should not be empty, and it starts with a letter from
# the latin alphapet ('a'-'z' and 'A'-'Z').
# - The substring after the dot should be one of these: ['txt', 'exe', 'dll']
# Examples:
# file_name_check("example.txt") # => 'Yes'
# file_name_check("1example.dll") # => 'No' (the name should start with a latin alphapet letter)
sub file_name_check {
    my($file_name) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&file_name_check;
        if(eq_deeply($candidate->("example.txt"),"Yes")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1example.dll"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("s1sdf3.asd"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("K.dll"),"Yes")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("MY16FILE3.exe"),"Yes")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("His12FILE94.exe"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("_Y.txt"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("?aREYA.exe"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("/this_is_valid.dll"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("this_is_valid.wow"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("this_is_valid.txt"),"Yes")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("this_is_valid.txtexe"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("#this2_i4s_5valid.ten"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("@this1_is6_valid.exe"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("this_is_12valid.6exe4.txt"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("all.exe.txt"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("I563_No.exe"),"Yes")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Is3youfault.txt"),"Yes")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("no_one#knows.dll"),"Yes")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1I563_Yes3.exe"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("I563_Yes3.txtt"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("final..txt"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("final132"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("_f4indsartal132."),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(".txt"),"No")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("s."),"No")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# "
# This function will take a list of integers. For all entries in the list, the function shall square the integer entry if its index is a
# multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not
# change the entries in the list whose indexes are not a multiple of 3 or 4. The function shall then return the sum of all entries.
# Examples:
# For lst = [1,2,3] the output should be 6
# For lst = []  the output should be 0
# For lst = [-1,-5,2,-1,-5]  the output should be -126
sub sum_squares {
    my($lst) = @_;


Prompt:
# You are given a string representing a sentence,
# the sentence contains some words separated by a space,
# and you have to return a string that contains the words from the original sentence,
# whose lengths are prime numbers,
# the order of the words in the new string should be the same as the original one.
# Example 1:
# Input: sentence = "This is a test"
# Output: "is"
# Example 2:
# Input: sentence = "lets go for swimming"
# Output: "go for"
# Constraints:
# * 1 <= len(sentence) <= 100
# * sentence contains only letters
sub words_in_sentence {
    my($sentence) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&words_in_sentence;
        if(eq_deeply($candidate->("This is a test"),"is")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("lets go for swimming"),"go for")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("there is no place available here"),"there is no place")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Hi I am Hussein"),"Hi am Hussein")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("go for it"),"go for it")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("here"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("here is"),"is")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Your task is to implement a function that will simplify the expression
# x * n. The function returns True if x * n evaluates to a whole number and False
# otherwise. Both x and n, are string representation of a fraction, and have the following format,
# <numerator>/<denominator> where both numerator and denominator are positive whole numbers.
# You can assume that x, and n are valid fractions, and do not have zero as denominator.
# simplify("1/5", "5/1") = True
# simplify("1/6", "2/1") = False
# simplify("7/10", "10/2") = False
sub simplify {
    my($x, $n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&simplify;
        if(eq_deeply($candidate->("1/5", "5/1"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1/6", "2/1"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("5/1", "3/1"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("7/10", "10/2"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("2/10", "50/10"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("7/2", "4/2"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("11/6", "6/1"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("2/3", "5/2"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("5/2", "3/5"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("2/4", "8/4"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("2/4", "4/2"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1/5", "5/1"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1/5", "1/5"),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Write a function which sorts the given list of integers
# in ascending order according to the sum of their digits.
# Note: if there are several items with similar sum of their digits,
# order them based on their index in original list.
# For example:
# >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
# >>> order_by_points([]) == []
sub order_by_points {
    my($nums) = @_;


Prompt:
# Write a function that takes an array of numbers as input and returns
# the number of elements in the array that are greater than 10 and both
# first and last digits of a number are odd (1, 3, 5, 7, 9).
# For example:
# specialFilter([15, -73, 14, -15]) => 1
# specialFilter([33, -2, -3, 45, 21, 109]) => 2
sub specialFilter {
    my($nums) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&specialFilter;
        if(eq_deeply($candidate->([5, -2, 1, -5]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([15, -73, 14, -15]),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([33, -2, -3, 45, 21, 109]),2)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([43, -12, 93, 125, 121, 109]),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([71, -2, -33, 75, 21, 19]),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([1]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([]),0)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# You are given a positive integer n. You have to create an integer array a of length n.
# For each i (1 ≤ i ≤ n), the value of a[i] = i * i - i + 1.
# Return the number of triples (a[i], a[j], a[k]) of a where i < j < k,
# and a[i] + a[j] + a[k] is a multiple of 3.
# Example :
# Input: n = 5
# Output: 1
# Explanation:
# a = [1, 3, 7, 13, 21]
# The only valid triple is (1, 7, 13).
sub get_max_triples {
    my($n) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&get_max_triples;
        if(eq_deeply($candidate->(5),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(6),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10),36)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(100),53361)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# There are eight planets in our solar system: the closerst to the Sun
# is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
# Uranus, Neptune.
# Write a function that takes two planet names as strings planet1 and planet2.
# The function should return a tuple containing all planets whose orbits are
# located between the orbit of planet1 and the orbit of planet2, sorted by
# the proximity to the sun.
# The function should return an empty tuple if planet1 or planet2
# are not correct planet names.
# Examples
# bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
# bf("Earth", "Mercury") ==> ("Venus")
# bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
sub bf {
    my($planet1, $planet2) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&bf;
        if(eq_deeply($candidate->("Jupiter", "Neptune"),["Saturn", "Uranus"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Earth", "Mercury"),["Venus"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Mercury", "Uranus"),["Venus", "Earth", "Mars", "Jupiter", "Saturn"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Neptune", "Venus"),["Earth", "Mars", "Jupiter", "Saturn", "Uranus"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Earth", "Earth"),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Mars", "Earth"),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Jupiter", "Makemake"),[])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Write a function that accepts a list of strings as a parameter,
# deletes the strings that have odd lengths from it,
# and returns the resulted list with a sorted order,
# The list is always a list of strings and never an array of numbers,
# and it may contain duplicates.
# The order of the list should be ascending by length of each word, and you
# should return the list sorted by that rule.
# If two words have the same length, sort the list alphabetically.
# The function should return a list of strings in sorted order.
# You may assume that all words will have the same length.
# For example:
# assert list_sort(["aa", "a", "aaa"]) => ["aa"]
# assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
sub sorted_list_sum {
    my($lst) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&sorted_list_sum;
        if(eq_deeply($candidate->(["aa", "a", "aaa"]),["aa"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["school", "AI", "asdf", "b"]),["AI", "asdf", "school"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["d", "b", "c", "a"]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["d", "dcba", "abcd", "a"]),["abcd", "dcba"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["AI", "ai", "au"]),["AI", "ai", "au"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["a", "b", "b", "c", "c", "a"]),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["aaaa", "bbbb", "dd", "cc"]),["cc", "dd", "aaaa", "bbbb"])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Return list of all prefixes from shortest to longest of the input string
# >>> all_prefixes('abc')
# ['a', 'ab', 'abc']
sub all_prefixes {
    my($string) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&all_prefixes;
        if(eq_deeply($candidate->(""),[])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("asdfgh"),["a", "as", "asd", "asdf", "asdfg", "asdfgh"])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("WWW"),["W", "WW", "WWW"])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# A simple program which should return the value of x if n is
# a prime number and should return the value of y otherwise.
# Examples:
# for x_or_y(7, 34, 12) == 34
# for x_or_y(15, 8, 5) == 5
sub x_or_y {
    my($n, $x, $y) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&x_or_y;
        if(eq_deeply($candidate->(7, 34, 12),34)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(15, 8, 5),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3, 33, 5212),33)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1259, 3, 52),3)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7919, -1, 12),-1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3609, 1245, 583),583)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(91, 56, 129),129)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(6, 34, 1234),1234)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1, 2, 0),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 2, 0),2)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a list of numbers, return the sum of squares of the numbers
# in the list that are odd. Ignore numbers that are negative or not integers.
# double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
# double_the_difference([-1, -2, 0]) == 0
# double_the_difference([9, -2]) == 81
# double_the_difference([0]) == 0
# If the input list is empty, return 0.
sub double_the_difference {
    my($lst) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&double_the_difference;
        if(eq_deeply($candidate->([]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([5.0, 4.0]),25)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([0.1, 0.2, 0.3]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-10.0, -20.0, -30.0]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-1.0, -2.0, 8.0]),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([0.2, 3.0, 5.0]),34)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->([-9.0, -7.0, -5.0, -3.0, -1.0, 1.0, 3.0, 5.0, 7.0, 9.0]),165)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# I think we all remember that feeling when the result of some long-awaited
# event is finally known. The feelings and thoughts you have at that moment are
# definitely worth noting down and comparing.
# Your task is to determine if a person correctly guessed the results of a number of matches.
# You are given two arrays of scores and guesses of equal length, where each index shows a match.
# Return an array of the same length denoting how far off each guess was. If they have guessed correctly,
# the value is 0, and if not, the value is the absolute difference between the guess and the score.
# example:
# compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
# compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
sub compare {
    my($game, $guess) = @_;


Prompt:
# You will be given the name of a class (a string) and a list of extensions.
# The extensions are to be used to load additional classes to the class. The
# strength of the extension is as follows: Let CAP be the number of the uppercase
# letters in the extension's name, and let SM be the number of lowercase letters
# in the extension's name, the strength is given by the fraction CAP - SM.
# You should find the strongest extension and return a string in this
# format: ClassName.StrongestExtensionName.
# If there are two or more extensions with the same strength, you should
# choose the one that comes first in the list.
# For example, if you are given "Slices" as the class and a list of the
# extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
# return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension
# (its strength is -1).
# Example:
# for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
sub Strongest_Extension {
    my($class_name, $extensions) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&Strongest_Extension;
        if(eq_deeply($candidate->("Watashi", ["tEN", "niNE", "eIGHt8OKe"]),"Watashi.eIGHt8OKe")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Boku123", ["nani", "NazeDa", "YEs.WeCaNe", "32145tggg"]),"Boku123.YEs.WeCaNe")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("__YESIMHERE", ["t", "eMptY", "nothing", "zeR00", "NuLl__", "123NoooneB321"]),"__YESIMHERE.NuLl__")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("K", ["Ta", "TAR", "t234An", "cosSo"]),"K.TAR")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("__HAHA", ["Tab", "123", "781345", "-_-"]),"__HAHA.123")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("YameRore", ["HhAas", "okIWILL123", "WorkOut", "Fails", "-_-"]),"YameRore.okIWILL123")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("finNNalLLly", ["Die", "NowW", "Wow", "WoW"]),"finNNalLLly.WoW")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("_", ["Bb", "91245"]),"_.Bb")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Sp", ["671235", "Bb"]),"Sp.671235")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word
# cycpattern_check("abcd","abd") => False
# cycpattern_check("hello","ell") => True
# cycpattern_check("whassup","psus") => False
# cycpattern_check("abab","baa") => True
# cycpattern_check("efef","eeff") => False
# cycpattern_check("himenss","simen") => True
sub cycpattern_check {
    my($a, $b) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&cycpattern_check;
        if(eq_deeply($candidate->("xyzw", "xyw"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("yello", "ell"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("whattup", "ptut"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("efef", "fee"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abab", "aabb"),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("winemtt", "tinem"),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given an integer. return a tuple that has the number of even and odd digits respectively.
# Example:
# even_odd_count(-12) ==> (1, 1)
# even_odd_count(123) ==> (1, 2)
sub even_odd_count {
    my($num) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&even_odd_count;
        if(eq_deeply($candidate->(7),[0, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(-78),[1, 1])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(3452),[2, 2])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(346211),[3, 3])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(-345821),[3, 3])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(-2),[1, 0])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(-45347),[2, 3])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(0),[1, 0])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a positive integer, obtain its roman numeral equivalent as a string,
# and return it in lowercase.
# Restrictions: 1 <= num <= 1000
# Examples:
# >>> int_to_mini_roman(19) == 'xix'
# >>> int_to_mini_roman(152) == 'clii'
# >>> int_to_mini_roman(426) == 'cdxxvi'
sub int_to_mini_roman {
    my($number) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&int_to_mini_roman;
        if(eq_deeply($candidate->(19),"xix")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(152),"clii")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(251),"ccli")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(426),"cdxxvi")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(500),"d")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1),"i")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(4),"iv")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(43),"xliii")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(90),"xc")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(94),"xciv")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(532),"dxxxii")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(900),"cm")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(994),"cmxciv")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1000),"m")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given the lengths of the three sides of a triangle. Return True if the three
# sides form a right-angled triangle, False otherwise.
# A right-angled triangle is a triangle in which one angle is right angle or
# 90 degree.
# Example:
# right_angle_triangle(3, 4, 5) == True
# right_angle_triangle(1, 2, 3) == False
sub right_angle_triangle {
    my($a, $b, $c) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&right_angle_triangle;
        if(eq_deeply($candidate->(3, 4, 5),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1, 2, 3),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10, 6, 8),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 2, 2),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(7, 24, 25),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10, 5, 7),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(5, 12, 13),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(15, 8, 17),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(48, 55, 73),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(1, 1, 1),"")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(2, 2, 10),"")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Write a function that accepts a list of strings.
# The list contains different words. Return the word with maximum number
# of unique characters. If multiple strings have maximum number of unique
# characters, return the one which comes first in lexicographical order.
# find_max(["name", "of", "string"]) == "string"
# find_max(["name", "enam", "game"]) == "enam"
# find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
sub find_max {
    my($words) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&find_max;
        if(eq_deeply($candidate->(["name", "of", "string"]),"string")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["name", "enam", "game"]),"enam")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["aaaaaaa", "bb", "cc"]),"aaaaaaa")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["abc", "cba"]),"abc")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["play", "this", "game", "of", "footbott"]),"footbott")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["we", "are", "gonna", "rock"]),"gonna")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["we", "are", "a", "mad", "nation"]),"nation")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["this", "is", "a", "prrk"]),"this")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["b"]),"b")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(["play", "play", "play"]),"play")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# You're a hungry rabbit, and you already have eaten a certain number of carrots,
# but now you need to eat more carrots to complete the day's meals.
# you should return an array of [ total number of eaten carrots after your meals,
# the number of carrots left after your meals ]
# if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
# Example:
# * eat(5, 6, 10) -> [11, 4]
# * eat(4, 8, 9) -> [12, 1]
# * eat(1, 10, 10) -> [11, 0]
# * eat(2, 11, 5) -> [7, 0]
# Variables:
# @number : integer
# the number of carrots that you have eaten.
# @need : integer
# the number of carrots that you need to eat.
# @remaining : integer
# the number of remaining carrots thet exist in stock
# Constrain:
# * 0 <= number <= 1000
# * 0 <= need <= 1000
# * 0 <= remaining <= 1000
# Have fun :)
sub eat {
    my($number, $need, $remaining) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Return a string containing space-delimited numbers starting from 0 upto n inclusive.
# >>> string_sequence(0)
# '0'
# >>> string_sequence(5)
# '0 1 2 3 4 5'
sub string_sequence {
    my($n) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Given two lists operator, and operand. The first list has basic algebra operations, and
# the second list is a list of integers. Use the two given lists to build the algebric
# expression and return the evaluation of this expression.
# The basic algebra operations:
# Addition ( + )
# Subtraction ( - )
# Multiplication ( * )
# Floor division ( // )
# Exponentiation ( ** )
# Example:
# operator['+', '*', '-']
# array = [2, 3, 4, 5]
# result = 2 + 3 * 4 - 5
# => result = 9
# Note:
# The length of operator list is equal to the length of operand list minus one.
# Operand is a list of of non-negative integers.
# Operator list has at least one operator, and operand list has at least two operands.
sub do_algebra {
    my($operator, $operand) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# You are given a string s.
# if s[i] is a letter, reverse its case from lower to upper or vise versa,
# otherwise keep it as it is.
# If the string contains no letters, reverse the string.
# The function should return the resulted string.
# Examples
# solve("1234") = "4321"
# solve("ab") = "AB"
# solve("#a@C") = "#A@c"
sub solve {
    my($s) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&solve;
        if(eq_deeply($candidate->("AsDf"),"aSdF")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("1234"),"4321")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("ab"),"AB")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("#a@C"),"#A@c")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("#AsdfW^45"),"#aSDFw^45")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("#6@2"),"2@6#")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("#$a^D"),"#$A^d")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("#ccc"),"#CCC")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a string 'text', return its md5 hash equivalent string.
# If 'text' is an empty string, return None.
# >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
sub string_to_md5 {
    my($text) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&string_to_md5;
        if(eq_deeply($candidate->("Hello world"),"3e25960a79dbc69b674cd4ec67a72c62")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(""),undef)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("A B C"),"0ef78513b0cb8cef12743f5aeb35f888")) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("password"),"5f4dcc3b5aa765d61d8327deb882cf99")) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given two positive integers a and b, return the even digits between a
# and b, in ascending order.
# For example:
# generate_integers(2, 8) => [2, 4, 6, 8]
# generate_integers(8, 2) => [2, 4, 6, 8]
# generate_integers(10, 14) => []
sub generate_integers {
    my($a, $b) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&generate_integers;
        if(eq_deeply($candidate->(2, 10),[2, 4, 6, 8])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(10, 2),[2, 4, 6, 8])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(132, 2),[2, 4, 6, 8])) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->(17, 89),[])) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Given a string, find out how many distinct characters (regardless of case) does it consist of
# >>> count_distinct_characters('xyzXYZ')
# 3
# >>> count_distinct_characters('Jerry')
# 4
sub count_distinct_characters {
    my($string) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&count_distinct_characters;
        if(eq_deeply($candidate->(""),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcde"),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("abcdecadeCADE"),5)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("aaaaAAAAaaaa"),1)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("Jerry jERRY JeRRRY"),5)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();


Prompt:
# Input to this function is a string representing musical notes in a special ASCII format.
# Your task is to parse this string and return list of integers corresponding to how many beats does each
# not last.
# Here is a legend:
# 'o' - whole note, lasts four beats
# 'o|' - half note, lasts two beats
# '.|' - quater note, lasts one beat
# >>> parse_music('o o| .| o| o| .| .| .| .| o o')
# [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
sub parse_music {
    my($music_string) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Find how many times a given substring can be found in the original string. Count overlaping cases.
# >>> how_many_times('', 'a')
# 0
# >>> how_many_times('aaa', 'a')
# 3
# >>> how_many_times('aaaa', 'aa')
# 3
sub how_many_times {
    my($string, $substring) = @_;

use Test::Deep;

sub testhumaneval {
    my $candidate = \&how_many_times;
        if(eq_deeply($candidate->("", "x"),0)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("xyxyxyx", "x"),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("cacacacac", "cac"),4)) {
        print "ok!" }else{
        exit 1;
        }
        if(eq_deeply($candidate->("john doe", "john"),1)) {
        print "ok!" }else{
        exit 1;
        }
}

testhumaneval();