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
    // >>> AllPrefixes(("abc"))
    // (new List<string>(new string[]{(string)"a", (string)"ab", (string)"abc"}))
    //     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:
    // >>> XOrY((7L), (34L), (12L))
    // (34L)
    // >>> XOrY((15L), (8L), (5L))
    // (5L)
    //     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.
    // >>> DoubleTheDifference((new List<float>(new long[]{(long)1L, (long)3L, (long)2L, (long)0L})))
    // (10L)
    // >>> DoubleTheDifference((new List<float>(new long[]{(long)-1L, (long)-2L, (long)0L})))
    // (0L)
    // >>> DoubleTheDifference((new List<float>(new long[]{(long)9L, (long)-2L})))
    // (81L)
    // >>> DoubleTheDifference((new List<float>(new long[]{(long)0L})))
    // (0L)
    // 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:
    // >>> 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})))
    // (new List<long>(new long[]{(long)0L, (long)0L, (long)0L, (long)0L, (long)3L, (long)3L}))
    // >>> Compare((new List<long>(new long[]{(long)0L, (long)5L, (long)0L, (long)0L, (long)0L, (long)4L})), (new List<long>(new long[]{(long)4L, (long)1L, (long)1L, (long)0L, (long)0L, (long)-2L})))
    // (new List<long>(new long[]{(long)4L, (long)4L, (long)1L, (long)0L, (long)0L, (long)6L}))
    //     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:
    // >>> StrongestExtension(("my_class"), (new List<string>(new string[]{(string)"AA", (string)"Be", (string)"CC"})))
    // ("my_class.AA")
    //     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
    // >>> CycpatternCheck(("abcd"), ("abd"))
    // (false)
    // >>> CycpatternCheck(("hello"), ("ell"))
    // (true)
    // >>> CycpatternCheck(("whassup"), ("psus"))
    // (false)
    // >>> CycpatternCheck(("abab"), ("baa"))
    // (true)
    // >>> CycpatternCheck(("efef"), ("eeff"))
    // (false)
    // >>> CycpatternCheck(("himenss"), ("simen"))
    // (true)
    //     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:
    // >>> EvenOddCount((-12L))
    // (Tuple.Create(1L, 1L))
    // >>> EvenOddCount((123L))
    // (Tuple.Create(1L, 2L))
    //     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:
    // >>> IntToMiniRoman((19L))
    // ("xix")
    // >>> IntToMiniRoman((152L))
    // ("clii")
    // >>> IntToMiniRoman((426L))
    // ("cdxxvi")
    //     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:
    // >>> RightAngleTriangle((3L), (4L), (5L))
    // (true)
    // >>> RightAngleTriangle((1L), (2L), (3L))
    // (false)
    //     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.
    // >>> FindMax((new List<string>(new string[]{(string)"name", (string)"of", (string)"string"})))
    // ("string")
    // >>> FindMax((new List<string>(new string[]{(string)"name", (string)"enam", (string)"game"})))
    // ("enam")
    // >>> FindMax((new List<string>(new string[]{(string)"aaaaaaa", (string)"bb", (string)"cc"})))
    // ("aaaaaaa")
    //     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")));
    }

}


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're a hungry rabbit, and you already have eaten a certain number of carrots,
    // but now you need to eat more carrots to complete the day's meals.
    // you should return an array of [ total number of eaten carrots after your meals,
    // the number of carrots left after your meals ]
    // if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
    // Example:
    // >>> Eat((5L), (6L), (10L))
    // (new List<long>(new long[]{(long)11L, (long)4L}))
    // >>> Eat((4L), (8L), (9L))
    // (new List<long>(new long[]{(long)12L, (long)1L}))
    // >>> Eat((1L), (10L), (10L))
    // (new List<long>(new long[]{(long)11L, (long)0L}))
    // >>> Eat((2L), (11L), (5L))
    // (new List<long>(new long[]{(long)7L, (long)0L}))
    // Variables:
    // @number : integer
    // the number of carrots that you have eaten.
    // @need : integer
    // the number of carrots that you need to eat.
    // @remaining : integer
    // the number of remaining carrots thet exist in stock
    // Constrain:
    // * 0 <= number <= 1000
    // * 0 <= need <= 1000
    // * 0 <= remaining <= 1000
    // Have fun :)
    //     public static List<long> Eat(long number, long need, long remaining) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Eat((5L), (6L), (10L)).Equals((new List<long>(new long[]{(long)11L, (long)4L}))));
    Debug.Assert(Eat((4L), (8L), (9L)).Equals((new List<long>(new long[]{(long)12L, (long)1L}))));
    Debug.Assert(Eat((1L), (10L), (10L)).Equals((new List<long>(new long[]{(long)11L, (long)0L}))));
    Debug.Assert(Eat((2L), (11L), (5L)).Equals((new List<long>(new long[]{(long)7L, (long)0L}))));
    Debug.Assert(Eat((4L), (5L), (7L)).Equals((new List<long>(new long[]{(long)9L, (long)2L}))));
    Debug.Assert(Eat((4L), (5L), (1L)).Equals((new List<long>(new long[]{(long)5L, (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 {
    // Return a string containing space-delimited numbers starting from 0 upto n inclusive.
    // >>> StringSequence((0L))
    // ("0")
    // >>> StringSequence((5L))
    // ("0 1 2 3 4 5")
    //     public static string StringSequence(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(StringSequence((0L)).Equals(("0")));
    Debug.Assert(StringSequence((3L)).Equals(("0 1 2 3")));
    Debug.Assert(StringSequence((10L)).Equals(("0 1 2 3 4 5 6 7 8 9 10")));
    }

}


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 two lists operator, and operand. The first list has basic algebra operations, and
    // the second list is a list of integers. Use the two given lists to build the algebric
    // expression and return the evaluation of this expression.
    // The basic algebra operations:
    // Addition ( + )
    // Subtraction ( - )
    // Multiplication ( * )
    // Floor division ( // )
    // Exponentiation ( ** )
    // Example:
    // operator['+', '*', '-']
    // array = [2, 3, 4, 5]
    // result = 2 + 3 * 4 - 5
    // => result = 9
    // Note:
    // The length of operator list is equal to the length of operand list minus one.
    // Operand is a list of of non-negative integers.
    // Operator list has at least one operator, and operand list has at least two operands.
    //     public static long DoAlgebra(List<string> op, List<long> operand) {

    }
    public static void Main(string[] args) {
    Debug.Assert(DoAlgebra((new List<string>(new string[]{(string)"**", (string)"*", (string)"+"})), (new List<long>(new long[]{(long)2L, (long)3L, (long)4L, (long)5L}))) == (37L));
    Debug.Assert(DoAlgebra((new List<string>(new string[]{(string)"+", (string)"*", (string)"-"})), (new List<long>(new long[]{(long)2L, (long)3L, (long)4L, (long)5L}))) == (9L));
    Debug.Assert(DoAlgebra((new List<string>(new string[]{(string)"//", (string)"*"})), (new List<long>(new long[]{(long)7L, (long)3L, (long)4L}))) == (8L));
    }

}


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 s.
    // if s[i] is a letter, reverse its case from lower to upper or vise versa,
    // otherwise keep it as it is.
    // If the string contains no letters, reverse the string.
    // The function should return the resulted string.
    // Examples
    // >>> Solve(("1234"))
    // ("4321")
    // >>> Solve(("ab"))
    // ("AB")
    // >>> Solve(("#a@C"))
    // ("#A@c")
    //     public static string Solve(string s) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Solve(("AsDf")).Equals(("aSdF")));
    Debug.Assert(Solve(("1234")).Equals(("4321")));
    Debug.Assert(Solve(("ab")).Equals(("AB")));
    Debug.Assert(Solve(("#a@C")).Equals(("#A@c")));
    Debug.Assert(Solve(("#AsdfW^45")).Equals(("#aSDFw^45")));
    Debug.Assert(Solve(("#6@2")).Equals(("2@6#")));
    Debug.Assert(Solve(("#$a^D")).Equals(("#$A^d")));
    Debug.Assert(Solve(("#ccc")).Equals(("#CCC")));
    }

}


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', return its md5 hash equivalent string.
    // If 'text' is an empty string, return None.
    // >>> StringToMd5(("Hello world"))
    // ("3e25960a79dbc69b674cd4ec67a72c62")
    //     public static string StringToMd5(string text) {

    }
    public static void Main(string[] args) {
    Debug.Assert(StringToMd5(("Hello world")).Equals(("3e25960a79dbc69b674cd4ec67a72c62")));
    Debug.Assert(StringToMd5(("")).Equals(null));
    Debug.Assert(StringToMd5(("A B C")).Equals(("0ef78513b0cb8cef12743f5aeb35f888")));
    Debug.Assert(StringToMd5(("password")).Equals(("5f4dcc3b5aa765d61d8327deb882cf99")));
    }

}


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 two positive integers a and b, return the even digits between a
    // and b, in ascending order.
    // For example:
    // >>> GenerateIntegers((2L), (8L))
    // (new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))
    // >>> GenerateIntegers((8L), (2L))
    // (new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))
    // >>> GenerateIntegers((10L), (14L))
    // (new List<long>())
    //     public static List<long> GenerateIntegers(long a, long b) {

    }
    public static void Main(string[] args) {
    Debug.Assert(GenerateIntegers((2L), (10L)).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))));
    Debug.Assert(GenerateIntegers((10L), (2L)).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))));
    Debug.Assert(GenerateIntegers((132L), (2L)).Equals((new List<long>(new long[]{(long)2L, (long)4L, (long)6L, (long)8L}))));
    Debug.Assert(GenerateIntegers((17L), (89L)).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 string, find out how many distinct characters (regardless of case) does it consist of
    // >>> CountDistinctCharacters(("xyzXYZ"))
    // (3L)
    // >>> CountDistinctCharacters(("Jerry"))
    // (4L)
    //     public static long CountDistinctCharacters(string str) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CountDistinctCharacters(("")) == (0L));
    Debug.Assert(CountDistinctCharacters(("abcde")) == (5L));
    Debug.Assert(CountDistinctCharacters(("abcdecadeCADE")) == (5L));
    Debug.Assert(CountDistinctCharacters(("aaaaAAAAaaaa")) == (1L));
    Debug.Assert(CountDistinctCharacters(("Jerry jERRY JeRRRY")) == (5L));
    }

}


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 to this function is a string representing musical notes in a special ASCII format.
    // Your task is to parse this string and return list of integers corresponding to how many beats does each
    // not last.
    // Here is a legend:
    // 'o' - whole note, lasts four beats
    // 'o|' - half note, lasts two beats
    // '.|' - quater note, lasts one beat
    // >>> ParseMusic(("o o| .| o| o| .| .| .| .| o o"))
    // (new List<long>(new long[]{(long)4L, (long)2L, (long)1L, (long)2L, (long)2L, (long)1L, (long)1L, (long)1L, (long)1L, (long)4L, (long)4L}))
    //     public static List<long> ParseMusic(string music_string) {

    }
    public static void Main(string[] args) {
    Debug.Assert(ParseMusic(("")).Equals((new List<long>())));
    Debug.Assert(ParseMusic(("o o o o")).Equals((new List<long>(new long[]{(long)4L, (long)4L, (long)4L, (long)4L}))));
    Debug.Assert(ParseMusic((".| .| .| .|")).Equals((new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L}))));
    Debug.Assert(ParseMusic(("o| o| .| .| o o o o")).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)1L, (long)1L, (long)4L, (long)4L, (long)4L, (long)4L}))));
    Debug.Assert(ParseMusic(("o| .| o| .| o o| o o|")).Equals((new List<long>(new long[]{(long)2L, (long)1L, (long)2L, (long)1L, (long)4L, (long)2L, (long)4L, (long)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 {
    // Find how many times a given substring can be found in the original string. Count overlaping cases.
    // >>> HowManyTimes((""), ("a"))
    // (0L)
    // >>> HowManyTimes(("aaa"), ("a"))
    // (3L)
    // >>> HowManyTimes(("aaaa"), ("aa"))
    // (3L)
    //     public static long HowManyTimes(string str, string substring) {

    }
    public static void Main(string[] args) {
    Debug.Assert(HowManyTimes((""), ("x")) == (0L));
    Debug.Assert(HowManyTimes(("xyxyxyx"), ("x")) == (4L));
    Debug.Assert(HowManyTimes(("cacacacac"), ("cac")) == (4L));
    Debug.Assert(HowManyTimes(("john doe"), ("john")) == (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 {
    // Input is a space-delimited string of numberals from 'zero' to 'nine'.
    // Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
    // Return the string with numbers sorted from smallest to largest
    // >>> SortNumbers(("three one five"))
    // ("one three five")
    //     public static string SortNumbers(string numbers) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SortNumbers(("")).Equals(("")));
    Debug.Assert(SortNumbers(("three")).Equals(("three")));
    Debug.Assert(SortNumbers(("three five nine")).Equals(("three five nine")));
    Debug.Assert(SortNumbers(("five zero four seven nine eight")).Equals(("zero four five seven eight nine")));
    Debug.Assert(SortNumbers(("six five four three two one zero")).Equals(("zero one two three four five six")));
    }

}


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 to this function is a string containing multiple groups of nested parentheses. Your goal is to
    // separate those group into separate strings and return the list of those.
    // Separate groups are balanced (each open brace is properly closed) and not nested within each other
    // Ignore any spaces in the input string.
    // >>> SeparateParenGroups(("( ) (( )) (( )( ))"))
    // (new List<string>(new string[]{(string)"()", (string)"(())", (string)"(()())"}))
    //     public static List<string> SeparateParenGroups(string paren_string) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SeparateParenGroups(("(()()) ((())) () ((())()())")).Equals((new List<string>(new string[]{(string)"(()())", (string)"((()))", (string)"()", (string)"((())()())"}))));
    Debug.Assert(SeparateParenGroups(("() (()) ((())) (((())))")).Equals((new List<string>(new string[]{(string)"()", (string)"(())", (string)"((()))", (string)"(((())))"}))));
    Debug.Assert(SeparateParenGroups(("(()(())((())))")).Equals((new List<string>(new string[]{(string)"(()(())((())))"}))));
    Debug.Assert(SeparateParenGroups(("( ) (( )) (( )( ))")).Equals((new List<string>(new string[]{(string)"()", (string)"(())", (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 {
    // From a supplied list of numbers (of length at least two) select and return two that are the closest to each
    // other and return them in order (smaller number, larger number).
    // >>> FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.2f})))
    // (Tuple.Create(2.0f, 2.2f))
    // >>> FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})))
    // (Tuple.Create(2.0f, 2.0f))
    //     public static Tuple<float, float> FindClosestElements(List<float> numbers) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f}))).Equals((Tuple.Create(3.9f, 4.0f))));
    Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f}))).Equals((Tuple.Create(5.0f, 5.9f))));
    Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.2f}))).Equals((Tuple.Create(2.0f, 2.2f))));
    Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f}))).Equals((Tuple.Create(2.0f, 2.0f))));
    Debug.Assert(FindClosestElements((new List<float>(new float[]{(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f}))).Equals((Tuple.Create(2.2f, 3.1f))));
    }

}


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 list of numbers (of at least two elements), apply a linear transform to that list,
    // such that the smallest number will become 0 and the largest will become 1
    // >>> RescaleToUnit((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f})))
    // (new List<float>(new float[]{(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f}))
    //     public static List<float> RescaleToUnit(List<float> numbers) {

    }
    public static void Main(string[] args) {
    Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)2.0f, (float)49.9f}))).Equals((new List<float>(new float[]{(float)0.0f, (float)1.0f}))));
    Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)100.0f, (float)49.9f}))).Equals((new List<float>(new float[]{(float)1.0f, (float)0.0f}))));
    Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))).Equals((new List<float>(new float[]{(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f}))));
    Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)2.0f, (float)1.0f, (float)5.0f, (float)3.0f, (float)4.0f}))).Equals((new List<float>(new float[]{(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f}))));
    Debug.Assert(RescaleToUnit((new List<float>(new float[]{(float)12.0f, (float)11.0f, (float)15.0f, (float)13.0f, (float)14.0f}))).Equals((new List<float>(new float[]{(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f}))));
    }

}


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 {
    // Filter given list of any python values only for integers
    // >>> FilterIntegers((new List<object>(new string[]{(string)"a", (string)3.14f, (string)5L})))
    // (new List<long>(new long[]{(long)5L}))
    // >>> FilterIntegers((new List<object>(new object[]{1L, 2L, 3L, "abc", new List<object>()})))
    // (new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))
    //     public static List<long> FilterIntegers(List<object> values) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FilterIntegers((new List<object>())).Equals((new List<long>())));
    Debug.Assert(FilterIntegers((new List<object>(new object[]{4L, new List<object>(), 23.2f, 9L, "adasd"}))).Equals((new List<long>(new long[]{(long)4L, (long)9L}))));
    Debug.Assert(FilterIntegers((new List<object>(new object[]{3L, "c", 3L, 3L, "a", "b"}))).Equals((new List<long>(new long[]{(long)3L, (long)3L, (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 {
    // Return length of given string
    // >>> StringLength((""))
    // (0L)
    // >>> StringLength(("abc"))
    // (3L)
    //     public static long Strlen(string str) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Strlen(("")) == (0L));
    Debug.Assert(Strlen(("x")) == (1L));
    Debug.Assert(Strlen(("asdasnakj")) == (9L));
    }

}


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 {
    // For a given number n, find the largest number that divides n evenly, smaller than n
    // >>> LargestDivisor((15L))
    // (5L)
    //     public static long LargestDivisor(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(LargestDivisor((3L)) == (1L));
    Debug.Assert(LargestDivisor((7L)) == (1L));
    Debug.Assert(LargestDivisor((10L)) == (5L));
    Debug.Assert(LargestDivisor((100L)) == (50L));
    Debug.Assert(LargestDivisor((49L)) == (7L));
    }

}


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 prime factors of given integer in the order from smallest to largest.
    // Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
    // Input number should be equal to the product of all factors
    // >>> Factorize((8L))
    // (new List<long>(new long[]{(long)2L, (long)2L, (long)2L}))
    // >>> Factorize((25L))
    // (new List<long>(new long[]{(long)5L, (long)5L}))
    // >>> Factorize((70L))
    // (new List<long>(new long[]{(long)2L, (long)5L, (long)7L}))
    //     public static List<long> Factorize(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Factorize((2L)).Equals((new List<long>(new long[]{(long)2L}))));
    Debug.Assert(Factorize((4L)).Equals((new List<long>(new long[]{(long)2L, (long)2L}))));
    Debug.Assert(Factorize((8L)).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)2L}))));
    Debug.Assert(Factorize((57L)).Equals((new List<long>(new long[]{(long)3L, (long)19L}))));
    Debug.Assert(Factorize((3249L)).Equals((new List<long>(new long[]{(long)3L, (long)3L, (long)19L, (long)19L}))));
    Debug.Assert(Factorize((185193L)).Equals((new List<long>(new long[]{(long)3L, (long)3L, (long)3L, (long)19L, (long)19L, (long)19L}))));
    Debug.Assert(Factorize((20577L)).Equals((new List<long>(new long[]{(long)3L, (long)19L, (long)19L, (long)19L}))));
    Debug.Assert(Factorize((18L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (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 {
    // From a list of integers, remove all elements that occur more than once.
    // Keep order of elements left the same as in the input.
    // >>> RemoveDuplicates((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)4L})))
    // (new List<long>(new long[]{(long)1L, (long)3L, (long)4L}))
    //     public static List<long> RemoveDuplicates(List<long> numbers) {

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

}


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 {
    // For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
    // >>> FlipCase(("Hello"))
    // ("hELLO")
    //     public static string FlipCase(string str) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FlipCase(("")).Equals(("")));
    Debug.Assert(FlipCase(("Hello!")).Equals(("hELLO!")));
    Debug.Assert(FlipCase(("These violent delights have violent ends")).Equals(("tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS")));
    }

}


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 {
    // Concatenate list of strings into a single string
    // >>> Concatenate((new List<string>()))
    // ("")
    // >>> Concatenate((new List<string>(new string[]{(string)"a", (string)"b", (string)"c"})))
    // ("abc")
    //     public static string Concatenate(List<string> strings) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Concatenate((new List<string>())).Equals(("")));
    Debug.Assert(Concatenate((new List<string>(new string[]{(string)"x", (string)"y", (string)"z"}))).Equals(("xyz")));
    Debug.Assert(Concatenate((new List<string>(new string[]{(string)"x", (string)"y", (string)"z", (string)"w", (string)"k"}))).Equals(("xyzwk")));
    }

}


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 {
    // Filter an input list of strings only for ones that start with a given prefix.
    // >>> FilterByPrefix((new List<string>()), ("a"))
    // (new List<string>())
    // >>> FilterByPrefix((new List<string>(new string[]{(string)"abc", (string)"bcd", (string)"cde", (string)"array"})), ("a"))
    // (new List<string>(new string[]{(string)"abc", (string)"array"}))
    //     public static List<string> FilterByPrefix(List<string> strings, string prefix) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FilterByPrefix((new List<string>()), ("john")).Equals((new List<string>())));
    Debug.Assert(FilterByPrefix((new List<string>(new string[]{(string)"xxx", (string)"asd", (string)"xxy", (string)"john doe", (string)"xxxAAA", (string)"xxx"})), ("xxx")).Equals((new List<string>(new string[]{(string)"xxx", (string)"xxxAAA", (string)"xxx"}))));
    }

}


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 floating point number, it can be decomposed into
    // and integer part (largest integer smaller than given number) and decimals
    // (leftover part always smaller than 1).
    // Return the decimal part of the number.
    // >>> TruncateNumber((3.5f))
    // (0.5f)
    //     public static float TruncateNumber(float number) {

    }
    public static void Main(string[] args) {
    Debug.Assert(TruncateNumber((3.5f)) == (0.5f));
    Debug.Assert(TruncateNumber((1.25f)) == (0.25f));
    Debug.Assert(TruncateNumber((123.0f)) == (0.0f));
    }

}


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 only positive numbers in the list.
    // >>> GetPositive((new List<long>(new long[]{(long)-1L, (long)2L, (long)-4L, (long)5L, (long)6L})))
    // (new List<long>(new long[]{(long)2L, (long)5L, (long)6L}))
    // >>> GetPositive((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)9L, (long)0L, (long)123L, (long)1L, (long)-10L})))
    // (new List<long>(new long[]{(long)5L, (long)3L, (long)2L, (long)3L, (long)9L, (long)123L, (long)1L}))
    //     public static List<long> GetPositive(List<long> l) {

    }
    public static void Main(string[] args) {
    Debug.Assert(GetPositive((new List<long>(new long[]{(long)-1L, (long)-2L, (long)4L, (long)5L, (long)6L}))).Equals((new List<long>(new long[]{(long)4L, (long)5L, (long)6L}))));
    Debug.Assert(GetPositive((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)3L, (long)3L, (long)9L, (long)0L, (long)123L, (long)1L, (long)-10L}))).Equals((new List<long>(new long[]{(long)5L, (long)3L, (long)2L, (long)3L, (long)3L, (long)9L, (long)123L, (long)1L}))));
    Debug.Assert(GetPositive((new List<long>(new long[]{(long)-1L, (long)-2L}))).Equals((new List<long>())));
    Debug.Assert(GetPositive((new List<long>())).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 {
    // Return true if a given number is prime, and false otherwise.
    // >>> IsPrime((6L))
    // (false)
    // >>> IsPrime((101L))
    // (true)
    // >>> IsPrime((11L))
    // (true)
    // >>> IsPrime((13441L))
    // (true)
    // >>> IsPrime((61L))
    // (true)
    // >>> IsPrime((4L))
    // (false)
    // >>> IsPrime((1L))
    // (false)
    //     public static bool IsPrime(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IsPrime((6L)) == (false));
    Debug.Assert(IsPrime((101L)) == (true));
    Debug.Assert(IsPrime((11L)) == (true));
    Debug.Assert(IsPrime((13441L)) == (true));
    Debug.Assert(IsPrime((61L)) == (true));
    Debug.Assert(IsPrime((4L)) == (false));
    Debug.Assert(IsPrime((1L)) == (false));
    Debug.Assert(IsPrime((5L)) == (true));
    Debug.Assert(IsPrime((11L)) == (true));
    Debug.Assert(IsPrime((17L)) == (true));
    Debug.Assert(IsPrime((85L)) == (false));
    Debug.Assert(IsPrime((77L)) == (false));
    Debug.Assert(IsPrime((255379L)) == (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 {
    // This function takes a list l and returns a list l' such that
    // l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
    // to the values of the corresponding indicies of l, but sorted.
    // >>> SortThird((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))
    // (new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))
    // >>> SortThird((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)2L})))
    // (new List<long>(new long[]{(long)2L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)5L}))
    //     public static List<long> SortThird(List<long> l) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SortThird((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)2L}))).Equals((new List<long>(new long[]{(long)2L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)5L}))));
    Debug.Assert(SortThird((new List<long>(new long[]{(long)5L, (long)8L, (long)3L, (long)4L, (long)6L, (long)9L, (long)2L}))).Equals((new List<long>(new long[]{(long)2L, (long)8L, (long)3L, (long)4L, (long)6L, (long)9L, (long)5L}))));
    Debug.Assert(SortThird((new List<long>(new long[]{(long)5L, (long)6L, (long)9L, (long)4L, (long)8L, (long)3L, (long)2L}))).Equals((new List<long>(new long[]{(long)2L, (long)6L, (long)9L, (long)4L, (long)8L, (long)3L, (long)5L}))));
    Debug.Assert(SortThird((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)2L, (long)1L}))).Equals((new List<long>(new long[]{(long)2L, (long)6L, (long)3L, (long)4L, (long)8L, (long)9L, (long)5L, (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 {
    // Return sorted unique elements in a list
    // >>> Unique((new List<long>(new long[]{(long)5L, (long)3L, (long)5L, (long)2L, (long)3L, (long)3L, (long)9L, (long)0L, (long)123L})))
    // (new List<long>(new long[]{(long)0L, (long)2L, (long)3L, (long)5L, (long)9L, (long)123L}))
    //     public static List<long> Unique(List<long> l) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Unique((new List<long>(new long[]{(long)5L, (long)3L, (long)5L, (long)2L, (long)3L, (long)3L, (long)9L, (long)0L, (long)123L}))).Equals((new List<long>(new long[]{(long)0L, (long)2L, (long)3L, (long)5L, (long)9L, (long)123L}))));
    }

}


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 maximum element in the list.
    // >>> MaxElement((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))
    // (3L)
    // >>> MaxElement((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)9L, (long)0L, (long)123L, (long)1L, (long)-10L})))
    // (123L)
    //     public static long MaxElement(List<long> l) {

    }
    public static void Main(string[] args) {
    Debug.Assert(MaxElement((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))) == (3L));
    Debug.Assert(MaxElement((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)9L, (long)0L, (long)124L, (long)1L, (long)-10L}))) == (124L));
    }

}


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 the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
    // >>> FizzBuzz((50L))
    // (0L)
    // >>> FizzBuzz((78L))
    // (2L)
    // >>> FizzBuzz((79L))
    // (3L)
    //     public static long FizzBuzz(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FizzBuzz((50L)) == (0L));
    Debug.Assert(FizzBuzz((78L)) == (2L));
    Debug.Assert(FizzBuzz((79L)) == (3L));
    Debug.Assert(FizzBuzz((100L)) == (3L));
    Debug.Assert(FizzBuzz((200L)) == (6L));
    Debug.Assert(FizzBuzz((4000L)) == (192L));
    Debug.Assert(FizzBuzz((10000L)) == (639L));
    Debug.Assert(FizzBuzz((100000L)) == (8026L));
    }

}


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 a list l and returns a list l' such that
    // l' is identical to l in the odd indicies, while its values at the even indicies are equal
    // to the values of the even indicies of l, but sorted.
    // >>> SortEven((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))
    // (new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))
    // >>> SortEven((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)4L})))
    // (new List<long>(new long[]{(long)3L, (long)6L, (long)5L, (long)4L}))
    //     public static List<long> SortEven(List<long> l) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SortEven((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))).Equals((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))));
    Debug.Assert(SortEven((new List<long>(new long[]{(long)5L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)9L, (long)0L, (long)123L, (long)1L, (long)-10L}))).Equals((new List<long>(new long[]{(long)-10L, (long)3L, (long)-5L, (long)2L, (long)-3L, (long)3L, (long)5L, (long)0L, (long)9L, (long)1L, (long)123L}))));
    Debug.Assert(SortEven((new List<long>(new long[]{(long)5L, (long)8L, (long)-12L, (long)4L, (long)23L, (long)2L, (long)3L, (long)11L, (long)12L, (long)-10L}))).Equals((new List<long>(new long[]{(long)-12L, (long)8L, (long)3L, (long)4L, (long)5L, (long)2L, (long)12L, (long)11L, (long)23L, (long)-10L}))));
    }

}


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 {
    // prime_fib returns n-th number that is a Fibonacci number and it's also prime.
    // >>> PrimeFib((1L))
    // (2L)
    // >>> PrimeFib((2L))
    // (3L)
    // >>> PrimeFib((3L))
    // (5L)
    // >>> PrimeFib((4L))
    // (13L)
    // >>> PrimeFib((5L))
    // (89L)
    //     public static long PrimeFib(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(PrimeFib((1L)) == (2L));
    Debug.Assert(PrimeFib((2L)) == (3L));
    Debug.Assert(PrimeFib((3L)) == (5L));
    Debug.Assert(PrimeFib((4L)) == (13L));
    Debug.Assert(PrimeFib((5L)) == (89L));
    Debug.Assert(PrimeFib((6L)) == (233L));
    Debug.Assert(PrimeFib((7L)) == (1597L));
    Debug.Assert(PrimeFib((8L)) == (28657L));
    Debug.Assert(PrimeFib((9L)) == (514229L));
    Debug.Assert(PrimeFib((10L)) == (433494437L));
    }

}


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're given a list of deposit and withdrawal operations on a bank account that starts with
    // zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
    // at that point function should return True. Otherwise it should return False.
    // >>> BelowZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))
    // (false)
    // >>> BelowZero((new List<long>(new long[]{(long)1L, (long)2L, (long)-4L, (long)5L})))
    // (true)
    //     public static bool BelowZero(List<long> operations) {

    }
    public static void Main(string[] args) {
    Debug.Assert(BelowZero((new List<long>())) == (false));
    Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)2L, (long)-3L, (long)1L, (long)2L, (long)-3L}))) == (false));
    Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)2L, (long)-4L, (long)5L, (long)6L}))) == (true));
    Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)-1L, (long)2L, (long)-2L, (long)5L, (long)-5L, (long)4L, (long)-4L}))) == (false));
    Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)-1L, (long)2L, (long)-2L, (long)5L, (long)-5L, (long)4L, (long)-5L}))) == (true));
    Debug.Assert(BelowZero((new List<long>(new long[]{(long)1L, (long)-2L, (long)2L, (long)-2L, (long)5L, (long)-5L, (long)4L, (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 {
    // triples_sum_to_zero takes a list of integers as an input.
    // it returns True if there are three distinct elements in the list that
    // sum to zero, and False otherwise.
    // >>> TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)0L})))
    // (false)
    // >>> TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)-2L, (long)1L})))
    // (true)
    // >>> TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)7L})))
    // (false)
    // >>> TriplesSumToZero((new List<long>(new long[]{(long)2L, (long)4L, (long)-5L, (long)3L, (long)9L, (long)7L})))
    // (true)
    // >>> TriplesSumToZero((new List<long>(new long[]{(long)1L})))
    // (false)
    //     public static bool TriplesSumToZero(List<long> l) {

    }
    public static void Main(string[] args) {
    Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)0L}))) == (false));
    Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)-1L}))) == (false));
    Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)-2L, (long)1L}))) == (true));
    Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)7L}))) == (false));
    Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)5L, (long)7L}))) == (false));
    Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)2L, (long)4L, (long)-5L, (long)3L, (long)9L, (long)7L}))) == (true));
    Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L}))) == (false));
    Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)-100L}))) == (false));
    Debug.Assert(TriplesSumToZero((new List<long>(new long[]{(long)100L, (long)3L, (long)5L, (long)-100L}))) == (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 {
    // Imagine a road that's a perfectly straight infinitely long line.
    // n cars are driving left to right;  simultaneously, a different set of n cars
    // are driving right to left.   The two sets of cars start out being very far from
    // each other.  All cars move in the same speed.  Two cars are said to collide
    // when a car that's moving left to right hits a car that's moving right to left.
    // However, the cars are infinitely sturdy and strong; as a result, they continue moving
    // in their trajectory as if they did not collide.
    // This function outputs the number of such collisions.
    //     public static long CarRaceCollision(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CarRaceCollision((2L)) == (4L));
    Debug.Assert(CarRaceCollision((3L)) == (9L));
    Debug.Assert(CarRaceCollision((4L)) == (16L));
    Debug.Assert(CarRaceCollision((8L)) == (64L));
    Debug.Assert(CarRaceCollision((10L)) == (100L));
    }

}


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 with elements incremented by 1.
    // >>> IncrList((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))
    // (new List<long>(new long[]{(long)2L, (long)3L, (long)4L}))
    // >>> IncrList((new List<long>(new long[]{(long)5L, (long)3L, (long)5L, (long)2L, (long)3L, (long)3L, (long)9L, (long)0L, (long)123L})))
    // (new List<long>(new long[]{(long)6L, (long)4L, (long)6L, (long)3L, (long)4L, (long)4L, (long)10L, (long)1L, (long)124L}))
    //     public static List<long> IncrList(List<long> l) {

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

}


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 {
    // pairs_sum_to_zero takes a list of integers as an input.
    // it returns True if there are two distinct elements in the list that
    // sum to zero, and False otherwise.
    // >>> PairsSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)0L})))
    // (false)
    // >>> PairsSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)-2L, (long)1L})))
    // (false)
    // >>> PairsSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)7L})))
    // (false)
    // >>> PairsSumToZero((new List<long>(new long[]{(long)2L, (long)4L, (long)-5L, (long)3L, (long)5L, (long)7L})))
    // (true)
    // >>> PairsSumToZero((new List<long>(new long[]{(long)1L})))
    // (false)
    //     public static bool PairsSumToZero(List<long> l) {

    }
    public static void Main(string[] args) {
    Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)5L, (long)0L}))) == (false));
    Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)1L, (long)3L, (long)-2L, (long)1L}))) == (false));
    Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)7L}))) == (false));
    Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)2L, (long)4L, (long)-5L, (long)3L, (long)5L, (long)7L}))) == (true));
    Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)1L}))) == (false));
    Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)-3L, (long)9L, (long)-1L, (long)3L, (long)2L, (long)30L}))) == (true));
    Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)-3L, (long)9L, (long)-1L, (long)3L, (long)2L, (long)31L}))) == (true));
    Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)-3L, (long)9L, (long)-1L, (long)4L, (long)2L, (long)30L}))) == (false));
    Debug.Assert(PairsSumToZero((new List<long>(new long[]{(long)-3L, (long)9L, (long)-1L, (long)4L, (long)2L, (long)31L}))) == (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 {
    // Change numerical base of input number x to base.
    // return string representation after the conversion.
    // base numbers are less than 10.
    // >>> ChangeBase((8L), (3L))
    // ("22")
    // >>> ChangeBase((8L), (2L))
    // ("1000")
    // >>> ChangeBase((7L), (2L))
    // ("111")
    //     public static string ChangeBase(long x, long numBase) {

    }
    public static void Main(string[] args) {
    Debug.Assert(ChangeBase((8L), (3L)).Equals(("22")));
    Debug.Assert(ChangeBase((9L), (3L)).Equals(("100")));
    Debug.Assert(ChangeBase((234L), (2L)).Equals(("11101010")));
    Debug.Assert(ChangeBase((16L), (2L)).Equals(("10000")));
    Debug.Assert(ChangeBase((8L), (2L)).Equals(("1000")));
    Debug.Assert(ChangeBase((7L), (2L)).Equals(("111")));
    Debug.Assert(ChangeBase((2L), (3L)).Equals(("2")));
    Debug.Assert(ChangeBase((3L), (4L)).Equals(("3")));
    Debug.Assert(ChangeBase((4L), (5L)).Equals(("4")));
    Debug.Assert(ChangeBase((5L), (6L)).Equals(("5")));
    Debug.Assert(ChangeBase((6L), (7L)).Equals(("6")));
    Debug.Assert(ChangeBase((7L), (8L)).Equals(("7")));
    }

}


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 length of a side and high return area for a triangle.
    // >>> TriangleArea((5L), (3L))
    // (7.5f)
    //     public static float TriangleArea(long a, long h) {

    }
    public static void Main(string[] args) {
    Debug.Assert(TriangleArea((5L), (3L)) == (7.5f));
    Debug.Assert(TriangleArea((2L), (2L)) == (2.0f));
    Debug.Assert(TriangleArea((10L), (8L)) == (40.0f));
    }

}


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 Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
    // fib4(0) -> 0
    // fib4(1) -> 0
    // fib4(2) -> 2
    // fib4(3) -> 0
    // fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    // Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
    // >>> Fib4((5L))
    // (4L)
    // >>> Fib4((6L))
    // (8L)
    // >>> Fib4((7L))
    // (14L)
    //     public static long Fib4(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Fib4((5L)) == (4L));
    Debug.Assert(Fib4((8L)) == (28L));
    Debug.Assert(Fib4((10L)) == (104L));
    Debug.Assert(Fib4((12L)) == (386L));
    }

}


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 median of elements in the list l.
    // >>> Median((new List<long>(new long[]{(long)3L, (long)1L, (long)2L, (long)4L, (long)5L})))
    // (float)3L
    // >>> Median((new List<long>(new long[]{(long)-10L, (long)4L, (long)6L, (long)1000L, (long)10L, (long)20L})))
    // (15.0f)
    //     public static float Median(List<long> l) {

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

}


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 {
    // Checks if given string is a palindrome
    // >>> IsPalindrome((""))
    // (true)
    // >>> IsPalindrome(("aba"))
    // (true)
    // >>> IsPalindrome(("aaaaa"))
    // (true)
    // >>> IsPalindrome(("zbcd"))
    // (false)
    //     public static bool IsPalindrome(string text) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IsPalindrome(("")) == (true));
    Debug.Assert(IsPalindrome(("aba")) == (true));
    Debug.Assert(IsPalindrome(("aaaaa")) == (true));
    Debug.Assert(IsPalindrome(("zbcd")) == (false));
    Debug.Assert(IsPalindrome(("xywyx")) == (true));
    Debug.Assert(IsPalindrome(("xywyz")) == (false));
    Debug.Assert(IsPalindrome(("xywzx")) == (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 {
    // Return 2^n modulo p (be aware of numerics).
    // >>> Modp((3L), (5L))
    // (3L)
    // >>> Modp((1101L), (101L))
    // (2L)
    // >>> Modp((0L), (101L))
    // (1L)
    // >>> Modp((3L), (11L))
    // (8L)
    // >>> Modp((100L), (101L))
    // (1L)
    //     public static long Modp(long n, long p) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Modp((3L), (5L)) == (3L));
    Debug.Assert(Modp((1101L), (101L)) == (2L));
    Debug.Assert(Modp((0L), (101L)) == (1L));
    Debug.Assert(Modp((3L), (11L)) == (8L));
    Debug.Assert(Modp((100L), (101L)) == (1L));
    Debug.Assert(Modp((30L), (5L)) == (4L));
    Debug.Assert(Modp((31L), (5L)) == (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 {
    // For a given list of input numbers, calculate Mean Absolute Deviation
    // around the mean of this dataset.
    // Mean Absolute Deviation is the average absolute difference between each
    // element and a centerpoint (mean in this case):
    // MAD = average | x - x_mean |
    // >>> MeanAbsoluteDeviation((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f})))
    // (1.0f)
    //     public static float MeanAbsoluteDeviation(List<float> numbers) {

    }
    public static void Main(string[] args) {
    Debug.Assert(MeanAbsoluteDeviation((new List<float>(new float[]{(float)1.0f, (float)2.0f}))) == (0.5f));
    Debug.Assert(MeanAbsoluteDeviation((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f}))) == (1.0f));
    Debug.Assert(MeanAbsoluteDeviation((new List<float>(new float[]{(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))) == (1.2f));
    }

}


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 {
    // remove_vowels is a function that takes string and returns string without vowels.
    // >>> RemoveVowels((""))
    // ("")
    // >>> RemoveVowels(("abcdef"))
    // ("bcdf")
    // >>> RemoveVowels(("aaaaa"))
    // ("")
    // >>> RemoveVowels(("aaBAA"))
    // ("B")
    // >>> RemoveVowels(("zbcd"))
    // ("zbcd")
    //     public static string RemoveVowels(string text) {

    }
    public static void Main(string[] args) {
    Debug.Assert(RemoveVowels(("")).Equals(("")));
    Debug.Assert(RemoveVowels(("abcdef\nghijklm")).Equals(("bcdf\nghjklm")));
    Debug.Assert(RemoveVowels(("fedcba")).Equals(("fdcb")));
    Debug.Assert(RemoveVowels(("eeeee")).Equals(("")));
    Debug.Assert(RemoveVowels(("acBAA")).Equals(("cB")));
    Debug.Assert(RemoveVowels(("EcBOO")).Equals(("cB")));
    Debug.Assert(RemoveVowels(("ybcd")).Equals(("ybcd")));
    }

}


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 True if all numbers in the list l are below threshold t.
    // >>> BelowThreshold((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)10L})), (100L))
    // (true)
    // >>> BelowThreshold((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})), (5L))
    // (false)
    //     public static bool BelowThreshold(List<long> l, long t) {

    }
    public static void Main(string[] args) {
    Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)10L})), (100L)) == (true));
    Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})), (5L)) == (false));
    Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})), (21L)) == (true));
    Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})), (22L)) == (true));
    Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)8L, (long)4L, (long)10L})), (11L)) == (true));
    Debug.Assert(BelowThreshold((new List<long>(new long[]{(long)1L, (long)8L, (long)4L, (long)10L})), (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 {
    // Add two numbers x and y
    // >>> Add((2L), (3L))
    // (5L)
    // >>> Add((5L), (7L))
    // (12L)
    //     public static long Add(long x, long y) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Add((0L), (1L)) == (1L));
    Debug.Assert(Add((1L), (0L)) == (1L));
    Debug.Assert(Add((2L), (3L)) == (5L));
    Debug.Assert(Add((5L), (7L)) == (12L));
    Debug.Assert(Add((7L), (5L)) == (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 {
    // Check if two words have the same characters.
    // >>> SameChars(("eabcdzzzz"), ("dddzzzzzzzddeddabc"))
    // (true)
    // >>> SameChars(("abcd"), ("dddddddabc"))
    // (true)
    // >>> SameChars(("dddddddabc"), ("abcd"))
    // (true)
    // >>> SameChars(("eabcd"), ("dddddddabc"))
    // (false)
    // >>> SameChars(("abcd"), ("dddddddabce"))
    // (false)
    // >>> SameChars(("eabcdzzzz"), ("dddzzzzzzzddddabc"))
    // (false)
    //     public static bool SameChars(string s0, string s1) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SameChars(("eabcdzzzz"), ("dddzzzzzzzddeddabc")) == (true));
    Debug.Assert(SameChars(("abcd"), ("dddddddabc")) == (true));
    Debug.Assert(SameChars(("dddddddabc"), ("abcd")) == (true));
    Debug.Assert(SameChars(("eabcd"), ("dddddddabc")) == (false));
    Debug.Assert(SameChars(("abcd"), ("dddddddabcf")) == (false));
    Debug.Assert(SameChars(("eabcdzzzz"), ("dddzzzzzzzddddabc")) == (false));
    Debug.Assert(SameChars(("aabb"), ("aaccc")) == (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 {
    // Return n-th Fibonacci number.
    // >>> Fib((10L))
    // (55L)
    // >>> Fib((1L))
    // (1L)
    // >>> Fib((8L))
    // (21L)
    //     public static long Fib(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Fib((10L)) == (55L));
    Debug.Assert(Fib((1L)) == (1L));
    Debug.Assert(Fib((8L)) == (21L));
    Debug.Assert(Fib((11L)) == (89L));
    Debug.Assert(Fib((12L)) == (144L));
    }

}


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 {
    // brackets is a string of "<" and ">".
    // return True if every opening bracket has a corresponding closing bracket.
    // >>> CorrectBracketing(("<"))
    // (false)
    // >>> CorrectBracketing(("<>"))
    // (true)
    // >>> CorrectBracketing(("<<><>>"))
    // (true)
    // >>> CorrectBracketing(("><<>"))
    // (false)
    //     public static bool CorrectBracketing(string brackets) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CorrectBracketing(("<>")) == (true));
    Debug.Assert(CorrectBracketing(("<<><>>")) == (true));
    Debug.Assert(CorrectBracketing(("<><><<><>><>")) == (true));
    Debug.Assert(CorrectBracketing(("<><><<<><><>><>><<><><<>>>")) == (true));
    Debug.Assert(CorrectBracketing(("<<<><>>>>")) == (false));
    Debug.Assert(CorrectBracketing(("><<>")) == (false));
    Debug.Assert(CorrectBracketing(("<")) == (false));
    Debug.Assert(CorrectBracketing(("<<<<")) == (false));
    Debug.Assert(CorrectBracketing((">")) == (false));
    Debug.Assert(CorrectBracketing(("<<>")) == (false));
    Debug.Assert(CorrectBracketing(("<><><<><>><>><<>")) == (false));
    Debug.Assert(CorrectBracketing(("<><><<><>><>>><>")) == (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 {
    // Return True is list elements are monotonically increasing or decreasing.
    // >>> Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)20L})))
    // (true)
    // >>> Monotonic((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L})))
    // (false)
    // >>> Monotonic((new List<long>(new long[]{(long)4L, (long)1L, (long)0L, (long)-10L})))
    // (true)
    //     public static bool Monotonic(List<long> l) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)10L}))) == (true));
    Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)4L, (long)20L}))) == (true));
    Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)20L, (long)4L, (long)10L}))) == (false));
    Debug.Assert(Monotonic((new List<long>(new long[]{(long)4L, (long)1L, (long)0L, (long)-10L}))) == (true));
    Debug.Assert(Monotonic((new List<long>(new long[]{(long)4L, (long)1L, (long)1L, (long)0L}))) == (true));
    Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)5L, (long)60L}))) == (false));
    Debug.Assert(Monotonic((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)60L}))) == (true));
    Debug.Assert(Monotonic((new List<long>(new long[]{(long)9L, (long)9L, (long)9L, (long)9L}))) == (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 {
    // Return sorted unique common elements for two lists.
    // >>> Common((new List<long>(new long[]{(long)1L, (long)4L, (long)3L, (long)34L, (long)653L, (long)2L, (long)5L})), (new List<long>(new long[]{(long)5L, (long)7L, (long)1L, (long)5L, (long)9L, (long)653L, (long)121L})))
    // (new List<long>(new long[]{(long)1L, (long)5L, (long)653L}))
    // >>> Common((new List<long>(new long[]{(long)5L, (long)3L, (long)2L, (long)8L})), (new List<long>(new long[]{(long)3L, (long)2L})))
    // (new List<long>(new long[]{(long)2L, (long)3L}))
    //     public static List<long> Common(List<long> l1, List<long> l2) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Common((new List<long>(new long[]{(long)1L, (long)4L, (long)3L, (long)34L, (long)653L, (long)2L, (long)5L})), (new List<long>(new long[]{(long)5L, (long)7L, (long)1L, (long)5L, (long)9L, (long)653L, (long)121L}))).Equals((new List<long>(new long[]{(long)1L, (long)5L, (long)653L}))));
    Debug.Assert(Common((new List<long>(new long[]{(long)5L, (long)3L, (long)2L, (long)8L})), (new List<long>(new long[]{(long)3L, (long)2L}))).Equals((new List<long>(new long[]{(long)2L, (long)3L}))));
    Debug.Assert(Common((new List<long>(new long[]{(long)4L, (long)3L, (long)2L, (long)8L})), (new List<long>(new long[]{(long)3L, (long)2L, (long)4L}))).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)4L}))));
    Debug.Assert(Common((new List<long>(new long[]{(long)4L, (long)3L, (long)2L, (long)8L})), (new List<long>())).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 {
    // Return the largest prime factor of n. Assume n > 1 and is not a prime.
    // >>> LargestPrimeFactor((13195L))
    // (29L)
    // >>> LargestPrimeFactor((2048L))
    // (2L)
    //     public static long LargestPrimeFactor(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(LargestPrimeFactor((15L)) == (5L));
    Debug.Assert(LargestPrimeFactor((27L)) == (3L));
    Debug.Assert(LargestPrimeFactor((63L)) == (7L));
    Debug.Assert(LargestPrimeFactor((330L)) == (11L));
    Debug.Assert(LargestPrimeFactor((13195L)) == (29L));
    }

}


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 {
    // Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
    // >>> Intersperse((new List<long>()), (4L))
    // (new List<long>())
    // >>> Intersperse((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})), (4L))
    // (new List<long>(new long[]{(long)1L, (long)4L, (long)2L, (long)4L, (long)3L}))
    //     public static List<long> Intersperse(List<long> numbers, long delimeter) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Intersperse((new List<long>()), (7L)).Equals((new List<long>())));
    Debug.Assert(Intersperse((new List<long>(new long[]{(long)5L, (long)6L, (long)3L, (long)2L})), (8L)).Equals((new List<long>(new long[]{(long)5L, (long)8L, (long)6L, (long)8L, (long)3L, (long)8L, (long)2L}))));
    Debug.Assert(Intersperse((new List<long>(new long[]{(long)2L, (long)2L, (long)2L})), (2L)).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)2L, (long)2L, (long)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 {
    // sum_to_n is a function that sums numbers from 1 to n.
    // >>> SumToN((30L))
    // (465L)
    // >>> SumToN((100L))
    // (5050L)
    // >>> SumToN((5L))
    // (15L)
    // >>> SumToN((10L))
    // (55L)
    // >>> SumToN((1L))
    // (1L)
    //     public static long SumToN(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SumToN((1L)) == (1L));
    Debug.Assert(SumToN((6L)) == (21L));
    Debug.Assert(SumToN((11L)) == (66L));
    Debug.Assert(SumToN((30L)) == (465L));
    Debug.Assert(SumToN((100L)) == (5050L));
    }

}


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 {
    // brackets is a string of "(" and ")".
    // return True if every opening bracket has a corresponding closing bracket.
    // >>> CorrectBracketing(("("))
    // (false)
    // >>> CorrectBracketing(("()"))
    // (true)
    // >>> CorrectBracketing(("(()())"))
    // (true)
    // >>> CorrectBracketing((")(()"))
    // (false)
    //     public static bool CorrectBracketing(string brackets) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CorrectBracketing(("()")) == (true));
    Debug.Assert(CorrectBracketing(("(()())")) == (true));
    Debug.Assert(CorrectBracketing(("()()(()())()")) == (true));
    Debug.Assert(CorrectBracketing(("()()((()()())())(()()(()))")) == (true));
    Debug.Assert(CorrectBracketing(("((()())))")) == (false));
    Debug.Assert(CorrectBracketing((")(()")) == (false));
    Debug.Assert(CorrectBracketing(("(")) == (false));
    Debug.Assert(CorrectBracketing(("((((")) == (false));
    Debug.Assert(CorrectBracketing((")")) == (false));
    Debug.Assert(CorrectBracketing(("(()")) == (false));
    Debug.Assert(CorrectBracketing(("()()(()())())(()")) == (false));
    Debug.Assert(CorrectBracketing(("()()(()())()))()")) == (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 {
    // xs represent coefficients of a polynomial.
    // xs[0] + xs[1] * x + xs[2] * x^2 + ....
    // Return derivative of this polynomial in the same form.
    // >>> Derivative((new List<long>(new long[]{(long)3L, (long)1L, (long)2L, (long)4L, (long)5L})))
    // (new List<long>(new long[]{(long)1L, (long)4L, (long)12L, (long)20L}))
    // >>> Derivative((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))
    // (new List<long>(new long[]{(long)2L, (long)6L}))
    //     public static List<long> Derivative(List<long> xs) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Derivative((new List<long>(new long[]{(long)3L, (long)1L, (long)2L, (long)4L, (long)5L}))).Equals((new List<long>(new long[]{(long)1L, (long)4L, (long)12L, (long)20L}))));
    Debug.Assert(Derivative((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))).Equals((new List<long>(new long[]{(long)2L, (long)6L}))));
    Debug.Assert(Derivative((new List<long>(new long[]{(long)3L, (long)2L, (long)1L}))).Equals((new List<long>(new long[]{(long)2L, (long)2L}))));
    Debug.Assert(Derivative((new List<long>(new long[]{(long)3L, (long)2L, (long)1L, (long)0L, (long)4L}))).Equals((new List<long>(new long[]{(long)2L, (long)2L, (long)0L, (long)16L}))));
    Debug.Assert(Derivative((new List<long>(new long[]{(long)1L}))).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 {
    // The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
    // fibfib(0) == 0
    // fibfib(1) == 0
    // fibfib(2) == 1
    // fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    // Please write a function to efficiently compute the n-th element of the fibfib number sequence.
    // >>> Fibfib((1L))
    // (0L)
    // >>> Fibfib((5L))
    // (4L)
    // >>> Fibfib((8L))
    // (24L)
    //     public static long Fibfib(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Fibfib((2L)) == (1L));
    Debug.Assert(Fibfib((1L)) == (0L));
    Debug.Assert(Fibfib((5L)) == (4L));
    Debug.Assert(Fibfib((8L)) == (24L));
    Debug.Assert(Fibfib((10L)) == (81L));
    Debug.Assert(Fibfib((12L)) == (274L));
    Debug.Assert(Fibfib((14L)) == (927L));
    }

}


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 vowels_count which takes a string representing
    // a word as input and returns the number of vowels in the string.
    // Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
    // vowel, but only when it is at the end of the given word.
    // Example:
    // >>> VowelsCount(("abcde"))
    // (2L)
    // >>> VowelsCount(("ACEDY"))
    // (3L)
    //     public static long VowelsCount(string s) {

    }
    public static void Main(string[] args) {
    Debug.Assert(VowelsCount(("abcde")) == (2L));
    Debug.Assert(VowelsCount(("Alone")) == (3L));
    Debug.Assert(VowelsCount(("key")) == (2L));
    Debug.Assert(VowelsCount(("bye")) == (1L));
    Debug.Assert(VowelsCount(("keY")) == (2L));
    Debug.Assert(VowelsCount(("bYe")) == (1L));
    Debug.Assert(VowelsCount(("ACEDY")) == (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 {
    // Circular shift the digits of the integer x, shift the digits right by shift
    // and return the result as a string.
    // If shift > number of digits, return digits reversed.
    // >>> CircularShift((12L), (1L))
    // ("21")
    // >>> CircularShift((12L), (2L))
    // ("12")
    //     public static string CircularShift(long x, long shift) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CircularShift((100L), (2L)).Equals(("001")));
    Debug.Assert(CircularShift((12L), (2L)).Equals(("12")));
    Debug.Assert(CircularShift((97L), (8L)).Equals(("79")));
    Debug.Assert(CircularShift((12L), (1L)).Equals(("21")));
    Debug.Assert(CircularShift((11L), (101L)).Equals(("11")));
    }

}


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
    // Write a function that takes a string as input and returns the sum of the upper characters only'
    // ASCII codes.
    // Examples:
    // >>> Digitsum((""))
    // (0L)
    // >>> Digitsum(("abAB"))
    // (131L)
    // >>> Digitsum(("abcCd"))
    // (67L)
    // >>> Digitsum(("helloE"))
    // (69L)
    // >>> Digitsum(("woArBld"))
    // (131L)
    // >>> Digitsum(("aAaaaXa"))
    // (153L)
    //     public static long Digitsum(string s) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Digitsum(("")) == (0L));
    Debug.Assert(Digitsum(("abAB")) == (131L));
    Debug.Assert(Digitsum(("abcCd")) == (67L));
    Debug.Assert(Digitsum(("helloE")) == (69L));
    Debug.Assert(Digitsum(("woArBld")) == (131L));
    Debug.Assert(Digitsum(("aAaaaXa")) == (153L));
    Debug.Assert(Digitsum((" How are yOu?")) == (151L));
    Debug.Assert(Digitsum(("You arE Very Smart")) == (327L));
    }

}


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 task, you will be given a string that represents a number of apples and oranges
    // that are distributed in a basket of fruit this basket contains
    // apples, oranges, and mango fruits. Given the string that represents the total number of
    // the oranges and apples and an integer that represent the total number of the fruits
    // in the basket return the number of the mango fruits in the basket.
    // for examble:
    // >>> FruitDistribution(("5 apples and 6 oranges"), (19L))
    // (8L)
    // >>> FruitDistribution(("0 apples and 1 oranges"), (3L))
    // (2L)
    // >>> FruitDistribution(("2 apples and 3 oranges"), (100L))
    // (95L)
    // >>> FruitDistribution(("100 apples and 1 oranges"), (120L))
    // (19L)
    //     public static long FruitDistribution(string s, long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FruitDistribution(("5 apples and 6 oranges"), (19L)) == (8L));
    Debug.Assert(FruitDistribution(("5 apples and 6 oranges"), (21L)) == (10L));
    Debug.Assert(FruitDistribution(("0 apples and 1 oranges"), (3L)) == (2L));
    Debug.Assert(FruitDistribution(("1 apples and 0 oranges"), (3L)) == (2L));
    Debug.Assert(FruitDistribution(("2 apples and 3 oranges"), (100L)) == (95L));
    Debug.Assert(FruitDistribution(("2 apples and 3 oranges"), (5L)) == (0L));
    Debug.Assert(FruitDistribution(("1 apples and 100 oranges"), (120L)) == (19L));
    }

}


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 representing a branch of a tree that has non-negative integer nodes
    // your task is to pluck one of the nodes and return it.
    // The plucked node should be the node with the smallest even value.
    // If multiple nodes with the same smallest even value are found return the node that has smallest index.
    // The plucked node should be returned in a list, [ smalest_value, its index ],
    // If there are no even values or the given array is empty, return [].
    // Example 1:
    // >>> Pluck((new List<long>(new long[]{(long)4L, (long)2L, (long)3L})))
    // (new List<long>(new long[]{(long)2L, (long)1L}))
    // Explanation: 2 has the smallest even value, and 2 has the smallest index.
    // Example 2:
    // >>> Pluck((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})))
    // (new List<long>(new long[]{(long)2L, (long)1L}))
    // Explanation: 2 has the smallest even value, and 2 has the smallest index.
    // Example 3:
    // >>> Pluck((new List<long>()))
    // (new List<long>())
    // Example 4:
    // >>> Pluck((new List<long>(new long[]{(long)5L, (long)0L, (long)3L, (long)0L, (long)4L, (long)2L})))
    // (new List<long>(new long[]{(long)0L, (long)1L}))
    // Explanation: 0 is the smallest value, but  there are two zeros,
    // so we will choose the first zero, which has the smallest index.
    // Constraints:
    // * 1 <= nodes.length <= 10000
    // * 0 <= node.value
    //     public static List<long> Pluck(List<long> arr) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Pluck((new List<long>(new long[]{(long)4L, (long)2L, (long)3L}))).Equals((new List<long>(new long[]{(long)2L, (long)1L}))));
    Debug.Assert(Pluck((new List<long>(new long[]{(long)1L, (long)2L, (long)3L}))).Equals((new List<long>(new long[]{(long)2L, (long)1L}))));
    Debug.Assert(Pluck((new List<long>())).Equals((new List<long>())));
    Debug.Assert(Pluck((new List<long>(new long[]{(long)5L, (long)0L, (long)3L, (long)0L, (long)4L, (long)2L}))).Equals((new List<long>(new long[]{(long)0L, (long)1L}))));
    Debug.Assert(Pluck((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)0L, (long)5L, (long)3L}))).Equals((new List<long>(new long[]{(long)0L, (long)3L}))));
    Debug.Assert(Pluck((new List<long>(new long[]{(long)5L, (long)4L, (long)8L, (long)4L, (long)8L}))).Equals((new List<long>(new long[]{(long)4L, (long)1L}))));
    Debug.Assert(Pluck((new List<long>(new long[]{(long)7L, (long)6L, (long)7L, (long)1L}))).Equals((new List<long>(new long[]{(long)6L, (long)1L}))));
    Debug.Assert(Pluck((new List<long>(new long[]{(long)7L, (long)9L, (long)7L, (long)1L}))).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 {
    // You are given a non-empty list of positive integers. Return the greatest integer that is greater than
    // zero, and has a frequency greater than or equal to the value of the integer itself.
    // The frequency of an integer is the number of times it appears in the list.
    // If no such a value exist, return -1.
    // Examples:
    // >>> Search((new List<long>(new long[]{(long)4L, (long)1L, (long)2L, (long)2L, (long)3L, (long)1L})))
    // (2L)
    // >>> Search((new List<long>(new long[]{(long)1L, (long)2L, (long)2L, (long)3L, (long)3L, (long)3L, (long)4L, (long)4L, (long)4L})))
    // (3L)
    // >>> Search((new List<long>(new long[]{(long)5L, (long)5L, (long)4L, (long)4L, (long)4L})))
    // (-1L)
    //     public static long Search(List<long> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Search((new List<long>(new long[]{(long)5L, (long)5L, (long)5L, (long)5L, (long)1L}))) == (1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)4L, (long)1L, (long)4L, (long)1L, (long)4L, (long)4L}))) == (4L));
    Debug.Assert(Search((new List<long>(new long[]{(long)3L, (long)3L}))) == (-1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)8L, (long)8L, (long)8L, (long)8L, (long)8L, (long)8L, (long)8L, (long)8L}))) == (8L));
    Debug.Assert(Search((new List<long>(new long[]{(long)2L, (long)3L, (long)3L, (long)2L, (long)2L}))) == (2L));
    Debug.Assert(Search((new List<long>(new long[]{(long)2L, (long)7L, (long)8L, (long)8L, (long)4L, (long)8L, (long)7L, (long)3L, (long)9L, (long)6L, (long)5L, (long)10L, (long)4L, (long)3L, (long)6L, (long)7L, (long)1L, (long)7L, (long)4L, (long)10L, (long)8L, (long)1L}))) == (1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)3L, (long)2L, (long)8L, (long)2L}))) == (2L));
    Debug.Assert(Search((new List<long>(new long[]{(long)6L, (long)7L, (long)1L, (long)8L, (long)8L, (long)10L, (long)5L, (long)8L, (long)5L, (long)3L, (long)10L}))) == (1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)8L, (long)8L, (long)3L, (long)6L, (long)5L, (long)6L, (long)4L}))) == (-1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)6L, (long)9L, (long)6L, (long)7L, (long)1L, (long)4L, (long)7L, (long)1L, (long)8L, (long)8L, (long)9L, (long)8L, (long)10L, (long)10L, (long)8L, (long)4L, (long)10L, (long)4L, (long)10L, (long)1L, (long)2L, (long)9L, (long)5L, (long)7L, (long)9L}))) == (1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)1L, (long)9L, (long)10L, (long)1L, (long)3L}))) == (1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)6L, (long)9L, (long)7L, (long)5L, (long)8L, (long)7L, (long)5L, (long)3L, (long)7L, (long)5L, (long)10L, (long)10L, (long)3L, (long)6L, (long)10L, (long)2L, (long)8L, (long)6L, (long)5L, (long)4L, (long)9L, (long)5L, (long)3L, (long)10L}))) == (5L));
    Debug.Assert(Search((new List<long>(new long[]{(long)1L}))) == (1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)8L, (long)8L, (long)10L, (long)6L, (long)4L, (long)3L, (long)5L, (long)8L, (long)2L, (long)4L, (long)2L, (long)8L, (long)4L, (long)6L, (long)10L, (long)4L, (long)2L, (long)1L, (long)10L, (long)2L, (long)1L, (long)1L, (long)5L}))) == (4L));
    Debug.Assert(Search((new List<long>(new long[]{(long)2L, (long)10L, (long)4L, (long)8L, (long)2L, (long)10L, (long)5L, (long)1L, (long)2L, (long)9L, (long)5L, (long)5L, (long)6L, (long)3L, (long)8L, (long)6L, (long)4L, (long)10L}))) == (2L));
    Debug.Assert(Search((new List<long>(new long[]{(long)1L, (long)6L, (long)10L, (long)1L, (long)6L, (long)9L, (long)10L, (long)8L, (long)6L, (long)8L, (long)7L, (long)3L}))) == (1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)9L, (long)2L, (long)4L, (long)1L, (long)5L, (long)1L, (long)5L, (long)2L, (long)5L, (long)7L, (long)7L, (long)7L, (long)3L, (long)10L, (long)1L, (long)5L, (long)4L, (long)2L, (long)8L, (long)4L, (long)1L, (long)9L, (long)10L, (long)7L, (long)10L, (long)2L, (long)8L, (long)10L, (long)9L, (long)4L}))) == (4L));
    Debug.Assert(Search((new List<long>(new long[]{(long)2L, (long)6L, (long)4L, (long)2L, (long)8L, (long)7L, (long)5L, (long)6L, (long)4L, (long)10L, (long)4L, (long)6L, (long)3L, (long)7L, (long)8L, (long)8L, (long)3L, (long)1L, (long)4L, (long)2L, (long)2L, (long)10L, (long)7L}))) == (4L));
    Debug.Assert(Search((new List<long>(new long[]{(long)9L, (long)8L, (long)6L, (long)10L, (long)2L, (long)6L, (long)10L, (long)2L, (long)7L, (long)8L, (long)10L, (long)3L, (long)8L, (long)2L, (long)6L, (long)2L, (long)3L, (long)1L}))) == (2L));
    Debug.Assert(Search((new List<long>(new long[]{(long)5L, (long)5L, (long)3L, (long)9L, (long)5L, (long)6L, (long)3L, (long)2L, (long)8L, (long)5L, (long)6L, (long)10L, (long)10L, (long)6L, (long)8L, (long)4L, (long)10L, (long)7L, (long)7L, (long)10L, (long)8L}))) == (-1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)10L}))) == (-1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)9L, (long)7L, (long)7L, (long)2L, (long)4L, (long)7L, (long)2L, (long)10L, (long)9L, (long)7L, (long)5L, (long)7L, (long)2L}))) == (2L));
    Debug.Assert(Search((new List<long>(new long[]{(long)5L, (long)4L, (long)10L, (long)2L, (long)1L, (long)1L, (long)10L, (long)3L, (long)6L, (long)1L, (long)8L}))) == (1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)7L, (long)9L, (long)9L, (long)9L, (long)3L, (long)4L, (long)1L, (long)5L, (long)9L, (long)1L, (long)2L, (long)1L, (long)1L, (long)10L, (long)7L, (long)5L, (long)6L, (long)7L, (long)6L, (long)7L, (long)7L, (long)6L}))) == (1L));
    Debug.Assert(Search((new List<long>(new long[]{(long)3L, (long)10L, (long)10L, (long)9L, (long)2L}))) == (-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 {
    // Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
    // For each of the group, output the deepest level of nesting of parentheses.
    // E.g. (()()) has maximum two levels of nesting while ((())) has three.
    // >>> ParseNestedParens(("(()()) ((())) () ((())()())"))
    // (new List<long>(new long[]{(long)2L, (long)3L, (long)1L, (long)3L}))
    //     public static List<long> ParseNestedParens(string paren_string) {

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

}