using System;

using System.Collections.Generic;

using System.Linq;

using System.Text.RegularExpressions;

using System.Threading;

​

/*

 * Instructions:

 * 

 * Analyze the code in this file. Complete any

 * code portion that is marked with "TODO".

 * At any time, you may execute the program to

 * see if the code you provided is accurate. If

 * it is, then the program output should be "All tests passed",

 * otherwise, a debugging type assertion will occur.

 */

​

namespace CoderTest

{

    public class Program

    {

        /// <summary>

        /// Computes the number of iterations it takes to decrease the given

        /// integer to a value below 1. The value is first decreased by 1, then

        /// subsequently decreased by twice the amount that it was previously.

        /// </summary>

        /// <param name="startValue">The starting value.</param>

        /// <returns>The number of iterations.</returns>

        /// <remarks>This function demonstrates a basic knowledge of basic loops and

        /// algorithms.</remarks>

        static int ComputeDecrementLoops(int startValue)

        {

            // TODO: Implement the function

​

            var decr = 1;

            var loops = 0;

            while (startValue >= 0)

            {

                startValue -= decr;

                decr *= 2;

                loops++;

            }

            return loops;

        }

​

        /// <summary>

        /// Picks the strings from the given iterator that are in a specific length

        /// range.

        /// </summary>

        /// <param name="strings">A collection of strings.</param>

        /// <param name="minLength">The inclusvie minimum length in the range.</param>

        /// <param name="maxLength">The exclusive maximum length in the range.</param>

        /// <returns>A non-null, sorted (ascending) list of strings.</returns>

        /// <remarks>

        /// This method will return a sorted collection of strings that were matched if their

        /// length was between the minimum (inclusive) and maximum (exclusive) specified lengths.

        /// </remarks>

        /// <remarks>This function demonstrates a basic knowledge of lambdas and LINQ.</remarks>

        static IList<string> GetStringsOfLength(IEnumerable<string> strings, int minLength, int maxLength)

        {

            // TODO: Implement the function

​

            return strings.Where(s => s.Length >= minLength && s.Length < maxLength)

                .OrderBy(s => s)

                .ToList();

        }

​

        /// <summary>

        /// Attaches a delegate to the "Invoked" event of the given object. The delegate

        /// increments the static integer property "InvocationCount" of the 

        /// EventReporter class every time the subscribed event occurs.

        /// </summary>

        /// <param name="obj">The EventReporter object to subscribe to.</param>

        /// <remarks>This function demonstrates a basic understanding of delegates and events.</remarks>

        static void TrackInvocations(EventReporter obj)

        {

            obj.Invoked += delegate(object sender, EventArgs args) { EventReporter.InvocationCount++; };

        }

​

        /// <summary>

        /// Finds all Person objects that have a birthday in the given month.

        /// </summary>

        /// <param name="people">The Person collection. See the class definition at the top

        /// of the code file.</param>

        /// <param name="month">The birthday month (1-12).</param>

        /// <returns>A Lookup of Person objects. The key of the lookup is the Department field.</returns>

        /// <remarks>This function demonstrates a basic knowledge of LINQ and lookup structures.</remarks>

        static ILookup<string, Person> FindByBirthdayMonth(IEnumerable<Person> people, int month)

        {

            // TODO: Implement the function

​

            return people.Where(p => p.Birthday.Month == month).ToLookup(p => p.Department);

        }

​

        /// <summary>

        /// Returns whether the given string matches a specific pattern. 

        /// </summary>

        /// <param name="code">The code to test.</param>

        /// <returns>True if the code is in the proper format, otherwise false if the code is

        /// invalid or null.</returns>

        /// <remarks>

        /// A code is considered properly formatted if, when read from left to right:

        /// 1. It begins with a #

        /// 2. It contains 3 upper case letters

        /// 3. Contains between 3 and 5 numbers

