using System;

using Shouldly;

using System.Collections.Generic;

using System.Linq;

​

/// <summary>

/// This test has three exercises.

/// The requirements are described in the relevant summary section of each class.

/// You will need to write the implementation inside the class of each exercise.

///

/// Before starting this test, press the "Fork" button in the toolbar above and then press save.

/// Press Run once and make sure the console output has no build errors.

/// If you made no changes and there are build errors, send an email to us.

///

/// This program is set up as a Console Application.

/// If you want to work on the test in another IDE, you will have to install the Shouldly nuget package for the tests

/// 

/// The Program.Main method checks the output of each exercise by comparing the result against the expected output.

/// You can use this to test your code

/// Running the code will make the test fail if the check does not pass.

///

/// Example check false.ShouldBe(true) - will always fail

///

/// You can also use it to add your own tests if you want to.

/// 

/// Before you are done make sure the following is true:

/// - Your code is compilable

/// - Your code is indented

/// - You tried to solve all exercises (partial code will still be evaluated)

///

/// When you are done with the test, save the fiddle and send the link to us by email.

///

/// Good luck!

///

/// </summary>

​

public class NumberWithSquareSumOfSquareDivisorsFinder

{

    /// <summary>

    ///

    /// Given the limits of an interval, find all numbers in that interval for which the sum of the square of it's divisors is a perfect square

    /// The interval is closed on both ends (the limits should also be checked)

    /// Example:

    /// The divisors of 42 are [1, 2, 3, 6, 7, 14, 21, 42]

    /// The divisors squared are [1, 4, 9, 36, 49, 196, 441, 1764]

    /// The sum of the squared divisors is 2500 which is the perfect square of 50

    /// This means 42 respects the rule

    ///

    /// </summary>

​

    public int[] Find(int start, int end)

    {

        int[] final = new int[end-start+1];

        int square = 0;

        int toint;

        int[] divisors = new int[end];

        int divisorsNumber;

        int finalNumber = 0;

        for(int i=start; i<=end; ++i)

        {

            divisorsNumber = 0;

            if(isPrime(i))

            {

                if(i>1)

                    square = 1 + i*i;

                else

                    square = 1;

            }

            else

            {

                divisors[divisorsNumber] = 1;

                divisorsNumber++;

                for(int j=2; j<i/2; ++j)

                {

                    if(isPrime(j))

                    {

                        divisors[divisorsNumber] = j;

                        divisorsNumber++;

                    }

                    else

                    {

                        int aux;

                        aux = areAlreadyDivisors(j, divisors);

                        if(aux != 1)

                        {

                            divisors[divisorsNumber] = aux;

                            divisorsNumber++;

                        }

                    }

                }

                for(int k=0; k<divisors.Length; ++k)

                {

                    square = square + divisors[k]*divisors[k];

                }

            }

            toint = Convert.ToInt32(Math.Sqrt(square));

            if((Math.Sqrt(square)-toint)==0)

            {

                final[finalNumber] = i;

                finalNumber++;

            }

        }

        return final;

    }

    public bool isPrime(int number)

    {

        bool boolean = true;

        for(int i=2; i<number/2; ++i)

        {

            if(number%i == 0)

            {

                boolean = false;

                break;

            }

        }

        return boolean;

    }

    public int areAlreadyDivisors(int number, int[] divisors)

    {

        int final = number;

        for(int i=0; i<divisors.Length; ++i)

        {

            if(final/i == 0)

            {

                final = final / i;

            }

        }

        return final;

    }

}

​

public class MaxcodeLatinTranslator

{

    /// <summary>

    ///

    /// Given a lowercase string containing a sentence, translate each word of the sentence into Maxcode Latin.

    /// The string will contain only letters and spaces.

    ///

    /// The rules for translating English into Maxcode Latin are:

    /// - if a word starts with a consonant, the consonant is moved to the end of the word and the sufix "ax" is added

    ///     Example: lion -> ion(l) -> ionl(ax) -> ionlax

    /// - if a word starts with a vowel, the vowel is moved to the end of the word and the prefix "ma" is added

    ///     Example: iron -> ron(i) -> (ma)roni -> maroni

    ///

    /// Full example: 

    ///     the orange fox jumps over every lazy dog -> hetax marangeo oxfax umpsjax mavero maverye azylax ogdax 

    ///

    /// </summary>

​

    public string Translate(string sentence)

