C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;

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 readonly dynamic TestValues = new[]
	{
		// single values
		new { value = 1, expectedText = "one"},
		new { value = 2, expectedText = "two"},
		new { value = 3, expectedText = "three"},
		new { value = 4, expectedText = "four"},
		new { value = 5, expectedText = "five"},
		new { value = 6, expectedText = "six"},
		new { value = 7, expectedText = "seven"},
		new { value = 8, expectedText = "eight"},
		new { value = 9, expectedText = "nine"},
		// teen-values
		new { value = 10, expectedText = "ten"},
		new { value = 11, expectedText = "eleven"},
		new { value = 12, expectedText = "twelve"},
		new { value = 13, expectedText = "thirteen"},
		new { value = 14, expectedText = "fourteen"},
		new { value = 15, expectedText = "fifteen"},
		new { value = 16, expectedText = "sixteen"},
		new { value = 17, expectedText = "seventeen"},
		new { value = 18, expectedText = "eighteen"},
		new { value = 19, expectedText = "nineteen"},
		// two-digits
		new { value = 20, expectedText = "twenty"},
		new { value = 21, expectedText = "twenty one"},
		new { value = 30, expectedText = "thirty"},
		new { value = 32, expectedText = "thirty two"},
		new { value = 40, expectedText = "fourty"},
		new { value = 43, expectedText = "fourty three"},
		new { value = 50, expectedText = "fifty"},
		new { value = 54, expectedText = "fifty four"},
		new { value = 60, expectedText = "sixty"},
		new { value = 65, expectedText = "sixty five"},
		new { value = 70, expectedText = "seventy"},
		new { value = 76, expectedText = "seventy six"},
		new { value = 80, expectedText = "eighty"},
		new { value = 87, expectedText = "eighty seven"},
		new { value = 90, expectedText = "ninety"},
		new { value = 98, expectedText = "ninety eight"},
		// three digits
		new { value = 100, expectedText = "one hundred"},
		new { value = 105, expectedText = "one hundred five"},
		new { value = 119, expectedText = "one hundred nineteen"},
		new { value = 199, expectedText = "one hundred ninety nine"},
		new { value = 500, expectedText = "five hundreds"},
		new { value = 505, expectedText = "five hundreds five"},
		new { value = 519, expectedText = "five hundreds nineteen"},
		new { value = 550, expectedText = "five hundreds fifty"},
		new { value = 599, expectedText = "five hundreds ninety nine"}
	};
	
	/// Current limits
	private static readonly decimal MaxSupportedValueExcluding = 1000;
	private static readonly decimal MinSupportedValue = 0;
	
	/// Amount of symbols in the group
	private static readonly int GroupSize = 3;
	
	/// 1-digit text representation
	private static readonly Dictionary<char, string> _singleNumberToText = new Dictionary<char, string>()
	{
		{'0', "zero"},
		{'1', "one"},
		{'2', "two"},
		{'3', "three"},
		{'4', "four"},
		{'5', "five"},
		{'6', "six"},
		{'7', "seven"},
		{'8', "eight"},
		{'9', "nine"},
	};
	
	/// 2-digits text representation
	private static readonly Dictionary<string, string> _doubledNumbersToText = new Dictionary<string, string>()
	{
		{"10", "ten"},
		{"11", "eleven"},
		{"12", "twelve"},
		{"13", "thirteen"},
		{"14", "fourteen"},
		{"15", "fifteen"},
		{"16", "sixteen"},
		{"17", "seventeen"},
		{"18", "eighteen"},
		{"19", "nineteen"},
		{"20", "twenty"},
		{"30", "thirty"},
		{"40", "fourty"},
		{"50", "fifty"},
		{"60", "sixty"},
		{"70", "seventy"},
		{"80", "eighty"},
		{"90", "ninety"}
	};
	
	/// <summary>
	/// Adds leading zeroes to a fully filled group (divided by 3)
	/// </summary>
	/// <example>10 -> 010, 1234 -> 001234</example>
	private static string PadNumberWithLeadZeroes(string numberAsText)
	{
		var zeroesToAdd = numberAsText.Length % GroupSize;
		if (zeroesToAdd > 0)
		{
			numberAsText = numberAsText.PadLeft(numberAsText.Length + (GroupSize - zeroesToAdd), '0');
		}
		
		return numberAsText;
	}
	
	/// <summary>
	/// Converts number group (3 consecutive digits) to its text representation
	/// </summary>
	/// <example>123 -> one hundren twenty three</example>
	private static void NumberGroupToText(List<string> result, char s1, char s2, char s3)
	{
		var proceed = true;
		
		// hundrends
		if (s1 != '0')
		{
			result.Add(_singleNumberToText[s1]);
			result.Add(s1 == '1' ? "hundred" : "hundreds");
		}
		
		// tenths
		if (s2 != '0')
		{
			// teen-values
			if (s2 == '1') 
			{
				result.Add(_doubledNumbersToText[new string(new char[] {s2, s3})]);
				proceed = false;
			}
			else
			{
				result.Add(_doubledNumbersToText[new string(new char[] {s2, '0'})]);
			}
		}
		
		// single values
		if (proceed && s3 != '0')
		{
			result.Add(_singleNumberToText[s3]);
		}
	}
	
	/// <summary>
	/// Returns group name such as thousands, millions etc
	/// 
	/// FYI: According to the task we should support only values less than 1000, so
	/// this function doesn't return the name of the group. It's empty is value is less than 100.
	/// However, for a future scale to support thousands, millions etc, they should be added here.
	///
	/// The group is a 3 consecutive numbers
	/// </summary>
	/// <example>
	///	 case 1:
	///		return plural ? "thousands" : "thousand";
	///  etc
	/// </example>
	private static string GetGroupName(int groupPos, bool plural)
	{
		switch (groupPos)
		{
			case 0:
				return null;
			default:
				throw new Exception("The number is too big");
		}
	}
	
	/// <summary>
	/// Converts ceil number to its text representation
	/// </summary>
	/// <example>123 -> one hundren twenty three</example>
	private static string NumberToText(string numberAsText)
	{
		// special case for zero
		if (numberAsText == "0")
		{
			return _singleNumberToText['0'];
		}
		
		numberAsText = PadNumberWithLeadZeroes(numberAsText);
		var result = new List<string>();
		
		// enumerate groups
		// example: 012345678 -> [012],[345],[678]
		var groupPos = numberAsText.Length / GroupSize - 1;
		for (var i = 0; i < numberAsText.Length; i += GroupSize, groupPos--)
		{
			NumberGroupToText(result, numberAsText[i], numberAsText[i+1], numberAsText[i+2]);
			
			var isGroupPlural = numberAsText[i] != 0 && numberAsText[i] != '1';
			var groupName = GetGroupName(groupPos, isGroupPlural);
			if (!string.IsNullOrEmpty(groupName))
			{
				result.Add(groupName);
			}
		}
		
		return string.Join(" ", result);
	}

	
	/// <summary>
	/// Write out a dollar value in words. Handles values less than $1,000, and
	/// up to two decimal places.
	///
	/// FYU: the task doesn't say what to do with negative numbers so they are excluded currently
	/// </summary>
	static string DollarsToWords(decimal value)
	{
		if (value > MaxSupportedValueExcluding)
		{
			throw new Exception("The number is too big");
		}
		
		if (value < MinSupportedValue)
		{
			throw new Exception("The number is too small");
		}
		
		// prepare values
		var dollarsPart = Math.Truncate(value);
		var centsPart = Math.Truncate((value - dollarsPart) * 100);
		
		var dollarsPartText = dollarsPart.ToString();
		var centsPartText = centsPart.ToString();
		
		var dollarsValue = dollarsPart > 0 ? NumberToText(dollarsPartText) + (dollarsPart == 1 ? " dollar" : " dollars") : null;
		var centsValue = centsPart > 0 ? NumberToText(centsPartText) + (centsPart == 1 ? " cent" : " cents") : null;
		
		// result
		if (!string.IsNullOrEmpty(dollarsValue))
		{
			return !string.IsNullOrEmpty(centsValue) ? dollarsValue + " and " + centsValue : dollarsValue;
		}
		else if (!string.IsNullOrEmpty(centsValue))
		{
			return centsValue;
		}
		else
		{
			return "zero dollars";
		}
	}
	
	public static void Main()
	{
		// test limits
		TestExpectException(1000);
		TestExpectException(-1);
		
		// test special cases
		Test(0, "zero dollars");
		
		// test dollars. Range: XXX.00
		foreach (var testValue in TestValues)
		{
			Test(testValue.value, testValue.expectedText + (testValue.value == 1 ? " dollar" : " dollars"));
		}
		
		// test cents (1..99). Range: 0.XX
		foreach (var testValue in TestValues)
		{
			if (testValue.value > 0 && testValue.value < 100)
			{
			   Test(testValue.value / 100.0m, testValue.expectedText + (testValue.value == 1 ? " cent" : " cents"));
			}
		}
		
		// test dollars and cents. Range XXX.XX
		Test(1.01m, "one dollar and one cent");
		Test(5.09m, "five dollars and nine cents");
		Test(19.30m, "nineteen dollars and thirty cents");
		Test(123.99m, "one hundred twenty three dollars and ninety nine cents");
	}

	static void TestExpectException(decimal number)
	{
		try 
		{
			DollarsToWords(number);
			
			Console.WriteLine($"{number}: FAIL");
			Console.WriteLine("  Expected: exception");
			Console.WriteLine();
		}
		catch
		{
			Console.WriteLine($"{number}: PASS");
		}
	}
			
	static void Test(decimal number, string expected)
	{
		var actual = DollarsToWords(number);
		
		if (actual == expected)
		{
			Console.WriteLine($"{number} - {expected}: PASS");
			return;
		}
			
		Console.WriteLine($"{number}: FAIL");
		Console.WriteLine($"  Expected: {expected}");
		Console.WriteLine($"  Actual:   {actual}");
		Console.WriteLine();
	}
}