        /// 4. Optionally contains an upper case letter enclosed in curly braces

        /// 5. Ends with either a + (plus) or - (dash)

        /// 6. Contains no leading whitespace

        /// E.g.:

        /// Matched: #ATD18829+

        /// Matched: #ATD129-

        /// Matched: #ATF00192{A}+

        /// Matched: #ATF00192{A}-

        /// 

        /// This function demonstrates a knowledge of regular expressions.

        /// </remarks>

        static bool IsValidCodeFormat(string code)

        {

            // TODO: Implement the function

​

            return code != null && Regex.IsMatch(code, @"^#[A-Z]{3}\d{3,5}(\{[A-Z]\})?[+|-]");

        }

​

        /// <summary>

        /// TODO: Make the following modifications to this class:

        /// 1. Provide an implementation of ToString that returns the planet's designator.

        /// 2. Provide an implementation of GetHashCode (assume the Designator property is unique among all planets)

        /// 3. Implement the IEquatable(of T) interface.

        /// 4. Implement the IComparable(of T) interace. Comparisons can be made using the planet's mass.

        /// 

        /// This will demonstrate a knowledge of basic .Net framework object behavior + generics.

        /// </summary>

        class Planet : IEquatable<Planet>, IComparable<Planet>

        {

            // Planet designation

            public string Designator { get; set; }

            // Mass

            public float Mass { get; set; }

​

            public override string ToString()

            {

                return Designator;

            }

​

            public override int GetHashCode()

            {

                return Designator.GetHashCode();

            }

​

            public bool Equals(Planet other)

            {

                return other != null && String.Equals(this.Designator, other.Designator);

            }

​

            public int CompareTo(Planet other)

            {

                return other == null ? 1 :

                    (Mass < other.Mass ? -1 : Math.Abs(Mass - other.Mass) < float.Epsilon ? 0 : 1);

            }

        }

​

        /// <summary>

        /// TODO: Implement the IDisposable pattern on this class type using the following

        /// guidelines:

        /// 1. If disposed, the SomeCode static field should be nullified.

        /// 2. If disposed, calls to GetDataFromUnmanagedResource should throw an

        ///    ObjectDisposedException

        /// 3. The class should handle situations where instances are not properly

        ///    disposed, but the "resource" still gets released (SomeCode set to null)

        ///    when the object goes out of scope.

        /// </summary>

        /// <remarks>

        /// This exercise will demonstrate your knowledge of disposable class types.

        /// </remarks>

        class SomeBigResource : IDisposable

        {

            public static string SomeCode = null;

            private bool _disposed = false;

​

            public SomeBigResource()

            {

                SomeCode = new Guid().ToString();

            }

​

            ~SomeBigResource()

            {

                Dispose();

            }

​

            public string GetDataFromUnmanagedResouce()

            {

                if (_disposed) throw new ObjectDisposedException("SomeCode");

                return SomeCode;

            }

​

            public void Dispose()

            {

                _disposed = true;

                SomeCode = null;

                GC.SuppressFinalize(this);

            }

        }

​

        #region Main

​

        public static void Main(string[] args)

