Prompt:
<?php
// 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
function has_close_elements($numbers, $threshold) {

function candidate(...$args) {
    return has_close_elements(...$args);
}

function test(): void {
    if (candidate(array(1.0, 2.0, 3.9, 4.0, 5.0, 2.2), 0.3) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1.0, 2.0, 3.9, 4.0, 5.0, 2.2), 0.05) !== false) { throw new Exception("Test failed!"); }
    if (candidate(array(1.0, 2.0, 5.9, 4.0, 5.0), 0.95) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1.0, 2.0, 5.9, 4.0, 5.0), 0.8) !== false) { throw new Exception("Test failed!"); }
    if (candidate(array(1.0, 2.0, 3.0, 4.0, 5.0, 2.0), 0.1) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1.1, 2.2, 3.1, 4.1, 5.1), 1.0) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1.1, 2.2, 3.1, 4.1, 5.1), 0.5) !== false) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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]
function make_a_pile($n) {

function candidate(...$args) {
    return make_a_pile(...$args);
}

function test(): void {
    if (candidate(3) !== array(3, 5, 7)) { throw new Exception("Test failed!"); }
    if (candidate(4) !== array(4, 6, 8, 10)) { throw new Exception("Test failed!"); }
    if (candidate(5) !== array(5, 7, 9, 11, 13)) { throw new Exception("Test failed!"); }
    if (candidate(6) !== array(6, 8, 10, 12, 14, 16)) { throw new Exception("Test failed!"); }
    if (candidate(8) !== array(8, 10, 12, 14, 16, 18, 20, 22)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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"]
function words_string($s) {

function candidate(...$args) {
    return words_string(...$args);
}

function test(): void {
    if (candidate("Hi, my name is John") !== array("Hi", "my", "name", "is", "John")) { throw new Exception("Test failed!"); }
    if (candidate("One, two, three, four, five, six") !== array("One", "two", "three", "four", "five", "six")) { throw new Exception("Test failed!"); }
    if (candidate("Hi, my name") !== array("Hi", "my", "name")) { throw new Exception("Test failed!"); }
    if (candidate("One,, two, three, four, five, six,") !== array("One", "two", "three", "four", "five", "six")) { throw new Exception("Test failed!"); }
    if (candidate("") !== array()) { throw new Exception("Test failed!"); }
    if (candidate("ahmed     , gamal") !== array("ahmed", "gamal")) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function choose_num($x, $y) {

function candidate(...$args) {
    return choose_num(...$args);
}

function test(): void {
    if (candidate(12, 15) !== 14) { throw new Exception("Test failed!"); }
    if (candidate(13, 12) !== -1) { throw new Exception("Test failed!"); }
    if (candidate(33, 12354) !== 12354) { throw new Exception("Test failed!"); }
    if (candidate(5234, 5233) !== -1) { throw new Exception("Test failed!"); }
    if (candidate(6, 29) !== 28) { throw new Exception("Test failed!"); }
    if (candidate(27, 10) !== -1) { throw new Exception("Test failed!"); }
    if (candidate(7, 7) !== -1) { throw new Exception("Test failed!"); }
    if (candidate(546, 546) !== 546) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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"
function rounded_avg($n, $m) {

function candidate(...$args) {
    return rounded_avg(...$args);
}

function test(): void {
    if (candidate(1, 5) !== "0b11") { throw new Exception("Test failed!"); }
    if (candidate(7, 13) !== "0b1010") { throw new Exception("Test failed!"); }
    if (candidate(964, 977) !== "0b1111001010") { throw new Exception("Test failed!"); }
    if (candidate(996, 997) !== "0b1111100100") { throw new Exception("Test failed!"); }
    if (candidate(560, 851) !== "0b1011000010") { throw new Exception("Test failed!"); }
    if (candidate(185, 546) !== "0b101101110") { throw new Exception("Test failed!"); }
    if (candidate(362, 496) !== "0b110101101") { throw new Exception("Test failed!"); }
    if (candidate(350, 902) !== "0b1001110010") { throw new Exception("Test failed!"); }
    if (candidate(197, 233) !== "0b11010111") { throw new Exception("Test failed!"); }
    if (candidate(7, 5) !== -1) { throw new Exception("Test failed!"); }
    if (candidate(5, 1) !== -1) { throw new Exception("Test failed!"); }
    if (candidate(5, 5) !== "0b101") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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])
// []
function unique_digits($x) {

function candidate(...$args) {
    return unique_digits(...$args);
}

function test(): void {
    if (candidate(array(15, 33, 1422, 1)) !== array(1, 15, 33)) { throw new Exception("Test failed!"); }
    if (candidate(array(152, 323, 1422, 10)) !== array()) { throw new Exception("Test failed!"); }
    if (candidate(array(12345, 2033, 111, 151)) !== array(111, 151)) { throw new Exception("Test failed!"); }
    if (candidate(array(135, 103, 31)) !== array(31, 135)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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']
function by_length($arr) {

function candidate(...$args) {
    return by_length(...$args);
}

function test(): void {
    if (candidate(array(2, 1, 1, 4, 5, 8, 2, 3)) !== array("Eight", "Five", "Four", "Three", "Two", "Two", "One", "One")) { throw new Exception("Test failed!"); }
    if (candidate(array()) !== array()) { throw new Exception("Test failed!"); }
    if (candidate(array(1, -1, 55)) !== array("One")) { throw new Exception("Test failed!"); }
    if (candidate(array(1, -1, 3, 2)) !== array("Three", "Two", "One")) { throw new Exception("Test failed!"); }
    if (candidate(array(9, 4, 8)) !== array("Nine", "Eight", "Four")) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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]
function f($n) {

function candidate(...$args) {
    return f(...$args);
}

function test(): void {
    if (candidate(5) !== array(1, 2, 6, 24, 15)) { throw new Exception("Test failed!"); }
    if (candidate(7) !== array(1, 2, 6, 24, 15, 720, 28)) { throw new Exception("Test failed!"); }
    if (candidate(1) !== array(1)) { throw new Exception("Test failed!"); }
    if (candidate(3) !== array(1, 2, 6)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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.
function even_odd_palindrome($n) {

function candidate(...$args) {
    return even_odd_palindrome(...$args);
}

function test(): void {
    if (candidate(123) !== array(8, 13)) { throw new Exception("Test failed!"); }
    if (candidate(12) !== array(4, 6)) { throw new Exception("Test failed!"); }
    if (candidate(3) !== array(1, 2)) { throw new Exception("Test failed!"); }
    if (candidate(63) !== array(6, 8)) { throw new Exception("Test failed!"); }
    if (candidate(25) !== array(5, 6)) { throw new Exception("Test failed!"); }
    if (candidate(19) !== array(4, 6)) { throw new Exception("Test failed!"); }
    if (candidate(9) !== array(4, 5)) { throw new Exception("Test failed!"); }
    if (candidate(1) !== array(0, 1)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function count_nums($arr) {

function candidate(...$args) {
    return count_nums(...$args);
}

function test(): void {
    if (candidate(array()) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, -2, 0)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 1, 2, -2, 3, 4, 5)) !== 6) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 6, 9, -6, 0, 1, 5)) !== 5) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 100, 98, -7, 1, -1)) !== 4) { throw new Exception("Test failed!"); }
    if (candidate(array(12, 23, 34, -45, -56, 0)) !== 5) { throw new Exception("Test failed!"); }
    if (candidate(array(0, 1)) !== 1) { throw new Exception("Test failed!"); }
    if (candidate(array(1)) !== 1) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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.
function move_one_ball($arr) {

function candidate(...$args) {
    return move_one_ball(...$args);
}

function test(): void {
    if (candidate(array(3, 4, 5, 1, 2)) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(3, 5, 10, 1, 2)) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(4, 3, 1, 2)) !== false) { throw new Exception("Test failed!"); }
    if (candidate(array(3, 5, 4, 1, 2)) !== false) { throw new Exception("Test failed!"); }
    if (candidate(array()) !== true) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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'
function make_palindrome($string) {

function candidate(...$args) {
    return make_palindrome(...$args);
}

function test(): void {
    if (candidate("") !== "") { throw new Exception("Test failed!"); }
    if (candidate("x") !== "x") { throw new Exception("Test failed!"); }
    if (candidate("xyz") !== "xyzyx") { throw new Exception("Test failed!"); }
    if (candidate("xyx") !== "xyx") { throw new Exception("Test failed!"); }
    if (candidate("jerry") !== "jerryrrej") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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.
function exchange($lst1, $lst2) {

function candidate(...$args) {
    return exchange(...$args);
}

function test(): void {
    if (candidate(array(1, 2, 3, 4), array(1, 2, 3, 4)) !== "YES") { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3, 4), array(1, 5, 3, 4)) !== "NO") { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3, 4), array(2, 1, 4, 3)) !== "YES") { throw new Exception("Test failed!"); }
    if (candidate(array(5, 7, 3), array(2, 6, 4)) !== "YES") { throw new Exception("Test failed!"); }
    if (candidate(array(5, 7, 3), array(2, 6, 3)) !== "NO") { throw new Exception("Test failed!"); }
    if (candidate(array(3, 2, 6, 1, 8, 9), array(3, 5, 5, 1, 1, 1)) !== "NO") { throw new Exception("Test failed!"); }
    if (candidate(array(100, 200), array(200, 200)) !== "YES") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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('') == {}
function histogram($test) {

function candidate(...$args) {
    return histogram(...$args);
}

function test(): void {
    if (candidate("a b b a") !== array("a" => 2, "b" => 2)) { throw new Exception("Test failed!"); }
    if (candidate("a b c a b") !== array("a" => 2, "b" => 2)) { throw new Exception("Test failed!"); }
    if (candidate("a b c d g") !== array("a" => 1, "b" => 1, "c" => 1, "d" => 1, "g" => 1)) { throw new Exception("Test failed!"); }
    if (candidate("r t g") !== array("r" => 1, "t" => 1, "g" => 1)) { throw new Exception("Test failed!"); }
    if (candidate("b b b b a") !== array("b" => 4)) { throw new Exception("Test failed!"); }
    if (candidate("r t g") !== array("r" => 1, "t" => 1, "g" => 1)) { throw new Exception("Test failed!"); }
    if (candidate("") !== array()) { throw new Exception("Test failed!"); }
    if (candidate("a") !== array("a" => 1)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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)
function reverse_delete($s, $c) {

function candidate(...$args) {
    return reverse_delete(...$args);
}

function test(): void {
    if (candidate("abcde", "ae") !== array("bcd", false)) { throw new Exception("Test failed!"); }
    if (candidate("abcdef", "b") !== array("acdef", false)) { throw new Exception("Test failed!"); }
    if (candidate("abcdedcba", "ab") !== array("cdedc", true)) { throw new Exception("Test failed!"); }
    if (candidate("dwik", "w") !== array("dik", false)) { throw new Exception("Test failed!"); }
    if (candidate("a", "a") !== array("", true)) { throw new Exception("Test failed!"); }
    if (candidate("abcdedcba", "") !== array("abcdedcba", true)) { throw new Exception("Test failed!"); }
    if (candidate("abcdedcba", "v") !== array("abcdedcba", true)) { throw new Exception("Test failed!"); }
    if (candidate("vabba", "v") !== array("abba", true)) { throw new Exception("Test failed!"); }
    if (candidate("mamma", "mia") !== array("", true)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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."]
function odd_count($lst) {

function candidate(...$args) {
    return odd_count(...$args);
}

function test(): void {
    if (candidate(array("1234567")) !== array("the number of odd elements 4n the str4ng 4 of the 4nput.")) { throw new Exception("Test failed!"); }
    if (candidate(array("3", "11111111")) !== array("the number of odd elements 1n the str1ng 1 of the 1nput.", "the number of odd elements 8n the str8ng 8 of the 8nput.")) { throw new Exception("Test failed!"); }
    if (candidate(array("271", "137", "314")) !== array("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.")) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function minSubArraySum($nums) {

function candidate(...$args) {
    return minSubArraySum(...$args);
}

function test(): void {
    if (candidate(array(2, 3, 4, 1, 2, 4)) !== 1) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, -2, -3)) !== -6) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, -2, -3, 2, -10)) !== -14) { throw new Exception("Test failed!"); }
    if (candidate(array(-9999999999999999)) !== -9999999999999999) { throw new Exception("Test failed!"); }
    if (candidate(array(0, 10, 20, 1000000)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, -2, -3, 10, -5)) !== -6) { throw new Exception("Test failed!"); }
    if (candidate(array(100, -1, -2, -3, 10, -5)) !== -6) { throw new Exception("Test failed!"); }
    if (candidate(array(10, 11, 13, 8, 3, 4)) !== 3) { throw new Exception("Test failed!"); }
    if (candidate(array(100, -33, 32, -1, 0, -2)) !== -33) { throw new Exception("Test failed!"); }
    if (candidate(array(-10)) !== -10) { throw new Exception("Test failed!"); }
    if (candidate(array(7)) !== 7) { throw new Exception("Test failed!"); }
    if (candidate(array(1, -1)) !== -1) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function max_fill($grid, $capacity) {

function candidate(...$args) {
    return max_fill(...$args);
}

function test(): void {
    if (candidate(array(array(0, 0, 1, 0), array(0, 1, 0, 0), array(1, 1, 1, 1)), 1) !== 6) { throw new Exception("Test failed!"); }
    if (candidate(array(array(0, 0, 1, 1), array(0, 0, 0, 0), array(1, 1, 1, 1), array(0, 1, 1, 1)), 2) !== 5) { throw new Exception("Test failed!"); }
    if (candidate(array(array(0, 0, 0), array(0, 0, 0)), 5) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(array(1, 1, 1, 1), array(1, 1, 1, 1)), 2) !== 4) { throw new Exception("Test failed!"); }
    if (candidate(array(array(1, 1, 1, 1), array(1, 1, 1, 1)), 9) !== 2) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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]
function sort_array($arr) {

function candidate(...$args) {
    return sort_array(...$args);
}

function test(): void {
    if (candidate(array(1, 5, 2, 3, 4)) !== array(1, 2, 4, 3, 5)) { throw new Exception("Test failed!"); }
    if (candidate(array(-2, -3, -4, -5, -6)) !== array(-4, -2, -6, -5, -3)) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 0, 2, 3, 4)) !== array(0, 1, 2, 4, 3)) { throw new Exception("Test failed!"); }
    if (candidate(array()) !== array()) { throw new Exception("Test failed!"); }
    if (candidate(array(2, 5, 77, 4, 5, 3, 5, 7, 2, 3, 4)) !== array(2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77)) { throw new Exception("Test failed!"); }
    if (candidate(array(3, 6, 44, 12, 32, 5)) !== array(32, 3, 5, 6, 12, 44)) { throw new Exception("Test failed!"); }
    if (candidate(array(2, 4, 8, 16, 32)) !== array(2, 4, 8, 16, 32)) { throw new Exception("Test failed!"); }
    if (candidate(array(2, 4, 8, 16, 32)) !== array(2, 4, 8, 16, 32)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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"]
function select_words($s, $n) {

function candidate(...$args) {
    return select_words(...$args);
}

function test(): void {
    if (candidate("Mary had a little lamb", 4) !== array("little")) { throw new Exception("Test failed!"); }
    if (candidate("Mary had a little lamb", 3) !== array("Mary", "lamb")) { throw new Exception("Test failed!"); }
    if (candidate("simple white space", 2) !== array()) { throw new Exception("Test failed!"); }
    if (candidate("Hello world", 4) !== array("world")) { throw new Exception("Test failed!"); }
    if (candidate("Uncle sam", 3) !== array("Uncle")) { throw new Exception("Test failed!"); }
    if (candidate("", 4) !== array()) { throw new Exception("Test failed!"); }
    if (candidate("a b c d e f", 1) !== array("b", "c", "d", "f")) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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") ==> ""
function get_closest_vowel($word) {

function candidate(...$args) {
    return get_closest_vowel(...$args);
}

function test(): void {
    if (candidate("yogurt") !== "u") { throw new Exception("Test failed!"); }
    if (candidate("full") !== "u") { throw new Exception("Test failed!"); }
    if (candidate("easy") !== "") { throw new Exception("Test failed!"); }
    if (candidate("eAsy") !== "") { throw new Exception("Test failed!"); }
    if (candidate("ali") !== "") { throw new Exception("Test failed!"); }
    if (candidate("bad") !== "a") { throw new Exception("Test failed!"); }
    if (candidate("most") !== "o") { throw new Exception("Test failed!"); }
    if (candidate("ab") !== "") { throw new Exception("Test failed!"); }
    if (candidate("ba") !== "") { throw new Exception("Test failed!"); }
    if (candidate("quick") !== "") { throw new Exception("Test failed!"); }
    if (candidate("anime") !== "i") { throw new Exception("Test failed!"); }
    if (candidate("Asia") !== "") { throw new Exception("Test failed!"); }
    if (candidate("Above") !== "o") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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'
function match_parens($lst) {

function candidate(...$args) {
    return match_parens(...$args);
}

function test(): void {
    if (candidate(array("()(", ")")) !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate(array(")", ")")) !== "No") { throw new Exception("Test failed!"); }
    if (candidate(array("(()(())", "())())")) !== "No") { throw new Exception("Test failed!"); }
    if (candidate(array(")())", "(()()(")) !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate(array("(())))", "(()())((")) !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate(array("()", "())")) !== "No") { throw new Exception("Test failed!"); }
    if (candidate(array("(()(", "()))()")) !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate(array("((((", "((())")) !== "No") { throw new Exception("Test failed!"); }
    if (candidate(array(")(()", "(()(")) !== "No") { throw new Exception("Test failed!"); }
    if (candidate(array(")(", ")(")) !== "No") { throw new Exception("Test failed!"); }
    if (candidate(array("(", ")")) !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate(array(")", "(")) !== "Yes") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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'
function string_xor($a, $b) {

function candidate(...$args) {
    return string_xor(...$args);
}

function test(): void {
    if (candidate("111000", "101010") !== "010010") { throw new Exception("Test failed!"); }
    if (candidate("1", "1") !== "0") { throw new Exception("Test failed!"); }
    if (candidate("0101", "0000") !== "0101") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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)
function maximum($arr, $k) {

function candidate(...$args) {
    return maximum(...$args);
}

function test(): void {
    if (candidate(array(-3, -4, 5), 3) !== array(-4, -3, 5)) { throw new Exception("Test failed!"); }
    if (candidate(array(4, -4, 4), 2) !== array(4, 4)) { throw new Exception("Test failed!"); }
    if (candidate(array(-3, 2, 1, 2, -1, -2, 1), 1) !== array(2)) { throw new Exception("Test failed!"); }
    if (candidate(array(123, -123, 20, 0, 1, 2, -3), 3) !== array(2, 20, 123)) { throw new Exception("Test failed!"); }
    if (candidate(array(-123, 20, 0, 1, 2, -3), 4) !== array(0, 1, 2, 20)) { throw new Exception("Test failed!"); }
    if (candidate(array(5, 15, 0, 3, -13, -8, 0), 7) !== array(-13, -8, 0, 0, 3, 5, 15)) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, 0, 2, 5, 3, -10), 2) !== array(3, 5)) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 0, 5, -7), 1) !== array(5)) { throw new Exception("Test failed!"); }
    if (candidate(array(4, -4), 2) !== array(-4, 4)) { throw new Exception("Test failed!"); }
    if (candidate(array(-10, 10), 2) !== array(-10, 10)) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3, -23, 243, -400, 0), 0) !== array()) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function solution($lst) {

function candidate(...$args) {
    return solution(...$args);
}

function test(): void {
    if (candidate(array(5, 8, 7, 1)) !== 12) { throw new Exception("Test failed!"); }
    if (candidate(array(3, 3, 3, 3, 3)) !== 9) { throw new Exception("Test failed!"); }
    if (candidate(array(30, 13, 24, 321)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(5, 9)) !== 5) { throw new Exception("Test failed!"); }
    if (candidate(array(2, 4, 8)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(30, 13, 23, 32)) !== 23) { throw new Exception("Test failed!"); }
    if (candidate(array(3, 13, 2, 9)) !== 3) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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)
function add_elements($arr, $k) {

function candidate(...$args) {
    return add_elements(...$args);
}

function test(): void {
    if (candidate(array(1, -2, -3, 41, 57, 76, 87, 88, 99), 3) !== -4) { throw new Exception("Test failed!"); }
    if (candidate(array(111, 121, 3, 4000, 5, 6), 2) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(11, 21, 3, 90, 5, 6, 7, 8, 9), 4) !== 125) { throw new Exception("Test failed!"); }
    if (candidate(array(111, 21, 3, 4000, 5, 6, 7, 8, 9), 4) !== 24) { throw new Exception("Test failed!"); }
    if (candidate(array(1), 1) !== 1) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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.
function get_odd_collatz($n) {

function candidate(...$args) {
    return get_odd_collatz(...$args);
}

function test(): void {
    if (candidate(14) !== array(1, 5, 7, 11, 13, 17)) { throw new Exception("Test failed!"); }
    if (candidate(5) !== array(1, 5)) { throw new Exception("Test failed!"); }
    if (candidate(12) !== array(1, 3, 5)) { throw new Exception("Test failed!"); }
    if (candidate(1) !== array(1)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function valid_date($date) {

function candidate(...$args) {
    return valid_date(...$args);
}

function test(): void {
    if (candidate("03-11-2000") !== true) { throw new Exception("Test failed!"); }
    if (candidate("15-01-2012") !== false) { throw new Exception("Test failed!"); }
    if (candidate("04-0-2040") !== false) { throw new Exception("Test failed!"); }
    if (candidate("06-04-2020") !== true) { throw new Exception("Test failed!"); }
    if (candidate("01-01-2007") !== true) { throw new Exception("Test failed!"); }
    if (candidate("03-32-2011") !== false) { throw new Exception("Test failed!"); }
    if (candidate("") !== false) { throw new Exception("Test failed!"); }
    if (candidate("04-31-3000") !== false) { throw new Exception("Test failed!"); }
    if (candidate("06-06-2005") !== true) { throw new Exception("Test failed!"); }
    if (candidate("21-31-2000") !== false) { throw new Exception("Test failed!"); }
    if (candidate("04-12-2003") !== true) { throw new Exception("Test failed!"); }
    if (candidate("04122003") !== false) { throw new Exception("Test failed!"); }
    if (candidate("20030412") !== false) { throw new Exception("Test failed!"); }
    if (candidate("2003-04") !== false) { throw new Exception("Test failed!"); }
    if (candidate("2003-04-12") !== false) { throw new Exception("Test failed!"); }
    if (candidate("04-2003") !== false) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function split_words($txt) {

function candidate(...$args) {
    return split_words(...$args);
}

function test(): void {
    if (candidate("Hello world!") !== array("Hello", "world!")) { throw new Exception("Test failed!"); }
    if (candidate("Hello,world!") !== array("Hello", "world!")) { throw new Exception("Test failed!"); }
    if (candidate("Hello world,!") !== array("Hello", "world,!")) { throw new Exception("Test failed!"); }
    if (candidate("Hello,Hello,world !") !== array("Hello,Hello,world", "!")) { throw new Exception("Test failed!"); }
    if (candidate("abcdef") !== 3) { throw new Exception("Test failed!"); }
    if (candidate("aaabb") !== 2) { throw new Exception("Test failed!"); }
    if (candidate("aaaBb") !== 1) { throw new Exception("Test failed!"); }
    if (candidate("") !== 0) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function is_sorted($lst) {

function candidate(...$args) {
    return is_sorted(...$args);
}

function test(): void {
    if (candidate(array(5)) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3, 4, 5)) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 3, 2, 4, 5)) !== false) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3, 4, 5, 6)) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3, 4, 5, 6, 7)) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 3, 2, 4, 5, 6, 7)) !== false) { throw new Exception("Test failed!"); }
    if (candidate(array()) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1)) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(3, 2, 1)) !== false) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 2, 2, 3, 4)) !== false) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3, 3, 3, 4)) !== false) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 2, 3, 3, 4)) !== true) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3, 4)) !== true) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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"
