C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Text;

namespace StringToInt
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var fromIntegerToWordsParser = new FromIntegerToWordsParser();
            var firstIntegerInWords = fromIntegerToWordsParser.GetIntegerInWords(-9223372036854775807L);
            Console.WriteLine("Integer in words: {0}\n", firstIntegerInWords);

            var fromWordsToIntegerParser = new FromWordsToIntegerParser();
            var firstInteger = fromWordsToIntegerParser.GetInteger(firstIntegerInWords);
            Console.WriteLine("Integer: {0}", firstInteger);
        }

        private class FromWordsToIntegerParser
        {
            private long _resultInteger;
            private int _currentAmountOfHundreds;
            private int _currentAmountOfTens;
            private bool _integerIsNegative;
            private readonly StringBuilder _stringBuilder = new StringBuilder();

            public long GetInteger(string integerInWords)
            {
                var arrayOfWords = integerInWords.Split(' ');

                if (integerInWords.Length == 0 || arrayOfWords.Length == 0)
                {
                    return 0L;
                }

                for (var i = 0; i < arrayOfWords.Length; i++)
                {
                    switch (arrayOfWords[i])
                    {
                        case "one":
                            {
                                _stringBuilder.Append("1");
                                break;
                            }
                        case "two":
                            {
                                _stringBuilder.Append("2");
                                break;
                            }
                        case "three":
                            {
                                _stringBuilder.Append("3");
                                break;
                            }
                        case "four":
                            {
                                _stringBuilder.Append("4");
                                break;
                            }
                        case "five":
                            {
                                _stringBuilder.Append("5");
                                break;
                            }
                        case "six":
                            {
                                _stringBuilder.Append("6");
                                break;
                            }
                        case "seven":
                            {
                                _stringBuilder.Append("7");
                                break;
                            }
                        case "eight":
                            {
                                _stringBuilder.Append("8");
                                break;
                            }
                        case "nine":
                            {
                                _stringBuilder.Append("9");
                                break;
                            }
                        case "ten":
                            {
                                _stringBuilder.Append("10");
                                break;
                            }
                        case "eleven":
                            {
                                _stringBuilder.Append("11");
                                break;
                            }
                        case "twelve":
                            {
                                _stringBuilder.Append("12");
                                break;
                            }
                        case "thirteen":
                            {
                                _stringBuilder.Append("13");
                                break;
                            }
                        case "fourteen":
                            {
                                _stringBuilder.Append("14");
                                break;
                            }
                        case "fifteen":
                            {
                                _stringBuilder.Append("15");
                                break;
                            }
                        case "sixteen":
                            {
                                _stringBuilder.Append("16");
                                break;
                            }
                        case "seventeen":
                            {
                                _stringBuilder.Append("17");
                                break;
                            }
                        case "eighteen":
                            {
                                _stringBuilder.Append("18");
                                break;
                            }
                        case "nineteen":
                            {
                                _stringBuilder.Append("19");
                                break;
                            }
                        case "twenty":
                            {
                                _currentAmountOfTens = 2;
                                break;
                            }
                        case "thirty":
                            {
                                _currentAmountOfTens = 3;
                                break;
                            }
                        case "forty":
                            {
                                _currentAmountOfTens = 4;
                                break;
                            }
                        case "fifty":
                            {
                                _currentAmountOfTens = 5;
                                break;
                            }
                        case "sixty":
                            {
                                _currentAmountOfTens = 6;
                                break;
                            }
                        case "seventy":
                            {
                                _currentAmountOfTens = 7;
                                break;
                            }
                        case "eighty":
                            {
                                _currentAmountOfTens = 8;
                                break;
                            }
                        case "ninety":
                            {
                                _currentAmountOfTens = 9;
                                break;
                            }
                        case "hundred":
                            {
                                _currentAmountOfHundreds = Convert.ToInt16(_stringBuilder.ToString());
                                _stringBuilder.Clear();
                                break;
                            }
                        case "thousand":
                            {
                                AddToResult(1000L);
                                break;
                            }
                        case "million":
                            {
                                AddToResult(1000000L);
                                break;
                            }
                        case "billion":
                            {
                                AddToResult(1000000000L);
                                break;
                            }
                        case "trillion":
                            {
                                AddToResult(1000000000000L);
                                break;
                            }
                        case "quadrillion":
                            {
                                AddToResult(1000000000000000L);
                                break;
                            }
                        case "quintillion":
                            {
                                AddToResult(1000000000000000000L);
                                break;
                            }
                        case "minus":
                            {
                                _integerIsNegative = true;
                                break;
                            }
                        default:
                        {
                            throw new Exception("String contains unidentified word.");
                        }
                    }
                }

                AddToResult(1L);

                if (_integerIsNegative)
                {
                    _resultInteger *= -1;
                }

                return _resultInteger;
            }

            private void AddToResult(long multiplier)
            {
                checked
                {
                    if (_currentAmountOfHundreds != 0)
                    {
                        _resultInteger += _currentAmountOfHundreds * 100 * multiplier;
                        _currentAmountOfHundreds = 0;
                    }

                    if (_currentAmountOfTens != 0)
                    {
                        _resultInteger += _currentAmountOfTens * 10 * multiplier;
                        _currentAmountOfTens = 0;
                    }

                    if (_stringBuilder.Length != 0)
                    {
                        _resultInteger += Convert.ToInt16(_stringBuilder.ToString()) * multiplier;
                        _stringBuilder.Clear();
                    }
                }
            }
        }

        private class FromIntegerToWordsParser
        {
            public string GetIntegerInWords(long number)
            {
                if (number == 0)
                {
                    return "";
                }

                var stringBuilder = new StringBuilder();

                if (number < 0)
                {
                    stringBuilder.Append("minus");
                    number *= -1;
                }

                var quintillions = (short)(number / 1000000000000000000L);
                var quintillionsInWords = GetNumberUnderThousandInWords(quintillions);
                AddSpaceIfIsNeeded(stringBuilder, quintillions > 0);
                stringBuilder.Append(quintillionsInWords);
                stringBuilder.Append(quintillionsInWords != "" ? " quintillion" : "");

                number = number - quintillions * 1000000000000000000L;
                var quadrillions = (short)(number / 1000000000000000L);
                var quadrillionsInWords = GetNumberUnderThousandInWords(quadrillions);
                AddSpaceIfIsNeeded(stringBuilder, quadrillions > 0);
                stringBuilder.Append(quadrillionsInWords);
                stringBuilder.Append(quadrillionsInWords != "" ? " quadrillion" : "");

                number = number - quadrillions * 1000000000000000L;
                var trillions = (short)(number / 1000000000000L);
                var trillionsInWords = GetNumberUnderThousandInWords(trillions);
                AddSpaceIfIsNeeded(stringBuilder, trillions > 0);
                stringBuilder.Append(trillionsInWords);
                stringBuilder.Append(trillionsInWords != "" ? " trillion" : "");

                number = number - trillions * 1000000000000L;
                var billions = (short)(number / 1000000000L);
                var billionsInWords = GetNumberUnderThousandInWords(billions);
                AddSpaceIfIsNeeded(stringBuilder, billions > 0);
                stringBuilder.Append(billionsInWords);
                stringBuilder.Append(billionsInWords != "" ? " billion" : "");

                number = number - billions * 1000000000L;
                var millions = (short)(number / 1000000L);
                var millionsInWords = GetNumberUnderThousandInWords(millions);
                AddSpaceIfIsNeeded(stringBuilder, millions > 0);
                stringBuilder.Append(millionsInWords);
                stringBuilder.Append(millionsInWords != "" ? " million" : "");

                number = number - millions * 1000000L;
                var thousands = (short)(number / 1000L);
                var thousandsInWords = GetNumberUnderThousandInWords(thousands);
                AddSpaceIfIsNeeded(stringBuilder, thousands > 0);
                stringBuilder.Append(thousandsInWords);
                stringBuilder.Append(thousandsInWords != "" ? " thousand" : "");

                number = number - thousands * 1000L;
                var numberUnderThousandInWords = GetNumberUnderThousandInWords((short)number);
                AddSpaceIfIsNeeded(stringBuilder, number > 0);
                stringBuilder.Append(numberUnderThousandInWords);

                return stringBuilder.ToString();
            }

            private string GetNumberUnderThousandInWords(short number)
            {
                if (number < 0 || number > 999)
                {
                    throw new Exception("Inappropriate number.");
                }

                if (number == 0)
                {
                    return "";
                }

                var stringBuilder = new StringBuilder();

                var hundreds = (byte)(number / 100);
                if (hundreds != 0)
                {
                    stringBuilder.Append(GetDigitInWords(hundreds));
                    stringBuilder.Append(" hundred");
                }

                number = (short)(number - (short)(hundreds * 100));
                var tens = (byte)(number / 10);
                if (tens != 0)
                {
                    AddSpaceIfIsNeeded(stringBuilder, true);

                    stringBuilder.Append(tens == 1
                        ? GetNumberFromTenToNineteenInWords((byte)number)
                        : GetNumberOfTensInWords(tens));
                }

                if (tens == 1) return stringBuilder.ToString();


                number = (short)(number - (short)(tens * 10));
                if (number != 0)
                {
                    AddSpaceIfIsNeeded(stringBuilder, true);

                    stringBuilder.Append(GetDigitInWords((byte)number));
                }

                return stringBuilder.ToString();
            }

            private string GetDigitInWords(byte number)
            {
                if (number < 1 || number > 9)
                {
                    throw new Exception("Inappropriate number.");
                }

                switch (number)
                {
                    case 1:
                        {
                            return "one";
                        }
                    case 2:
                        {
                            return "two";
                        }
                    case 3:
                        {
                            return "three";
                        }
                    case 4:
                        {
                            return "four";
                        }
                    case 5:
                        {
                            return "five";
                        }
                    case 6:
                        {
                            return "six";
                        }
                    case 7:
                        {
                            return "seven";
                        }
                    case 8:
                        {
                            return "eight";
                        }
                    case 9:
                        {
                            return "nine";
                        }
                }

                return "";
            }

            private string GetNumberFromTenToNineteenInWords(byte number)
            {
                if (number < 10 || number > 19)
                {
                    throw new Exception("Inappropriate number.");
                }

                switch (number)
                {
                    case 10:
                        {
                            return "ten";
                        }
                    case 11:
                        {
                            return "eleven";
                        }
                    case 12:
                        {
                            return "twelve";
                        }
                    case 13:
                        {
                            return "thirteen";
                        }
                    case 14:
                        {
                            return "fourteen";
                        }
                    case 15:
                        {
                            return "fifteen";
                        }
                    case 16:
                        {
                            return "sixteen";
                        }
                    case 17:
                        {
                            return "seventeen";
                        }
                    case 18:
                        {
                            return "eighteen";
                        }
                    case 19:
                        {
                            return "nineteen";
                        }
                }

                return "";
            }

            private string GetNumberOfTensInWords(byte number)
            {
                if (number < 2 || number > 9)
                {
                    throw new Exception("Inappropriate number.");
                }

                switch (number)
                {
                    case 2:
                        {
                            return "twenty";
                        }
                    case 3:
                        {
                            return "thirty";
                        }
                    case 4:
                        {
                            return "forty";
                        }
                    case 5:
                        {
                            return "fifty";
                        }
                    case 6:
                        {
                            return "sixty";
                        }
                    case 7:
                        {
                            return "seventy";
                        }
                    case 8:
                        {
                            return "eighty";
                        }
                    case 9:
                        {
                            return "ninety";
                        }
                }

                return "";
            }

            private void AddSpaceIfIsNeeded(StringBuilder stringBuilder, bool needed)
            {
                if (stringBuilder.Length != 0 && needed)
                {
                    stringBuilder.Append(" ");
                }
            }
        }
    }
}