​x
 
using System;
using System.Collections.Generic;
​
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 readonly dynamic TestValues = new[]
    {
        // single values
        new { value = 1, expectedText = "one"},
        new { value = 2, expectedText = "two"},
        new { value = 3, expectedText = "three"},
        new { value = 4, expectedText = "four"},
        new { value = 5, expectedText = "five"},
        new { value = 6, expectedText = "six"},
        new { value = 7, expectedText = "seven"},
        new { value = 8, expectedText = "eight"},
        new { value = 9, expectedText = "nine"},
        // teen-values
        new { value = 10, expectedText = "ten"},
        new { value = 11, expectedText = "eleven"},
        new { value = 12, expectedText = "twelve"},
        new { value = 13, expectedText = "thirteen"},
        new { value = 14, expectedText = "fourteen"},
        new { value = 15, expectedText = "fifteen"},
        new { value = 16, expectedText = "sixteen"},
        new { value = 17, expectedText = "seventeen"},
        new { value = 18, expectedText = "eighteen"},
        new { value = 19, expectedText = "nineteen"},
        // two-digits
        new { value = 20, expectedText = "twenty"},
        new { value = 21, expectedText = "twenty one"},
        new { value = 30, expectedText = "thirty"},
        new { value = 32, expectedText = "thirty two"},
        new { value = 40, expectedText = "fourty"},
        new { value = 43, expectedText = "fourty three"},
        new { value = 50, expectedText = "fifty"},
        new { value = 54, expectedText = "fifty four"},
        new { value = 60, expectedText = "sixty"},
        new { value = 65, expectedText = "sixty five"},
        new { value = 70, expectedText = "seventy"},
        new { value = 76, expectedText = "seventy six"},
        new { value = 80, expectedText = "eighty"},
        new { value = 87, expectedText = "eighty seven"},
        new { value = 90, expectedText = "ninety"},
        new { value = 98, expectedText = "ninety eight"},
        // three digits
        new { value = 100, expectedText = "one hundred"},
        new { value = 105, expectedText = "one hundred five"},
        new { value = 119, expectedText = "one hundred nineteen"},
        new { value = 199, expectedText = "one hundred ninety nine"},
        new { value = 500, expectedText = "five hundreds"},
        new { value = 505, expectedText = "five hundreds five"},
        new { value = 519, expectedText = "five hundreds nineteen"},
        new { value = 550, expectedText = "five hundreds fifty"},
        new { value = 599, expectedText = "five hundreds ninety nine"}
    };
    
    /// Current limits
    private static readonly decimal MaxSupportedValueExcluding = 1000;
    private static readonly decimal MinSupportedValue = 0;
    
    /// Amount of symbols in the group
    private static readonly int GroupSize = 3;
    
    /// 1-digit text representation
    private static readonly Dictionary<char, string> _singleNumberToText = new Dictionary<char, string>()
    {
        {'0', "zero"},
        {'1', "one"},
        {'2', "two"},
        {'3', "three"},
        {'4', "four"},
        {'5', "five"},
        {'6', "six"},
        {'7', "seven"},
        {'8', "eight"},
        {'9', "nine"},
    };
    
    /// 2-digits text representation
    private static readonly Dictionary<string, string> _doubledNumbersToText = new Dictionary<string, string>()
    {
        {"10", "ten"},
        {"11", "eleven"},
        {"12", "twelve"},
        {"13", "thirteen"},
        {"14", "fourteen"},
        {"15", "fifteen"},
        {"16", "sixteen"},
        {"17", "seventeen"},
        {"18", "eighteen"},
        {"19", "nineteen"},
        {"20", "twenty"},
        {"30", "thirty"},
        {"40", "fourty"},
        {"50", "fifty"},
        {"60", "sixty"},
        {"70", "seventy"},
        {"80", "eighty"},
        {"90", "ninety"}
    };
    
    /// <summary>
    /// Adds leading zeroes to a fully filled group (divided by 3)
    /// </summary>
    /// <example>10 -> 010, 1234 -> 001234</example>
    private static string PadNumberWithLeadZeroes(string numberAsText)
    {
        var zeroesToAdd = numberAsText.Length % GroupSize;
        if (zeroesToAdd > 0)
        {
            numberAsText = numberAsText.PadLeft(numberAsText.Length + (GroupSize - zeroesToAdd), '0');
        }
        
        return numberAsText;
    }
    
    /// <summary>
    /// Converts number group (3 consecutive digits) to its text representation
    /// </summary>
    /// <example>123 -> one hundren twenty three</example>
    private static void NumberGroupToText(List<string> result, char s1, char s2, char s3)
    {
        var proceed = true;
        
        // hundrends
        if (s1 != '0')
        {
            result.Add(_singleNumberToText[s1]);
            result.Add(s1 == '1' ? "hundred" : "hundreds");
        }
        
        // tenths
        if (s2 != '0')
        {
            // teen-values
            if (s2 == '1') 
            {
                result.Add(_doubledNumbersToText[new string(new char[] {s2, s3})]);
                proceed = false;
            }
            else
            {
                result.Add(_doubledNumbersToText[new string(new char[] {s2, '0'})]);
            }
        }
        
        // single values
        if (proceed && s3 != '0')
        {
            result.Add(_singleNumberToText[s3]);
        }
    }
    
    /// <summary>
    /// Returns group name such as thousands, millions etc
    /// 
    /// FYI: According to the task we should support only values less than 1000, so
    /// this function doesn't return the name of the group. It's empty is value is less than 100.
    /// However, for a future scale to support thousands, millions etc, they should be added here.
    ///
    /// The group is a 3 consecutive numbers
    /// </summary>
    /// <example>
    ///  case 1:
    ///     return plural ? "thousands" : "thousand";
    ///  etc
    /// </example>
    private static string GetGroupName(int groupPos, bool plural)
    {
        switch (groupPos)
        {
            case 0:
                return null;
            default:
                throw new Exception("The number is too big");
        }
    }
    
    /// <summary>
    /// Converts ceil number to its text representation
    /// </summary>
    /// <example>123 -> one hundren twenty three</example>
    private static string NumberToText(string numberAsText)
    {
        // special case for zero
        if (numberAsText == "0")
        {
            return _singleNumberToText['0'];
        }
        
        numberAsText = PadNumberWithLeadZeroes(numberAsText);
        var result = new List<string>();
        
        // enumerate groups
        // example: 012345678 -> [012],[345],[678]
        var groupPos = numberAsText.Length / GroupSize - 1;
        for (var i = 0; i < numberAsText.Length; i += GroupSize, groupPos--)
        {
            NumberGroupToText(result, numberAsText[i], numberAsText[i+1], numberAsText[i+2]);
            
            var isGroupPlural = numberAsText[i] != 0 && numberAsText[i] != '1';
            var groupName = GetGroupName(groupPos, isGroupPlural);
            if (!string.IsNullOrEmpty(groupName))
            {
                result.Add(groupName);
            }
        }
        
        return string.Join(" ", result);
    }