function intersection($interval1, $interval2) {

function candidate(...$args) {
    return intersection(...$args);
}

function test(): void {
    if (candidate(array(1, 2), array(2, 3)) !== "NO") { throw new Exception("Test failed!"); }
    if (candidate(array(-1, 1), array(0, 4)) !== "NO") { throw new Exception("Test failed!"); }
    if (candidate(array(-3, -1), array(-5, 5)) !== "YES") { throw new Exception("Test failed!"); }
    if (candidate(array(-2, 2), array(-4, 0)) !== "YES") { throw new Exception("Test failed!"); }
    if (candidate(array(-11, 2), array(-1, -1)) !== "NO") { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2), array(3, 5)) !== "NO") { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2), array(1, 2)) !== "NO") { throw new Exception("Test failed!"); }
    if (candidate(array(-2, -2), array(-3, -2)) !== "NO") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function prod_signs($arr) {

function candidate(...$args) {
    return prod_signs(...$args);
}

function test(): void {
    if (candidate(array(1, 2, 2, -4)) !== -9) { throw new Exception("Test failed!"); }
    if (candidate(array(0, 1)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 1, 1, 2, 3, -1, 1)) !== -10) { throw new Exception("Test failed!"); }
    if (candidate(array()) !== null) { throw new Exception("Test failed!"); }
    if (candidate(array(2, 4, 1, 2, -1, -1, 9)) !== 20) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, 1, -1, 1)) !== 4) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, 1, 1, 1)) !== -4) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, 1, 1, 0)) !== 0) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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]
