Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // You have been tasked to write a function that receives
    // a hexadecimal number as a string and counts the number of hexadecimal
    // digits that are primes (prime number, or a prime, is a natural number
    // greater than 1 that is not a product of two smaller natural numbers).
    // Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    // Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
    // So you have to determine a number of the following digits: 2, 3, 5, 7,
    // B (=decimal 11), D (=decimal 13).
    // Note: you may assume the input is always correct or empty string,
    // and symbols A,B,C,D,E,F are always uppercase.
    // Examples:
    // For num = "AB" the output should be 1.
    // For num = "1077E" the output should be 2.
    // For num = "ABED1A33" the output should be 4.
    // For num = "123456789ABCDEF0" the output should be 6.
    // For num = "2020" the output should be 2.
    //     public static long HexKey(string num) {

    }
    public static void Main(string[] args) {
    Debug.Assert(HexKey(("AB")) == (1L));
    Debug.Assert(HexKey(("1077E")) == (2L));
    Debug.Assert(HexKey(("ABED1A33")) == (4L));
    Debug.Assert(HexKey(("2020")) == (2L));
    Debug.Assert(HexKey(("123456789ABCDEF0")) == (6L));
    Debug.Assert(HexKey(("112233445566778899AABBCCDDEEFF00")) == (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 {
    // You will be given a number in decimal form and your task is to convert it to
    // binary format. The function should return a string, with each character representing a binary
    // number. Each character in the string will be '0' or '1'.
    // There will be an extra couple of characters 'db' at the beginning and at the end of the string.
    // The extra characters are there to help with the format.
    // Examples:
    // decimal_to_binary(15)   # returns "db1111db"
    // decimal_to_binary(32)   # returns "db100000db"
    //     public static string DecimalToBinary(long decimalNum) {

    }
    public static void Main(string[] args) {
    Debug.Assert(DecimalToBinary((0L)).Equals(("db0db")));
    Debug.Assert(DecimalToBinary((32L)).Equals(("db100000db")));
    Debug.Assert(DecimalToBinary((103L)).Equals(("db1100111db")));
    Debug.Assert(DecimalToBinary((15L)).Equals(("db1111db")));
    }

}


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 contain given substring
    // >>> filter_by_substring([], 'a')
    // []
    // >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    // ['abc', 'bacd', 'array']
    //     public static List<string> FilterBySubstring(List<string> strings, string substring) {

    }
    public static void Main(string[] args) {
    Debug.Assert(FilterBySubstring((new List<string>()), ("john")).Equals((new List<string>())));
    Debug.Assert(FilterBySubstring((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"}))));
    Debug.Assert(FilterBySubstring((new List<string>(new string[]{(string)"xxx", (string)"asd", (string)"aaaxxy", (string)"john doe", (string)"xxxAAA", (string)"xxx"})), ("xx")).Equals((new List<string>(new string[]{(string)"xxx", (string)"aaaxxy", (string)"xxxAAA", (string)"xxx"}))));
    Debug.Assert(FilterBySubstring((new List<string>(new string[]{(string)"grunt", (string)"trumpet", (string)"prune", (string)"gruesome"})), ("run")).Equals((new List<string>(new string[]{(string)"grunt", (string)"prune"}))));
    }

}


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.
    // Your task is to check if the string is happy or not.
    // A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
    // For example:
    // is_happy(a) => False
    // is_happy(aa) => False
    // is_happy(abcd) => True
    // is_happy(aabb) => False
    // is_happy(adb) => True
    // is_happy(xyy) => False
    //     public static bool IsHappy(string s) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IsHappy(("a")) == (false));
    Debug.Assert(IsHappy(("aa")) == (false));
    Debug.Assert(IsHappy(("abcd")) == (true));
    Debug.Assert(IsHappy(("aabb")) == (false));
    Debug.Assert(IsHappy(("adb")) == (true));
    Debug.Assert(IsHappy(("xyy")) == (false));
    Debug.Assert(IsHappy(("iopaxpoi")) == (true));
    Debug.Assert(IsHappy(("iopaxioi")) == (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 {
    // It is the last week of the semester and the teacher has to give the grades
    // to students. The teacher has been making her own algorithm for grading.
    // The only problem is, she has lost the code she used for grading.
    // She has given you a list of GPAs for some students and you have to write
    // a function that can output a list of letter grades using the following table:
    // GPA       |    Letter grade
    // 4.0                A+
    // > 3.7                A
    // > 3.3                A-
    // > 3.0                B+
    // > 2.7                B
    // > 2.3                B-
    // > 2.0                C+
    // > 1.7                C
    // > 1.3                C-
    // > 1.0                D+
    // > 0.7                D
    // > 0.0                D-
    // 0.0                E
    // Example:
    // grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    //     public static List<string> NumericalLetterGrade(List<float> grades) {

    }
    public static void Main(string[] args) {
    Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)4.0f, (float)3L, (float)1.7f, (float)2L, (float)3.5f}))).Equals((new List<string>(new string[]{(string)"A+", (string)"B", (string)"C-", (string)"C", (string)"A-"}))));
    Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)1.2f}))).Equals((new List<string>(new string[]{(string)"D+"}))));
    Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)0.5f}))).Equals((new List<string>(new string[]{(string)"D-"}))));
    Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)0.0f}))).Equals((new List<string>(new string[]{(string)"E"}))));
    Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)1.0f, (float)0.3f, (float)1.5f, (float)2.8f, (float)3.3f}))).Equals((new List<string>(new string[]{(string)"D", (string)"D-", (string)"C-", (string)"B", (string)"B+"}))));
    Debug.Assert(NumericalLetterGrade((new List<float>(new float[]{(float)0.0f, (float)0.7f}))).Equals((new List<string>(new string[]{(string)"E", (string)"D-"}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Write a function that takes a string and returns True if the string
    // length is a prime number or False otherwise
    // Examples
    // prime_length('Hello') == True
    // prime_length('abcdcba') == True
    // prime_length('kittens') == True
    // prime_length('orange') == False
    //     public static bool PrimeLength(string str) {

    }
    public static void Main(string[] args) {
    Debug.Assert(PrimeLength(("Hello")) == (true));
    Debug.Assert(PrimeLength(("abcdcba")) == (true));
    Debug.Assert(PrimeLength(("kittens")) == (true));
    Debug.Assert(PrimeLength(("orange")) == (false));
    Debug.Assert(PrimeLength(("wow")) == (true));
    Debug.Assert(PrimeLength(("world")) == (true));
    Debug.Assert(PrimeLength(("MadaM")) == (true));
    Debug.Assert(PrimeLength(("Wow")) == (true));
    Debug.Assert(PrimeLength(("")) == (false));
    Debug.Assert(PrimeLength(("HI")) == (true));
    Debug.Assert(PrimeLength(("go")) == (true));
    Debug.Assert(PrimeLength(("gogo")) == (false));
    Debug.Assert(PrimeLength(("aaaaaaaaaaaaaaa")) == (false));
    Debug.Assert(PrimeLength(("Madam")) == (true));
    Debug.Assert(PrimeLength(("M")) == (false));
    Debug.Assert(PrimeLength(("0")) == (false));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Given a positive integer n, return the count of the numbers of n-digit
    // positive integers that start or end with 1.
    //     public static long StartsOneEnds(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(StartsOneEnds((1L)) == (1L));
    Debug.Assert(StartsOneEnds((2L)) == (18L));
    Debug.Assert(StartsOneEnds((3L)) == (180L));
    Debug.Assert(StartsOneEnds((4L)) == (1800L));
    Debug.Assert(StartsOneEnds((5L)) == (18000L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Given a positive integer N, return the total sum of its digits in binary.
    // Example
    // For N = 1000, the sum of digits will be 1 the output should be "1".
    // For N = 150, the sum of digits will be 6 the output should be "110".
    // For N = 147, the sum of digits will be 12 the output should be "1100".
    // Variables:
    // @N integer
    // Constraints: 0 ≤ N ≤ 10000.
    // Output:
    // a string of binary number
    //     public static string Solve(long N) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Solve((1000L)).Equals(("1")));
    Debug.Assert(Solve((150L)).Equals(("110")));
    Debug.Assert(Solve((147L)).Equals(("1100")));
    Debug.Assert(Solve((333L)).Equals(("1001")));
    Debug.Assert(Solve((963L)).Equals(("10010")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Given a non-empty list of integers lst. add the even elements that are at odd indices..
    // Examples:
    // add([4, 2, 6, 7]) ==> 2
    //     public static long Add(List<long> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Add((new List<long>(new long[]{(long)4L, (long)88L}))) == (88L));
    Debug.Assert(Add((new List<long>(new long[]{(long)4L, (long)5L, (long)6L, (long)7L, (long)2L, (long)122L}))) == (122L));
    Debug.Assert(Add((new List<long>(new long[]{(long)4L, (long)0L, (long)6L, (long)7L}))) == (0L));
    Debug.Assert(Add((new List<long>(new long[]{(long)4L, (long)4L, (long)6L, (long)8L}))) == (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 {
    // Write a function that takes a string and returns an ordered version of it.
    // Ordered version of string, is a string where all words (separated by space)
    // are replaced by a new word where all the characters arranged in
    // ascending order based on ascii value.
    // Note: You should keep the order of words and blank spaces in the sentence.
    // For example:
    // anti_shuffle('Hi') returns 'Hi'
    // anti_shuffle('hello') returns 'ehllo'
    // anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    //     public static string AntiShuffle(string s) {

    }
    public static void Main(string[] args) {
    Debug.Assert(AntiShuffle(("Hi")).Equals(("Hi")));
    Debug.Assert(AntiShuffle(("hello")).Equals(("ehllo")));
    Debug.Assert(AntiShuffle(("number")).Equals(("bemnru")));
    Debug.Assert(AntiShuffle(("abcd")).Equals(("abcd")));
    Debug.Assert(AntiShuffle(("Hello World!!!")).Equals(("Hello !!!Wdlor")));
    Debug.Assert(AntiShuffle(("")).Equals(("")));
    Debug.Assert(AntiShuffle(("Hi. My name is Mister Robot. How are you?")).Equals((".Hi My aemn is Meirst .Rboot How aer ?ouy")));
    }

}


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 2 dimensional data, as a nested lists,
    // which is similar to matrix, however, unlike matrices,
    // each row may contain a different number of columns.
    // Given lst, and integer x, find integers x in the list,
    // and return list of tuples, [(x1, y1), (x2, y2) ...] such that
    // each tuple is a coordinate - (row, columns), starting with 0.
    // Sort coordinates initially by rows in ascending order.
    // Also, sort coordinates of the row by columns in descending order.
    // Examples:
    // get_row([
    // [1,2,3,4,5,6],
    // [1,2,3,4,1,6],
    // [1,2,3,4,5,1]
    // ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    // get_row([], 1) == []
    // get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    //     public static List<Tuple<long, long>> GetRow(List<List<long>> lst, long x) {

    }
    public static void Main(string[] args) {
    Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)1L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)1L})})), (1L)).Equals((new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(0L, 0L), (Tuple<long, long>)Tuple.Create(1L, 4L), (Tuple<long, long>)Tuple.Create(1L, 0L), (Tuple<long, long>)Tuple.Create(2L, 5L), (Tuple<long, long>)Tuple.Create(2L, 0L)}))));
    Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L})})), (2L)).Equals((new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(0L, 1L), (Tuple<long, long>)Tuple.Create(1L, 1L), (Tuple<long, long>)Tuple.Create(2L, 1L), (Tuple<long, long>)Tuple.Create(3L, 1L), (Tuple<long, long>)Tuple.Create(4L, 1L), (Tuple<long, long>)Tuple.Create(5L, 1L)}))));
    Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)1L, (long)3L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)1L, (long)4L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)1L, (long)5L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)1L, (long)6L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L, (long)1L})})), (1L)).Equals((new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(0L, 0L), (Tuple<long, long>)Tuple.Create(1L, 0L), (Tuple<long, long>)Tuple.Create(2L, 1L), (Tuple<long, long>)Tuple.Create(2L, 0L), (Tuple<long, long>)Tuple.Create(3L, 2L), (Tuple<long, long>)Tuple.Create(3L, 0L), (Tuple<long, long>)Tuple.Create(4L, 3L), (Tuple<long, long>)Tuple.Create(4L, 0L), (Tuple<long, long>)Tuple.Create(5L, 4L), (Tuple<long, long>)Tuple.Create(5L, 0L), (Tuple<long, long>)Tuple.Create(6L, 5L), (Tuple<long, long>)Tuple.Create(6L, 0L)}))));
    Debug.Assert(GetRow((new List<List<long>>()), (1L)).Equals((new List<Tuple<long, long>>())));
    Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(new long[]{(long)1L})})), (2L)).Equals((new List<Tuple<long, long>>())));
    Debug.Assert(GetRow((new List<List<long>>(new List<long>[]{(List<long>)new List<long>(), (List<long>)new List<long>(new long[]{(long)1L}), (List<long>)new List<long>(new long[]{(long)1L, (long)2L, (long)3L})})), (3L)).Equals((new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(2L, 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 {
    // Given an array of non-negative integers, return a copy of the given array after sorting,
    // you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
    // or sort it in descending order if the sum( first index value, last index value) is even.
    // Note:
    // * don't change the given array.
    // Examples:
    // * sort_array([]) => []
    // * sort_array([5]) => [5]
    // * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    // * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    //     public static List<long> SortArray(List<long> array) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SortArray((new List<long>())).Equals((new List<long>())));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)5L}))).Equals((new List<long>(new long[]{(long)5L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)3L, (long)0L, (long)1L, (long)5L}))).Equals((new List<long>(new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)3L, (long)0L, (long)1L, (long)5L, (long)6L}))).Equals((new List<long>(new long[]{(long)6L, (long)5L, (long)4L, (long)3L, (long)2L, (long)1L, (long)0L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)2L, (long)1L}))).Equals((new List<long>(new long[]{(long)1L, (long)2L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)15L, (long)42L, (long)87L, (long)32L, (long)11L, (long)0L}))).Equals((new List<long>(new long[]{(long)0L, (long)11L, (long)15L, (long)32L, (long)42L, (long)87L}))));
    Debug.Assert(SortArray((new List<long>(new long[]{(long)21L, (long)14L, (long)23L, (long)11L}))).Equals((new List<long>(new long[]{(long)23L, (long)21L, (long)14L, (long)11L}))));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Create a function encrypt that takes a string as an argument and
    // returns a string encrypted with the alphabet being rotated.
    // The alphabet should be rotated in a manner such that the letters
    // shift down by two multiplied to two places.
    // For example:
    // encrypt('hi') returns 'lm'
    // encrypt('asdfghjkl') returns 'ewhjklnop'
    // encrypt('gf') returns 'kj'
    // encrypt('et') returns 'ix'
    //     public static string Encrypt(string s) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Encrypt(("hi")).Equals(("lm")));
    Debug.Assert(Encrypt(("asdfghjkl")).Equals(("ewhjklnop")));
    Debug.Assert(Encrypt(("gf")).Equals(("kj")));
    Debug.Assert(Encrypt(("et")).Equals(("ix")));
    Debug.Assert(Encrypt(("faewfawefaewg")).Equals(("jeiajeaijeiak")));
    Debug.Assert(Encrypt(("hellomyfriend")).Equals(("lippsqcjvmirh")));
    Debug.Assert(Encrypt(("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh")).Equals(("hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl")));
    Debug.Assert(Encrypt(("a")).Equals(("e")));
    }

}


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 integers, return a tuple consisting of a sum and a product of all the integers in a list.
    // Empty sum should be equal to 0 and empty product should be equal to 1.
    // >>> sum_product([])
    // (0, 1)
    // >>> sum_product([1, 2, 3, 4])
    // (10, 24)
    //     public static Tuple<long, long> SumProduct(List<long> numbers) {

    }
    public static void Main(string[] args) {
    Debug.Assert(SumProduct((new List<long>())).Equals((Tuple.Create(0L, 1L))));
    Debug.Assert(SumProduct((new List<long>(new long[]{(long)1L, (long)1L, (long)1L}))).Equals((Tuple.Create(3L, 1L))));
    Debug.Assert(SumProduct((new List<long>(new long[]{(long)100L, (long)0L}))).Equals((Tuple.Create(100L, 0L))));
    Debug.Assert(SumProduct((new List<long>(new long[]{(long)3L, (long)5L, (long)7L}))).Equals((Tuple.Create(15L, 105L))));
    Debug.Assert(SumProduct((new List<long>(new long[]{(long)10L}))).Equals((Tuple.Create(10L, 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 {
    // You are given a list of integers.
    // Write a function next_smallest() that returns the 2nd smallest element of the list.
    // Return None if there is no such element.
    // next_smallest([1, 2, 3, 4, 5]) == 2
    // next_smallest([5, 1, 4, 3, 2]) == 2
    // next_smallest([]) == None
    // next_smallest([1, 1]) == None
    //     public static Nullable<long> NextSmallest(List<long> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(NextSmallest((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))).Equals(2L));
    Debug.Assert(NextSmallest((new List<long>(new long[]{(long)5L, (long)1L, (long)4L, (long)3L, (long)2L}))).Equals(2L));
    Debug.Assert(NextSmallest((new List<long>())).Equals(null));
    Debug.Assert(NextSmallest((new List<long>(new long[]{(long)1L, (long)1L}))).Equals(null));
    Debug.Assert(NextSmallest((new List<long>(new long[]{(long)1L, (long)1L, (long)1L, (long)1L, (long)0L}))).Equals(1L));
    Debug.Assert(NextSmallest((new List<long>(new long[]{(long)1L, (long)1L}))).Equals(null));
    Debug.Assert(NextSmallest((new List<long>(new long[]{(long)-35L, (long)34L, (long)12L, (long)-45L}))).Equals(-35L));
    }

}


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'll be given a string of words, and your task is to count the number
    // of boredoms. A boredom is a sentence that starts with the word "I".
    // Sentences are delimited by '.', '?' or '!'.
    // For example:
    // >>> is_bored("Hello world")
    // 0
    // >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    // 1
    //     public static long IsBored(string S) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IsBored(("Hello world")) == (0L));
    Debug.Assert(IsBored(("Is the sky blue?")) == (0L));
    Debug.Assert(IsBored(("I love It !")) == (1L));
    Debug.Assert(IsBored(("bIt")) == (0L));
    Debug.Assert(IsBored(("I feel good today. I will be productive. will kill It")) == (2L));
    Debug.Assert(IsBored(("You and I are going for a walk")) == (0L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Create a function that takes 3 numbers.
    // Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
    // Returns false in any other cases.
    // Examples
    // any_int(5, 2, 7) ➞ True
    // any_int(3, 2, 2) ➞ False
    // any_int(3, -2, 1) ➞ True
    // any_int(3.6, -2.2, 2) ➞ False
    //     public static bool AnyInt(float x, float y, float z) {

    }
    public static void Main(string[] args) {
    Debug.Assert(AnyInt((float)2L, (float)3L, (float)1L) == (true));
    Debug.Assert(AnyInt((2.5f), (float)2L, (float)3L) == (false));
    Debug.Assert(AnyInt((1.5f), (float)5L, (3.5f)) == (false));
    Debug.Assert(AnyInt((float)2L, (float)6L, (float)2L) == (false));
    Debug.Assert(AnyInt((float)4L, (float)2L, (float)2L) == (true));
    Debug.Assert(AnyInt((2.2f), (2.2f), (2.2f)) == (false));
    Debug.Assert(AnyInt((float)-4L, (float)6L, (float)2L) == (true));
    Debug.Assert(AnyInt((float)2L, (float)1L, (float)1L) == (true));
    Debug.Assert(AnyInt((float)3L, (float)4L, (float)7L) == (true));
    Debug.Assert(AnyInt((3.0f), (float)4L, (float)7L) == (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 takes a message, and encodes in such a
    // way that it swaps case of all letters, replaces all vowels in
    // the message with the letter that appears 2 places ahead of that
    // vowel in the english alphabet.
    // Assume only letters.
    // Examples:
    // >>> encode('test')
    // 'TGST'
    // >>> encode('This is a message')
    // 'tHKS KS C MGSSCGG'
    //     public static string Encode(string message) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Encode(("TEST")).Equals(("tgst")));
    Debug.Assert(Encode(("Mudasir")).Equals(("mWDCSKR")));
    Debug.Assert(Encode(("YES")).Equals(("ygs")));
    Debug.Assert(Encode(("This is a message")).Equals(("tHKS KS C MGSSCGG")));
    Debug.Assert(Encode(("I DoNt KnOw WhAt tO WrItE")).Equals(("k dQnT kNqW wHcT Tq wRkTg")));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // You are given a list of integers.
    // You need to find the largest prime value and return the sum of its digits.
    // Examples:
    // For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
    // For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25
    // For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
    // For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
    // For lst = [0,81,12,3,1,21] the output should be 3
    // For lst = [0,8,1,2,1,7] the output should be 7
    //     public static long Skjkasdkd(List<long> lst) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)0L, (long)3L, (long)2L, (long)1L, (long)3L, (long)5L, (long)7L, (long)4L, (long)5L, (long)5L, (long)5L, (long)2L, (long)181L, (long)32L, (long)4L, (long)32L, (long)3L, (long)2L, (long)32L, (long)324L, (long)4L, (long)3L}))) == (10L));
    Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)1L, (long)0L, (long)1L, (long)8L, (long)2L, (long)4597L, (long)2L, (long)1L, (long)3L, (long)40L, (long)1L, (long)2L, (long)1L, (long)2L, (long)4L, (long)2L, (long)5L, (long)1L}))) == (25L));
    Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)1L, (long)3L, (long)1L, (long)32L, (long)5107L, (long)34L, (long)83278L, (long)109L, (long)163L, (long)23L, (long)2323L, (long)32L, (long)30L, (long)1L, (long)9L, (long)3L}))) == (13L));
    Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)0L, (long)724L, (long)32L, (long)71L, (long)99L, (long)32L, (long)6L, (long)0L, (long)5L, (long)91L, (long)83L, (long)0L, (long)5L, (long)6L}))) == (11L));
    Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)0L, (long)81L, (long)12L, (long)3L, (long)1L, (long)21L}))) == (3L));
    Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)0L, (long)8L, (long)1L, (long)2L, (long)1L, (long)7L}))) == (7L));
    Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)8191L}))) == (19L));
    Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)8191L, (long)123456L, (long)127L, (long)7L}))) == (19L));
    Debug.Assert(Skjkasdkd((new List<long>(new long[]{(long)127L, (long)97L, (long)8192L}))) == (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 {
    // Given a dictionary, return True if all keys are strings in lower
    // case or all keys are strings in upper case, else return False.
    // The function should return False is the given dictionary is empty.
    // Examples:
    // check_dict_case({"a":"apple", "b":"banana"}) should return True.
    // check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) should return False.
    // check_dict_case({"a":"apple", "8":"banana", "a":"apple"}) should return False.
    // check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) should return False.
    // check_dict_case({"STATE":"NC", "ZIP":"12345" }) should return True.
    //     public static bool CheckDictCase(Dictionary<string,string> dict) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{"p", "pineapple"}, {"b", "banana"}})) == (true));
    Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{"p", "pineapple"}, {"A", "banana"}, {"B", "banana"}})) == (false));
    Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{"p", "pineapple"}, {"5", "banana"}, {"a", "apple"}})) == (false));
    Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{"Name", "John"}, {"Age", "36"}, {"City", "Houston"}})) == (false));
    Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{"STATE", "NC"}, {"ZIP", "12345"}})) == (true));
    Debug.Assert(CheckDictCase((new Dictionary<string,string>(){{"fruit", "Orange"}, {"taste", "Sweet"}})) == (true));
    Debug.Assert(CheckDictCase((new Dictionary<string,string>())) == (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 {
    // Implement a function that takes an non-negative integer and returns an array of the first n
    // integers that are prime numbers and less than n.
    // for example:
    // count_up_to(5) => [2,3]
    // count_up_to(11) => [2,3,5,7]
    // count_up_to(0) => []
    // count_up_to(20) => [2,3,5,7,11,13,17,19]
    // count_up_to(1) => []
    // count_up_to(18) => [2,3,5,7,11,13,17]
    //     public static List<long> CountUpTo(long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CountUpTo((5L)).Equals((new List<long>(new long[]{(long)2L, (long)3L}))));
    Debug.Assert(CountUpTo((6L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L}))));
    Debug.Assert(CountUpTo((7L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L}))));
    Debug.Assert(CountUpTo((10L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L}))));
    Debug.Assert(CountUpTo((0L)).Equals((new List<long>())));
    Debug.Assert(CountUpTo((22L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L, (long)19L}))));
    Debug.Assert(CountUpTo((1L)).Equals((new List<long>())));
    Debug.Assert(CountUpTo((18L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L}))));
    Debug.Assert(CountUpTo((47L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L, (long)19L, (long)23L, (long)29L, (long)31L, (long)37L, (long)41L, (long)43L}))));
    Debug.Assert(CountUpTo((101L)).Equals((new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L, (long)19L, (long)23L, (long)29L, (long)31L, (long)37L, (long)41L, (long)43L, (long)47L, (long)53L, (long)59L, (long)61L, (long)67L, (long)71L, (long)73L, (long)79L, (long)83L, (long)89L, (long)97L}))));
    }

}


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 {
    // Complete the function that takes two integers and returns
    // the product of their unit digits.
    // Assume the input is always valid.
    // Examples:
    // multiply(148, 412) should return 16.
    // multiply(19, 28) should return 72.
    // multiply(2020, 1851) should return 0.
    // multiply(14,-15) should return 20.
    //     public static long Multiply(long a, long b) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Multiply((148L), (412L)) == (16L));
    Debug.Assert(Multiply((19L), (28L)) == (72L));
    Debug.Assert(Multiply((2020L), (1851L)) == (0L));
    Debug.Assert(Multiply((14L), (-15L)) == (20L));
    Debug.Assert(Multiply((76L), (67L)) == (42L));
    Debug.Assert(Multiply((17L), (27L)) == (49L));
    Debug.Assert(Multiply((0L), (1L)) == (0L));
    Debug.Assert(Multiply((0L), (0L)) == (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 string s, count the number of uppercase vowels in even indices.
    // For example:
    // count_upper('aBCdEf') returns 1
    // count_upper('abcdefg') returns 0
    // count_upper('dBBE') returns 0
    //     public static long CountUpper(string s) {

    }
    public static void Main(string[] args) {
    Debug.Assert(CountUpper(("aBCdEf")) == (1L));
    Debug.Assert(CountUpper(("abcdefg")) == (0L));
    Debug.Assert(CountUpper(("dBBE")) == (0L));
    Debug.Assert(CountUpper(("B")) == (0L));
    Debug.Assert(CountUpper(("U")) == (1L));
    Debug.Assert(CountUpper(("")) == (0L));
    Debug.Assert(CountUpper(("EEEE")) == (2L));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Create a function that takes a value (string) representing a number
    // and returns the closest integer to it. If the number is equidistant
    // from two integers, round it away from zero.
    // Examples
    // >>> closest_integer("10")
    // 10
    // >>> closest_integer("15.3")
    // 15
    // Note:
    // Rounding away from zero means that if the given number is equidistant
    // from two integers, the one you should return is the one that is the
    // farthest from zero. For example closest_integer("14.5") should
    // return 15 and closest_integer("-14.5") should return -15.
    //     public static long ClosestInteger(string value) {

    }
    public static void Main(string[] args) {
    Debug.Assert(ClosestInteger(("10")) == (10L));
    Debug.Assert(ClosestInteger(("14.5")) == (15L));
    Debug.Assert(ClosestInteger(("-15.5")) == (-16L));
    Debug.Assert(ClosestInteger(("15.3")) == (15L));
    Debug.Assert(ClosestInteger(("0")) == (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 {
    // From a given list of integers, generate a list of rolling maximum element found until given moment
    // in the sequence.
    // >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    // [1, 2, 3, 3, 3, 4, 4]
    //     public static List<long> RollingMax(List<long> numbers) {

    }
    public static void Main(string[] args) {
    Debug.Assert(RollingMax((new List<long>())).Equals((new List<long>())));
    Debug.Assert(RollingMax((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(RollingMax((new List<long>(new long[]{(long)4L, (long)3L, (long)2L, (long)1L}))).Equals((new List<long>(new long[]{(long)4L, (long)4L, (long)4L, (long)4L}))));
    Debug.Assert(RollingMax((new List<long>(new long[]{(long)3L, (long)2L, (long)3L, (long)100L, (long)3L}))).Equals((new List<long>(new long[]{(long)3L, (long)3L, (long)3L, (long)100L, (long)100L}))));
    }

}