using System;

using System.Collections.Generic;

using System.Linq;

using System.Globalization;

public class Program

{

       public static void Main()

        {

            int space = 1;

            Console.WriteLine($"[{new String(' ', space)}] <--- needs to fit in here ({space} characters)");

            write(Double.NaN, space);

            write(Double.MaxValue, space);

            write(Double.MinValue, space);

            write(Double.PositiveInfinity, space);

            write(Double.NegativeInfinity, space);

            write(.1, space);

            write(1, space);

            write(12, space);

            write(0.0, space);

            write(1.1, space);

​

            space = 2;

            Console.WriteLine($"\n\n[{new String(' ', space)}] <--- needs to fit in here ({space} characters)");

            write(Double.NaN, space);

            write(Double.MaxValue, space);

            write(Double.MinValue, space);

            write(Double.PositiveInfinity, space);

            write(Double.NegativeInfinity, space);

            write(.1, space);

            write(1, space);

            write(12, space);

            write(0.0, space);

            write(1.1, space);

            write(2.4, space);

            write(0.9, space);

​

            space = 3;

            Console.WriteLine($"\n\n[{new String(' ', space)}] <--- needs to fit in here ({space} characters)");

            write(Double.NaN, space);

            write(Double.MaxValue, space);

            write(Double.MinValue, space);

            write(Double.PositiveInfinity, space);

            write(Double.NegativeInfinity, space);

            write(.1, space);

            write(1, space);

            write(12, space);

            write(0.0, space);

            write(1.1, space);

​

            space = 10;

            Console.WriteLine($"\n\n[{new String(' ', space)}] <--- needs to fit in here ({space} characters)");

            write(.1, space);

            write(1, space);

            write(12, space);

            write(0.0, space);

            write(1.1, space);

            write(26.6700000762939, space);

            write(26.67123456, space);

            write(12345678901, space);

            write(-0.00000000000123456, space);

            write(0.0021989234, space);

            write(0.0021999999, space);

            write(-0.0021999999, space);

            write(8888888888, space);

            write(123, space);

            write(123.45, space);

            write(9234567, space);

            write(123456, space);

            write(-123, space);

            write(-0.00000567, space);

            write(0, space);

            write(10E300, space);

            write(Double.NaN, space);

            write(Double.MaxValue, space);

            write(Double.MinValue, space);

            write(Double.PositiveInfinity, space);

            write(Double.NegativeInfinity, space);

            Console.WriteLine("\n\n--- Rounding Cases---\n\n");

            write(.1, space, 1);

            write(1, space, 2);

            write(12, space, 3);

            write(0.0, space, 1);

            write(1.1, space, 2);

            write(88888888888.1, space, 3);

            write(12345678901, space, -3);

            write(-0.00000000000123456, space, -3);

            write(0.0021989234, space, 300);

            write(0.0021999999, space, 300);

            write(88888888888.1, space, 3);

            write(12345678901, space, 3);

            write(-0.00000000000123456, space, 3);

            write(0.0021989234, space, 3);

            write(0.0021999999, space, 3);

            write(-0.0021999999, space, 3);

            write(8888888888, space, 3);

            write(123, space, 3);

            write(123.45, space, 3);

            write(9234567, space, 3);

            write(123456, space, 3);

            write(-123, space, 3);

            write(-0.00000567, space, 3);

            write(0, space, 3);

            write(17E307, space, 3);

            write(99E99, space, 3);

            write(Double.NaN, space, 3);

            write(Double.MaxValue, space, 3);

            write(Double.MinValue, space, 3);

            write(Double.PositiveInfinity, space, 3);

            write(Double.NegativeInfinity, space, 3);

​

            //Console.Read();

        }

​

        static void write(double inputNum, int space, int? roundDecimalToDigits = null)

        {

            Console.Write("[");

            if (roundDecimalToDigits == null)

                Console.Write(FitNumberToSpace(inputNum, space));

            else

                Console.Write(FitNumberToSpace(inputNum, space, roundDecimalToDigits));

            Console.WriteLine($"]   <-- Input= {inputNum}  Space= {space}   Round = {roundDecimalToDigits}");

        }

​

        public static string FitNumberToSpace(double inputNum, int space, int? roundDecimalToDigits = null, bool padRight = false)