​x
 
using System;
using System.Text;
​
namespace StringToInt
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var fromIntegerToWordsParser = new FromIntegerToWordsParser();
            var firstIntegerInWords = fromIntegerToWordsParser.GetIntegerInWords(-9223372036854775807L);
            Console.WriteLine("Integer in words: {0}\n", firstIntegerInWords);
​
            var fromWordsToIntegerParser = new FromWordsToIntegerParser();
            var firstInteger = fromWordsToIntegerParser.GetInteger(firstIntegerInWords);
            Console.WriteLine("Integer: {0}", firstInteger);
        }
​
        private class FromWordsToIntegerParser
        {
            private long _resultInteger;
            private int _currentAmountOfHundreds;
            private int _currentAmountOfTens;
            private bool _integerIsNegative;
            private readonly StringBuilder _stringBuilder = new StringBuilder();
​
            public long GetInteger(string integerInWords)
            {
                var arrayOfWords = integerInWords.Split(' ');
​
                if (integerInWords.Length == 0 || arrayOfWords.Length == 0)
                {
                    return 0L;
                }
​
                for (var i = 0; i < arrayOfWords.Length; i++)
                {
                    switch (arrayOfWords[i])
                    {
                        case "one":
                            {
                                _stringBuilder.Append("1");
                                break;
                            }
                        case "two":
                            {
                                _stringBuilder.Append("2");
                                break;
                            }
                        case "three":
                            {
                                _stringBuilder.Append("3");
                                break;
                            }
                        case "four":
                            {
                                _stringBuilder.Append("4");
                                break;
                            }
                        case "five":
                            {
                                _stringBuilder.Append("5");
                                break;
                            }
                        case "six":
                            {
                                _stringBuilder.Append("6");
                                break;
                            }
                        case "seven":
                            {
                                _stringBuilder.Append("7");
                                break;
                            }
                        case "eight":
                            {
                                _stringBuilder.Append("8");
                                break;
                            }
                        case "nine":
                            {
                                _stringBuilder.Append("9");
                                break;
                            }
                        case "ten":
                            {
                                _stringBuilder.Append("10");
                                break;
                            }
                        case "eleven":
                            {
                                _stringBuilder.Append("11");
                                break;
                            }
                        case "twelve":
                            {
                                _stringBuilder.Append("12");
                                break;
                            }
                        case "thirteen":
                            {
                                _stringBuilder.Append("13");
                                break;
                            }
                        case "fourteen":
                            {
                                _stringBuilder.Append("14");
                                break;
                            }
                        case "fifteen":
                            {
                                _stringBuilder.Append("15");
                                break;
                            }
                        case "sixteen":
                            {
                                _stringBuilder.Append("16");
                                break;
                            }
                        case "seventeen":
                            {
                                _stringBuilder.Append("17");
                                break;
                            }
                        case "eighteen":
                            {
                                _stringBuilder.Append("18");
                                break;
                            }
                        case "nineteen":
                            {
                                _stringBuilder.Append("19");
                                break;
                            }
                        case "twenty":
                            {
                                _currentAmountOfTens = 2;
                                break;
                            }
                        case "thirty":
                            {
                                _currentAmountOfTens = 3;
                                break;
                            }
                        case "forty":
                            {
                                _currentAmountOfTens = 4;
                                break;
                            }
                        case "fifty":
                            {
                                _currentAmountOfTens = 5;
                                break;
                            }
                        case "sixty":
                            {
                                _currentAmountOfTens = 6;
                                break;
                            }
                        case "seventy":
                            {
                                _currentAmountOfTens = 7;
                                break;
                            }
                        case "eighty":
                            {
                                _currentAmountOfTens = 8;
                                break;
                            }
                        case "ninety":
                            {
                                _currentAmountOfTens = 9;
                                break;
                            }
                        case "hundred":
                            {
                                _currentAmountOfHundreds = Convert.ToInt16(_stringBuilder.ToString());
                                _stringBuilder.Clear();
                                break;
                            }
                        case "thousand":
                            {
                                AddToResult(1000L);
                                break;
                            }
                        case "million":
                            {
                                AddToResult(1000000L);
                                break;
                            }
                        case "billion":
                            {
                                AddToResult(1000000000L);
                                break;
                            }
                        case "trillion":
                            {
                                AddToResult(1000000000000L);
                                break;
                            }
                        case "quadrillion":
                            {
                                AddToResult(1000000000000000L);
                                break;
                            }
                        case "quintillion":
                            {
                                AddToResult(1000000000000000000L);
                                break;
                            }
                        case "minus":
                            {
                                _integerIsNegative = true;
                                break;
                            }
                        default:
                        {
                            throw new Exception("String contains unidentified word.");
                        }
                    }
                }
​
                AddToResult(1L);
​
                if (_integerIsNegative)
                {
                    _resultInteger *= -1;
                }
​
                return _resultInteger;
            }
​
            private void AddToResult(long multiplier)
            {
                checked
                {
                    if (_currentAmountOfHundreds != 0)
                    {
                        _resultInteger += _currentAmountOfHundreds * 100 * multiplier;
                        _currentAmountOfHundreds = 0;
                    }
​
                    if (_currentAmountOfTens != 0)
                    {
                        _resultInteger += _currentAmountOfTens * 10 * multiplier;
                        _currentAmountOfTens = 0;
                    }
​
                    if (_stringBuilder.Length != 0)
                    {
                        _resultInteger += Convert.ToInt16(_stringBuilder.ToString()) * multiplier;
                        _stringBuilder.Clear();
                    }
                }
            }
        }
