[Fork] Maxcode Internship Spring 2019 | C# Online Compiler

[Fork] Maxcode Internship Spring 2019 by Ciocan.Andrei

using System;
using System.Linq;
using System.Collections.Generic;
using Xunit;

namespace InternshipSpring2019
{
	/// <summary>
	/// This test has three exercises.
	/// The requirements are described in the relevant summary section of each method or class.
	/// You will need to complete the classes with the implementation.
	///
	/// Before starting this test, press the "Fork" button in the toolbar above and then press save.
	/// 
	/// The Program.Main method checks the output of each exercise by asserting the result against the expected output.
	/// It will throw an Assert exception if the result is not the expected one.        
	/// 
	/// Fork this fiddle and when you feel ready save and send share the link with.
	/// You can create a dotnetfiddle account and use its Fork and Save features or just send an email at internship@maxcode.net with the complete implementation. 
	/// </summary>
	public static class Exercises
	{
		/// <summary>
		/// Given a list of integers, returns zero-based indices of any Pythagorean triplet.
		/// If there are no such elements, the method should return an empty collection.
		/// A Pythagorean triplet is when three numbers satisfy the following relation: a^2 + b^2 = c^2
		/// </summary>
		/// <example>
		/// For example, FindPythagoreans(new List<int>() { 1, 3, 4, 5, 12, 17, 13}) should return the following tuples of indices:
		/// -	(1, 2, 3) (because 3^2 + 4^2 = 5^2),
		/// -	(3, 4, 6) (because 5^2 + 12^2 = 13^2)
		/// </example>
		/// <param name = "elements">source list</param>        
		/// <returns>A pair containing the elements that matches the criteria.</returns>
		public static IEnumerable<Tuple<int, int, int>> FindPythagoreans(List<int> elements)
		{
			return null;
		}

		/// <summary>
		/// Encrypts a message using the given key and returns the encrypted version.
		///
		/// To encrypt the message first obtain from the given key the representation of the positions of each letter in key as they would be in an alphabetical order.
		/// For example, for the key `poker` we will get `43215` because of `ekopr` (sorted letters from the key).
		///
		/// Encryption is done by putting all the letters in the message in a matrix with a fixed column count equal to the length of the numerical key.
		/// From this matrix, colums will be sorted ascending based on the numerical values in the keys.
		/// The result will be taken from the matrix, element by element.
		///
		/// Let's encode "maxcodeinternship" using our key.
		/// 
		/// 4 3 2 1 5
		/// ---------
		/// m a x c o
		/// d e i n t
		/// e r n s h
		/// i p
		///
		/// After using the key
		/// 
		/// 1 2 3 4 5
		/// ---------
		/// c x a m o
		/// n i e d t
		/// s n r e h
		///     p i  
		///
		/// which results "cxamoniedtsnreh  pi"
		///
		/// </summary>
		/// <remarks>
		/// The message is never shorter than the key.
		/// </remarks>
		/// <param name = "message"></param>
		/// <param name = "key"></param>
		/// <returns>Encrypted data</returns>
		public static string Encrypt(string message, string key)
		{
			return null;
		}

		/// <summary>
		/// Implement a student ranking printer which receives a collection of students 
		/// and returns a formatted string with the rankings as a table with three columns:
		/// 	-	rank : the position of the student
		///		-	name : the name of the student formatted as "FirstName - LastName"
		///		-	grade : the letter corresponding to the American style grade of the student's average.
		///			-	< 5 -> F
		///			-	>= 5 AND < 7 -> D
		///			-	>= 7 AND < 8 -> C
		///			-	>= 8 AND < 9 -> B
		///			-	>= 9 AND <= 10 -> A
		///			-	Every student will have at least one grade and all averages will be different
		/// 
		/// The header is separated from the content by a line of 20 '#'
		/// The new line separator should be '\n'
		/// </summary>
		/// <example>
		/// Given students = [
		/// 	{
		///			FirstName = Bob,
		///			LastName = Ross,
		///			Grades = [7, 8, 10]
		///		},
		///		{
		///			FirstName = Mr,
		///			LastName = T,
		///			Grades = [9]
		///		}]
		///
		///	PrintRanking should return a string containing
		///	
		///	Rank#Name#Average
		/// ####################
		///	1#Mr - T#A
		///	2#Bob - Ross#B
		///	
		/// </example>
		/// <param name = "students">a colection of students</param>
		/// <returns>
		/// </returns>
		public class StudentRankingsPrinter
		{
			public StudentRankingsPrinter()
			{
			}

			public string PrintRankings(IEnumerable<Student> students)
			{
				return string.Empty;
			}
		}

		public class Student
		{
			public string FirstName;
			public string LastName;
			public double[] Grades;
			public Student(string firstName, string lastName, double[] grades)
			{
				FirstName = firstName;
				LastName = lastName;
				Grades = grades;
			}
		}
	}