        {

​

            if (space < 1) return "";

​

            double absInputNum = Math.Abs(inputNum);

​

            //Stop .Net from auto converting to Exp notation when converting to string

            string numStr = inputNum.ToString("0." + new String('#', 339));

            string absInputNumStr = absInputNum.ToString("0." + new String('#', 339));

​

            bool isNegative = inputNum < 0;

            bool inputNumHasDecimal = absInputNumStr.IndexOf('.') != -1;

​

            string fittedNumStr = numStr;

​

            bool isNanOrInfinity = (double.IsNaN(absInputNum) || double.IsInfinity(absInputNum))? true : false;

​

            //Available space for display in normal format. Accounting for sign and always required decimal point

            int avlSpace = space - (isNanOrInfinity ? 0 : 1) - (isNegative ? 1 : 0);

​

            //scientific notation for large and tiny numbers

            int numsBeforeDecPoint = inputNumHasDecimal ? absInputNumStr.IndexOf('.') : absInputNumStr.Length;

            bool largeNum = numsBeforeDecPoint > avlSpace;

            bool tinyNum = absInputNum > 0 && absInputNum < 5 * Math.Pow(10, - (avlSpace));

            bool usingSciNot = false;

​

            if (tinyNum || largeNum)

            {

                //Total available space for exponential notation. Accounting for sign (decimal not required)

                int avlSpaceSciNotation = isNegative ? space - 1 : space;

​

                //Check if enough space is available to fit exponential notation.. if not, return all #

                int noOfExpDigits = (tinyNum ? (absInputNumStr.IndexOf(absInputNumStr.First<char>(c => c != '.' && c > '0')) - 1) : (numsBeforeDecPoint - 1 )).ToString().Length;

                int minSpaceNeededSciNotation = (tinyNum ? 3 : 2) + noOfExpDigits;

                if (avlSpaceSciNotation < minSpaceNeededSciNotation) return new string('#', space);

​

                //determine how many numbers can we squeeze in or needs to be rounded to after the decimal

                int avlDecimalSpaces = avlSpaceSciNotation - minSpaceNeededSciNotation - 1;

                avlDecimalSpaces = Math.Min(roundDecimalToDigits ?? avlDecimalSpaces, avlDecimalSpaces);

                avlDecimalSpaces = avlDecimalSpaces < 0 ? 0 : avlDecimalSpaces;

​

                fittedNumStr = inputNum.ToString("0." + new string('#', avlDecimalSpaces) + "E-0", CultureInfo.InvariantCulture);

                usingSciNot = true;

​

                //Return all #s if it doesn't fit due to rounding of mantissa that can add another exponent digit, like in  9.9E9 -> 1E10 ) 

                if (fittedNumStr.Length > space) return new string('#', space);

            }

            //Numbers not requiring Sci notation

            else if (!isNanOrInfinity)

            {

                //determine how many numbers can we squeeze in or needs to be rounded to after the decimal

                int avlDecimalSpaces = avlSpace - numsBeforeDecPoint;

                avlDecimalSpaces = Math.Min(roundDecimalToDigits ?? avlDecimalSpaces, avlDecimalSpaces);

                avlDecimalSpaces = avlDecimalSpaces < 0 ? 0 : avlDecimalSpaces;

​

                //Abs Numbers less than 1 but not requiring Sci notation

                if (absInputNum > 0 && absInputNum < 1)

                    fittedNumStr = inputNum.ToString("0." + new string('#', avlDecimalSpaces), CultureInfo.InvariantCulture);

​

                //Abs Numbers >= 1 that can fit without Sci Notation

                if (absInputNum >= 1)

                    fittedNumStr = inputNum.ToString("0." + new string('#', avlDecimalSpaces), CultureInfo.InvariantCulture);

            }

​

            //add a decimal at the end 

            bool hasDecimal = fittedNumStr.IndexOf('.') != -1;

            if (!hasDecimal && !usingSciNot && !isNanOrInfinity) fittedNumStr = fittedNumStr + '.';

​

            //add trailing 0 after decimal if space is available

            if (fittedNumStr.Substring(fittedNumStr.Length - 1) == "." && fittedNumStr.Length < space) fittedNumStr = fittedNumStr + '0';

​

            //Left/Right align

            fittedNumStr = padRight ? fittedNumStr.PadRight(space) : fittedNumStr.PadLeft(space);

            return fittedNumStr;

        }

}