​
    
    /// <summary>
    /// Write out a dollar value in words. Handles values less than $1,000, and
    /// up to two decimal places.
    ///
    /// FYU: the task doesn't say what to do with negative numbers so they are excluded currently
    /// </summary>
    static string DollarsToWords(decimal value)
    {
        if (value > MaxSupportedValueExcluding)
        {
            throw new Exception("The number is too big");
        }
        
        if (value < MinSupportedValue)
        {
            throw new Exception("The number is too small");
        }
        
        // prepare values
        var dollarsPart = Math.Truncate(value);
        var centsPart = Math.Truncate((value - dollarsPart) * 100);
        
        var dollarsPartText = dollarsPart.ToString();
        var centsPartText = centsPart.ToString();
        
        var dollarsValue = dollarsPart > 0 ? NumberToText(dollarsPartText) + (dollarsPart == 1 ? " dollar" : " dollars") : null;
        var centsValue = centsPart > 0 ? NumberToText(centsPartText) + (centsPart == 1 ? " cent" : " cents") : null;
        
        // result
        if (!string.IsNullOrEmpty(dollarsValue))
        {
            return !string.IsNullOrEmpty(centsValue) ? dollarsValue + " and " + centsValue : dollarsValue;
        }
        else if (!string.IsNullOrEmpty(centsValue))
        {
            return centsValue;
        }
        else
        {
            return "zero dollars";
        }
    }
    
    public static void Main()
    {
        // test limits
        TestExpectException(1000);
        TestExpectException(-1);
        
        // test special cases
        Test(0, "zero dollars");
        
        // test dollars. Range: XXX.00
        foreach (var testValue in TestValues)
        {
            Test(testValue.value, testValue.expectedText + (testValue.value == 1 ? " dollar" : " dollars"));
        }
        
        // test cents (1..99). Range: 0.XX
        foreach (var testValue in TestValues)
        {
            if (testValue.value > 0 && testValue.value < 100)
            {
               Test(testValue.value / 100.0m, testValue.expectedText + (testValue.value == 1 ? " cent" : " cents"));
            }
        }
        
        // test dollars and cents. Range XXX.XX
        Test(1.01m, "one dollar and one cent");
        Test(5.09m, "five dollars and nine cents");
        Test(19.30m, "nineteen dollars and thirty cents");
        Test(123.99m, "one hundred twenty three dollars and ninety nine cents");
    }
​
    static void TestExpectException(decimal number)
    {
        try 
        {
            DollarsToWords(number);
            
            Console.WriteLine($"{number}: FAIL");
            Console.WriteLine("  Expected: exception");
            Console.WriteLine();
        }
        catch
        {
            Console.WriteLine($"{number}: PASS");
        }
    }
            
    static void Test(decimal number, string expected)
    {
        var actual = DollarsToWords(number);
        
        if (actual == expected)
        {
            Console.WriteLine($"{number} - {expected}: PASS");
            return;
        }
            
        Console.WriteLine($"{number}: FAIL");
        Console.WriteLine($"  Expected: {expected}");
        Console.WriteLine($"  Actual:   {actual}");
        Console.WriteLine();
    }
}

Unhandled exception. System.Exception: Must be a numerical value greater than or equal to 1
at Program.CheckIfValueIsValid(String settingName, String settingValue)
at Program.Main()
Command terminated by signal 6

Last Run:	8:04:48 pm
Compile:	0.005s
Execute:	0.18s
Memory:	5.09Mb
CPU:	0.185s

View IL Code