	public class Program
	{
		public static void Main(string[] args)
		{
			ExerciseForFindPythagoreansWhenNone(new List<int>{1, 3});
			ExerciseForFindPythagoreans(new List<int>{1, 3, 4, 5, 12, 17, 13}, new[]{Tuple.Create(1, 2, 3), Tuple.Create(3, 4, 6)});
			
			ExerciseEncrypt("secretinformation", "crazy", "cseerntiofarmit on  ");
			ExerciseEncrypt("abcd", "abc", "abcd  ");
			ExerciseEncrypt("1234567890", "ba", "2143658709");
			ExerciseEncrypt("key", "key", "eky");
			
			ExercisePrintRanking(new[]{new Exercises.Student("Bob", "Ross", new[]{6.0, 8.0, 10.0})}, "Rank#Name#Average\n####################\n1#Bob - Ross#B");
			ExercisePrintRanking(new[]{new Exercises.Student("Bob", "Ross", new[]{7.0, 6.0, 8.5, 8.0}), new Exercises.Student("Rob", "Boss", new[]{9.0, 8.0})}, "Rank#Name#Average\n####################\n1#Rob - Boss#B\n2#Bob - Ross#C");
			
			Console.WriteLine("Well done!");
		}

		private static void ExerciseForFindPythagoreans(List<int> elements, Tuple<int, int, int>[] expectedAnyOf)
		{
			var result = Exercises.FindPythagoreans(elements);
			foreach (var pythagorean in result)
			{
				var containsResult = expectedAnyOf.Any(c => pythagorean.Item1 + pythagorean.Item2 + pythagorean.Item3 == c.Item1 + c.Item2 + c.Item3);
				Assert.True(containsResult, string.Format("The pair {0}, {1}, {2} does not match the criteria", pythagorean.Item1, pythagorean.Item2, pythagorean.Item3));
			}
		}

		private static void ExerciseForFindPythagoreansWhenNone(List<int> elements)
		{
			var result = Exercises.FindPythagoreans(elements);
			Assert.Empty(result);
		}

		private static void ExerciseEncrypt(string message, string key, string expected)
		{
			var encrypted = Exercises.Encrypt(message, key);
			Assert.Equal(expected, encrypted);
		}

		private static void ExercisePrintRanking(IEnumerable<Exercises.Student> students, string expected)
		{
			var printer = new Exercises.StudentRankingsPrinter();
			var rankings = printer.PrintRankings(students);
			Assert.Equal(expected, rankings);
		}
	}
}

​x
 