function minPath($grid, $k) {

function candidate(...$args) {
    return minPath(...$args);
}

function test(): void {
    if (candidate(array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 9)), 3) !== array(1, 2, 1)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(5, 9, 3), array(4, 1, 6), array(7, 8, 2)), 1) !== array(1)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(1, 2, 3, 4), array(5, 6, 7, 8), array(9, 10, 11, 12), array(13, 14, 15, 16)), 4) !== array(1, 2, 1, 2)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(6, 4, 13, 10), array(5, 7, 12, 1), array(3, 16, 11, 15), array(8, 14, 9, 2)), 7) !== array(1, 10, 1, 10, 1, 10, 1)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(8, 14, 9, 2), array(6, 4, 13, 15), array(5, 7, 1, 12), array(3, 10, 11, 16)), 5) !== array(1, 7, 1, 7, 1)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(11, 8, 7, 2), array(5, 16, 14, 4), array(9, 3, 15, 6), array(12, 13, 10, 1)), 9) !== array(1, 6, 1, 6, 1, 6, 1, 6, 1)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(12, 13, 10, 1), array(9, 3, 15, 6), array(5, 16, 14, 4), array(11, 8, 7, 2)), 12) !== array(1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(2, 7, 4), array(3, 1, 5), array(6, 8, 9)), 8) !== array(1, 3, 1, 3, 1, 3, 1, 3)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(6, 1, 5), array(3, 8, 9), array(2, 7, 4)), 8) !== array(1, 5, 1, 5, 1, 5, 1, 5)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(1, 2), array(3, 4)), 10) !== array(1, 2, 1, 2, 1, 2, 1, 2, 1, 2)) { throw new Exception("Test failed!"); }
    if (candidate(array(array(1, 3), array(3, 2)), 10) !== array(1, 3, 1, 3, 1, 3, 1, 3, 1, 3)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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'
function longest($strings) {

function candidate(...$args) {
    return longest(...$args);
}

function test(): void {
    if (candidate(array()) !== null) { throw new Exception("Test failed!"); }
    if (candidate(array("x", "y", "z")) !== "x") { throw new Exception("Test failed!"); }
    if (candidate(array("x", "yyy", "zzzz", "www", "kkkk", "abc")) !== "zzzz") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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]
function tri($n) {

function candidate(...$args) {
    return tri(...$args);
}

function test(): void {
    if (candidate(3) !== array(1, 3, 2, 8)) { throw new Exception("Test failed!"); }
    if (candidate(4) !== array(1, 3, 2, 8, 3)) { throw new Exception("Test failed!"); }
    if (candidate(5) !== array(1, 3, 2, 8, 3, 15)) { throw new Exception("Test failed!"); }
    if (candidate(6) !== array(1, 3, 2, 8, 3, 15, 4)) { throw new Exception("Test failed!"); }
    if (candidate(7) !== array(1, 3, 2, 8, 3, 15, 4, 24)) { throw new Exception("Test failed!"); }
    if (candidate(8) !== array(1, 3, 2, 8, 3, 15, 4, 24, 5)) { throw new Exception("Test failed!"); }
    if (candidate(9) !== array(1, 3, 2, 8, 3, 15, 4, 24, 5, 35)) { throw new Exception("Test failed!"); }
    if (candidate(20) !== array(1, 3, 2, 8, 3, 15, 4, 24, 5, 35, 6, 48, 7, 63, 8, 80, 9, 99, 10, 120, 11)) { throw new Exception("Test failed!"); }
    if (candidate(0) !== array(1)) { throw new Exception("Test failed!"); }
    if (candidate(1) !== array(1, 3)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function digits($n) {

function candidate(...$args) {
    return digits(...$args);
}

function test(): void {
    if (candidate(5) !== 5) { throw new Exception("Test failed!"); }
    if (candidate(54) !== 5) { throw new Exception("Test failed!"); }
    if (candidate(120) !== 1) { throw new Exception("Test failed!"); }
    if (candidate(5014) !== 5) { throw new Exception("Test failed!"); }
    if (candidate(98765) !== 315) { throw new Exception("Test failed!"); }
    if (candidate(5576543) !== 2625) { throw new Exception("Test failed!"); }
    if (candidate(2468) !== 0) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function is_nested($string) {

function candidate(...$args) {
    return is_nested(...$args);
}

function test(): void {
    if (candidate("[[]]") !== true) { throw new Exception("Test failed!"); }
    if (candidate("[]]]]]]][[[[[]") !== false) { throw new Exception("Test failed!"); }
    if (candidate("[][]") !== false) { throw new Exception("Test failed!"); }
    if (candidate("[]") !== false) { throw new Exception("Test failed!"); }
    if (candidate("[[[[]]]]") !== true) { throw new Exception("Test failed!"); }
    if (candidate("[]]]]]]]]]]") !== false) { throw new Exception("Test failed!"); }
    if (candidate("[][][[]]") !== true) { throw new Exception("Test failed!"); }
    if (candidate("[[]") !== false) { throw new Exception("Test failed!"); }
    if (candidate("[]]") !== false) { throw new Exception("Test failed!"); }
    if (candidate("[[]][[") !== true) { throw new Exception("Test failed!"); }
    if (candidate("[[][]]") !== true) { throw new Exception("Test failed!"); }
    if (candidate("") !== false) { throw new Exception("Test failed!"); }
    if (candidate("[[[[[[[[") !== false) { throw new Exception("Test failed!"); }
    if (candidate("]]]]]]]]") !== false) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function sum_squares($lst) {

function candidate(...$args) {
    return sum_squares(...$args);
}

function test(): void {
    if (candidate(array(1.0, 2.0, 3.0)) !== 14) { throw new Exception("Test failed!"); }
    if (candidate(array(1.0, 2.0, 3.0)) !== 14) { throw new Exception("Test failed!"); }
    if (candidate(array(1.0, 3.0, 5.0, 7.0)) !== 84) { throw new Exception("Test failed!"); }
    if (candidate(array(1.4, 4.2, 0.0)) !== 29) { throw new Exception("Test failed!"); }
    if (candidate(array(-2.4, 1.0, 1.0)) !== 6) { throw new Exception("Test failed!"); }
    if (candidate(array(100.0, 1.0, 15.0, 2.0)) !== 10230) { throw new Exception("Test failed!"); }
    if (candidate(array(10000.0, 10000.0)) !== 200000000) { throw new Exception("Test failed!"); }
    if (candidate(array(-1.4, 4.6, 6.3)) !== 75) { throw new Exception("Test failed!"); }
    if (candidate(array(-1.4, 17.9, 18.9, 19.9)) !== 1086) { throw new Exception("Test failed!"); }
    if (candidate(array(0.0)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(-1.0)) !== 1) { throw new Exception("Test failed!"); }
    if (candidate(array(-1.0, 1.0, 0.0)) !== 2) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function check_if_last_char_is_a_letter($txt) {

function candidate(...$args) {
    return check_if_last_char_is_a_letter(...$args);
}

function test(): void {
    if (candidate("apple") !== false) { throw new Exception("Test failed!"); }
    if (candidate("apple pi e") !== true) { throw new Exception("Test failed!"); }
    if (candidate("eeeee") !== false) { throw new Exception("Test failed!"); }
    if (candidate("A") !== true) { throw new Exception("Test failed!"); }
    if (candidate("Pumpkin pie ") !== false) { throw new Exception("Test failed!"); }
    if (candidate("Pumpkin pie 1") !== false) { throw new Exception("Test failed!"); }
    if (candidate("") !== false) { throw new Exception("Test failed!"); }
    if (candidate("eeeee e ") !== false) { throw new Exception("Test failed!"); }
    if (candidate("apple pie") !== false) { throw new Exception("Test failed!"); }
    if (candidate("apple pi e ") !== false) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function can_arrange($arr) {

function candidate(...$args) {
    return can_arrange(...$args);
}

function test(): void {
    if (candidate(array(1, 2, 4, 3, 5)) !== 3) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 4, 5)) !== -1) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 4, 2, 5, 6, 7, 8, 9, 10)) !== 2) { throw new Exception("Test failed!"); }
    if (candidate(array(4, 8, 5, 7, 3)) !== 4) { throw new Exception("Test failed!"); }
    if (candidate(array()) !== -1) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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)
function largest_smallest_integers($lst) {

function candidate(...$args) {
    return largest_smallest_integers(...$args);
}

function test(): void {
    if (candidate(array(2, 4, 1, 3, 5, 7)) !== array(null, 1)) { throw new Exception("Test failed!"); }
    if (candidate(array(2, 4, 1, 3, 5, 7, 0)) !== array(null, 1)) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 3, 2, 4, 5, 6, -2)) !== array(-2, 1)) { throw new Exception("Test failed!"); }
    if (candidate(array(4, 5, 3, 6, 2, 7, -7)) !== array(-7, 2)) { throw new Exception("Test failed!"); }
    if (candidate(array(7, 3, 8, 4, 9, 2, 5, -9)) !== array(-9, 2)) { throw new Exception("Test failed!"); }
    if (candidate(array()) !== array(null, null)) { throw new Exception("Test failed!"); }
    if (candidate(array(0)) !== array(null, null)) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, -3, -5, -6)) !== array(-1, null)) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, -3, -5, -6, 0)) !== array(-1, null)) { throw new Exception("Test failed!"); }
    if (candidate(array(-6, -4, -4, -3, 1)) !== array(-3, 1)) { throw new Exception("Test failed!"); }
    if (candidate(array(-6, -4, -4, -3, -100, 1)) !== array(-3, 1)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function compare_one($a, $b) {

function candidate(...$args) {
    return compare_one(...$args);
}

function test(): void {
    if (candidate(1, 2) !== 2) { throw new Exception("Test failed!"); }
    if (candidate(1, 2.5) !== 2.5) { throw new Exception("Test failed!"); }
    if (candidate(2, 3) !== 3) { throw new Exception("Test failed!"); }
    if (candidate(5, 6) !== 6) { throw new Exception("Test failed!"); }
    if (candidate(1, "2,3") !== "2,3") { throw new Exception("Test failed!"); }
    if (candidate("5,1", "6") !== "6") { throw new Exception("Test failed!"); }
    if (candidate("1", "2") !== "2") { throw new Exception("Test failed!"); }
    if (candidate("1", 1) !== null) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function is_equal_to_sum_even($n) {

function candidate(...$args) {
    return is_equal_to_sum_even(...$args);
}

function test(): void {
    if (candidate(4) !== false) { throw new Exception("Test failed!"); }
    if (candidate(6) !== false) { throw new Exception("Test failed!"); }
    if (candidate(8) !== true) { throw new Exception("Test failed!"); }
    if (candidate(10) !== true) { throw new Exception("Test failed!"); }
    if (candidate(11) !== false) { throw new Exception("Test failed!"); }
    if (candidate(12) !== true) { throw new Exception("Test failed!"); }
    if (candidate(13) !== false) { throw new Exception("Test failed!"); }
    if (candidate(16) !== true) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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.
function special_factorial($n) {

function candidate(...$args) {
    return special_factorial(...$args);
}

function test(): void {
    if (candidate(4) !== 288) { throw new Exception("Test failed!"); }
    if (candidate(5) !== 34560) { throw new Exception("Test failed!"); }
    if (candidate(7) !== 125411328000) { throw new Exception("Test failed!"); }
    if (candidate(1) !== 1) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// Return a greatest common divisor of two integers a and b
// >>> greatest_common_divisor(3, 5)
// 1
// >>> greatest_common_divisor(25, 15)
// 5
function greatest_common_divisor($a, $b) {

function candidate(...$args) {
    return greatest_common_divisor(...$args);
}

function test(): void {
    if (candidate(3, 7) !== 1) { throw new Exception("Test failed!"); }
    if (candidate(10, 15) !== 5) { throw new Exception("Test failed!"); }
    if (candidate(49, 14) !== 7) { throw new Exception("Test failed!"); }
    if (candidate(144, 60) !== 12) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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"
function fix_spaces($text) {

function candidate(...$args) {
    return fix_spaces(...$args);
}

function test(): void {
    if (candidate("Example") !== "Example") { throw new Exception("Test failed!"); }
    if (candidate("Mudasir Hanif ") !== "Mudasir_Hanif_") { throw new Exception("Test failed!"); }
    if (candidate("Yellow Yellow  Dirty  Fellow") !== "Yellow_Yellow__Dirty__Fellow") { throw new Exception("Test failed!"); }
    if (candidate("Exa   mple") !== "Exa-mple") { throw new Exception("Test failed!"); }
    if (candidate("   Exa 1 2 2 mple") !== "-Exa_1_2_2_mple") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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)
function file_name_check($file_name) {

function candidate(...$args) {
    return file_name_check(...$args);
}

function test(): void {
    if (candidate("example.txt") !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate("1example.dll") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("s1sdf3.asd") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("K.dll") !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate("MY16FILE3.exe") !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate("His12FILE94.exe") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("_Y.txt") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("?aREYA.exe") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("/this_is_valid.dll") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("this_is_valid.wow") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("this_is_valid.txt") !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate("this_is_valid.txtexe") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("#this2_i4s_5valid.ten") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("@this1_is6_valid.exe") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("this_is_12valid.6exe4.txt") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("all.exe.txt") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("I563_No.exe") !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate("Is3youfault.txt") !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate("no_one#knows.dll") !== "Yes") { throw new Exception("Test failed!"); }
    if (candidate("1I563_Yes3.exe") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("I563_Yes3.txtt") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("final..txt") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("final132") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("_f4indsartal132.") !== "No") { throw new Exception("Test failed!"); }
    if (candidate(".txt") !== "No") { throw new Exception("Test failed!"); }
    if (candidate("s.") !== "No") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// "
// 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
function sum_squares($lst) {

function candidate(...$args) {
    return sum_squares(...$args);
}

function test(): void {
    if (candidate(array(1, 2, 3)) !== 6) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 4, 9)) !== 14) { throw new Exception("Test failed!"); }
    if (candidate(array()) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 1, 1, 1, 1, 1, 1, 1, 1)) !== 9) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, -1, -1, -1, -1, -1, -1, -1, -1)) !== -3) { throw new Exception("Test failed!"); }
    if (candidate(array(0)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, -5, 2, -1, -5)) !== -126) { throw new Exception("Test failed!"); }
    if (candidate(array(-56, -99, 1, 0, -2)) !== 3030) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, 0, 0, 0, 0, 0, 0, 0, -1)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37)) !== -14196) { throw new Exception("Test failed!"); }
    if (candidate(array(-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10)) !== -1448) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function words_in_sentence($sentence) {

function candidate(...$args) {
    return words_in_sentence(...$args);
}

function test(): void {
    if (candidate("This is a test") !== "is") { throw new Exception("Test failed!"); }
    if (candidate("lets go for swimming") !== "go for") { throw new Exception("Test failed!"); }
    if (candidate("there is no place available here") !== "there is no place") { throw new Exception("Test failed!"); }
    if (candidate("Hi I am Hussein") !== "Hi am Hussein") { throw new Exception("Test failed!"); }
    if (candidate("go for it") !== "go for it") { throw new Exception("Test failed!"); }
    if (candidate("here") !== "") { throw new Exception("Test failed!"); }
    if (candidate("here is") !== "is") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function simplify($x, $n) {

function candidate(...$args) {
    return simplify(...$args);
}

function test(): void {
    if (candidate("1/5", "5/1") !== true) { throw new Exception("Test failed!"); }
    if (candidate("1/6", "2/1") !== false) { throw new Exception("Test failed!"); }
    if (candidate("5/1", "3/1") !== true) { throw new Exception("Test failed!"); }
    if (candidate("7/10", "10/2") !== false) { throw new Exception("Test failed!"); }
    if (candidate("2/10", "50/10") !== true) { throw new Exception("Test failed!"); }
    if (candidate("7/2", "4/2") !== true) { throw new Exception("Test failed!"); }
    if (candidate("11/6", "6/1") !== true) { throw new Exception("Test failed!"); }
    if (candidate("2/3", "5/2") !== false) { throw new Exception("Test failed!"); }
    if (candidate("5/2", "3/5") !== false) { throw new Exception("Test failed!"); }
    if (candidate("2/4", "8/4") !== true) { throw new Exception("Test failed!"); }
    if (candidate("2/4", "4/2") !== true) { throw new Exception("Test failed!"); }
    if (candidate("1/5", "5/1") !== true) { throw new Exception("Test failed!"); }
    if (candidate("1/5", "1/5") !== false) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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([]) == []
function order_by_points($nums) {


Prompt:
<?php
// 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
function specialFilter($nums) {

function candidate(...$args) {
    return specialFilter(...$args);
}

function test(): void {
    if (candidate(array(5, -2, 1, -5)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(15, -73, 14, -15)) !== 1) { throw new Exception("Test failed!"); }
    if (candidate(array(33, -2, -3, 45, 21, 109)) !== 2) { throw new Exception("Test failed!"); }
    if (candidate(array(43, -12, 93, 125, 121, 109)) !== 4) { throw new Exception("Test failed!"); }
    if (candidate(array(71, -2, -33, 75, 21, 19)) !== 3) { throw new Exception("Test failed!"); }
    if (candidate(array(1)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array()) !== 0) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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).
function get_max_triples($n) {

function candidate(...$args) {
    return get_max_triples(...$args);
}

function test(): void {
    if (candidate(5) !== 1) { throw new Exception("Test failed!"); }
    if (candidate(6) !== 4) { throw new Exception("Test failed!"); }
    if (candidate(10) !== 36) { throw new Exception("Test failed!"); }
    if (candidate(100) !== 53361) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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")
function bf($planet1, $planet2) {

function candidate(...$args) {
    return bf(...$args);
}

function test(): void {
    if (candidate("Jupiter", "Neptune") !== array("Saturn", "Uranus")) { throw new Exception("Test failed!"); }
    if (candidate("Earth", "Mercury") !== array("Venus")) { throw new Exception("Test failed!"); }
    if (candidate("Mercury", "Uranus") !== array("Venus", "Earth", "Mars", "Jupiter", "Saturn")) { throw new Exception("Test failed!"); }
    if (candidate("Neptune", "Venus") !== array("Earth", "Mars", "Jupiter", "Saturn", "Uranus")) { throw new Exception("Test failed!"); }
    if (candidate("Earth", "Earth") !== array()) { throw new Exception("Test failed!"); }
    if (candidate("Mars", "Earth") !== array()) { throw new Exception("Test failed!"); }
    if (candidate("Jupiter", "Makemake") !== array()) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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"]
function sorted_list_sum($lst) {

function candidate(...$args) {
    return sorted_list_sum(...$args);
}

function test(): void {
    if (candidate(array("aa", "a", "aaa")) !== array("aa")) { throw new Exception("Test failed!"); }
    if (candidate(array("school", "AI", "asdf", "b")) !== array("AI", "asdf", "school")) { throw new Exception("Test failed!"); }
    if (candidate(array("d", "b", "c", "a")) !== array()) { throw new Exception("Test failed!"); }
    if (candidate(array("d", "dcba", "abcd", "a")) !== array("abcd", "dcba")) { throw new Exception("Test failed!"); }
    if (candidate(array("AI", "ai", "au")) !== array("AI", "ai", "au")) { throw new Exception("Test failed!"); }
    if (candidate(array("a", "b", "b", "c", "c", "a")) !== array()) { throw new Exception("Test failed!"); }
    if (candidate(array("aaaa", "bbbb", "dd", "cc")) !== array("cc", "dd", "aaaa", "bbbb")) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// Return list of all prefixes from shortest to longest of the input string
// >>> all_prefixes('abc')
// ['a', 'ab', 'abc']
function all_prefixes($string) {

function candidate(...$args) {
    return all_prefixes(...$args);
}

function test(): void {
    if (candidate("") !== array()) { throw new Exception("Test failed!"); }
    if (candidate("asdfgh") !== array("a", "as", "asd", "asdf", "asdfg", "asdfgh")) { throw new Exception("Test failed!"); }
    if (candidate("WWW") !== array("W", "WW", "WWW")) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function x_or_y($n, $x, $y) {

function candidate(...$args) {
    return x_or_y(...$args);
}

function test(): void {
    if (candidate(7, 34, 12) !== 34) { throw new Exception("Test failed!"); }
    if (candidate(15, 8, 5) !== 5) { throw new Exception("Test failed!"); }
    if (candidate(3, 33, 5212) !== 33) { throw new Exception("Test failed!"); }
    if (candidate(1259, 3, 52) !== 3) { throw new Exception("Test failed!"); }
    if (candidate(7919, -1, 12) !== -1) { throw new Exception("Test failed!"); }
    if (candidate(3609, 1245, 583) !== 583) { throw new Exception("Test failed!"); }
    if (candidate(91, 56, 129) !== 129) { throw new Exception("Test failed!"); }
    if (candidate(6, 34, 1234) !== 1234) { throw new Exception("Test failed!"); }
    if (candidate(1, 2, 0) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(2, 2, 0) !== 2) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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.
function double_the_difference($lst) {

function candidate(...$args) {
    return double_the_difference(...$args);
}

function test(): void {
    if (candidate(array()) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(5.0, 4.0)) !== 25) { throw new Exception("Test failed!"); }
    if (candidate(array(0.1, 0.2, 0.3)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(-10.0, -20.0, -30.0)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(-1.0, -2.0, 8.0)) !== 0) { throw new Exception("Test failed!"); }
    if (candidate(array(0.2, 3.0, 5.0)) !== 34) { throw new Exception("Test failed!"); }
    if (candidate(array(-9.0, -7.0, -5.0, -3.0, -1.0, 1.0, 3.0, 5.0, 7.0, 9.0)) !== 165) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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]
function compare($game, $guess) {

function candidate(...$args) {
    return compare(...$args);
}

function test(): void {
    if (candidate(array(1, 2, 3, 4, 5, 1), array(1, 2, 3, 4, 2, -2)) !== array(0, 0, 0, 0, 3, 3)) { throw new Exception("Test failed!"); }
    if (candidate(array(0, 0, 0, 0, 0, 0), array(0, 0, 0, 0, 0, 0)) !== array(0, 0, 0, 0, 0, 0)) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3), array(-1, -2, -3)) !== array(2, 4, 6)) { throw new Exception("Test failed!"); }
    if (candidate(array(1, 2, 3, 5), array(-1, 2, 3, 4)) !== array(2, 0, 0, 1)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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'
function Strongest_Extension($class_name, $extensions) {

function candidate(...$args) {
    return Strongest_Extension(...$args);
}

function test(): void {
    if (candidate("Watashi", array("tEN", "niNE", "eIGHt8OKe")) !== "Watashi.eIGHt8OKe") { throw new Exception("Test failed!"); }
    if (candidate("Boku123", array("nani", "NazeDa", "YEs.WeCaNe", "32145tggg")) !== "Boku123.YEs.WeCaNe") { throw new Exception("Test failed!"); }
    if (candidate("__YESIMHERE", array("t", "eMptY", "nothing", "zeR00", "NuLl__", "123NoooneB321")) !== "__YESIMHERE.NuLl__") { throw new Exception("Test failed!"); }
    if (candidate("K", array("Ta", "TAR", "t234An", "cosSo")) !== "K.TAR") { throw new Exception("Test failed!"); }
    if (candidate("__HAHA", array("Tab", "123", "781345", "-_-")) !== "__HAHA.123") { throw new Exception("Test failed!"); }
    if (candidate("YameRore", array("HhAas", "okIWILL123", "WorkOut", "Fails", "-_-")) !== "YameRore.okIWILL123") { throw new Exception("Test failed!"); }
    if (candidate("finNNalLLly", array("Die", "NowW", "Wow", "WoW")) !== "finNNalLLly.WoW") { throw new Exception("Test failed!"); }
    if (candidate("_", array("Bb", "91245")) !== "_.Bb") { throw new Exception("Test failed!"); }
    if (candidate("Sp", array("671235", "Bb")) !== "Sp.671235") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function cycpattern_check($a, $b) {

function candidate(...$args) {
    return cycpattern_check(...$args);
}

function test(): void {
    if (candidate("xyzw", "xyw") !== false) { throw new Exception("Test failed!"); }
    if (candidate("yello", "ell") !== true) { throw new Exception("Test failed!"); }
    if (candidate("whattup", "ptut") !== false) { throw new Exception("Test failed!"); }
    if (candidate("efef", "fee") !== true) { throw new Exception("Test failed!"); }
    if (candidate("abab", "aabb") !== false) { throw new Exception("Test failed!"); }
    if (candidate("winemtt", "tinem") !== true) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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)
function even_odd_count($num) {

function candidate(...$args) {
    return even_odd_count(...$args);
}

function test(): void {
    if (candidate(7) !== array(0, 1)) { throw new Exception("Test failed!"); }
    if (candidate(-78) !== array(1, 1)) { throw new Exception("Test failed!"); }
    if (candidate(3452) !== array(2, 2)) { throw new Exception("Test failed!"); }
    if (candidate(346211) !== array(3, 3)) { throw new Exception("Test failed!"); }
    if (candidate(-345821) !== array(3, 3)) { throw new Exception("Test failed!"); }
    if (candidate(-2) !== array(1, 0)) { throw new Exception("Test failed!"); }
    if (candidate(-45347) !== array(2, 3)) { throw new Exception("Test failed!"); }
    if (candidate(0) !== array(1, 0)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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'
function int_to_mini_roman($number) {

function candidate(...$args) {
    return int_to_mini_roman(...$args);
}

function test(): void {
    if (candidate(19) !== "xix") { throw new Exception("Test failed!"); }
    if (candidate(152) !== "clii") { throw new Exception("Test failed!"); }
    if (candidate(251) !== "ccli") { throw new Exception("Test failed!"); }
    if (candidate(426) !== "cdxxvi") { throw new Exception("Test failed!"); }
    if (candidate(500) !== "d") { throw new Exception("Test failed!"); }
    if (candidate(1) !== "i") { throw new Exception("Test failed!"); }
    if (candidate(4) !== "iv") { throw new Exception("Test failed!"); }
    if (candidate(43) !== "xliii") { throw new Exception("Test failed!"); }
    if (candidate(90) !== "xc") { throw new Exception("Test failed!"); }
    if (candidate(94) !== "xciv") { throw new Exception("Test failed!"); }
    if (candidate(532) !== "dxxxii") { throw new Exception("Test failed!"); }
    if (candidate(900) !== "cm") { throw new Exception("Test failed!"); }
    if (candidate(994) !== "cmxciv") { throw new Exception("Test failed!"); }
    if (candidate(1000) !== "m") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function right_angle_triangle($a, $b, $c) {

function candidate(...$args) {
    return right_angle_triangle(...$args);
}

function test(): void {
    if (candidate(3, 4, 5) !== true) { throw new Exception("Test failed!"); }
    if (candidate(1, 2, 3) !== false) { throw new Exception("Test failed!"); }
    if (candidate(10, 6, 8) !== true) { throw new Exception("Test failed!"); }
    if (candidate(2, 2, 2) !== false) { throw new Exception("Test failed!"); }
    if (candidate(7, 24, 25) !== true) { throw new Exception("Test failed!"); }
    if (candidate(10, 5, 7) !== false) { throw new Exception("Test failed!"); }
    if (candidate(5, 12, 13) !== true) { throw new Exception("Test failed!"); }
    if (candidate(15, 8, 17) !== true) { throw new Exception("Test failed!"); }
    if (candidate(48, 55, 73) !== true) { throw new Exception("Test failed!"); }
    if (candidate(1, 1, 1) !== false) { throw new Exception("Test failed!"); }
    if (candidate(2, 2, 10) !== false) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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"
function find_max($words) {

function candidate(...$args) {
    return find_max(...$args);
}

function test(): void {
    if (candidate(array("name", "of", "string")) !== "string") { throw new Exception("Test failed!"); }
    if (candidate(array("name", "enam", "game")) !== "enam") { throw new Exception("Test failed!"); }
    if (candidate(array("aaaaaaa", "bb", "cc")) !== "aaaaaaa") { throw new Exception("Test failed!"); }
    if (candidate(array("abc", "cba")) !== "abc") { throw new Exception("Test failed!"); }
    if (candidate(array("play", "this", "game", "of", "footbott")) !== "footbott") { throw new Exception("Test failed!"); }
    if (candidate(array("we", "are", "gonna", "rock")) !== "gonna") { throw new Exception("Test failed!"); }
    if (candidate(array("we", "are", "a", "mad", "nation")) !== "nation") { throw new Exception("Test failed!"); }
    if (candidate(array("this", "is", "a", "prrk")) !== "this") { throw new Exception("Test failed!"); }
    if (candidate(array("b")) !== "b") { throw new Exception("Test failed!"); }
    if (candidate(array("play", "play", "play")) !== "play") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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 :)
function eat($number, $need, $remaining) {

function candidate(...$args) {
    return eat(...$args);
}

function test(): void {
    if (candidate(5, 6, 10) !== array(11, 4)) { throw new Exception("Test failed!"); }
    if (candidate(4, 8, 9) !== array(12, 1)) { throw new Exception("Test failed!"); }
    if (candidate(1, 10, 10) !== array(11, 0)) { throw new Exception("Test failed!"); }
    if (candidate(2, 11, 5) !== array(7, 0)) { throw new Exception("Test failed!"); }
    if (candidate(4, 5, 7) !== array(9, 2)) { throw new Exception("Test failed!"); }
    if (candidate(4, 5, 1) !== array(5, 0)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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'
function string_sequence($n) {

function candidate(...$args) {
    return string_sequence(...$args);
}

function test(): void {
    if (candidate(0) !== "0") { throw new Exception("Test failed!"); }
    if (candidate(3) !== "0 1 2 3") { throw new Exception("Test failed!"); }
    if (candidate(10) !== "0 1 2 3 4 5 6 7 8 9 10") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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.
function do_algebra($operator, $operand) {

function candidate(...$args) {
    return do_algebra(...$args);
}

function test(): void {
    if (candidate(array("**", "*", "+"), array(2, 3, 4, 5)) !== 37) { throw new Exception("Test failed!"); }
    if (candidate(array("+", "*", "-"), array(2, 3, 4, 5)) !== 9) { throw new Exception("Test failed!"); }
    if (candidate(array("//", "*"), array(7, 3, 4)) !== 8) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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"
function solve($s) {

function candidate(...$args) {
    return solve(...$args);
}

function test(): void {
    if (candidate("AsDf") !== "aSdF") { throw new Exception("Test failed!"); }
    if (candidate("1234") !== "4321") { throw new Exception("Test failed!"); }
    if (candidate("ab") !== "AB") { throw new Exception("Test failed!"); }
    if (candidate("#a@C") !== "#A@c") { throw new Exception("Test failed!"); }
    if (candidate("#AsdfW^45") !== "#aSDFw^45") { throw new Exception("Test failed!"); }
    if (candidate("#6@2") !== "2@6#") { throw new Exception("Test failed!"); }
    if (candidate("#$a^D") !== "#$A^d") { throw new Exception("Test failed!"); }
    if (candidate("#ccc") !== "#CCC") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// Given a string 'text', return its md5 hash equivalent string.
// If 'text' is an empty string, return None.
// >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
function string_to_md5($text) {

function candidate(...$args) {
    return string_to_md5(...$args);
}

function test(): void {
    if (candidate("Hello world") !== "3e25960a79dbc69b674cd4ec67a72c62") { throw new Exception("Test failed!"); }
    if (candidate("") !== null) { throw new Exception("Test failed!"); }
    if (candidate("A B C") !== "0ef78513b0cb8cef12743f5aeb35f888") { throw new Exception("Test failed!"); }
    if (candidate("password") !== "5f4dcc3b5aa765d61d8327deb882cf99") { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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) => []
function generate_integers($a, $b) {

function candidate(...$args) {
    return generate_integers(...$args);
}

function test(): void {
    if (candidate(2, 10) !== array(2, 4, 6, 8)) { throw new Exception("Test failed!"); }
    if (candidate(10, 2) !== array(2, 4, 6, 8)) { throw new Exception("Test failed!"); }
    if (candidate(132, 2) !== array(2, 4, 6, 8)) { throw new Exception("Test failed!"); }
    if (candidate(17, 89) !== array()) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function count_distinct_characters($string) {

function candidate(...$args) {
    return count_distinct_characters(...$args);
}

function test(): void {
    if (candidate("") !== 0) { throw new Exception("Test failed!"); }
    if (candidate("abcde") !== 5) { throw new Exception("Test failed!"); }
    if (candidate("abcdecadeCADE") !== 5) { throw new Exception("Test failed!"); }
    if (candidate("aaaaAAAAaaaa") !== 1) { throw new Exception("Test failed!"); }
    if (candidate("Jerry jERRY JeRRRY") !== 5) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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]
function parse_music($music_string) {

function candidate(...$args) {
    return parse_music(...$args);
}

function test(): void {
    if (candidate("") !== array()) { throw new Exception("Test failed!"); }
    if (candidate("o o o o") !== array(4, 4, 4, 4)) { throw new Exception("Test failed!"); }
    if (candidate(".| .| .| .|") !== array(1, 1, 1, 1)) { throw new Exception("Test failed!"); }
    if (candidate("o| o| .| .| o o o o") !== array(2, 2, 1, 1, 4, 4, 4, 4)) { throw new Exception("Test failed!"); }
    if (candidate("o| .| o| .| o o| o o|") !== array(2, 1, 2, 1, 4, 2, 4, 2)) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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
function how_many_times($string, $substring) {

function candidate(...$args) {
    return how_many_times(...$args);
}

function test(): void {
    if (candidate("", "x") !== 0) { throw new Exception("Test failed!"); }
    if (candidate("xyxyxyx", "x") !== 4) { throw new Exception("Test failed!"); }
    if (candidate("cacacacac", "cac") !== 4) { throw new Exception("Test failed!"); }
    if (candidate("john doe", "john") !== 1) { throw new Exception("Test failed!"); }
}

test();


Prompt:
<?php
// 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'
function sort_numbers($numbers) {

function candidate(...$args) {
    return sort_numbers(...$args);
}

function test(): void {
    if (candidate("") !== "") { throw new Exception("Test failed!"); }
    if (candidate("three") !== "three") { throw new Exception("Test failed!"); }
    if (candidate("three five nine") !== "three five nine") { throw new Exception("Test failed!"); }
    if (candidate("five zero four seven nine eight") !== "zero four five seven eight nine") { throw new Exception("Test failed!"); }
    if (candidate("six five four three two one zero") !== "zero one two three four five six") { throw new Exception("Test failed!"); }
}

test();


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


Prompt:
<?php
// From a supplied list of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
// (2.0, 2.2)
// >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
// (2.0, 2.0)
function find_closest_elements($numbers) {

function candidate(...$args) {
    return find_closest_elements(...$args);
}

function test(): void {
    if (candidate(array(1.0, 2.0, 3.9, 4.0, 5.0, 2.2)) !== array(3.9, 4.0)) { throw new Exception("Test failed!"); }
    if (candidate(array(1.0, 2.0, 5.9, 4.0, 5.0)) !== array(5.0, 5.9)) { throw new Exception("Test failed!"); }
    if (candidate(array(1.0, 2.0, 3.0, 4.0, 5.0, 2.2)) !== array(2.0, 2.2)) { throw new Exception("Test failed!"); }
    if (candidate(array(1.0, 2.0, 3.0, 4.0, 5.0, 2.0)) !== array(2.0, 2.0)) { throw new Exception("Test failed!"); }
    if (candidate(array(1.1, 2.2, 3.1, 4.1, 5.1)) !== array(2.2, 3.1)) { throw new Exception("Test failed!"); }
}

test();