using System;

​

public class Program {

    /*

    Complete the function below which takes a dollar value and writes it out in

    words. It's not a trick question but has a few logic details to work out.

    We're interested in:

    * How you solve a problem

    * Clean, concise code, which communicates your ideas clearly

    * Good understanding of unit testing

​

    Some tests are given below, but they aren't complete. Consider other cases and

    how you might handle them.

​

    There isn't any time limit but it shouldn't take more than a couple of hours,

    and if you are really stuck please get in touch for a hint. We work in a team

    in the real world so sensible questions wont be considered a failure!

    */

​

    private static string[] units = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };

    private static string[] tens = { "", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };

​

    //***********************

    //This extends the program to handle cases larger than 1000!

    private static string[] thousandGroups = { "" };    //comments this to extend the handling of thousands

    //private static string[] thousandGroups = {"", "thousand", "million", "billion" }; //uncomment this to handle thousands

    //***********************//

​

​

    /// <summary>

    /// Write out a dollar value in words. Handles values less than $1,000, and

    /// up to two decimal places. Any extra digits will be truncated.

    /// </summary>

    static string DollarsToWords(decimal value) {

        if (value < 0)

            return "Dollar cannot be negative.";

        if (decimal.ToDouble(value) >= Math.Pow(1000, thousandGroups.Length))

            return "Number too large.";

​

        try {

            decimal dollarPart = decimal.Truncate(value);

            int centPart = decimal.ToInt32(decimal.Truncate((value - decimal.Truncate(value)) * 100));

​

            return DollarsToWords(dollarPart, centPart);

        }

        catch (Exception) {

            return "Invalid Input.";

        }

​

    }

​

    /// <summary>

    /// Similar to DollarsToWords(decimal value) but it handle dollar and cent part seperately. It also addes "dollar" word to the number and handle special cases like zero dollars and no "s" after dollar for one.

    /// It calls ExtractThousands to extends the handling more than 1000.

    /// </summary>

    /// <param name="dollarPart">Integral part of dollar</param>

    /// <param name="centPart">fractional part of dollar. Upto 2 decimal places and rest is trucated.</param>

    /// <returns>Return English word representaion of a dollar, including cents.</returns>

    private static string DollarsToWords(decimal dollarPart, int centPart) {

        string centString = CentsToWords(centPart);

​

        if (dollarPart == 0)

            return centString == null ? "zero dollars" : centString;

        if (dollarPart == 1)

            return "one dollar" + (centString == null ? "" : " and " + centString);

​

        if (thousandGroups.Length > 1)      //This extends the handling for more than 1000.

            return ExtractThousands(dollarPart, 0).TrimEnd() + " dollars" + (centString == null ? "" : " and " + centString);

        return HundredToWord(decimal.ToInt32(dollarPart)) + " dollars" + (centString == null ? "" : " and " + centString);

    }

​

    /// <summary>

    /// Add the word "cents" for fractional part of dollar. Handle special case like no cent and one cent with has no "s".

    /// </summary>

    /// <param name="i">Fractional part of dollar in cents. In integer.</param>

    /// <returns>Word represents of cent part of a dollar with word "cent(s)"</returns>

    private static string CentsToWords(int i){

        if (i == 0)

            return null;

        if (i == 1)

            return "one cent";

        return HundredToWord(i) + " cents";

    }

​

    /// <summary>

    /// This is the core method to convert number less than 1000 into english word. It can be used by both integral and cents part of dollar. If input number larger than 1000 or less than 0 return ArgumentException.

    /// </summary>

    /// <param name="number">Integer larger or equal to 0 and less than 1000. </param>

    /// <returns>Word represents of the number</returns>

    static string HundredToWord(int number){

        if (number < 0)

            throw new ArgumentException();

        if (number < 20)

            return units[number];

        if (number < 100)

            return tens[number / 10] + (number % 10 > 0 ? " " + HundredToWord(number % 10) : "");

        if (number < 1000)

            return units[number / 100] + " hundred" + (number % 100 > 0 ? " and " + HundredToWord(number % 100) : "");

        throw new ArgumentException();

    }

