using System;

using System.Linq;

using System.Collections.Generic;

using Xunit;

using System.Text;

​

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)

        {

            List<Tuple<int, int, int>> tuples = new List<Tuple<int, int, int>>();

            if (elements.Count < 3)

                return tuples;

            for (int i = 0; i < elements.Count - 1; i++)

            {

                int a = elements[i];

                for (int j = i + 1; j < elements.Count; j++)

                {

                    int b = elements[j];

                    for (int k = 0; k < elements.Count; k++)

                    {

                        if (k != i && k != j)

                        {

                            int c = elements[k];

                            if (a * a + b * b == c * c)

                            {

                                tuples.Add(Tuple.Create(i, j, k));

                            }

                        }

                    }

                }

            }

            return tuples;

        }

​

        /// <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)

        {

            int j = key.Length, i = 0, c = 0;

​

            if (message.Length % j == 0)

                i = message.Length / j;

            else i = message.Length / j + 1;

​

            char[] LineOfMessage = new char[j];

            int[,] KeyMatrix = new int[2, j];

            StringBuilder EncryptedMessage = new StringBuilder("", i*j);

​

            // decompose the key

            for (int k = 0; k < j; k++)

            {

                KeyMatrix[0, k] = key[k];

                KeyMatrix[1, k] = k;

            }

​

            // sort the key's characters but 

            // save their original position

            for (int k = 0; k < j; k++)

                for (int l = 0; l < j; l++)

                {

                    if (KeyMatrix[0, k] <= KeyMatrix[0, l])

                    {

                        int temp = KeyMatrix[0, k];

                        KeyMatrix[0, k] = KeyMatrix[0, l];

                        KeyMatrix[0, l] = temp;

                        temp = KeyMatrix[1, k];

                        KeyMatrix[1, k] = KeyMatrix[1, l];

                        KeyMatrix[1, l] = temp;

                    }

                }

​

            for (int k = 0; k < i; k++)

            {

                // create a line from the message

                for (int l = 0; l < j; l++)

                {

                    if (c != message.Length)

                    {

                        LineOfMessage[l] = message[c];

                        c++;

                    }

                    else

                        LineOfMessage[l] = ' ';

                }

                // rebuild the string using the new order of the key

                for (int l = 0; l < j; l++)

                {

                    EncryptedMessage.Append(LineOfMessage[KeyMatrix[1, l]]);

                }

            }

            return EncryptedMessage.ToString();

        }

​

        /// <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.

        ///         -   < 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)

            {

                StringBuilder FormattedString = new StringBuilder();

                FormattedString.Append("Rank#Name#Average\n####################\n");

                int i = 1;

                for (int j = students.Count() - 1; j >= 0; j--)

                {

                    FormattedString.Append(i++);

                    FormattedString.Append("#" + students.ElementAt(j).FirstName + " - " + students.ElementAt(j).LastName + "#");

                    double average = 0;

                    foreach (double grade in students.ElementAt(j).Grades)

                    {

                        average += grade;

                    }

                    average /= students.ElementAt(j).Grades.Length;

                    if (average < 5)

                        FormattedString.Append("F\n");

                    else if (average < 7)

                        FormattedString.Append("D\n");

                    else if (average < 8)

                        FormattedString.Append("C\n");

                    else if (average < 9)

                        FormattedString.Append("B\n");

                    else if (average <= 10)

                        FormattedString.Append("A\n");

                }

                FormattedString.Remove(FormattedString.Length - 1, 1);

                return FormattedString.ToString();

            }

        }

​

        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);

        }

    }

}