Prompt:
# Given an array arr of integers, find the minimum number of elements that
# need to be changed to make the array palindromic. A palindromic array is an array that
# is read the same backwards and forwards. In one change, you can change one element to any other element.
# For example:
# >>> smallest_change([1, 2, 3, 5, 4, 7, 9, 6])
# 4
# >>> smallest_change([1, 2, 3, 4, 3, 2, 2])
# 1
# >>> smallest_change([1, 2, 3, 2, 1])
# 0
sub smallest_change {
    my($arr) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# You are given an array of numbers.
# You need to return the sum of squared numbers in the given array,
# round each element in the array to the upper int(Ceiling) first.
# Examples:
# >>> lst([1.0, 2.0, 3.0])
# 14
# >>> lst([1.0, 4.0, 9.0])
# 98
# >>> lst([1.0, 3.0, 5.0, 7.0])
# 84
# >>> lst([1.4, 4.2, 0.0])
# 29
# >>> lst([-2.4, 1.0, 1.0])
# 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 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"
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:
# triples_sum_to_zero takes an array of integers as an input.
# it returns 1 if there are three distinct elements in the array that
# sum to zero, and '' otherwise.
# >>> triples_sum_to_zero([1, 3, 5, 0])
# ""
# >>> triples_sum_to_zero([1, 3, -2, 1])
# 1
# >>> triples_sum_to_zero([1, 2, 3, 7])
# ""
# >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
# 1
# >>> triples_sum_to_zero([1])
# ""
sub triples_sum_to_zero {
    my($l) = @_;

use Test::Deep;

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

testhumaneval();


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


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

use Test::Deep;

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

testhumaneval();


Prompt:
# Create a function that returns 1 if the last character
# of a given string is an alphabetical character and is not
# a part of a word, and '' otherwise.
# Note: "word" is a group of characters separated by space.
# Examples:
# >>> check_if_last_char_is_a_letter("apple pie")
# ""
# >>> check_if_last_char_is_a_letter("apple pi e")
# 1
# >>> check_if_last_char_is_a_letter("apple pi e ")
# ""
# >>> check_if_last_char_is_a_letter("")
# ""
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:
# You have to write a function which validates a given date string and
# returns 1 if the date is valid otherwise ''.
# 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
# >>> valid_date("03-11-2000")
# 1
# >>> valid_date("15-01-2012")
# ""
# >>> valid_date("04-0-2040")
# ""
# >>> valid_date("06-04-2020")
# 1
# >>> valid_date("06/04/2020")
# ""
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:
# 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:
# Write a function that takes a string and returns an ordered version of it.
# Ordered version of string, is a string where all words (separated by space)
# are replaced by a new word where all the characters arranged in
# ascending order based on ascii value.
# Note: You should keep the order of words and blank spaces in the sentence.
# For example:
# >>> anti_shuffle("Hi")
# "Hi"
# >>> anti_shuffle("hello")
# "ehllo"
# >>> anti_shuffle("Hello World!!!")
# "Hello !!!Wdlor"
sub anti_shuffle {
    my($s) = @_;

use Test::Deep;

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

testhumaneval();


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

use Test::Deep;

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

testhumaneval();


Prompt:
# 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:
# Return true if a given number is prime, and false otherwise.
# >>> is_prime(6)
# ""
# >>> is_prime(101)
# 1
# >>> is_prime(11)
# 1
# >>> is_prime(13441)
# 1
# >>> is_prime(61)
# 1
# >>> is_prime(4)
# ""
# >>> is_prime(1)
# ""
sub is_prime {
    my($n) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Your task is to implement a function that will simplify the expression
# x * n. The function returns 1 if x * n evaluates to a whole number and ''
# 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")
# 1
# >>> simplify("1/6", "2/1")
# ""
# >>> simplify("7/10", "10/2")
# ""
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:
# You have been tasked to write a function that receives
# a hexadecimal number as a string and counts the number of hexadecimal
# digits that are primes (prime number, or a prime, is a natural number
# greater than 1 that is not a product of two smaller natural numbers).
# Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
# Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
# So you have to determine a number of the following digits: 2, 3, 5, 7,
# B (=decimal 11), D (=decimal 13).
# Note: you may assume the input is always correct or empty string,
# and symbols A,B,C,D,E,F are always uppercase.
# Examples:
# >>> hex_key("AB")
# 1
# >>> hex_key("1077E")
# 2
# >>> hex_key("ABED1A33")
# 4
# >>> hex_key("123456789ABCDEF0")
# 6
# >>> hex_key("2020")
# 2
sub hex_key {
    my($num) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# You 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:
# >>> words_in_sentence("This is a test")
# "is"
# Example 2:
# >>> words_in_sentence("lets go for swimming")
# "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:
# Given a string representing a space separated lowercase letters, return a hash
# 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:
# You are given a 2 dimensional data, as a nested arrays,
# which is similar to matrix, however, unlike matrices,
# each row may contain a different number of columns.
# Given lst, and integer x, find integers x in the array,
# and return array of arrays, [(x1, y1), (x2, y2) ...] such that
# each array is a coordinate - (row, columns), starting with 0.
# Sort coordinates initially by rows in ascending order.
# Also, sort coordinates of the row by columns in descending order.
# Examples:
# >>> get_row([[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 1, 6], [1, 2, 3, 4, 5, 1]], 1)
# [[0, 0], [1, 4], [1, 0], [2, 5], [2, 0]]
# >>> get_row([], 1)
# []
# >>> get_row([[], [1], [1, 2, 3]], 3)
# [[2, 2]]
sub get_row {
    my($lst, $x) = @_;


Prompt:
# Given a positive integer n, return a sorted array 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 array 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.
# >>> get_odd_collatz(5)
# [1, 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:
# 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:
# Input is a space-delimited string of numberals from 'zero' to 'nine'.
# Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
# Return the string with numbers sorted from smallest to largest
# >>> sort_numbers("three one five")
# "one three five"
sub sort_numbers {
    my($numbers) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Circular shift the digits of the integer x, shift the digits right by shift
# and return the result as a string.
# If shift > number of digits, return digits reversed.
# >>> circular_shift(12, 1)
# "21"
# >>> circular_shift(12, 2)
# "12"
sub circular_shift {
    my($x, $shift) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# "
# This function will take an array of integers. For all entries in the array, 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 array whose indexes are not a multiple of 3 or 4. The function shall then return the sum of all entries.
# Examples:
# >>> lst
# [1, 2, 3]
# >>> lst
# []
# >>> lst
# [-1, -5, 2, -1, -5]
sub sum_squares {
    my($lst) = @_;


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


Prompt:
# For a given array of integers, return an array consisting of a sum and a product of all the integers in an array.
# Empty sum should be equal to 0 and empty product should be equal to 1.
# >>> sum_product([])
# [0, 1]
# >>> sum_product([1, 2, 3, 4])
# [10, 24]
sub sum_product {
    my($numbers) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# 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:
# Create a function that returns an array (a, b), where 'a' is
# the largest of negative integers, and 'b' is the smallest
# of positive integers in an array.
# If there is no negative or positive integers, return them as undef.
# Examples:
# >>> largest_smallest_integers([2, 4, 1, 3, 5, 7])
# [undef, 1]
# >>> largest_smallest_integers([])
# [undef, undef]
# >>> largest_smallest_integers([0])
# [undef, undef]
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:
# 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:
# 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 an array, 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 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 undef for empty arr.
# Example:
# >>> prod_signs([1, 2, 2, -4])
# 9
# >>> prod_signs([0, 1])
# 0
# >>> prod_signs([])
# undef
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 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:
# 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:
# You are given 2 words. You need to return 1 if the second word or any of its rotations is a substring in the first word
# >>> cycpattern_check("abcd", "abd")
# ""
# >>> cycpattern_check("hello", "ell")
# 1
# >>> cycpattern_check("whassup", "psus")
# ""
# >>> cycpattern_check("abab", "baa")
# 1
# >>> cycpattern_check("efef", "eeff")
# ""
# >>> cycpattern_check("himenss", "simen")
# 1
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:
# Return 1 is array elements are monotonically increasing or decreasing.
# >>> monotonic([1, 2, 4, 20])
# 1
# >>> monotonic([1, 20, 4, 10])
# ""
# >>> monotonic([4, 1, 0, -10])
# 1
sub monotonic {
    my($l) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Out of array of strings, return the longest one. Return the first one in case of multiple
# strings of the same length. Return undef in case the input array is empty.
# >>> longest([])
# undef
# >>> 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:
# Return 1 if all numbers in the array l are below threshold t.
# >>> below_threshold([1, 2, 4, 10], 100)
# 1
# >>> below_threshold([1, 20, 4, 10], 5)
# ""
sub below_threshold {
    my($l, $t) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Write a function that returns true if the given number is the multiplication of 3 prime numbers
# and false otherwise.
# Knowing that (a) is less then 100.
# Example:
# >>> is_multiply_prime(30)
# 1
# 30 = 2 * 3 * 5
sub is_multiply_prime {
    my($a) = @_;

use Test::Deep;

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

testhumaneval();


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

use Test::Deep;

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

testhumaneval();


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


Prompt:
# Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
# For each of the group, output the deepest level of nesting of parentheses.
# E.g. (()()) has maximum two levels of nesting while ((())) has three.
# >>> parse_nested_parens("(()()) ((())) () ((())()())")
# [2, 3, 1, 3]
sub parse_nested_parens {
    my($paren_string) = @_;

use Test::Deep;

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

testhumaneval();


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

use Test::Deep;

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

testhumaneval();


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

use Test::Deep;

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

testhumaneval();


Prompt:
# For a given array of input numbers, calculate Mean Absolute Deviation
# around the mean of this dataset.
# Mean Absolute Deviation is the average absolute difference between each
# element and a centerpoint (mean in this case):
# MAD = average | x - x_mean |
# >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
# 1.0
sub mean_absolute_deviation {
    my($numbers) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Return sorted unique common elements for two arrays.
# >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
# [1, 5, 653]
# >>> common([5, 3, 2, 8], [3, 2])
# [2, 3]
sub common {
    my($l1, $l2) = @_;


Prompt:
# 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:
# In this task, you will be given a string that represents a number of apples and oranges
# that are distributed in a basket of fruit this basket contains
# apples, oranges, and mango fruits. Given the string that represents the total number of
# the oranges and apples and an integer that represent the total number of the fruits
# in the basket return the number of the mango fruits in the basket.
# for examble:
# >>> fruit_distribution("5 apples and 6 oranges", 19)
# 8
# >>> fruit_distribution("0 apples and 1 oranges", 3)
# 2
# >>> fruit_distribution("2 apples and 3 oranges", 100)
# 95
# >>> fruit_distribution("100 apples and 1 oranges", 120)
# 19
sub fruit_distribution {
    my($s, $n) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# 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 an array containing the result string and 1/'' for the check.
# Example
# >>> reverse_delete("abcde", "ae")
# ["bcd", ""]
# >>> reverse_delete("abcdef", "b")
# ["acdef", ""]
# >>> reverse_delete("abcdedcba", "ab")
# ["cdedc", 1]
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:
# 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 of words, return an array 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:
# 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:
# Concatenate array of strings into a single string
# >>> concatenate([])
# ""
# >>> concatenate(["a", "b", "c"])
# "abc"
sub concatenate {
    my($strings) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Write a function that accepts an array of strings as a parameter,
# deletes the strings that have odd lengths from it,
# and returns the resulted array with a sorted order,
# The array is always an array of strings and never an array of numbers,
# and it may contain duplicates.
# The order of the array should be ascending by length of each word, and you
# should return the array sorted by that rule.
# If two words have the same length, sort the array alphabetically.
# The function should return an array of strings in sorted order.
# You may assume that all words will have the same length.
# For example:
# >>> list_sort(["aa", "a", "aaa"])
# ["aa"]
# >>> 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:
# Filter an input array of strings only for ones that contain given substring
# >>> filter_by_substring([], "a")
# []
# >>> filter_by_substring(["abc", "bacd", "cde", "array"], "a")
# ["abc", "bacd", "array"]
sub filter_by_substring {
    my($strings, $substring) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Create a function that takes a value (string) representing a number
# and returns the closest integer to it. If the number is equidistant
# from two integers, round it away from zero.
# Examples
# >>> closest_integer("10")
# 10
# >>> closest_integer("15.3")
# 15
# Note:
# Rounding away from zero means that if the given number is equidistant
# from two integers, the one you should return is the one that is the
# farthest from zero. For example closest_integer("14.5") should
# return 15 and closest_integer("-14.5") should return -15.
sub closest_integer {
    my($value) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Write a function vowels_count which takes a string representing
# a word as input and returns the number of vowels in the string.
# Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
# vowel, but only when it is at the end of the given word.
# Example:
# >>> vowels_count("abcde")
# 2
# >>> vowels_count("ACEDY")
# 3
sub vowels_count {
    my($s) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Write a function that accepts an array of strings.
# The array 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:
# Given a string 'text', return its md5 hash equivalent string.
# If 'text' is an empty string, return undef.
# >>> 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:
# Change numerical base of input number x to base.
# return string representation after the conversion.
# base numbers are less than 10.
# >>> change_base(8, 3)
# "22"
# >>> change_base(8, 2)
# "1000"
# >>> change_base(7, 2)
# "111"
sub change_base {
    my($x, $base) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Given the lengths of the three sides of a triangle. Return 1 if the three
# sides form a right-angled triangle, '' 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)
# 1
# >>> right_angle_triangle(1, 2, 3)
# ""
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:
# It is the last week of the semester and the teacher has to give the grades
# to students. The teacher has been making her own algorithm for grading.
# The only problem is, she has lost the code she used for grading.
# She has given you an array of GPAs for some students and you have to write
# a function that can output an array of letter grades using the following table:
# GPA       |    Letter grade
# 4.0                A+
# > 3.7                A
# > 3.3                A-
# > 3.0                B+
# > 2.7                B
# > 2.3                B-
# > 2.0                C+
# > 1.7                C
# > 1.3                C-
# > 1.0                D+
# > 0.7                D
# > 0.0                D-
# 0.0                E
# Example:
# >>> grade_equation([4.0, 3, 1.7, 2, 3.5])
# ["A+", "B", "C-", "C", "A-"]
sub numerical_letter_grade {
    my($grades) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
# >>> intersperse([], 4)
# []
# >>> intersperse([1, 2, 3], 4)
# [1, 4, 2, 4, 3]
sub intersperse {
    my($numbers, $delimeter) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# 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:
# sum_to_n is a function that sums numbers from 1 to n.
# >>> sum_to_n(30)
# 465
# >>> sum_to_n(100)
# 5050
# >>> sum_to_n(5)
# 15
# >>> sum_to_n(10)
# 55
# >>> sum_to_n(1)
# 1
sub sum_to_n {
    my($n) = @_;

use Test::Deep;

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

testhumaneval();


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

use Test::Deep;

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

testhumaneval();


Prompt:
# 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:
# From a given array of integers, generate an array of rolling maximum element found until given moment
# in the sequence.
# >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
# [1, 2, 3, 3, 3, 4, 4]
sub rolling_max {
    my($numbers) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# You're given an array of deposit and withdrawal operations on a bank account that starts with
# zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
# at that point function should return 1. Otherwise it should return ''.
# >>> below_zero([1, 2, 3])
# ""
# >>> below_zero([1, 2, -4, 5])
# 1
sub below_zero {
    my($operations) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# You are given a non-empty array of positive integers. Return the greatest integer that is greater than
# zero, and has a frequency greater than or equal to the value of the integer itself.
# The frequency of an integer is the number of times it appears in the array.
# If no such a value exist, return -1.
# Examples:
# >>> search([4, 1, 2, 2, 3, 1])
# 2
# >>> search([1, 2, 2, 3, 3, 3, 4, 4, 4])
# 3
# >>> search([5, 5, 4, 4, 4])
# -1
sub search {
    my($lst) = @_;


Prompt:
# brackets is a string of "(" and ")".
# return 1 if every opening bracket has a corresponding closing bracket.
# >>> correct_bracketing("(")
# ""
# >>> correct_bracketing("()")
# 1
# >>> correct_bracketing("(()())")
# 1
# >>> correct_bracketing(")(()")
# ""
sub correct_bracketing {
    my($brackets) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# This function takes an array l and returns an array l' such that
# l' is identical to l in the odd indicies, while its values at the even indicies are equal
# to the values of the even indicies of l, but sorted.
# >>> sort_even([1, 2, 3])
# [1, 2, 3]
# >>> sort_even([5, 6, 3, 4])
# [3, 6, 5, 4]
sub sort_even {
    my($l) = @_;


Prompt:
# Check if two words have the same characters.
# >>> same_chars("eabcdzzzz", "dddzzzzzzzddeddabc")
# 1
# >>> same_chars("abcd", "dddddddabc")
# 1
# >>> same_chars("dddddddabc", "abcd")
# 1
# >>> same_chars("eabcd", "dddddddabc")
# ""
# >>> same_chars("abcd", "dddddddabce")
# ""
# >>> same_chars("eabcdzzzz", "dddzzzzzzzddddabc")
# ""
sub same_chars {
    my($s0, $s1) = @_;

use Test::Deep;

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

testhumaneval();


Prompt:
# brackets is a string of "<" and ">".
# return 1 if every opening bracket has a corresponding closing bracket.
# >>> correct_bracketing("<")
# ""
# >>> correct_bracketing("<>")
# 1
# >>> correct_bracketing("<<><>>")
# 1
# >>> correct_bracketing("><<>")
# ""
sub correct_bracketing {
    my($brackets) = @_;

use Test::Deep;

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

testhumaneval();