Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Check if in given list of numbers, are any two numbers closer to each other than
    // given threshold.
    //     public static bool HasCloseElements(List<float> numbers, float threshold) {

    }
    public static void Main(string[] args) {
    Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.3f)) == (true));
    Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.05f)) == (false));
    Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.95f)) == (true));
    Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.8f)) == (false));
    Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})), (0.1f)) == (true));
    Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (1.0f)) == (true));
    Debug.Assert(HasCloseElements((new List<float>(new float[]{(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (0.5f)) == (false));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<long> MakeAPile(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(MakeAPile((3L)).Equals((new List<long>(new long[]{(long)3L, (long)5L, (long)7L}))));
    Debug.Assert(MakeAPile((4L)).Equals((new List<long>(new long[]{(long)4L, (long)6L, (long)8L, (long)10L}))));
    Debug.Assert(MakeAPile((5L)).Equals((new List<long>(new long[]{(long)5L, (long)7L, (long)9L, (long)11L, (long)13L}))));
    Debug.Assert(MakeAPile((6L)).Equals((new List<long>(new long[]{(long)6L, (long)8L, (long)10L, (long)12L, (long)14L, (long)16L}))));
    Debug.Assert(MakeAPile((8L)).Equals((new List<long>(new long[]{(long)8L, (long)10L, (long)12L, (long)14L, (long)16L, (long)18L, (long)20L, (long)22L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<string> WordsString(string s) {

    }
    public static void Main(string[] args) {
    Debug.Assert(WordsString(("Hi, my name is John")).Equals((new List<string>(new string[]{(string)"Hi", (string)"my", (string)"name", (string)"is", (string)"John"}))));
    Debug.Assert(WordsString(("One, two, three, four, five, six")).Equals((new List<string>(new string[]{(string)"One", (string)"two", (string)"three", (string)"four", (string)"five", (string)"six"}))));
    Debug.Assert(WordsString(("Hi, my name")).Equals((new List<string>(new string[]{(string)"Hi", (string)"my", (string)"name"}))));
    Debug.Assert(WordsString(("One,, two, three, four, five, six,")).Equals((new List<string>(new string[]{(string)"One", (string)"two", (string)"three", (string)"four", (string)"five", (string)"six"}))));
    Debug.Assert(WordsString(("")).Equals((new List<string>())));
    Debug.Assert(WordsString(("ahmed     , gamal")).Equals((new List<string>(new string[]{(string)"ahmed", (string)"gamal"}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static long ChooseNum(long x, long y) {

    }
    public static void Main(string[] args) {
    Debug.Assert(ChooseNum((12L), (15L)) == (14L));
    Debug.Assert(ChooseNum((13L), (12L)) == (-1L));
    Debug.Assert(ChooseNum((33L), (12354L)) == (12354L));
    Debug.Assert(ChooseNum((5234L), (5233L)) == (-1L));
    Debug.Assert(ChooseNum((6L), (29L)) == (28L));
    Debug.Assert(ChooseNum((27L), (10L)) == (-1L));
    Debug.Assert(ChooseNum((7L), (7L)) == (-1L));
    Debug.Assert(ChooseNum((546L), (546L)) == (546L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<long> UniqueDigits(List<long> x) {

    }
    public static void Main(string[] args) {
    Debug.Assert(UniqueDigits((new List<long>(new long[]{(long)15L, (long)33L, (long)1422L, (long)1L}))).Equals((new List<long>(new long[]{(long)1L, (long)15L, (long)33L}))));
    Debug.Assert(UniqueDigits((new List<long>(new long[]{(long)152L, (long)323L, (long)1422L, (long)10L}))).Equals((new List<long>())));
    Debug.Assert(UniqueDigits((new List<long>(new long[]{(long)12345L, (long)2033L, (long)111L, (long)151L}))).Equals((new List<long>(new long[]{(long)111L, (long)151L}))));
    Debug.Assert(UniqueDigits((new List<long>(new long[]{(long)135L, (long)103L, (long)31L}))).Equals((new List<long>(new long[]{(long)31L, (long)135L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    // If the array is empty, return an empty array:
    // If the array has any strange number ignore it:
    //     public static List<string> ByLength(List<long> arr) {

    }
    public static void Main(string[] args) {
    Debug.Assert(ByLength((new List<long>(new long[]{(long)2L, (long)1L, (long)1L, (long)4L, (long)5L, (long)8L, (long)2L, (long)3L}))).Equals((new List<string>(new string[]{(string)"Eight", (string)"Five", (string)"Four", (string)"Three", (string)"Two", (string)"Two", (string)"One", (string)"One"}))));
    Debug.Assert(ByLength((new List<long>())).Equals((new List<string>())));
    Debug.Assert(ByLength((new List<long>(new long[]{(long)1L, (long)-1L, (long)55L}))).Equals((new List<string>(new string[]{(string)"One"}))));
    Debug.Assert(ByLength((new List<long>(new long[]{(long)1L, (long)-1L, (long)3L, (long)2L}))).Equals((new List<string>(new string[]{(string)"Three", (string)"Two", (string)"One"}))));
    Debug.Assert(ByLength((new List<long>(new long[]{(long)9L, (long)4L, (long)8L}))).Equals((new List<string>(new string[]{(string)"Nine", (string)"Eight", (string)"Four"}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<long> F(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(F((5L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)6L, (long)24L, (long)15L}))));
    Debug.Assert(F((7L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)6L, (long)24L, (long)15L, (long)720L, (long)28L}))));
    Debug.Assert(F((1L)).Equals((new List<long>(new long[]{(long)1L}))));
    Debug.Assert(F((3L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)6L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    // Explanation:
    // Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
    // Example 2:
    // 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.
    //     public static Tuple<long, long> EvenOddPalindrome(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(EvenOddPalindrome((123L)).Equals((Tuple.Create(8L, 13L))));
    Debug.Assert(EvenOddPalindrome((12L)).Equals((Tuple.Create(4L, 6L))));
    Debug.Assert(EvenOddPalindrome((3L)).Equals((Tuple.Create(1L, 2L))));
    Debug.Assert(EvenOddPalindrome((63L)).Equals((Tuple.Create(6L, 8L))));
    Debug.Assert(EvenOddPalindrome((25L)).Equals((Tuple.Create(5L, 6L))));
    Debug.Assert(EvenOddPalindrome((19L)).Equals((Tuple.Create(4L, 6L))));
    Debug.Assert(EvenOddPalindrome((9L)).Equals((Tuple.Create(4L, 5L))));
    Debug.Assert(EvenOddPalindrome((1L)).Equals((Tuple.Create(0L, 1L))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    //     public static long CountNums(List<long> arr) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CountNums((new List<long>())) == (0L));
    Debug.Assert(CountNums((new List<long>(new long[]{(long)-1L, (long)-2L, (long)0L}))) == (0L));
    Debug.Assert(CountNums((new List<long>(new long[]{(long)1L, (long)1L, (long)2L, (long)-2L, (long)3L, (long)4L, (long)5L}))) == (6L));
    Debug.Assert(CountNums((new List<long>(new long[]{(long)1L, (long)6L, (long)9L, (long)-6L, (long)0L, (long)1L, (long)5L}))) == (5L));
    Debug.Assert(CountNums((new List<long>(new long[]{(long)1L, (long)100L, (long)98L, (long)-7L, (long)1L, (long)-1L}))) == (4L));
    Debug.Assert(CountNums((new List<long>(new long[]{(long)12L, (long)23L, (long)34L, (long)-45L, (long)-56L, (long)0L}))) == (5L));
    Debug.Assert(CountNums((new List<long>(new long[]{(long)0L, (long)1L}))) == (1L));
    Debug.Assert(CountNums((new List<long>(new long[]{(long)1L}))) == (1L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    // Explanation: By performin 2 right shift operations, non-decreasing order can
    // be achieved for the given array.
    // Explanation:It is not possible to get non-decreasing order for the given
    // array by performing any number of right shift operations.
    //     public static bool MoveOneBall(List<long> arr) {

    }
    public static void Main(string[] args) {
    Debug.Assert(MoveOneBall((new List<long>(new long[]{(long)3L, (long)4L, (long)5L, (long)1L, (long)2L}))) == (true));
    Debug.Assert(MoveOneBall((new List<long>(new long[]{(long)3L, (long)5L, (long)10L, (long)1L, (long)2L}))) == (true));
    Debug.Assert(MoveOneBall((new List<long>(new long[]{(long)4L, (long)3L, (long)1L, (long)2L}))) == (false));
    Debug.Assert(MoveOneBall((new List<long>(new long[]{(long)3L, (long)5L, (long)4L, (long)1L, (long)2L}))) == (false));
    Debug.Assert(MoveOneBall((new List<long>())) == (true));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    //     public static string MakePalindrome(string str) {

    }
    public static void Main(string[] args) {
    Debug.Assert(MakePalindrome(("")).Equals(("")));
    Debug.Assert(MakePalindrome(("x")).Equals(("x")));
    Debug.Assert(MakePalindrome(("xyz")).Equals(("xyzyx")));
    Debug.Assert(MakePalindrome(("xyx")).Equals(("xyx")));
    Debug.Assert(MakePalindrome(("jerry")).Equals(("jerryrrej")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    // It is assumed that the input lists will be non-empty.
    //     public static string Exchange(List<long> lst1, List<long> lst2) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Exchange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})), (new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))).Equals(("YES")));
    Debug.Assert(Exchange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})), (new List<long>(new long[]{(long)1L, (long)5L, (long)3L, (long)4L}))).Equals(("NO")));
    Debug.Assert(Exchange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})), (new List<long>(new long[]{(long)2L, (long)1L, (long)4L, (long)3L}))).Equals(("YES")));
    Debug.Assert(Exchange((new List<long>(new long[]{(long)5L, (long)7L, (long)3L})), (new List<long>(new long[]{(long)2L, (long)6L, (long)4L}))).Equals(("YES")));
    Debug.Assert(Exchange((new List<long>(new long[]{(long)5L, (long)7L, (long)3L})), (new List<long>(new long[]{(long)2L, (long)6L, (long)3L}))).Equals(("NO")));
    Debug.Assert(Exchange((new List<long>(new long[]{(long)3L, (long)2L, (long)6L, (long)1L, (long)8L, (long)9L})), (new List<long>(new long[]{(long)3L, (long)5L, (long)5L, (long)1L, (long)1L, (long)1L}))).Equals(("NO")));
    Debug.Assert(Exchange((new List<long>(new long[]{(long)100L, (long)200L})), (new List<long>(new long[]{(long)200L, (long)200L}))).Equals(("YES")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static Dictionary<string,long> Histogram(string test) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Histogram(("a b b a")).Equals((new Dictionary<string,long>(){{"a", 2L}, {"b", 2L}})));
    Debug.Assert(Histogram(("a b c a b")).Equals((new Dictionary<string,long>(){{"a", 2L}, {"b", 2L}})));
    Debug.Assert(Histogram(("a b c d g")).Equals((new Dictionary<string,long>(){{"a", 1L}, {"b", 1L}, {"c", 1L}, {"d", 1L}, {"g", 1L}})));
    Debug.Assert(Histogram(("r t g")).Equals((new Dictionary<string,long>(){{"r", 1L}, {"t", 1L}, {"g", 1L}})));
    Debug.Assert(Histogram(("b b b b a")).Equals((new Dictionary<string,long>(){{"b", 4L}})));
    Debug.Assert(Histogram(("r t g")).Equals((new Dictionary<string,long>(){{"r", 1L}, {"t", 1L}, {"g", 1L}})));
    Debug.Assert(Histogram(("")).Equals((new Dictionary<string,long>())));
    Debug.Assert(Histogram(("a")).Equals((new Dictionary<string,long>(){{"a", 1L}})));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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
    //     public static Tuple<string, bool> ReverseDelete(string s, string c) {

    }
    public static void Main(string[] args) {
    Debug.Assert(ReverseDelete(("abcde"), ("ae")).Equals((Tuple.Create("bcd", false))));
    Debug.Assert(ReverseDelete(("abcdef"), ("b")).Equals((Tuple.Create("acdef", false))));
    Debug.Assert(ReverseDelete(("abcdedcba"), ("ab")).Equals((Tuple.Create("cdedc", true))));
    Debug.Assert(ReverseDelete(("dwik"), ("w")).Equals((Tuple.Create("dik", false))));
    Debug.Assert(ReverseDelete(("a"), ("a")).Equals((Tuple.Create("", true))));
    Debug.Assert(ReverseDelete(("abcdedcba"), ("")).Equals((Tuple.Create("abcdedcba", true))));
    Debug.Assert(ReverseDelete(("abcdedcba"), ("v")).Equals((Tuple.Create("abcdedcba", true))));
    Debug.Assert(ReverseDelete(("vabba"), ("v")).Equals((Tuple.Create("abba", true))));
    Debug.Assert(ReverseDelete(("mamma"), ("mia")).Equals((Tuple.Create("", true))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    //     public static List<string> OddCount(List<string> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(OddCount((new List<string>(new string[]{(string)"1234567"}))).Equals((new List<string>(new string[]{(string)"the number of odd elements 4n the str4ng 4 of the 4nput."}))));
    Debug.Assert(OddCount((new List<string>(new string[]{(string)"3", (string)"11111111"}))).Equals((new List<string>(new string[]{(string)"the number of odd elements 1n the str1ng 1 of the 1nput.", (string)"the number of odd elements 8n the str8ng 8 of the 8nput."}))));
    Debug.Assert(OddCount((new List<string>(new string[]{(string)"271", (string)"137", (string)"314"}))).Equals((new List<string>(new string[]{(string)"the number of odd elements 2n the str2ng 2 of the 2nput.", (string)"the number of odd elements 3n the str3ng 3 of the 3nput.", (string)"the number of odd elements 2n the str2ng 2 of the 2nput."}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Given an array of integers nums, find the minimum sum of any non-empty sub-array
    // of nums.
    // Example
    //     public static long Minsubarraysum(List<long> nums) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)2L, (long)3L, (long)4L, (long)1L, (long)2L, (long)4L}))) == (1L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-1L, (long)-2L, (long)-3L}))) == (-6L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-1L, (long)-2L, (long)-3L, (long)2L, (long)-10L}))) == (-14L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-9999999999999999L}))) == (-9999999999999999L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)0L, (long)10L, (long)20L, (long)1000000L}))) == (0L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-1L, (long)-2L, (long)-3L, (long)10L, (long)-5L}))) == (-6L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)100L, (long)-1L, (long)-2L, (long)-3L, (long)10L, (long)-5L}))) == (-6L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)10L, (long)11L, (long)13L, (long)8L, (long)3L, (long)4L}))) == (3L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)100L, (long)-33L, (long)32L, (long)-1L, (long)0L, (long)-2L}))) == (-33L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)-10L}))) == (-10L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)7L}))) == (7L));
    Debug.Assert(Minsubarraysum((new List<long>(new long[]{(long)1L, (long)-1L}))) == (-1L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    // Example 2:
    // Example 3:
    // 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
    //     public static long MaxFill(List<List<long>> grid, long capacity) {

    }
    public static void Main(string[] args) {
    Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)1L, (long)0L}), (List<long>)new List<long>(new long[]{(long)0L, (long)1L, (long)0L, (long)0L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L})})), (1L)) == (6L));
    Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)0L, (long)1L, (long)1L, (long)1L})})), (2L)) == (5L));
    Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)0L}), (List<long>)new List<long>(new long[]{(long)0L, (long)0L, (long)0L})})), (5L)) == (0L));
    Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L})})), (2L)) == (4L));
    Debug.Assert(MaxFill((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L})})), (9L)) == (2L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<long> SortArray(List<long> arr) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SortArray((new List<long>(new long[]{(long)1L, (long)5L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)3L, (long)5L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)-2L, (long)-3L, (long)-4L, (long)-5L, (long)-6L}))).Equals((new List<long>(new long[]{(long)-4L, (long)-2L, (long)-6L, (long)-5L, (long)-3L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)1L, (long)0L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)0L, (long)1L, (long)2L, (long)4L, (long)3L}))));
    Debug.Assert(SortArray((new List<long>())).Equals((new List<long>())));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)5L, (long)77L, (long)4L, (long)5L, (long)3L, (long)5L, (long)7L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)4L, (long)4L, (long)3L, (long)3L, (long)5L, (long)5L, (long)5L, (long)7L, (long)77L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)3L, (long)6L, (long)44L, (long)12L, (long)32L, (long)5L}))).Equals((new List<long>(new long[]{(long)32L, (long)3L, (long)5L, (long)6L, (long)12L, (long)44L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)8L, (long)16L, (long)32L}))).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)8L, (long)16L, (long)32L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)8L, (long)16L, (long)32L}))).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)8L, (long)16L, (long)32L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<string> SelectWords(string s, long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SelectWords(("Mary had a little lamb"), (4L)).Equals((new List<string>(new string[]{(string)"little"}))));
    Debug.Assert(SelectWords(("Mary had a little lamb"), (3L)).Equals((new List<string>(new string[]{(string)"Mary", (string)"lamb"}))));
    Debug.Assert(SelectWords(("simple white space"), (2L)).Equals((new List<string>())));
    Debug.Assert(SelectWords(("Hello world"), (4L)).Equals((new List<string>(new string[]{(string)"world"}))));
    Debug.Assert(SelectWords(("Uncle sam"), (3L)).Equals((new List<string>(new string[]{(string)"Uncle"}))));
    Debug.Assert(SelectWords((""), (4L)).Equals((new List<string>())));
    Debug.Assert(SelectWords(("a b c d e f"), (1L)).Equals((new List<string>(new string[]{(string)"b", (string)"c", (string)"d", (string)"f"}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static string GetClosestVowel(string word) {

    }
    public static void Main(string[] args) {
    Debug.Assert(GetClosestVowel(("yogurt")).Equals(("u")));
    Debug.Assert(GetClosestVowel(("full")).Equals(("u")));
    Debug.Assert(GetClosestVowel(("easy")).Equals(("")));
    Debug.Assert(GetClosestVowel(("eAsy")).Equals(("")));
    Debug.Assert(GetClosestVowel(("ali")).Equals(("")));
    Debug.Assert(GetClosestVowel(("bad")).Equals(("a")));
    Debug.Assert(GetClosestVowel(("most")).Equals(("o")));
    Debug.Assert(GetClosestVowel(("ab")).Equals(("")));
    Debug.Assert(GetClosestVowel(("ba")).Equals(("")));
    Debug.Assert(GetClosestVowel(("quick")).Equals(("")));
    Debug.Assert(GetClosestVowel(("anime")).Equals(("i")));
    Debug.Assert(GetClosestVowel(("Asia")).Equals(("")));
    Debug.Assert(GetClosestVowel(("Above")).Equals(("o")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static string MatchParens(List<string> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)"()(", (string)")"}))).Equals(("Yes")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)")", (string)")"}))).Equals(("No")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)"(()(())", (string)"())())"}))).Equals(("No")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)")())", (string)"(()()("}))).Equals(("Yes")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)"(())))", (string)"(()())(("}))).Equals(("Yes")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)"()", (string)"())"}))).Equals(("No")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)"(()(", (string)"()))()"}))).Equals(("Yes")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)"((((", (string)"((())"}))).Equals(("No")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)")(()", (string)"(()("}))).Equals(("No")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)")(", (string)")("}))).Equals(("No")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)"(", (string)")"}))).Equals(("Yes")));
    Debug.Assert(MatchParens((new List<string>(new string[]{(string)")", (string)"("}))).Equals(("Yes")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    //     public static string StringXor(string a, string b) {

    }
    public static void Main(string[] args) {
    Debug.Assert(StringXor(("111000"), ("101010")).Equals(("010010")));
    Debug.Assert(StringXor(("1"), ("1")).Equals(("0")));
    Debug.Assert(StringXor(("0101"), ("0000")).Equals(("0101")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    // Example 2:
    // Example 3:
    // 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)
    //     public static List<long> Maximum(List<long> arr, long k) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Maximum((new List<long>(new long[]{(long)-3L, (long)-4L, (long)5L})), (3L)).Equals((new List<long>(new long[]{(long)-4L, (long)-3L, (long)5L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)4L, (long)-4L, (long)4L})), (2L)).Equals((new List<long>(new long[]{(long)4L, (long)4L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)-3L, (long)2L, (long)1L, (long)2L, (long)-1L, (long)-2L, (long)1L})), (1L)).Equals((new List<long>(new long[]{(long)2L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)123L, (long)-123L, (long)20L, (long)0L, (long)1L, (long)2L, (long)-3L})), (3L)).Equals((new List<long>(new long[]{(long)2L, (long)20L, (long)123L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)-123L, (long)20L, (long)0L, (long)1L, (long)2L, (long)-3L})), (4L)).Equals((new List<long>(new long[]{(long)0L, (long)1L, (long)2L, (long)20L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)5L, (long)15L, (long)0L, (long)3L, (long)-13L, (long)-8L, (long)0L})), (7L)).Equals((new List<long>(new long[]{(long)-13L, (long)-8L, (long)0L, (long)0L, (long)3L, (long)5L, (long)15L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)-1L, (long)0L, (long)2L, (long)5L, (long)3L, (long)-10L})), (2L)).Equals((new List<long>(new long[]{(long)3L, (long)5L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)1L, (long)0L, (long)5L, (long)-7L})), (1L)).Equals((new List<long>(new long[]{(long)5L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)4L, (long)-4L})), (2L)).Equals((new List<long>(new long[]{(long)-4L, (long)4L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)-10L, (long)10L})), (2L)).Equals((new List<long>(new long[]{(long)-10L, (long)10L}))));
    Debug.Assert(Maximum((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)-23L, (long)243L, (long)-400L, (long)0L})), (0L)).Equals((new List<long>())));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Given a non-empty list of integers, return the sum of all of the odd elements that are in even positions.
    // Examples
    //     public static long Solution(List<long> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Solution((new List<long>(new long[]{(long)5L, (long)8L, (long)7L, (long)1L}))) == (12L));
    Debug.Assert(Solution((new List<long>(new long[]{(long)3L, (long)3L, (long)3L, (long)3L, (long)3L}))) == (9L));
    Debug.Assert(Solution((new List<long>(new long[]{(long)30L, (long)13L, (long)24L, (long)321L}))) == (0L));
    Debug.Assert(Solution((new List<long>(new long[]{(long)5L, (long)9L}))) == (5L));
    Debug.Assert(Solution((new List<long>(new long[]{(long)2L, (long)4L, (long)8L}))) == (0L));
    Debug.Assert(Solution((new List<long>(new long[]{(long)30L, (long)13L, (long)23L, (long)32L}))) == (23L));
    Debug.Assert(Solution((new List<long>(new long[]{(long)3L, (long)13L, (long)2L, (long)9L}))) == (3L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    // Constraints:
    // 1. 1 <= len(arr) <= 100
    // 2. 1 <= k <= len(arr)
    //     public static long AddElements(List<long> arr, long k) {

    }
    public static void Main(string[] args) {
    Debug.Assert(AddElements((new List<long>(new long[]{(long)1L, (long)-2L, (long)-3L, (long)41L, (long)57L, (long)76L, (long)87L, (long)88L, (long)99L})), (3L)) == (-4L));
    Debug.Assert(AddElements((new List<long>(new long[]{(long)111L, (long)121L, (long)3L, (long)4000L, (long)5L, (long)6L})), (2L)) == (0L));
    Debug.Assert(AddElements((new List<long>(new long[]{(long)11L, (long)21L, (long)3L, (long)90L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L})), (4L)) == (125L));
    Debug.Assert(AddElements((new List<long>(new long[]{(long)111L, (long)21L, (long)3L, (long)4000L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L})), (4L)) == (24L));
    Debug.Assert(AddElements((new List<long>(new long[]{(long)1L})), (1L)) == (1L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    //     public static List<long> GetOddCollatz(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(GetOddCollatz((14L)).Equals((new List<long>(new long[]{(long)1L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L}))));
    Debug.Assert(GetOddCollatz((5L)).Equals((new List<long>(new long[]{(long)1L, (long)5L}))));
    Debug.Assert(GetOddCollatz((12L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)5L}))));
    Debug.Assert(GetOddCollatz((1L)).Equals((new List<long>(new long[]{(long)1L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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
    //     public static bool ValidDate(string date) {

    }
    public static void Main(string[] args) {
    Debug.Assert(ValidDate(("03-11-2000")) == (true));
    Debug.Assert(ValidDate(("15-01-2012")) == (false));
    Debug.Assert(ValidDate(("04-0-2040")) == (false));
    Debug.Assert(ValidDate(("06-04-2020")) == (true));
    Debug.Assert(ValidDate(("01-01-2007")) == (true));
    Debug.Assert(ValidDate(("03-32-2011")) == (false));
    Debug.Assert(ValidDate(("")) == (false));
    Debug.Assert(ValidDate(("04-31-3000")) == (false));
    Debug.Assert(ValidDate(("06-06-2005")) == (true));
    Debug.Assert(ValidDate(("21-31-2000")) == (false));
    Debug.Assert(ValidDate(("04-12-2003")) == (true));
    Debug.Assert(ValidDate(("04122003")) == (false));
    Debug.Assert(ValidDate(("20030412")) == (false));
    Debug.Assert(ValidDate(("2003-04")) == (false));
    Debug.Assert(ValidDate(("2003-04-12")) == (false));
    Debug.Assert(ValidDate(("04-2003")) == (false));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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
    //     public static bool IsSorted(List<long> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)5L}))) == (true));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))) == (true));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)4L, (long)5L}))) == (false));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}))) == (true));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L}))) == (true));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)4L, (long)5L, (long)6L, (long)7L}))) == (false));
    Debug.Assert(IsSorted((new List<long>())) == (true));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L}))) == (true));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)3L, (long)2L, (long)1L}))) == (false));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)2L, (long)3L, (long)4L}))) == (false));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)3L, (long)3L, (long)4L}))) == (false));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)3L, (long)3L, (long)4L}))) == (true));
    Debug.Assert(IsSorted((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}))) == (true));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static string Intersection(Tuple<long, long> interval1, Tuple<long, long> interval2) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Intersection((Tuple.Create(1L, 2L)), (Tuple.Create(2L, 3L))).Equals(("NO")));
    Debug.Assert(Intersection((Tuple.Create(-1L, 1L)), (Tuple.Create(0L, 4L))).Equals(("NO")));
    Debug.Assert(Intersection((Tuple.Create(-3L, -1L)), (Tuple.Create(-5L, 5L))).Equals(("YES")));
    Debug.Assert(Intersection((Tuple.Create(-2L, 2L)), (Tuple.Create(-4L, 0L))).Equals(("YES")));
    Debug.Assert(Intersection((Tuple.Create(-11L, 2L)), (Tuple.Create(-1L, -1L))).Equals(("NO")));
    Debug.Assert(Intersection((Tuple.Create(1L, 2L)), (Tuple.Create(3L, 5L))).Equals(("NO")));
    Debug.Assert(Intersection((Tuple.Create(1L, 2L)), (Tuple.Create(1L, 2L))).Equals(("NO")));
    Debug.Assert(Intersection((Tuple.Create(-2L, -2L)), (Tuple.Create(-3L, -2L))).Equals(("NO")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static Nullable<long> ProdSigns(List<long> arr) {

    }
    public static void Main(string[] args) {
    Debug.Assert(ProdSigns((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)-4L}))).Equals(-9L));
    Debug.Assert(ProdSigns((new List<long>(new long[]{(long)0L, (long)1L}))).Equals(0L));
    Debug.Assert(ProdSigns((new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)2L, (long)3L, (long)-1L, (long)1L}))).Equals(-10L));
    Debug.Assert(ProdSigns((new List<long>())).Equals(null));
    Debug.Assert(ProdSigns((new List<long>(new long[]{(long)2L, (long)4L, (long)1L, (long)2L, (long)-1L, (long)-1L, (long)9L}))).Equals(20L));
    Debug.Assert(ProdSigns((new List<long>(new long[]{(long)-1L, (long)1L, (long)-1L, (long)1L}))).Equals(4L));
    Debug.Assert(ProdSigns((new List<long>(new long[]{(long)-1L, (long)1L, (long)1L, (long)1L}))).Equals(-4L));
    Debug.Assert(ProdSigns((new List<long>(new long[]{(long)-1L, (long)1L, (long)1L, (long)0L}))).Equals(0L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<long> Minpath(List<List<long>> grid, long k) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L}), (List<long>)new List<long>(new long[]{(long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)7L, (long)8L, (long)9L})})), (3L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)1L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)5L, (long)9L, (long)3L}), (List<long>)new List<long>(new long[]{(long)4L, (long)1L, (long)6L}), (List<long>)new List<long>(new long[]{(long)7L, (long)8L, (long)2L})})), (1L)).Equals((new List<long>(new long[]{(long)1L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L}), (List<long>)new List<long>(new long[]{(long)5L, (long)6L, (long)7L, (long)8L}), (List<long>)new List<long>(new long[]{(long)9L, (long)10L, (long)11L, (long)12L}), (List<long>)new List<long>(new long[]{(long)13L, (long)14L, (long)15L, (long)16L})})), (4L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)1L, (long)2L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)6L, (long)4L, (long)13L, (long)10L}), (List<long>)new List<long>(new long[]{(long)5L, (long)7L, (long)12L, (long)1L}), (List<long>)new List<long>(new long[]{(long)3L, (long)16L, (long)11L, (long)15L}), (List<long>)new List<long>(new long[]{(long)8L, (long)14L, (long)9L, (long)2L})})), (7L)).Equals((new List<long>(new long[]{(long)1L, (long)10L, (long)1L, (long)10L, (long)1L, (long)10L, (long)1L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)8L, (long)14L, (long)9L, (long)2L}), (List<long>)new List<long>(new long[]{(long)6L, (long)4L, (long)13L, (long)15L}), (List<long>)new List<long>(new long[]{(long)5L, (long)7L, (long)1L, (long)12L}), (List<long>)new List<long>(new long[]{(long)3L, (long)10L, (long)11L, (long)16L})})), (5L)).Equals((new List<long>(new long[]{(long)1L, (long)7L, (long)1L, (long)7L, (long)1L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)11L, (long)8L, (long)7L, (long)2L}), (List<long>)new List<long>(new long[]{(long)5L, (long)16L, (long)14L, (long)4L}), (List<long>)new List<long>(new long[]{(long)9L, (long)3L, (long)15L, (long)6L}), (List<long>)new List<long>(new long[]{(long)12L, (long)13L, (long)10L, (long)1L})})), (9L)).Equals((new List<long>(new long[]{(long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)12L, (long)13L, (long)10L, (long)1L}), (List<long>)new List<long>(new long[]{(long)9L, (long)3L, (long)15L, (long)6L}), (List<long>)new List<long>(new long[]{(long)5L, (long)16L, (long)14L, (long)4L}), (List<long>)new List<long>(new long[]{(long)11L, (long)8L, (long)7L, (long)2L})})), (12L)).Equals((new List<long>(new long[]{(long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L, (long)1L, (long)6L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)2L, (long)7L, (long)4L}), (List<long>)new List<long>(new long[]{(long)3L, (long)1L, (long)5L}), (List<long>)new List<long>(new long[]{(long)6L, (long)8L, (long)9L})})), (8L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)6L, (long)1L, (long)5L}), (List<long>)new List<long>(new long[]{(long)3L, (long)8L, (long)9L}), (List<long>)new List<long>(new long[]{(long)2L, (long)7L, (long)4L})})), (8L)).Equals((new List<long>(new long[]{(long)1L, (long)5L, (long)1L, (long)5L, (long)1L, (long)5L, (long)1L, (long)5L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L}), (List<long>)new List<long>(new long[]{(long)3L, (long)4L})})), (10L)).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)1L, (long)2L, (long)1L, (long)2L, (long)1L, (long)2L, (long)1L, (long)2L}))));
    Debug.Assert(Minpath((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)3L}), (List<long>)new List<long>(new long[]{(long)3L, (long)2L})})), (10L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L, (long)1L, (long)3L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    //     public static string Longest(List<string> strings) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Longest((new List<string>())).Equals(null));
    Debug.Assert(Longest((new List<string>(new string[]{(string)"x", (string)"y", (string)"z"}))).Equals(("x")));
    Debug.Assert(Longest((new List<string>(new string[]{(string)"x", (string)"yyy", (string)"zzzz", (string)"www", (string)"kkkk", (string)"abc"}))).Equals(("zzzz")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<long> Tri(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Tri((3L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L}))));
    Debug.Assert(Tri((4L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L}))));
    Debug.Assert(Tri((5L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L}))));
    Debug.Assert(Tri((6L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L}))));
    Debug.Assert(Tri((7L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L, (long)24L}))));
    Debug.Assert(Tri((8L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L, (long)24L, (long)5L}))));
    Debug.Assert(Tri((9L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L, (long)24L, (long)5L, (long)35L}))));
    Debug.Assert(Tri((20L)).Equals((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)8L, (long)3L, (long)15L, (long)4L, (long)24L, (long)5L, (long)35L, (long)6L, (long)48L, (long)7L, (long)63L, (long)8L, (long)80L, (long)9L, (long)99L, (long)10L, (long)120L, (long)11L}))));
    Debug.Assert(Tri((0L)).Equals((new List<long>(new long[]{(long)1L}))));
    Debug.Assert(Tri((1L)).Equals((new List<long>(new long[]{(long)1L, (long)3L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Given a positive integer n, return the product of the odd digits.
    // Return 0 if all digits are even.
    // For example:
    //     public static long Digits(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Digits((5L)) == (5L));
    Debug.Assert(Digits((54L)) == (5L));
    Debug.Assert(Digits((120L)) == (1L));
    Debug.Assert(Digits((5014L)) == (5L));
    Debug.Assert(Digits((98765L)) == (315L));
    Debug.Assert(Digits((5576543L)) == (2625L));
    Debug.Assert(Digits((2468L)) == (0L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    //     public static bool IsNested(string str) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IsNested(("[[]]")) == (true));
    Debug.Assert(IsNested(("[]]]]]]][[[[[]")) == (false));
    Debug.Assert(IsNested(("[][]")) == (false));
    Debug.Assert(IsNested(("[]")) == (false));
    Debug.Assert(IsNested(("[[[[]]]]")) == (true));
    Debug.Assert(IsNested(("[]]]]]]]]]]")) == (false));
    Debug.Assert(IsNested(("[][][[]]")) == (true));
    Debug.Assert(IsNested(("[[]")) == (false));
    Debug.Assert(IsNested(("[]]")) == (false));
    Debug.Assert(IsNested(("[[]][[")) == (true));
    Debug.Assert(IsNested(("[[][]]")) == (true));
    Debug.Assert(IsNested(("")) == (false));
    Debug.Assert(IsNested(("[[[[[[[[")) == (false));
    Debug.Assert(IsNested(("]]]]]]]]")) == (false));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static long SumSquares(List<float> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f}))) == (14L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f}))) == (14L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f}))) == (84L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)1.4f, (float)4.2f, (float)0.0f}))) == (29L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)-2.4f, (float)1.0f, (float)1.0f}))) == (6L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)100.0f, (float)1.0f, (float)15.0f, (float)2.0f}))) == (10230L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)10000.0f, (float)10000.0f}))) == (200000000L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)-1.4f, (float)4.6f, (float)6.3f}))) == (75L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)-1.4f, (float)17.9f, (float)18.9f, (float)19.9f}))) == (1086L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)0.0f}))) == (0L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)-1.0f}))) == (1L));
    Debug.Assert(SumSquares((new List<float>(new float[]{(float)-1.0f, (float)1.0f, (float)0.0f}))) == (2L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static bool CheckIfLastCharIsALetter(string txt) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CheckIfLastCharIsALetter(("apple")) == (false));
    Debug.Assert(CheckIfLastCharIsALetter(("apple pi e")) == (true));
    Debug.Assert(CheckIfLastCharIsALetter(("eeeee")) == (false));
    Debug.Assert(CheckIfLastCharIsALetter(("A")) == (true));
    Debug.Assert(CheckIfLastCharIsALetter(("Pumpkin pie ")) == (false));
    Debug.Assert(CheckIfLastCharIsALetter(("Pumpkin pie 1")) == (false));
    Debug.Assert(CheckIfLastCharIsALetter(("")) == (false));
    Debug.Assert(CheckIfLastCharIsALetter(("eeeee e ")) == (false));
    Debug.Assert(CheckIfLastCharIsALetter(("apple pie")) == (false));
    Debug.Assert(CheckIfLastCharIsALetter(("apple pi e ")) == (false));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static long CanArrange(List<long> arr) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CanArrange((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)3L, (long)5L}))) == (3L));
    Debug.Assert(CanArrange((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)5L}))) == (-1L));
    Debug.Assert(CanArrange((new List<long>(new long[]{(long)1L, (long)4L, (long)2L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L, (long)10L}))) == (2L));
    Debug.Assert(CanArrange((new List<long>(new long[]{(long)4L, (long)8L, (long)5L, (long)7L, (long)3L}))) == (4L));
    Debug.Assert(CanArrange((new List<long>())) == (-1L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static Tuple<Nullable<long>, Nullable<long>> LargestSmallestIntegers(List<long> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)2L, (long)4L, (long)1L, (long)3L, (long)5L, (long)7L}))).Equals(Tuple.Create((Nullable<long>)null, 1L)));
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)2L, (long)4L, (long)1L, (long)3L, (long)5L, (long)7L, (long)0L}))).Equals(Tuple.Create((Nullable<long>)null, 1L)));
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)1L, (long)3L, (long)2L, (long)4L, (long)5L, (long)6L, (long)-2L}))).Equals(Tuple.Create(-2L, 1L)));
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)4L, (long)5L, (long)3L, (long)6L, (long)2L, (long)7L, (long)-7L}))).Equals(Tuple.Create(-7L, 2L)));
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)7L, (long)3L, (long)8L, (long)4L, (long)9L, (long)2L, (long)5L, (long)-9L}))).Equals(Tuple.Create(-9L, 2L)));
    Debug.Assert(LargestSmallestIntegers((new List<long>())).Equals(Tuple.Create((Nullable<long>)null, (Nullable<long>)null)));
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)0L}))).Equals(Tuple.Create((Nullable<long>)null, (Nullable<long>)null)));
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)-1L, (long)-3L, (long)-5L, (long)-6L}))).Equals(Tuple.Create(-1L, (Nullable<long>)null)));
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)-1L, (long)-3L, (long)-5L, (long)-6L, (long)0L}))).Equals(Tuple.Create(-1L, (Nullable<long>)null)));
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)-6L, (long)-4L, (long)-4L, (long)-3L, (long)1L}))).Equals(Tuple.Create(-3L, 1L)));
    Debug.Assert(LargestSmallestIntegers((new List<long>(new long[]{(long)-6L, (long)-4L, (long)-4L, (long)-3L, (long)-100L, (long)1L}))).Equals(Tuple.Create(-3L, 1L)));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
    // Example
    //     public static bool IsEqualToSumEven(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IsEqualToSumEven((4L)) == (false));
    Debug.Assert(IsEqualToSumEven((6L)) == (false));
    Debug.Assert(IsEqualToSumEven((8L)) == (true));
    Debug.Assert(IsEqualToSumEven((10L)) == (true));
    Debug.Assert(IsEqualToSumEven((11L)) == (false));
    Debug.Assert(IsEqualToSumEven((12L)) == (true));
    Debug.Assert(IsEqualToSumEven((13L)) == (false));
    Debug.Assert(IsEqualToSumEven((16L)) == (true));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // The Brazilian factorial is defined as:
    // brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    // where n > 0
    // For example:
    // The function will receive an integer as input and should return the special
    // factorial of this integer.
    //     public static long SpecialFactorial(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SpecialFactorial((4L)) == (288L));
    Debug.Assert(SpecialFactorial((5L)) == (34560L));
    Debug.Assert(SpecialFactorial((7L)) == (125411328000L));
    Debug.Assert(SpecialFactorial((1L)) == (1L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Return a greatest common divisor of two integers a and b
    //     public static long GreatestCommonDivisor(long a, long b) {

    }
    public static void Main(string[] args) {
    Debug.Assert(GreatestCommonDivisor((3L), (7L)) == (1L));
    Debug.Assert(GreatestCommonDivisor((10L), (15L)) == (5L));
    Debug.Assert(GreatestCommonDivisor((49L), (14L)) == (7L));
    Debug.Assert(GreatestCommonDivisor((144L), (60L)) == (12L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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 -
    //     public static string FixSpaces(string text) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FixSpaces(("Example")).Equals(("Example")));
    Debug.Assert(FixSpaces(("Mudasir Hanif ")).Equals(("Mudasir_Hanif_")));
    Debug.Assert(FixSpaces(("Yellow Yellow  Dirty  Fellow")).Equals(("Yellow_Yellow__Dirty__Fellow")));
    Debug.Assert(FixSpaces(("Exa   mple")).Equals(("Exa-mple")));
    Debug.Assert(FixSpaces(("   Exa 1 2 2 mple")).Equals(("-Exa_1_2_2_mple")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static string FileNameCheck(string file_name) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FileNameCheck(("example.txt")).Equals(("Yes")));
    Debug.Assert(FileNameCheck(("1example.dll")).Equals(("No")));
    Debug.Assert(FileNameCheck(("s1sdf3.asd")).Equals(("No")));
    Debug.Assert(FileNameCheck(("K.dll")).Equals(("Yes")));
    Debug.Assert(FileNameCheck(("MY16FILE3.exe")).Equals(("Yes")));
    Debug.Assert(FileNameCheck(("His12FILE94.exe")).Equals(("No")));
    Debug.Assert(FileNameCheck(("_Y.txt")).Equals(("No")));
    Debug.Assert(FileNameCheck(("?aREYA.exe")).Equals(("No")));
    Debug.Assert(FileNameCheck(("/this_is_valid.dll")).Equals(("No")));
    Debug.Assert(FileNameCheck(("this_is_valid.wow")).Equals(("No")));
    Debug.Assert(FileNameCheck(("this_is_valid.txt")).Equals(("Yes")));
    Debug.Assert(FileNameCheck(("this_is_valid.txtexe")).Equals(("No")));
    Debug.Assert(FileNameCheck(("#this2_i4s_5valid.ten")).Equals(("No")));
    Debug.Assert(FileNameCheck(("@this1_is6_valid.exe")).Equals(("No")));
    Debug.Assert(FileNameCheck(("this_is_12valid.6exe4.txt")).Equals(("No")));
    Debug.Assert(FileNameCheck(("all.exe.txt")).Equals(("No")));
    Debug.Assert(FileNameCheck(("I563_No.exe")).Equals(("Yes")));
    Debug.Assert(FileNameCheck(("Is3youfault.txt")).Equals(("Yes")));
    Debug.Assert(FileNameCheck(("no_one#knows.dll")).Equals(("Yes")));
    Debug.Assert(FileNameCheck(("1I563_Yes3.exe")).Equals(("No")));
    Debug.Assert(FileNameCheck(("I563_Yes3.txtt")).Equals(("No")));
    Debug.Assert(FileNameCheck(("final..txt")).Equals(("No")));
    Debug.Assert(FileNameCheck(("final132")).Equals(("No")));
    Debug.Assert(FileNameCheck(("_f4indsartal132.")).Equals(("No")));
    Debug.Assert(FileNameCheck((".txt")).Equals(("No")));
    Debug.Assert(FileNameCheck(("s.")).Equals(("No")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // "
    // 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:
    //     public static long SumSquares(List<long> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))) == (6L));
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)1L, (long)4L, (long)9L}))) == (14L));
    Debug.Assert(SumSquares((new List<long>())) == (0L));
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L, (long)1L, (long)1L, (long)1L, (long)1L, (long)1L}))) == (9L));
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L, (long)-1L}))) == (-3L));
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)0L}))) == (0L));
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)-1L, (long)-5L, (long)2L, (long)-1L, (long)-5L}))) == (-126L));
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)-56L, (long)-99L, (long)1L, (long)0L, (long)-2L}))) == (3030L));
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)-1L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)-1L}))) == (0L));
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)-16L, (long)-9L, (long)-2L, (long)36L, (long)36L, (long)26L, (long)-20L, (long)25L, (long)-40L, (long)20L, (long)-4L, (long)12L, (long)-26L, (long)35L, (long)37L}))) == (-14196L));
    Debug.Assert(SumSquares((new List<long>(new long[]{(long)-1L, (long)-3L, (long)17L, (long)-1L, (long)-15L, (long)13L, (long)-1L, (long)14L, (long)-14L, (long)-12L, (long)-5L, (long)14L, (long)-14L, (long)6L, (long)13L, (long)11L, (long)16L, (long)16L, (long)4L, (long)10L}))) == (-1448L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    // Example 2:
    // Constraints:
    // * 1 <= len(sentence) <= 100
    // * sentence contains only letters
    //     public static string WordsInSentence(string sentence) {

    }
    public static void Main(string[] args) {
    Debug.Assert(WordsInSentence(("This is a test")).Equals(("is")));
    Debug.Assert(WordsInSentence(("lets go for swimming")).Equals(("go for")));
    Debug.Assert(WordsInSentence(("there is no place available here")).Equals(("there is no place")));
    Debug.Assert(WordsInSentence(("Hi I am Hussein")).Equals(("Hi am Hussein")));
    Debug.Assert(WordsInSentence(("go for it")).Equals(("go for it")));
    Debug.Assert(WordsInSentence(("here")).Equals(("")));
    Debug.Assert(WordsInSentence(("here is")).Equals(("is")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    //     public static bool Simplify(string x, string n) {


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<long> OrderByPoints(List<long> nums) {

    }
    public static void Main(string[] args) {
    Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)1L, (long)11L, (long)-1L, (long)-11L, (long)-12L}))).Equals((new List<long>(new long[]{(long)-1L, (long)-11L, (long)1L, (long)-12L, (long)11L}))));
    Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)1234L, (long)423L, (long)463L, (long)145L, (long)2L, (long)423L, (long)423L, (long)53L, (long)6L, (long)37L, (long)3457L, (long)3L, (long)56L, (long)0L, (long)46L}))).Equals((new List<long>(new long[]{(long)0L, (long)2L, (long)3L, (long)6L, (long)53L, (long)423L, (long)423L, (long)423L, (long)1234L, (long)145L, (long)37L, (long)46L, (long)56L, (long)463L, (long)3457L}))));
    Debug.Assert(OrderByPoints((new List<long>())).Equals((new List<long>())));
    Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)1L, (long)-11L, (long)-32L, (long)43L, (long)54L, (long)-98L, (long)2L, (long)-3L}))).Equals((new List<long>(new long[]{(long)-3L, (long)-32L, (long)-98L, (long)-11L, (long)1L, (long)2L, (long)43L, (long)54L}))));
    Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L, (long)10L, (long)11L}))).Equals((new List<long>(new long[]{(long)1L, (long)10L, (long)2L, (long)11L, (long)3L, (long)4L, (long)5L, (long)6L, (long)7L, (long)8L, (long)9L}))));
    Debug.Assert(OrderByPoints((new List<long>(new long[]{(long)0L, (long)6L, (long)6L, (long)-76L, (long)-21L, (long)23L, (long)4L}))).Equals((new List<long>(new long[]{(long)-76L, (long)-21L, (long)0L, (long)4L, (long)23L, (long)6L, (long)6L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static long Specialfilter(List<long> nums) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Specialfilter((new List<long>(new long[]{(long)5L, (long)-2L, (long)1L, (long)-5L}))) == (0L));
    Debug.Assert(Specialfilter((new List<long>(new long[]{(long)15L, (long)-73L, (long)14L, (long)-15L}))) == (1L));
    Debug.Assert(Specialfilter((new List<long>(new long[]{(long)33L, (long)-2L, (long)-3L, (long)45L, (long)21L, (long)109L}))) == (2L));
    Debug.Assert(Specialfilter((new List<long>(new long[]{(long)43L, (long)-12L, (long)93L, (long)125L, (long)121L, (long)109L}))) == (4L));
    Debug.Assert(Specialfilter((new List<long>(new long[]{(long)71L, (long)-2L, (long)-33L, (long)75L, (long)21L, (long)19L}))) == (3L));
    Debug.Assert(Specialfilter((new List<long>(new long[]{(long)1L}))) == (0L));
    Debug.Assert(Specialfilter((new List<long>())) == (0L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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 :
    // Explanation:
    // a = [1, 3, 7, 13, 21]
    // The only valid triple is (1, 7, 13).
    //     public static long GetMaxTriples(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(GetMaxTriples((5L)) == (1L));
    Debug.Assert(GetMaxTriples((6L)) == (4L));
    Debug.Assert(GetMaxTriples((10L)) == (36L));
    Debug.Assert(GetMaxTriples((100L)) == (53361L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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
    //     public static List<string> Bf(string planet1, string planet2) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Bf(("Jupiter"), ("Neptune")).Equals((new List<string>(new string[]{(string)"Saturn", (string)"Uranus"}))));
    Debug.Assert(Bf(("Earth"), ("Mercury")).Equals((new List<string>(new string[]{(string)"Venus"}))));
    Debug.Assert(Bf(("Mercury"), ("Uranus")).Equals((new List<string>(new string[]{(string)"Venus", (string)"Earth", (string)"Mars", (string)"Jupiter", (string)"Saturn"}))));
    Debug.Assert(Bf(("Neptune"), ("Venus")).Equals((new List<string>(new string[]{(string)"Earth", (string)"Mars", (string)"Jupiter", (string)"Saturn", (string)"Uranus"}))));
    Debug.Assert(Bf(("Earth"), ("Earth")).Equals((new List<string>())));
    Debug.Assert(Bf(("Mars"), ("Earth")).Equals((new List<string>())));
    Debug.Assert(Bf(("Jupiter"), ("Makemake")).Equals((new List<string>())));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<string> SortedListSum(List<string> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SortedListSum((new List<string>(new string[]{(string)"aa", (string)"a", (string)"aaa"}))).Equals((new List<string>(new string[]{(string)"aa"}))));
    Debug.Assert(SortedListSum((new List<string>(new string[]{(string)"school", (string)"AI", (string)"asdf", (string)"b"}))).Equals((new List<string>(new string[]{(string)"AI", (string)"asdf", (string)"school"}))));
    Debug.Assert(SortedListSum((new List<string>(new string[]{(string)"d", (string)"b", (string)"c", (string)"a"}))).Equals((new List<string>())));
    Debug.Assert(SortedListSum((new List<string>(new string[]{(string)"d", (string)"dcba", (string)"abcd", (string)"a"}))).Equals((new List<string>(new string[]{(string)"abcd", (string)"dcba"}))));
    Debug.Assert(SortedListSum((new List<string>(new string[]{(string)"AI", (string)"ai", (string)"au"}))).Equals((new List<string>(new string[]{(string)"AI", (string)"ai", (string)"au"}))));
    Debug.Assert(SortedListSum((new List<string>(new string[]{(string)"a", (string)"b", (string)"b", (string)"c", (string)"c", (string)"a"}))).Equals((new List<string>())));
    Debug.Assert(SortedListSum((new List<string>(new string[]{(string)"aaaa", (string)"bbbb", (string)"dd", (string)"cc"}))).Equals((new List<string>(new string[]{(string)"cc", (string)"dd", (string)"aaaa", (string)"bbbb"}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Return list of all prefixes from shortest to longest of the input string
    //     public static List<string> AllPrefixes(string str) {

    }
    public static void Main(string[] args) {
    Debug.Assert(AllPrefixes(("")).Equals((new List<string>())));
    Debug.Assert(AllPrefixes(("asdfgh")).Equals((new List<string>(new string[]{(string)"a", (string)"as", (string)"asd", (string)"asdf", (string)"asdfg", (string)"asdfgh"}))));
    Debug.Assert(AllPrefixes(("WWW")).Equals((new List<string>(new string[]{(string)"W", (string)"WW", (string)"WWW"}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static long XOrY(long n, long x, long y) {


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    // If the input list is empty, return 0.
    //     public static long DoubleTheDifference(List<float> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(DoubleTheDifference((new List<float>())) == (0L));
    Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)5.0f, (float)4.0f}))) == (25L));
    Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)0.1f, (float)0.2f, (float)0.3f}))) == (0L));
    Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)-10.0f, (float)-20.0f, (float)-30.0f}))) == (0L));
    Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)-1.0f, (float)-2.0f, (float)8.0f}))) == (0L));
    Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)0.2f, (float)3.0f, (float)5.0f}))) == (34L));
    Debug.Assert(DoubleTheDifference((new List<float>(new float[]{(float)-9.0f, (float)-7.0f, (float)-5.0f, (float)-3.0f, (float)-1.0f, (float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f, (float)9.0f}))) == (165L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static List<long> Compare(List<long> game, List<long> guess) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Compare((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)1L})), (new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)2L, (long)-2L}))).Equals((new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)3L, (long)3L}))));
    Debug.Assert(Compare((new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L})), (new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L}))).Equals((new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)0L, (long)0L}))));
    Debug.Assert(Compare((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})), (new List<long>(new long[]{(long)-1L, (long)-2L, (long)-3L}))).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)6L}))));
    Debug.Assert(Compare((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)5L})), (new List<long>(new long[]{(long)-1L, (long)2L, (long)3L, (long)4L}))).Equals((new List<long>(new long[]{(long)2L, (long)0L, (long)0L, (long)1L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static string StrongestExtension(string class_name, List<string> extensions) {

    }
    public static void Main(string[] args) {
    Debug.Assert(StrongestExtension(("Watashi"), (new List<string>(new string[]{(string)"tEN", (string)"niNE", (string)"eIGHt8OKe"}))).Equals(("Watashi.eIGHt8OKe")));
    Debug.Assert(StrongestExtension(("Boku123"), (new List<string>(new string[]{(string)"nani", (string)"NazeDa", (string)"YEs.WeCaNe", (string)"32145tggg"}))).Equals(("Boku123.YEs.WeCaNe")));
    Debug.Assert(StrongestExtension(("__YESIMHERE"), (new List<string>(new string[]{(string)"t", (string)"eMptY", (string)"nothing", (string)"zeR00", (string)"NuLl__", (string)"123NoooneB321"}))).Equals(("__YESIMHERE.NuLl__")));
    Debug.Assert(StrongestExtension(("K"), (new List<string>(new string[]{(string)"Ta", (string)"TAR", (string)"t234An", (string)"cosSo"}))).Equals(("K.TAR")));
    Debug.Assert(StrongestExtension(("__HAHA"), (new List<string>(new string[]{(string)"Tab", (string)"123", (string)"781345", (string)"-_-"}))).Equals(("__HAHA.123")));
    Debug.Assert(StrongestExtension(("YameRore"), (new List<string>(new string[]{(string)"HhAas", (string)"okIWILL123", (string)"WorkOut", (string)"Fails", (string)"-_-"}))).Equals(("YameRore.okIWILL123")));
    Debug.Assert(StrongestExtension(("finNNalLLly"), (new List<string>(new string[]{(string)"Die", (string)"NowW", (string)"Wow", (string)"WoW"}))).Equals(("finNNalLLly.WoW")));
    Debug.Assert(StrongestExtension(("_"), (new List<string>(new string[]{(string)"Bb", (string)"91245"}))).Equals(("_.Bb")));
    Debug.Assert(StrongestExtension(("Sp"), (new List<string>(new string[]{(string)"671235", (string)"Bb"}))).Equals(("Sp.671235")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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
    //     public static bool CycpatternCheck(string a, string b) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CycpatternCheck(("xyzw"), ("xyw")) == (false));
    Debug.Assert(CycpatternCheck(("yello"), ("ell")) == (true));
    Debug.Assert(CycpatternCheck(("whattup"), ("ptut")) == (false));
    Debug.Assert(CycpatternCheck(("efef"), ("fee")) == (true));
    Debug.Assert(CycpatternCheck(("abab"), ("aabb")) == (false));
    Debug.Assert(CycpatternCheck(("winemtt"), ("tinem")) == (true));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Given an integer. return a tuple that has the number of even and odd digits respectively.
    // Example:
    //     public static Tuple<long, long> EvenOddCount(long num) {

    }
    public static void Main(string[] args) {
    Debug.Assert(EvenOddCount((7L)).Equals((Tuple.Create(0L, 1L))));
    Debug.Assert(EvenOddCount((-78L)).Equals((Tuple.Create(1L, 1L))));
    Debug.Assert(EvenOddCount((3452L)).Equals((Tuple.Create(2L, 2L))));
    Debug.Assert(EvenOddCount((346211L)).Equals((Tuple.Create(3L, 3L))));
    Debug.Assert(EvenOddCount((-345821L)).Equals((Tuple.Create(3L, 3L))));
    Debug.Assert(EvenOddCount((-2L)).Equals((Tuple.Create(1L, 0L))));
    Debug.Assert(EvenOddCount((-45347L)).Equals((Tuple.Create(2L, 3L))));
    Debug.Assert(EvenOddCount((0L)).Equals((Tuple.Create(1L, 0L))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Given a positive integer, obtain its roman numeral equivalent as a string,
    // and return it in lowercase.
    // Restrictions: 1 <= num <= 1000
    // Examples:
    //     public static string IntToMiniRoman(long number) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IntToMiniRoman((19L)).Equals(("xix")));
    Debug.Assert(IntToMiniRoman((152L)).Equals(("clii")));
    Debug.Assert(IntToMiniRoman((251L)).Equals(("ccli")));
    Debug.Assert(IntToMiniRoman((426L)).Equals(("cdxxvi")));
    Debug.Assert(IntToMiniRoman((500L)).Equals(("d")));
    Debug.Assert(IntToMiniRoman((1L)).Equals(("i")));
    Debug.Assert(IntToMiniRoman((4L)).Equals(("iv")));
    Debug.Assert(IntToMiniRoman((43L)).Equals(("xliii")));
    Debug.Assert(IntToMiniRoman((90L)).Equals(("xc")));
    Debug.Assert(IntToMiniRoman((94L)).Equals(("xciv")));
    Debug.Assert(IntToMiniRoman((532L)).Equals(("dxxxii")));
    Debug.Assert(IntToMiniRoman((900L)).Equals(("cm")));
    Debug.Assert(IntToMiniRoman((994L)).Equals(("cmxciv")));
    Debug.Assert(IntToMiniRoman((1000L)).Equals(("m")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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:
    //     public static bool RightAngleTriangle(long a, long b, long c) {

    }
    public static void Main(string[] args) {
    Debug.Assert(RightAngleTriangle((3L), (4L), (5L)) == (true));
    Debug.Assert(RightAngleTriangle((1L), (2L), (3L)) == (false));
    Debug.Assert(RightAngleTriangle((10L), (6L), (8L)) == (true));
    Debug.Assert(RightAngleTriangle((2L), (2L), (2L)) == (false));
    Debug.Assert(RightAngleTriangle((7L), (24L), (25L)) == (true));
    Debug.Assert(RightAngleTriangle((10L), (5L), (7L)) == (false));
    Debug.Assert(RightAngleTriangle((5L), (12L), (13L)) == (true));
    Debug.Assert(RightAngleTriangle((15L), (8L), (17L)) == (true));
    Debug.Assert(RightAngleTriangle((48L), (55L), (73L)) == (true));
    Debug.Assert(RightAngleTriangle((1L), (1L), (1L)) == (false));
    Debug.Assert(RightAngleTriangle((2L), (2L), (10L)) == (false));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // 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.
    //     public static string FindMax(List<string> words) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"name", (string)"of", (string)"string"}))).Equals(("string")));
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"name", (string)"enam", (string)"game"}))).Equals(("enam")));
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"aaaaaaa", (string)"bb", (string)"cc"}))).Equals(("aaaaaaa")));
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"abc", (string)"cba"}))).Equals(("abc")));
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"play", (string)"this", (string)"game", (string)"of", (string)"footbott"}))).Equals(("footbott")));
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"we", (string)"are", (string)"gonna", (string)"rock"}))).Equals(("gonna")));
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"we", (string)"are", (string)"a", (string)"mad", (string)"nation"}))).Equals(("nation")));
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"this", (string)"is", (string)"a", (string)"prrk"}))).Equals(("this")));
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"b"}))).Equals(("b")));
    Debug.Assert(FindMax((new List<string>(new string[]{(string)"play", (string)"play", (string)"play"}))).Equals(("play")));
    }

}