Problem:
Score : 300 points

Problem Statement

You are given an integer N.

For two positive integers A and B, we will define F(A,B) as the larger of the following: the number of digits in the decimal notation of A, and the number of digits in the decimal notation of B.

For example, F(3,11) = 2 since 3 has one digit and 11 has two digits.

Find the minimum value of F(A,B) as (A,B) ranges over all pairs of positive integers such that N = A \times B.

Constraints

1 \leq N \leq 10^{10}

N is an integer.

Input

The input is given from Standard Input in the following format:

N

Output

Print the minimum value of F(A,B) as (A,B) ranges over all pairs of positive integers such that N = A \times B.

Sample Input 1

10000

Sample Output 1

3

F(A,B) has a minimum value of 3 at (A,B)=(100,100).

Sample Input 2

1000003

Sample Output 2

7

There are two pairs (A,B) that satisfy the condition: (1,1000003) and (1000003,1). For these pairs, F(1,1000003)=F(1000003,1)=7.

Sample Input 3

9876543210

Sample Output 3

6

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;

namespace AtCoder
{
    internal class Program
    {
        static void Main(string[] args)
        {
            var sr = new InputReader(Console.In);
            //var sr = new InputReader(new StreamReader(new MemoryStream(Encoding.Unicode.GetBytes("input.txt"))));
            using (var sw = Console.Out)
            //using (var sw = new StreamWriter("output.txt"))
            {
                Solve(sr, sw);
            }

        }


        internal static void Solve(InputReader sr, TextWriter sw)
        {
            var n = sr.NextInt64();
            var primeNumbers = EnumeratePrimeFactor(n);
            if (primeNumbers.Count() == 1)
            {
                sw.WriteLine(n.ToString().Length);
                return;
            }


            var root = (int)Math.Sqrt(n);

            if (root * root == n)
            {
                if (n % root == 0)
                {
                    sw.WriteLine(root.ToString().Length * 2);
                    return;
                }
            }

            var divs = primeNumbers.ToList();
            var count = divs.Count;
            var product = divs.Aggregate((x, next) => x * next);
            if (product < root)
            {
                divs.Add(product);
            }
            var baseNum = divs[0];
            for (var i = 0; i < count - 1; ++i)
            {
                for (var j = i + 1; j < count; ++j)
                {
                    var div = baseNum * divs[j];
                    if (div < root)
                    {
                        divs.Add(div);
                    }
                }
                baseNum *= divs[i+1];
                if (baseNum > root)
                {
                    break;
                }
            }
            var ans = divs.Max();
            sw.WriteLine(ans.ToString().Length);
        }

        public static IEnumerable<long> EnumeratePrimeFactor(long disassemblyNum)
        {
            while (disassemblyNum % 2 == 0 && 1 < disassemblyNum)
            {
                disassemblyNum >>= 1;
                yield return 2;
            }

            for (var divNum = 3; 1 < disassemblyNum; divNum += 2)
            {
                if (disassemblyNum % divNum == 0)
                {
                    yield return divNum;
                    disassemblyNum /= divNum;
                    divNum -= 2;
                }
            }
        }

        internal class InputReader : IDisposable
        {
            private bool isDispose;
            private readonly TextReader sr;

            public InputReader(TextReader stream)
            {
                sr = stream;
            }

            public void Dispose()
            {
                //Dispose(true);
                GC.SuppressFinalize(this);
            }

            public string NextString()
            {
                var result = sr.ReadLine();
                return result;
            }

            public int NextInt32()
            {
                return int.Parse(NextString());
            }

            public long NextInt64()
            {
                return long.Parse(NextString());
            }

            public string[] NextSplitStrings()
            {
                return NextString()
                    .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            }

            public int[] NextSplitInts()
            {
                return NextString()
                    .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                    .Select(int.Parse).ToArray();
            }
            public long[] NextSplitLongs()
            {
                return NextString()
                    .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                    .Select(long.Parse).ToArray();
            }

            public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
            {
                return NextSplitStrings()
                    .Select(s => func(s, CultureInfo.InvariantCulture))
                    .ToArray();
            }

            public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
            {
                return str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                    .Select(s => func(s, CultureInfo.InvariantCulture))
                    .ToArray();
            }

            //protected void Dispose(bool dispose)
            //{
            //    if (isDispose) return;
            //    if (dispose)
            //    {
            //        sr.Close();
            //    }
            //    isDispose = true;
            //}

            //~InputReader()
            //{
            //    Dispose(false);
            //}
        }
    }
}