integer_to_sentence, C#

Language: Layout:

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Rextester
{
    
    public static class Utility
    {
        /// <summary>
        /// Group the integer from right to left, save it to a List
        /// </summary>
        /// <param name="input"></param>
        /// <param name="groupLength"></param>
        /// <returns></returns>
        public static Tuple<bool, IList<string>> GroupInteger<T>(this T input, int groupLength = 3)
        {
            string userInput = input.ToString().Trim();
            bool isNegative = userInput.Contains("-");

//remove negative
            userInput = userInput.Replace("-", "");

int inputLength = userInput.Length;
            int startIndex = 0, length = 0;

IList<string> groupNumbers = new List<string>();

string inputGroup = string.Empty;

//read from right to left
            //group 3 digit from right to left
            while (inputLength > 0)
            {
                inputLength = inputLength - groupLength;

if (inputLength < 0)
                {
                    startIndex = 0;
                    length = groupLength + inputLength;
                }
                else
                {
                    startIndex = inputLength;
                    length = groupLength;
                }

inputGroup = userInput.Substring(startIndex, length);

groupNumbers.Add(inputGroup);
            }

Tuple<bool, IList<string>> listNumbers = new Tuple<bool, IList<string>>(isNegative, groupNumbers);

return listNumbers;
 
        }
    }
    
    public class Program
    {
        static IList<string> singleNumber = new List<string>()
            {
                "", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"
            };

static IList<string> twoNumber = new List<string>()
            {
               "", "Eleven","Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"
            };

static IList<string> multipleOfTen = new List<string>()
            {
               "", "Ten","Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"
            };

static IList<string> numberScales = new List<string>()
            {
                "Hundred","Thousand", "Million", "Billion", "Trillion", "Quadrillion", "Quintillion", "Seven", "Sextillion", "Septillion"
            };

public static void Main(string[] args)
        {
            CultureInfo provider = new CultureInfo("en-US"); ;

Console.WriteLine("------------ Text Data ------------------");
            Console.WriteLine("Input: " + Int64.MaxValue.ToString());
            Console.WriteLine("Output: " + IntegerToSentence(Int64.MaxValue));
            Console.WriteLine("------------------------------------------");
            Console.WriteLine("Input: " + 9);
            Console.WriteLine("Output: " + IntegerToSentence(9));
            Console.WriteLine("------------------------------------------");
            Console.WriteLine("Input: " + -890008509);
            Console.WriteLine("Output: " + IntegerToSentence(-890008509));
            Console.WriteLine("------------------------------------------");
            Console.WriteLine("Input: " + "10000000001001");
            Console.WriteLine("Output: " + IntegerToSentence(10000000001001));
            Console.WriteLine("------------------------------------------");
            Console.WriteLine("Input: " + UInt64.MaxValue.ToString());
            Console.WriteLine("Output: " + IntegerToSentence(UInt64.MaxValue));
            Console.WriteLine("------------------------------------------");
            Console.WriteLine("Input: " + "12,345");
            Console.WriteLine("Output: " + IntegerToSentence(int.Parse("12,345", NumberStyles.AllowThousands | NumberStyles.AllowLeadingSign, provider)));
            Console.WriteLine("------------------------------------------");
            Console.WriteLine("Input: " + "-98,123,345");
            Console.WriteLine("Output: " + IntegerToSentence(int.Parse("-98,123,345", NumberStyles.AllowThousands | NumberStyles.AllowLeadingSign, provider)));
            Console.WriteLine("------------ End Text Data ------------------");
            Console.WriteLine();

bool exit = false;
            Int64 userInput = 0;
            UInt64 userInputUnsigned = 0;
           /* do
            {
                Console.WriteLine("Enter some integer:");

string result = Console.ReadLine();
                if (string.IsNullOrEmpty(result))
                {
                    exit = true;
                }
                else
                {

if (Int64.TryParse(result, NumberStyles.AllowThousands | NumberStyles.AllowLeadingSign, provider, out userInput))
                    {
                        Console.WriteLine(IntegerToSentence(userInput));
                    }
                    else if (UInt64.TryParse(result, NumberStyles.AllowThousands, provider, out userInputUnsigned))
                    {
                        Console.WriteLine(IntegerToSentence(userInputUnsigned));
                    }
                    else
                    {
                        Console.WriteLine("Integer only!");
                    }
                }

} while (!exit); */
        }

//handle case 2, remove code redundancy
        static string IntegerToSentenceHelper(int firstElement, int secondElement, ref string output, ref IEnumerable<string> subGroupIntegers)
        {
            if (subGroupIntegers.ElementAt(firstElement) == "1")
            {
                if (subGroupIntegers.ElementAt(secondElement) == "0")
                {
                    output += multipleOfTen.ElementAt(int.Parse(subGroupIntegers.ElementAt(firstElement))) + " ";
                }
                else
                {
                    output += twoNumber.ElementAt(int.Parse(subGroupIntegers.ElementAt(secondElement))) + " ";
                }
            }
            else
            {
                //twenty
                output += multipleOfTen.ElementAt(int.Parse(subGroupIntegers.ElementAt(firstElement)));

if (int.Parse(subGroupIntegers.ElementAt(1)) > 1 && int.Parse(subGroupIntegers.ElementAt(secondElement)) > 0)
                {
                    output += "-";
                }

//three
                output += singleNumber.ElementAt(int.Parse(subGroupIntegers.ElementAt(secondElement)));
            }

return output;
        }

static string IntegerToSentence<T>(T input, bool unsigned = false)
        {
            string output = string.Empty;
            var listInteger = input.GroupInteger<T>();

int j = 0;
            //minus sign
            if (listInteger.Item1)
            {
                output += "Minus ";
            }
            //number of group
            j = listInteger.Item2.Count - 1;

//loop over the List
            while (j >= 0)
            {
                //group the integer into 1 number per group and return as Tuple<bool,List>
                var subGroup = Convert.ToInt64(listInteger.Item2[j]).GroupInteger(1);

//example: 123
                var subGroupIntegers = subGroup.Item2.Reverse();

//handle 100
                if (int.Parse(string.Join("", subGroupIntegers.ToArray())) > 0 && j != listInteger.Item2.Count - 1)
                {
                    //make sure the last three integer are in the hundreds before appending a comma
                    if (j == 0)
                    {
                        if (int.Parse(string.Join("", subGroupIntegers.ToArray())) > 99)
                        {
                            output += ", ";
                        }
                    }
                    else
                    {
                        output += ", ";
                    }
                }

switch (subGroupIntegers.Count())
                {
                    case 3:
                        //one
                        output += singleNumber.ElementAt(int.Parse(subGroupIntegers.ElementAt(0))) + " ";

//hundred
                        output += numberScales[0] + " ";

if (j == 0 && int.Parse(subGroupIntegers.ElementAt(1) + subGroupIntegers.ElementAt(2)) > 0)
                        {
                            output += " and ";
                        }

if (subGroupIntegers.ElementAt(1) == "0")
                        {
                            output += singleNumber.ElementAt(int.Parse(subGroupIntegers.ElementAt(2))) + " ";
                        }
                        else
                        {
                            IntegerToSentenceHelper(1, 2, ref output, ref subGroupIntegers);
                        }

if (j > 0)
                        {
                            output += " " + numberScales[j] + " ";
                        }

break;
                    case 2:
                        //avoid "and Integer"
                        if (j == 0 && listInteger.Item2.Count > 1)
                        {
                            output += " and ";
                        }

IntegerToSentenceHelper(0, 1, ref output, ref subGroupIntegers);

if (j > 0)
                        {
                            output += " " + numberScales[j] + " ";
                        }

break;
                    default:
                        if (int.Parse(subGroupIntegers.ElementAt(0)) > 0)
                        {
                            if (j == 0 && listInteger.Item2.Count > 1)
                            {
                                output += " and ";
                            }

output += singleNumber.ElementAt(int.Parse(subGroupIntegers.ElementAt(0)));

if (j > 0)
                            {
                                output += " " + numberScales[j] + " ";
                            }
                        }

//zero hack
                        //user enter 0
                        if (int.Parse(subGroupIntegers.ElementAt(0)) == 0 && listInteger.Item2.Count == 1)
                        {
                            output = "Zero";
                        }

break;
                }

j--;
            }
            //cleanup extra spaces
            return output.Replace("  ", " ").Replace(" ,", ",");
        }

}
}

Show compiler warnings [ + ] Show input
Compilation time: 0,19 sec, absolute running time: 0,11 sec, cpu time: 0,11 sec, average memory usage: 15 Mb, average nr of threads: 3