using System;
using System.Linq;
using System.Collections.Generic;
using Xunit;
​
namespace InternshipSpring2019
{
    /// <summary>
    /// This test has three exercises.
    /// The requirements are described in the relevant summary section of each method or class.
    /// You will need to complete the classes with the implementation.
    ///
    /// Before starting this test, press the "Fork" button in the toolbar above and then press save.
    /// 
    /// The Program.Main method checks the output of each exercise by asserting the result against the expected output.
    /// It will throw an Assert exception if the result is not the expected one.        
    /// 
    /// Fork this fiddle and when you feel ready save and send share the link with.
    /// You can create a dotnetfiddle account and use its Fork and Save features or just send an email at internship@maxcode.net with the complete implementation. 
    /// </summary>
    public static class Exercises
    {
        /// <summary>
        /// Given a list of integers, returns zero-based indices of any Pythagorean triplet.
        /// If there are no such elements, the method should return an empty collection.
        /// A Pythagorean triplet is when three numbers satisfy the following relation: a^2 + b^2 = c^2
        /// </summary>
        /// <example>
        /// For example, FindPythagoreans(new List<int>() { 1, 3, 4, 5, 12, 17, 13}) should return the following tuples of indices:
        /// -   (1, 2, 3) (because 3^2 + 4^2 = 5^2),
        /// -   (3, 4, 6) (because 5^2 + 12^2 = 13^2)
        /// </example>
        /// <param name = "elements">source list</param>        
        /// <returns>A pair containing the elements that matches the criteria.</returns>
        public static IEnumerable<Tuple<int, int, int>> FindPythagoreans(List<int> elements)
        {
            return null;
        }
​
        /// <summary>
        /// Encrypts a message using the given key and returns the encrypted version.
        ///
        /// To encrypt the message first obtain from the given key the representation of the positions of each letter in key as they would be in an alphabetical order.
        /// For example, for the key `poker` we will get `43215` because of `ekopr` (sorted letters from the key).
        ///
        /// Encryption is done by putting all the letters in the message in a matrix with a fixed column count equal to the length of the numerical key.
        /// From this matrix, colums will be sorted ascending based on the numerical values in the keys.
        /// The result will be taken from the matrix, element by element.
        ///
        /// Let's encode "maxcodeinternship" using our key.
        /// 
        /// 4 3 2 1 5
        /// ---------
        /// m a x c o
        /// d e i n t
        /// e r n s h
        /// i p
        ///
        /// After using the key
        /// 
        /// 1 2 3 4 5
        /// ---------
        /// c x a m o
        /// n i e d t
        /// s n r e h
        ///     p i  
        ///
        /// which results "cxamoniedtsnreh  pi"
        ///
        /// </summary>
        /// <remarks>
        /// The message is never shorter than the key.
        /// </remarks>
        /// <param name = "message"></param>
        /// <param name = "key"></param>
        /// <returns>Encrypted data</returns>
        public static string Encrypt(string message, string key)
        {
            return null;
        }
​
        /// <summary>
        /// Implement a student ranking printer which receives a collection of students 
        /// and returns a formatted string with the rankings as a table with three columns:
        ///     -   rank : the position of the student
        ///     -   name : the name of the student formatted as "FirstName - LastName"
        ///     -   grade : the letter corresponding to the American style grade of the student's average.
        ///         -   < 5 -> F
        ///         -   >= 5 AND < 7 -> D
        ///         -   >= 7 AND < 8 -> C
        ///         -   >= 8 AND < 9 -> B
        ///         -   >= 9 AND <= 10 -> A
        ///         -   Every student will have at least one grade and all averages will be different
        /// 
        /// The header is separated from the content by a line of 20 '#'
        /// The new line separator should be '\n'
        /// </summary>
        /// <example>
        /// Given students = [
        ///     {
        ///         FirstName = Bob,
        ///         LastName = Ross,
        ///         Grades = [7, 8, 10]
        ///     },
        ///     {
        ///         FirstName = Mr,
        ///         LastName = T,
        ///         Grades = [9]
        ///     }]
        ///
        /// PrintRanking should return a string containing
        /// 
        /// Rank#Name#Average
        /// ####################
        /// 1#Mr - T#A
        /// 2#Bob - Ross#B
        /// 
        /// </example>
        /// <param name = "students">a colection of students</param>
        /// <returns>
        /// </returns>
        public class StudentRankingsPrinter
        {
            public StudentRankingsPrinter()
            {
            }
​
            public string PrintRankings(IEnumerable<Student> students)
            {
                return string.Empty;
            }
        }
​
        public class Student
        {
            public string FirstName;
            public string LastName;
            public double[] Grades;
            public Student(string firstName, string lastName, double[] grades)
            {
                FirstName = firstName;
                LastName = lastName;
                Grades = grades;
            }
        }
    }
​
    public class Program
    {
        public static void Main(string[] args)
        {
            ExerciseForFindPythagoreansWhenNone(new List<int>{1, 3});
            ExerciseForFindPythagoreans(new List<int>{1, 3, 4, 5, 12, 17, 13}, new[]{Tuple.Create(1, 2, 3), Tuple.Create(3, 4, 6)});
            
            ExerciseEncrypt("secretinformation", "crazy", "cseerntiofarmit on  ");
            ExerciseEncrypt("abcd", "abc", "abcd  ");
            ExerciseEncrypt("1234567890", "ba", "2143658709");
            ExerciseEncrypt("key", "key", "eky");
            
            ExercisePrintRanking(new[]{new Exercises.Student("Bob", "Ross", new[]{6.0, 8.0, 10.0})}, "Rank#Name#Average\n####################\n1#Bob - Ross#B");
            ExercisePrintRanking(new[]{new Exercises.Student("Bob", "Ross", new[]{7.0, 6.0, 8.5, 8.0}), new Exercises.Student("Rob", "Boss", new[]{9.0, 8.0})}, "Rank#Name#Average\n####################\n1#Rob - Boss#B\n2#Bob - Ross#C");
            
            Console.WriteLine("Well done!");
        }
​
        private static void ExerciseForFindPythagoreans(List<int> elements, Tuple<int, int, int>[] expectedAnyOf)
        {
            var result = Exercises.FindPythagoreans(elements);
            foreach (var pythagorean in result)
            {
                var containsResult = expectedAnyOf.Any(c => pythagorean.Item1 + pythagorean.Item2 + pythagorean.Item3 == c.Item1 + c.Item2 + c.Item3);
                Assert.True(containsResult, string.Format("The pair {0}, {1}, {2} does not match the criteria", pythagorean.Item1, pythagorean.Item2, pythagorean.Item3));
            }
        }
​
        private static void ExerciseForFindPythagoreansWhenNone(List<int> elements)
        {
            var result = Exercises.FindPythagoreans(elements);
            Assert.Empty(result);
        }
​
        private static void ExerciseEncrypt(string message, string key, string expected)
        {
            var encrypted = Exercises.Encrypt(message, key);
            Assert.Equal(expected, encrypted);
        }
​
        private static void ExercisePrintRanking(IEnumerable<Exercises.Student> students, string expected)
        {
            var printer = new Exercises.StudentRankingsPrinter();
            var rankings = printer.PrintRankings(students);
            Assert.Equal(expected, rankings);
        }
    }
}

View IL Code