    {

        string result;

        string final = null;

        sentence = sentence.ToLower();

        string[] aux = sentence.Split(' ');

        for(int i=0; i<aux.Length; ++i){

            string first = aux[i].Substring(0, 1);

            if(first.Equals("a") || first.Equals("e") || first.Equals("i") || first.Equals("o") || first.Equals("u"))

            {

                result = "ma";

                result = result + aux[i].Substring(1) + first;

                if(i==0)

                    final = result;

                else

                    final = final + " " + result;

            }

            else if(first.Equals("b") || first.Equals("c") || first.Equals("d") || first.Equals("f") || first.Equals("g") || first.Equals("h") || first.Equals("j") || first.Equals("k") || first.Equals("l") || first.Equals("m") || first.Equals("n") || first.Equals("p") || first.Equals("q") || first.Equals("r") || first.Equals("s") || first.Equals("t") || first.Equals("v") || first.Equals("w") || first.Equals("x") || first.Equals("y") || first.Equals("z"))

            {

                result = aux[i].Substring(1) + first + "ax";

                if(i==0)

                    final = result;

                else

                    final = final + " " + result;

            }

            else

            {

                if(i==0)

                    final = aux[i];

                else

                    final = final + " " + aux[i];

            }

        }

        return final;

    }

}

​

/// <summary>

///

/// Implement an altered version of the Observable that does the following:

/// - it can subscribe/unsubscribe a genericly typed observer

/// - it can emit a generic type of data

/// - it will only notify the observers that can handle that type of data

///

/// The class is declared below. Write your code only in the MaxObservable class

/// You are NOT allowed to change the declared methods in MaxObservables, but you are free to add your own methods.

///

/// Example:

/// given an MaxObservable maxObservable and three observers: IObserver<string> stringObserver, IObserver<string> anotherStringObserver 

/// and IObserver<int> intObserver

/// 

/// maxObservable.Subscribe<string>(stringObserver);

/// maxObservable.Subscribe<string>(anotherStringObserver);

/// maxObservable.Subscribe<int>(intObserver);

/// 

/// maxObservable.Emit<string>("some data") should call Notify only on stringObserver and anotherStringObserver with "some data"

/// maxObservable.Emit<int>(3) should call Notify only on intObserver with 3

///

/// maxObservable.Unsubscribe<string>(anotherStringObserver);

/// maxObservable.Emit<string>("some more data") should call Notify only on stringObserver with "some more data"

///

/// </summary>

​

public class MaxObservable

{

    public void Emit<T>(T data)

    {

        throw new NotImplementedException();

    }

​

    public void Subscribe<T>(IObserver<T> observer)

    {

        throw new NotImplementedException();

    }

​

    public void Unsubscribe<T>(IObserver<T> observer)

    {

        throw new NotImplementedException();

    }

}

​

public interface IObserver<T>

{

    void Notify(T data);

}

​

​

/// <summary>

/// This part of the code calls the unit tests.

/// It does not contain exercises for this test, but feel free to look around if you want

/// </summary>

​

public class Program

{

    public static void Main()

    {

        Run();

    }

​

    private static void Run()

    {

        new NumberWithSquareSumOfSquareDivisorsFinderTests().Start();

        new MaxcodeLatinTranslatorTests().Start();

        new MaxObservableTests().Start();

    }

}

​

​

​

/// <summary>

/// This class contains the unit tests for the NumberWithSquareSumOfSquareDivisorsFinder exercise

/// </summary>

public class NumberWithSquareSumOfSquareDivisorsFinderTests

{

    public void Start()

    {

        Tests.Run("NumberWithSquareSumOfSquareDivisorsFinder should", (it) =>

        {

            it.Should(() => FindAllNumbersWithTheSumOfTheirDivisorsSquaredASquareNumber(),

                      "Find all numbers with the sum of their divisors squared a square number");

        });

    }

​

    public void FindAllNumbersWithTheSumOfTheirDivisorsSquaredASquareNumber()

    {

        var finder = new NumberWithSquareSumOfSquareDivisorsFinder();

​

        finder.Find(42, 1000).ShouldBe(new int[] { 42, 246, 287, 728 });

​

        finder.Find(1000, 1880).ShouldBe(new int[] { 1434, 1673, 1880 });

    }

}

​

/// <summary>

/// This class contains the unit tests for the MaxcodeLatinTranslator exercise

/// </summary>

public class MaxcodeLatinTranslatorTests

{

    public void Start()

