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 integers, return list in strange order.
    // Strange sorting, is when you start with the minimum value,
    // then maximum of the remaining integers, then minimum and so on.
    // Examples:
    // >>> StrangeSortList((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})))
    // (new List<long>(new long[]{(long)1L, (long)4L, (long)2L, (long)3L}))
    // >>> StrangeSortList((new List<long>(new long[]{(long)5L, (long)5L, (long)5L, (long)5L})))
    // (new List<long>(new long[]{(long)5L, (long)5L, (long)5L, (long)5L}))
    // >>> StrangeSortList((new List<long>()))
    // (new List<long>())
    //     public static List<long> StrangeSortList(List<long> lst) {

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

}


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 the area of
    // the triangle rounded to 2 decimal points if the three sides form a valid triangle.
    // Otherwise return -1
    // Three sides make a valid triangle when the sum of any two sides is greater
    // than the third side.
    // Example:
    // >>> TriangleArea((3L), (4L), (5L))
    // (6.0f)
    // >>> TriangleArea((1L), (2L), (10L))
    // (float)-1L
    //     public static float TriangleArea(long a, long b, long c) {

    }
    public static void Main(string[] args) {
    Debug.Assert(TriangleArea((3L), (4L), (5L)) == (6.0f));
    Debug.Assert(TriangleArea((1L), (2L), (10L)) == (float)-1L);
    Debug.Assert(TriangleArea((4L), (8L), (5L)) == (8.18f));
    Debug.Assert(TriangleArea((2L), (2L), (2L)) == (1.73f));
    Debug.Assert(TriangleArea((1L), (2L), (3L)) == (float)-1L);
    Debug.Assert(TriangleArea((10L), (5L), (7L)) == (16.25f));
    Debug.Assert(TriangleArea((2L), (6L), (3L)) == (float)-1L);
    Debug.Assert(TriangleArea((1L), (1L), (1L)) == (0.43f));
    Debug.Assert(TriangleArea((2L), (2L), (10L)) == (float)-1L);
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Write a function that returns True if the object q will fly, and False otherwise.
    // The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.
    // Example:
    // >>> WillItFly((new List<long>(new long[]{(long)1L, (long)2L})), (5L))
    // (false)
    // # 1+2 is less than the maximum possible weight, but it's unbalanced.
    // >>> WillItFly((new List<long>(new long[]{(long)3L, (long)2L, (long)3L})), (1L))
    // (false)
    // # it's balanced, but 3+2+3 is more than the maximum possible weight.
    // >>> WillItFly((new List<long>(new long[]{(long)3L, (long)2L, (long)3L})), (9L))
    // (true)
    // # 3+2+3 is less than the maximum possible weight, and it's balanced.
    // >>> WillItFly((new List<long>(new long[]{(long)3L})), (5L))
    // (true)
    // # 3 is less than the maximum possible weight, and it's balanced.
    //     public static bool WillItFly(List<long> q, long w) {

    }
    public static void Main(string[] args) {
    Debug.Assert(WillItFly((new List<long>(new long[]{(long)3L, (long)2L, (long)3L})), (9L)) == (true));
    Debug.Assert(WillItFly((new List<long>(new long[]{(long)1L, (long)2L})), (5L)) == (false));
    Debug.Assert(WillItFly((new List<long>(new long[]{(long)3L})), (5L)) == (true));
    Debug.Assert(WillItFly((new List<long>(new long[]{(long)3L, (long)2L, (long)3L})), (1L)) == (false));
    Debug.Assert(WillItFly((new List<long>(new long[]{(long)1L, (long)2L, (long)3L})), (6L)) == (false));
    Debug.Assert(WillItFly((new List<long>(new long[]{(long)5L})), (5L)) == (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 array arr of integers, find the minimum number of elements that
    // need to be changed to make the array palindromic. A palindromic array is an array that
    // is read the same backwards and forwards. In one change, you can change one element to any other element.
    // For example:
    // >>> SmallestChange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)5L, (long)4L, (long)7L, (long)9L, (long)6L})))
    // (4L)
    // >>> SmallestChange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)3L, (long)2L, (long)2L})))
    // (1L)
    // >>> SmallestChange((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)1L})))
    // (0L)
    //     public static long SmallestChange(List<long> arr) {

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

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Write a function that accepts two lists of strings and returns the list that has
    // total number of chars in the all strings of the list less than the other list.
    // if the two lists have the same number of chars, return the first list.
    // Examples
    // >>> TotalMatch((new List<string>()), (new List<string>()))
    // (new List<string>())
    // >>> TotalMatch((new List<string>(new string[]{(string)"hi", (string)"admin"})), (new List<string>(new string[]{(string)"hI", (string)"Hi"})))
    // (new List<string>(new string[]{(string)"hI", (string)"Hi"}))
    // >>> TotalMatch((new List<string>(new string[]{(string)"hi", (string)"admin"})), (new List<string>(new string[]{(string)"hi", (string)"hi", (string)"admin", (string)"project"})))
    // (new List<string>(new string[]{(string)"hi", (string)"admin"}))
    // >>> TotalMatch((new List<string>(new string[]{(string)"hi", (string)"admin"})), (new List<string>(new string[]{(string)"hI", (string)"hi", (string)"hi"})))
    // (new List<string>(new string[]{(string)"hI", (string)"hi", (string)"hi"}))
    // >>> TotalMatch((new List<string>(new string[]{(string)"4"})), (new List<string>(new string[]{(string)"1", (string)"2", (string)"3", (string)"4", (string)"5"})))
    // (new List<string>(new string[]{(string)"4"}))
    //     public static List<string> TotalMatch(List<string> lst1, List<string> lst2) {

    }
    public static void Main(string[] args) {
    Debug.Assert(TotalMatch((new List<string>()), (new List<string>())).Equals((new List<string>())));
    Debug.Assert(TotalMatch((new List<string>(new string[]{(string)"hi", (string)"admin"})), (new List<string>(new string[]{(string)"hi", (string)"hi"}))).Equals((new List<string>(new string[]{(string)"hi", (string)"hi"}))));
    Debug.Assert(TotalMatch((new List<string>(new string[]{(string)"hi", (string)"admin"})), (new List<string>(new string[]{(string)"hi", (string)"hi", (string)"admin", (string)"project"}))).Equals((new List<string>(new string[]{(string)"hi", (string)"admin"}))));
    Debug.Assert(TotalMatch((new List<string>(new string[]{(string)"4"})), (new List<string>(new string[]{(string)"1", (string)"2", (string)"3", (string)"4", (string)"5"}))).Equals((new List<string>(new string[]{(string)"4"}))));
    Debug.Assert(TotalMatch((new List<string>(new string[]{(string)"hi", (string)"admin"})), (new List<string>(new string[]{(string)"hI", (string)"Hi"}))).Equals((new List<string>(new string[]{(string)"hI", (string)"Hi"}))));
    Debug.Assert(TotalMatch((new List<string>(new string[]{(string)"hi", (string)"admin"})), (new List<string>(new string[]{(string)"hI", (string)"hi", (string)"hi"}))).Equals((new List<string>(new string[]{(string)"hI", (string)"hi", (string)"hi"}))));
    Debug.Assert(TotalMatch((new List<string>(new string[]{(string)"hi", (string)"admin"})), (new List<string>(new string[]{(string)"hI", (string)"hi", (string)"hii"}))).Equals((new List<string>(new string[]{(string)"hi", (string)"admin"}))));
    Debug.Assert(TotalMatch((new List<string>()), (new List<string>(new string[]{(string)"this"}))).Equals((new List<string>())));
    Debug.Assert(TotalMatch((new List<string>(new string[]{(string)"this"})), (new List<string>())).Equals((new List<string>())));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // Write a function that returns true if the given number is the multiplication of 3 prime numbers
    // and false otherwise.
    // Knowing that (a) is less then 100.
    // Example:
    // >>> IsMultiplyPrime((30L))
    // (true)
    // 30 = 2 * 3 * 5
    //     public static bool IsMultiplyPrime(long a) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IsMultiplyPrime((5L)) == (false));
    Debug.Assert(IsMultiplyPrime((30L)) == (true));
    Debug.Assert(IsMultiplyPrime((8L)) == (true));
    Debug.Assert(IsMultiplyPrime((10L)) == (false));
    Debug.Assert(IsMultiplyPrime((125L)) == (true));
    Debug.Assert(IsMultiplyPrime((105L)) == (true));
    Debug.Assert(IsMultiplyPrime((126L)) == (false));
    Debug.Assert(IsMultiplyPrime((729L)) == (false));
    Debug.Assert(IsMultiplyPrime((891L)) == (false));
    Debug.Assert(IsMultiplyPrime((1001L)) == (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 {
    // Your task is to write a function that returns true if a number x is a simple
    // power of n and false in other cases.
    // x is a simple power of n if n**int=x
    // For example:
    // >>> IsSimplePower((1L), (4L))
    // (true)
    // >>> IsSimplePower((2L), (2L))
    // (true)
    // >>> IsSimplePower((8L), (2L))
    // (true)
    // >>> IsSimplePower((3L), (2L))
    // (false)
    // >>> IsSimplePower((3L), (1L))
    // (false)
    // >>> IsSimplePower((5L), (3L))
    // (false)
    //     public static bool IsSimplePower(long x, long n) {

    }
    public static void Main(string[] args) {
    Debug.Assert(IsSimplePower((16L), (2L)) == (true));
    Debug.Assert(IsSimplePower((143214L), (16L)) == (false));
    Debug.Assert(IsSimplePower((4L), (2L)) == (true));
    Debug.Assert(IsSimplePower((9L), (3L)) == (true));
    Debug.Assert(IsSimplePower((16L), (4L)) == (true));
    Debug.Assert(IsSimplePower((24L), (2L)) == (false));
    Debug.Assert(IsSimplePower((128L), (4L)) == (false));
    Debug.Assert(IsSimplePower((12L), (6L)) == (false));
    Debug.Assert(IsSimplePower((1L), (1L)) == (true));
    Debug.Assert(IsSimplePower((1L), (12L)) == (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 {
    // Write a function that takes an integer a and returns True
    // if this ingeger is a cube of some integer number.
    // Note: you may assume the input is always valid.
    // Examples:
    // >>> Iscube((1L))
    // (true)
    // >>> Iscube((2L))
    // (false)
    // >>> Iscube((-1L))
    // (true)
    // >>> Iscube((64L))
    // (true)
    // >>> Iscube((0L))
    // (true)
    // >>> Iscube((180L))
    // (false)
    //     public static bool Iscube(long a) {

    }
    public static void Main(string[] args) {
    Debug.Assert(Iscube((1L)) == (true));
    Debug.Assert(Iscube((2L)) == (false));
    Debug.Assert(Iscube((-1L)) == (true));
    Debug.Assert(Iscube((64L)) == (true));
    Debug.Assert(Iscube((180L)) == (false));
    Debug.Assert(Iscube((1000L)) == (true));
    Debug.Assert(Iscube((0L)) == (true));
    Debug.Assert(Iscube((1729L)) == (false));
    }

}


Prompt:
using System;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
class Problem {
    // You 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:
    // >>> HexKey(("AB"))
    // (1L)
    // >>> HexKey(("1077E"))
    // (2L)
    // >>> HexKey(("ABED1A33"))
    // (4L)
    // >>> HexKey(("123456789ABCDEF0"))
    // (6L)
    // >>> HexKey(("2020"))
    // (2L)
    //     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:
    // >>> DecimalToBinary((15L))
    // ("db1111db")
    // >>> DecimalToBinary((32L))
    // ("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
    // >>> FilterBySubstring((new List<string>()), ("a"))
    // (new List<string>())
    // >>> FilterBySubstring((new List<string>(new string[]{(string)"abc", (string)"bacd", (string)"cde", (string)"array"})), ("a"))
    // (new List<string>(new string[]{(string)"abc", (string)"bacd", (string)"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:
    // >>> IsHappy(("a"))
    // (false)
    // >>> IsHappy(("aa"))
    // (false)
    // >>> IsHappy(("abcd"))
    // (true)
    // >>> IsHappy(("aabb"))
    // (false)
    // >>> IsHappy(("adb"))
    // (true)
    // >>> IsHappy(("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:
    // >>> GradeEquation((new List<float>(new float[]{(float)4.0f, (float)3L, (float)1.7f, (float)2L, (float)3.5f})))
    // (new List<string>(new string[]{(string)"A+", (string)"B", (string)"C-", (string)"C", (string)"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
    // >>> PrimeLength(("Hello"))
    // (true)
    // >>> PrimeLength(("abcdcba"))
    // (true)
    // >>> PrimeLength(("kittens"))
    // (true)
    // >>> PrimeLength(("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
    // >>> Solve((1000L))
    // ("1")
    // >>> Solve((150L))
    // ("110")
    // >>> Solve((147L))
    // ("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((new List<long>(new long[]{(long)4L, (long)2L, (long)6L, (long)7L})))
    // (2L)
    //     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:
    // >>> AntiShuffle(("Hi"))
    // ("Hi")
    // >>> AntiShuffle(("hello"))
    // ("ehllo")
    // >>> AntiShuffle(("Hello World!!!"))
    // ("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:
    // >>> 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))
    // (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)}))
    // >>> GetRow((new List<List<long>>()), (1L))
    // (new List<Tuple<long, long>>())
    // >>> 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))
    // (new List<Tuple<long, long>>(new Tuple<long, long>[]{(Tuple<long, long>)Tuple.Create(2L, 2L)}))
    //     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:
    // >>> SortArray((new List<long>()))
    // (new List<long>())
    // >>> SortArray((new List<long>(new long[]{(long)5L})))
    // (new List<long>(new long[]{(long)5L}))
    // >>> SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)3L, (long)0L, (long)1L, (long)5L})))
    // (new List<long>(new long[]{(long)0L, (long)1L, (long)2L, (long)3L, (long)4L, (long)5L}))
    // >>> SortArray((new List<long>(new long[]{(long)2L, (long)4L, (long)3L, (long)0L, (long)1L, (long)5L, (long)6L})))
    // (new List<long>(new long[]{(long)6L, (long)5L, (long)4L, (long)3L, (long)2L, (long)1L, (long)0L}))
    //     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"))
    // ("lm")
    // >>> Encrypt(("asdfghjkl"))
    // ("ewhjklnop")
    // >>> Encrypt(("gf"))
    // ("kj")
    // >>> Encrypt(("et"))
    // ("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.
    // >>> SumProduct((new List<long>()))
    // (Tuple.Create(0L, 1L))
    // >>> SumProduct((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L})))
    // (Tuple.Create(10L, 24L))
    //     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.
    // >>> NextSmallest((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)4L, (long)5L})))
    // 2L
    // >>> NextSmallest((new List<long>(new long[]{(long)5L, (long)1L, (long)4L, (long)3L, (long)2L})))
    // 2L
    // >>> NextSmallest((new List<long>()))
    // null
    // >>> NextSmallest((new List<long>(new long[]{(long)1L, (long)1L})))
    // null
    //     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:
    // >>> IsBored(("Hello world"))
    // (0L)
    // >>> IsBored(("The sky is blue. The sun is shining. I love this weather"))
    // (1L)
    //     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
    // >>> AnyInt((float)5L, (float)2L, (float)7L)
    // (true)
    // >>> AnyInt((float)3L, (float)2L, (float)2L)
    // (false)
    // >>> AnyInt((float)3L, (float)-2L, (float)1L)
    // (true)
    // >>> AnyInt((3.6f), (-2.2f), (float)2L)
    // (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:
    // >>> 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)
    // >>> 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)
    // >>> 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)
    // >>> 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)
    // >>> Skjkasdkd((new List<long>(new long[]{(long)0L, (long)81L, (long)12L, (long)3L, (long)1L, (long)21L})))
    // (3L)
    // >>> Skjkasdkd((new List<long>(new long[]{(long)0L, (long)8L, (long)1L, (long)2L, (long)1L, (long)7L})))
    // (7L)
    //     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:
    // >>> CheckDictCase((new Dictionary<string,string>(){{"a", "apple"}, {"b", "banana"}}))
    // (true)
    // >>> CheckDictCase((new Dictionary<string,string>(){{"a", "apple"}, {"A", "banana"}, {"B", "banana"}}))
    // (false)
    // >>> CheckDictCase((new Dictionary<string,string>(){{"a", "apple"}, {8L, "banana"}, {"a", "apple"}}))
    // (false)
    // >>> CheckDictCase((new Dictionary<string,string>(){{"Name", "John"}, {"Age", "36"}, {"City", "Houston"}}))
    // (false)
    // >>> CheckDictCase((new Dictionary<string,string>(){{"STATE", "NC"}, {"ZIP", "12345"}}))
    // (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:
    // >>> CountUpTo((5L))
    // (new List<long>(new long[]{(long)2L, (long)3L}))
    // >>> CountUpTo((11L))
    // (new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L}))
    // >>> CountUpTo((0L))
    // (new List<long>())
    // >>> CountUpTo((20L))
    // (new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L, (long)19L}))
    // >>> CountUpTo((1L))
    // (new List<long>())
    // >>> CountUpTo((18L))
    // (new List<long>(new long[]{(long)2L, (long)3L, (long)5L, (long)7L, (long)11L, (long)13L, (long)17L}))
    //     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((148L), (412L))
    // (16L)
    // >>> Multiply((19L), (28L))
    // (72L)
    // >>> Multiply((2020L), (1851L))
    // (0L)
    // >>> Multiply((14L), (-15L))
    // (20L)
    //     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:
    // >>> CountUpper(("aBCdEf"))
    // (1L)
    // >>> CountUpper(("abcdefg"))
    // (0L)
    // >>> CountUpper(("dBBE"))
    // (0L)
    //     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
    // >>> ClosestInteger(("10"))
    // (10L)
    // >>> ClosestInteger(("15.3"))
    // (15L)
    // 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.
    // >>> RollingMax((new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)2L, (long)3L, (long)4L, (long)2L})))
    // (new List<long>(new long[]{(long)1L, (long)2L, (long)3L, (long)3L, (long)3L, (long)4L, (long)4L}))
    //     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}))));
    }

}