​
        private class FromIntegerToWordsParser
        {
            public string GetIntegerInWords(long number)
            {
                if (number == 0)
                {
                    return "";
                }
​
                var stringBuilder = new StringBuilder();
​
                if (number < 0)
                {
                    stringBuilder.Append("minus");
                    number *= -1;
                }
​
                var quintillions = (short)(number / 1000000000000000000L);
                var quintillionsInWords = GetNumberUnderThousandInWords(quintillions);
                AddSpaceIfIsNeeded(stringBuilder, quintillions > 0);
                stringBuilder.Append(quintillionsInWords);
                stringBuilder.Append(quintillionsInWords != "" ? " quintillion" : "");
​
                number = number - quintillions * 1000000000000000000L;
                var quadrillions = (short)(number / 1000000000000000L);
                var quadrillionsInWords = GetNumberUnderThousandInWords(quadrillions);
                AddSpaceIfIsNeeded(stringBuilder, quadrillions > 0);
                stringBuilder.Append(quadrillionsInWords);
                stringBuilder.Append(quadrillionsInWords != "" ? " quadrillion" : "");
​
                number = number - quadrillions * 1000000000000000L;
                var trillions = (short)(number / 1000000000000L);
                var trillionsInWords = GetNumberUnderThousandInWords(trillions);
                AddSpaceIfIsNeeded(stringBuilder, trillions > 0);
                stringBuilder.Append(trillionsInWords);
                stringBuilder.Append(trillionsInWords != "" ? " trillion" : "");
​
                number = number - trillions * 1000000000000L;
                var billions = (short)(number / 1000000000L);
                var billionsInWords = GetNumberUnderThousandInWords(billions);
                AddSpaceIfIsNeeded(stringBuilder, billions > 0);
                stringBuilder.Append(billionsInWords);
                stringBuilder.Append(billionsInWords != "" ? " billion" : "");
​
                number = number - billions * 1000000000L;
                var millions = (short)(number / 1000000L);
                var millionsInWords = GetNumberUnderThousandInWords(millions);
                AddSpaceIfIsNeeded(stringBuilder, millions > 0);
                stringBuilder.Append(millionsInWords);
                stringBuilder.Append(millionsInWords != "" ? " million" : "");
​
                number = number - millions * 1000000L;
                var thousands = (short)(number / 1000L);
                var thousandsInWords = GetNumberUnderThousandInWords(thousands);
                AddSpaceIfIsNeeded(stringBuilder, thousands > 0);
                stringBuilder.Append(thousandsInWords);
                stringBuilder.Append(thousandsInWords != "" ? " thousand" : "");
​
                number = number - thousands * 1000L;
                var numberUnderThousandInWords = GetNumberUnderThousandInWords((short)number);
                AddSpaceIfIsNeeded(stringBuilder, number > 0);
                stringBuilder.Append(numberUnderThousandInWords);
​
                return stringBuilder.ToString();
            }
​
            private string GetNumberUnderThousandInWords(short number)
            {
                if (number < 0 || number > 999)
                {
                    throw new Exception("Inappropriate number.");
                }
​
                if (number == 0)
                {
                    return "";
                }
​
                var stringBuilder = new StringBuilder();
​
                var hundreds = (byte)(number / 100);
                if (hundreds != 0)
                {
                    stringBuilder.Append(GetDigitInWords(hundreds));
                    stringBuilder.Append(" hundred");
                }
​
                number = (short)(number - (short)(hundreds * 100));
                var tens = (byte)(number / 10);
                if (tens != 0)
                {
                    AddSpaceIfIsNeeded(stringBuilder, true);
​
                    stringBuilder.Append(tens == 1
                        ? GetNumberFromTenToNineteenInWords((byte)number)
                        : GetNumberOfTensInWords(tens));
                }
​
                if (tens == 1) return stringBuilder.ToString();
​
​
                number = (short)(number - (short)(tens * 10));
                if (number != 0)
                {
                    AddSpaceIfIsNeeded(stringBuilder, true);
​
                    stringBuilder.Append(GetDigitInWords((byte)number));
                }
​
                return stringBuilder.ToString();
            }
​
            private string GetDigitInWords(byte number)
            {
                if (number < 1 || number > 9)
                {
                    throw new Exception("Inappropriate number.");
                }
​
                switch (number)
                {
                    case 1:
                        {
                            return "one";
                        }
                    case 2:
                        {
                            return "two";
                        }
                    case 3:
                        {
                            return "three";
                        }
                    case 4:
                        {
                            return "four";
                        }
                    case 5:
                        {
                            return "five";
                        }
                    case 6:
                        {
                            return "six";
                        }
                    case 7:
                        {
                            return "seven";
                        }
                    case 8:
                        {
                            return "eight";
                        }
                    case 9:
                        {
                            return "nine";
                        }
                }
​
                return "";
            }
​
            private string GetNumberFromTenToNineteenInWords(byte number)
            {
                if (number < 10 || number > 19)
                {
                    throw new Exception("Inappropriate number.");
                }
​
                switch (number)
                {
                    case 10:
                        {
                            return "ten";
                        }
                    case 11:
                        {
                            return "eleven";
                        }
                    case 12:
                        {
                            return "twelve";
                        }
                    case 13:
                        {
                            return "thirteen";
                        }
                    case 14:
                        {
                            return "fourteen";
                        }
                    case 15:
                        {
                            return "fifteen";
                        }
                    case 16:
                        {
                            return "sixteen";
                        }
                    case 17:
                        {
                            return "seventeen";
                        }
                    case 18:
                        {
                            return "eighteen";
                        }
                    case 19:
                        {
                            return "nineteen";
                        }
                }
​
                return "";
            }
​
            private string GetNumberOfTensInWords(byte number)
            {
                if (number < 2 || number > 9)
                {
                    throw new Exception("Inappropriate number.");
                }
​
                switch (number)
                {
                    case 2:
                        {
                            return "twenty";
                        }
                    case 3:
                        {
                            return "thirty";
                        }
                    case 4:
                        {
                            return "forty";
                        }
                    case 5:
                        {
                            return "fifty";
                        }
                    case 6:
                        {
                            return "sixty";
                        }
                    case 7:
                        {
                            return "seventy";
                        }
                    case 8:
                        {
                            return "eighty";
                        }
                    case 9:
                        {
                            return "ninety";
                        }
                }
​
                return "";
            }
​
            private void AddSpaceIfIsNeeded(StringBuilder stringBuilder, bool needed)
            {
                if (stringBuilder.Length != 0 && needed)
                {
                    stringBuilder.Append(" ");
                }
            }
        }
    }
}
​

Compilation error (line 5, col 27): ; expected
Compilation error (line 5, col 27): } expected

Last Run:	10:49:48 am
Compile:	0s
Execute:	0.021s
Memory:	0b
CPU:	0s

View IL Code