    {

        Tests.Run("MaxcodeLatinTranslator should", (it) =>

        {

            it.Should(() => TranslateAWordStartingWithAVowel(), "Translate a word starting with a vowel");

            it.Should(() => TranslateAWordStartingWithAConsonant(), "Translate a word starting with a consonant");

            it.Should(() => TranslateASentence(), "Translate a sentence");

        });

    }

​

    public void TranslateAWordStartingWithAVowel()

    {

        var translator = new MaxcodeLatinTranslator();

​

        translator.Translate("orange").ShouldBe("marangeo");

    }

​

    public void TranslateAWordStartingWithAConsonant()

    {

        var translator = new MaxcodeLatinTranslator();

​

        translator.Translate("jumps").ShouldBe("umpsjax");

    }

​

    public void TranslateASentence()

    {

        var translator = new MaxcodeLatinTranslator();

​

        translator.Translate("i hope you are enjoying this exercise")

            .ShouldBe("mai opehax ouyax marea manjoyinge histax maxercisee");

    }

}

​

/// <summary>

/// This class contains the unit tests for the Observer exercise

/// </summary>

​

public class MaxObservableTests

{

    public void Start()

    {

        Tests.Run("MaxObservable should", (it) => {

            it.Should(() => NotifySubscribedObserversOfTheEmittedDataType(), "Notify subscribed observers of the emitted data type");

            it.Should(() => NotNotifyUnsubscribedObservers(), "Not notify unsubscribed observers");

        });

    }

​

    public void NotifySubscribedObserversOfTheEmittedDataType()

    {

        var stringObserver = new FakeObserver<string>();

        var intObserver = new FakeObserver<int>();

        var anotherIntObserver = new FakeObserver<int>();

​

        var maxObservable = new MaxObservable();

​

        maxObservable.Subscribe(stringObserver);

        maxObservable.Subscribe(intObserver);

        maxObservable.Subscribe(anotherIntObserver);

​

        maxObservable.Emit(3);

        maxObservable.Emit(20);

​

        intObserver.WasNotifiedWith(3).ShouldBe(true, "did not notify observers of emitted value type");

        anotherIntObserver.WasNotifiedWith(3).ShouldBe(true, "did not notify observers of emitted value type");

​

        intObserver.WasNotifiedWith(20).ShouldBe(true, "did not notify observers of emitted value type");

        anotherIntObserver.WasNotifiedWith(20).ShouldBe(true, "did not notify observers of emitted value type");

​

        stringObserver.WasNotified().ShouldBe(false, "notified observers of different type than the emitted value type");

    }

​

    public void NotNotifyUnsubscribedObservers()

    {

        var stringObserver = new FakeObserver<string>();

        var anotherStringObserver = new FakeObserver<string>();

​

        var maxObservable = new MaxObservable();

​

        maxObservable.Subscribe(stringObserver);

        maxObservable.Subscribe(anotherStringObserver);

        maxObservable.Unsubscribe(anotherStringObserver);

​

        maxObservable.Emit("a string value");

​

        stringObserver.WasNotifiedWith("a string value").ShouldBe(true, "did not notify subscribed observer of emitted data type");

​

        anotherStringObserver.WasNotifiedWith("a string value").ShouldBe(false, "notified unsubscribed observer");

    }

​

    public class FakeObserver<T> : IObserver<T>

    {

        private HashSet<T> notifications = new HashSet<T>();

​

        public void Notify(T data)

        {

            notifications.Add(data);

        }

​

        public bool WasNotifiedWith(T data)

        {

            return notifications.Contains(data);

        }

​

        public bool WasNotified()

        {

            return notifications.Any();

        }

    }

}

​

/// <summary>

/// This class runs the tests and formats the results

/// </summary>

​

public class Tests

{

    private Tests() { }

​

    public static void Run(string testGroup, Action<Tests> tests)

    {

        StartTests(testGroup);

        tests(new Tests());

        EndTests();

    }

​

    public static void StartTests(string testGroup)

    {

        Console.WriteLine("====================================================");

        Console.WriteLine(testGroup);

        Console.WriteLine("====================================================");

    }

​

    public void Should(Action test, string testName)

    {

        try

        {

            Console.WriteLine(testName);

            test();

            Console.WriteLine(" Passed");

        }

        catch (Exception e)

        {

            Console.WriteLine(" Failed");

            Console.WriteLine(" " + e.Message);

        }

        finally

        {

            Console.WriteLine();

        }

    }

​

    public static void EndTests()

    {

        Console.WriteLine();

    }

}