        {

            var strings = GetStringsOfLength("yellow|blue|green|red|black|white|pink|brown|cyan".Split('|'), 4, 5);

            Assert(strings.Intersect("blue|cyan|pink".Split('|')).Count() == 3);

            Assert(strings[0] == "blue");

            var people = new[]

            {

                new Person{Id=1, GivenName = "Bill", FamilyName = "Smith", Department = "Sales", Birthday = DateTime.Parse("7/1/1980")},

                new Person{Id=2, GivenName = "Alice", FamilyName = "Jones", Department = "Support", Birthday = DateTime.Parse("10/15/2011")},

                new Person{Id=3, GivenName = "Jenny", FamilyName = "James", Department = "Sales", Birthday = DateTime.Parse("7/15/1950")},

                new Person{Id=4, GivenName = "Kevin", FamilyName = "Scott", Department = "Support", Birthday = DateTime.Parse("7/10/1979")},

                new Person{Id=5, GivenName = "Jerry", FamilyName = "Richards", Department = "Support", Birthday = DateTime.Parse("3/6/1972")}

            };

            var lu = FindByBirthdayMonth(people, 7);

            Assert(lu["Sales"].Any(p => p.Id == 1));

            Assert(lu["Sales"].Any(p => p.Id == 3));

            Assert(lu["Support"].Any(p => p.Id == 4));

            Assert(ComputeDecrementLoops(3000) == 12);

            Assert(!IsValidCodeFormat(""));

            Assert(!IsValidCodeFormat(null));

            Assert(!IsValidCodeFormat("  #ATD18829+"));

            Assert(!IsValidCodeFormat("#AT1982-"));

            Assert(!IsValidCodeFormat("ATF88198+"));

            Assert(!IsValidCodeFormat("ATF+"));

            Assert(!IsValidCodeFormat("#AKD901."));

            Assert(!IsValidCodeFormat("#AKD901{.}"));

            Assert(IsValidCodeFormat("#ABC123+ "));

            Assert(IsValidCodeFormat("#ABC123+"));

            Assert(IsValidCodeFormat("#ABC1234+"));

            Assert(IsValidCodeFormat("#ABC12345+"));

            Assert(IsValidCodeFormat("#ABC12345-"));

            Assert(IsValidCodeFormat("#ABC12345{A}+"));

​

            var planets = new[]

            {

                new Planet {Designator = "P105", Mass = 1000f},

                new Planet {Designator = "ZX6005", Mass = 2000f},

                new Planet {Designator = "P1009", Mass = 2000f},

                new Planet {Designator = "YX99180", Mass = 5000f},

            };

            Assert(planets[0].ToString() == "P105");

            Assert(planets[0].GetHashCode() == "P105".GetHashCode());

            Assert(!planets[0].Equals(planets[1]));

            Assert(planets[1].CompareTo(planets[2]) == 0);

            Assert(planets[3].CompareTo(planets[2]) == 1);

            using (var br = new SomeBigResource())

            {

                Assert(br.GetDataFromUnmanagedResouce() == SomeBigResource.SomeCode);

            }

            Assert(SomeBigResource.SomeCode == null);

            var br2 = new SomeBigResource();

            Assert(br2.GetDataFromUnmanagedResouce() == SomeBigResource.SomeCode);

            br2.Dispose();

            var caught = false;

            try

            { br2.GetDataFromUnmanagedResouce(); }

            catch (ObjectDisposedException)

            { caught = true; }

            Assert(caught);

            SomeOtherFn();

            GC.Collect();

            Thread.Sleep(5); // This may not work in all circumstances

            Assert(SomeBigResource.SomeCode == null);

​

            var er = new EventReporter();

            TrackInvocations(er);

            for (var c = 0; c < 15; c++) er.Invoke();

            Assert(EventReporter.InvocationCount == 15);

​

            Console.WriteLine("All tests passed!");

        }

​

        static void SomeOtherFn()

        {

            var br = new SomeBigResource();

            // Go out of scope

        }

​

        static void Assert(bool condition)

        {

            if (!condition) throw new Exception("Test failed.");

        }

​

        /// <summary>

        /// Sample entity for exercises below.

        /// </summary>

        class Person

        {

            public int Id { get; set; }

            public string GivenName { get; set; }

            public string FamilyName { get; set; }

            public DateTime Birthday { get; set; }

            public string Department { get; set; }

        }

​

        // Sample class used for event/delegate exercises.

        class EventReporter

        {

            public static int InvocationCount { get; set; }

            public event EventHandler<EventArgs> Invoked;

            public void Invoke() { if (Invoked != null) Invoked(this, EventArgs.Empty); }

        }

​

        #endregion

    }

}

​