​

    public static void Main() {

        Test(0, "zero dollars");

        Test(0.12m, "twelve cents");

        Test(10.55m, "ten dollars and fifty five cents");

        Test(120, "one hundred and twenty cents");

        Test(0.00m, "zero dollars");

        Test(1, "one dollar");                              //singular dollar

        Test(1.09m, "one dollar and nine cents");           //singular dollar with cents

        Test(0.01m, "one cent");                            //singular cent

        Test(0.001m, "zero dollars");                       //More than 2 d.p.

        Test(1.999m, "one dollar and ninety nine cents");   //More than 2 d.p. Test rounding

        Test(0.20m, "twenty cents");                        //tailing 0

        Test(00.99m, "ninety nine cents");                  //leading 0

        Test(245, "two hundred and forty five dollars");    //hundred

        Test(999.99m, "nine hundred and ninety nine dollars and ninety nine cents");    //thousand boundary

        Test(100, "one hundred dollars");                 //hundred, boundary

        Test(101, "one hundred and one dollars");         //hundred, units

        Test(110, "one hundred and ten dollars");             //hundred, tens

        Test(decimal.MinusOne, "Dollar cannot be negative.");//Dollar cannot be negative, invalid

        Test(decimal.MaxValue, "Number too large.");         //Too large, invalid

        Test(decimal.MinValue, "Dollar cannot be negative.");//Too small/negative value, invalid

​

        //Extended tests

        if (thousandGroups.Length > 1) {

            Test(1100, "one thousand one hundred dollars");     //thousand, hundreds

            Test(1000000, "one million dollars");            //million, boundary

            Test(999999999999.99m, "nine hundred and ninety nine billion nine hundred and ninety nine million nine hundred and ninety nine thousand nine hundred and ninety nine dollars and ninety nine cents");         //billion, boundary

            Test(123456789012.34m, "one hundred and twenty three billion four hundred and fifty six million seven hundred and eighty nine thousand twelve dollars and thirty four cents");                 //all numbers

            Test(1000000000000, "Number too large.");         //1 trillion, boundary

        }

    }

​

    static void Test(decimal number, string expected) {

        var actual = DollarsToWords(number);

​

        if (actual == expected) {

            Console.WriteLine($"{number}: PASS");

            return;

        }

​

        Console.WriteLine($"{number}: FAIL");

        Console.WriteLine($"  Expected: {expected}");

        Console.WriteLine($"  Actual:   {actual}");

        Console.WriteLine();

    }

​

    //***********************************

    //The following part extends the handling to thousands. Not sure by the original requirement

    //*************************************

​

    /// <summary>

    /// A resursive method to extract thousand groups from the integral parameter.

    /// </summary>

    /// <param name="integral">The integer input</param>

    /// <param name="group">Index for thousandGroups</param>

    /// <returns></returns>

    private static string ExtractThousands(decimal integral, int group) {

        if (integral >= 1000) {

            decimal thousandPart = Math.Truncate(integral / 1000);

            int hundredPart = decimal.ToInt32(integral % 1000);

​

            return ExtractThousands(thousandPart, group + 1) + GroupedHundredToWord(hundredPart, group);

        }

        return GroupedHundredToWord(decimal.ToInt32(integral), group);

    }

​

​

    /// <summary>

    /// The core method called by ExtractThousands. It handles values inside the thousand groups and add the thousand word. If the number is larger than valid thousands in thousandGroups it will raise ArgumentException.

    /// </summary>

    /// <param name="number"> Less than 1000 integer. To be used by HundredToWord.</param>

    /// <param name="thousandGroup">Index for thousandGroups</param>

    /// <returns>word with thousand group word</returns>

    static string GroupedHundredToWord(int number, int thousandGroup) {

        if (number == 0)

            return "";

        if (thousandGroup >= thousandGroups.Length)

            throw new ArgumentException();

        if (thousandGroup == 0)

            return HundredToWord(number);

        return HundredToWord(number) + " " + thousandGroups[thousandGroup] + " ";

    }

}