Problem:
Score : 400 points

Problem Statement

Given is a positive integer N.

Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:

When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.

Constraints

1 \leq N \leq 2 \times 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N

Output

Print the answer.

Sample Input 1

25

Sample Output 1

17

The following 17 pairs satisfy the condition: (1,1), (1,11), (2,2), (2,22), (3,3), (4,4), (5,5), (6,6), (7,7), (8,8), (9,9), (11,1), (11,11), (12,21), (21,12), (22,2), and (22,22).

Sample Input 2

1

Sample Output 2

1

Sample Input 3

100

Sample Output 3

108

Sample Input 4

2020

Sample Output 4

40812

Sample Input 5

200000

Sample Output 5

400000008

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

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

namespace A
{
    class StartingPoint
    {
        static void Main(string[] args)
        {
            if (args?.Any() == true)
            {
                var assembly = Assembly.GetEntryAssembly();
                var resourceName = "AtCoderCSharp.In.txt";
                var stream = assembly.GetManifestResourceStream(resourceName);
                var streamReader = new StreamReader(stream, Encoding.UTF8);
                var str = streamReader.ReadToEnd();
                var textReader = new StringReader(str);
                Console.SetIn(textReader);
            }

            try
            {
                foreach (var s in new Program().Solve())
                {
                    Console.WriteLine(s);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                if (args?.Any() != true)
                    throw e;
            }

            if (args?.Any() == true)
                Console.ReadKey();
        }
    }

    class Program
    {
        public List<int> ScanInts(int count) => Enumerable.Range(0, count).Select(_ => ScanInt).ToList();
        public List<int> ScanInts(long count) => ScanInts((int)count);
        public List<long> ScanLongs(int count) => Enumerable.Range(0, count).Select(_ => Scan).ToList();
        public List<long> ScanLongs(long count) => ScanLongs((int)count);
        public int ScanInt => int.Parse(Str);
        public long Scan => long.Parse(Str);
        public double ScanDouble => (double)Scan;

        StringBuilder sb = new StringBuilder();

        public string Str => ScanStr();
        public string ScanStr()
        {
            sb.Clear();

            int r = 0;
            bool? b = null;
            do
            {
                r = Console.Read();
                b = IsBreak(r);
            } while (b == true);

            if (b == null)
                throw new Exception("input error: unexpected end of stream");

            do
            {
                sb.Append((char)r);
                r = Console.Read();
                b = IsBreak(r);
            } while (b == false);

            return sb.ToString();
        }

        bool? IsBreak(int c)
        {
            switch (c)
            {
                case -1:
                    return null;
                case (int)' ':
                case (int)'\n':
                case (int)'\r':
                    return true;
                default:
                    return false;
            }
        }

        public IEnumerable<int> Loop(int count) => Enumerable.Range(0, count);
        public IEnumerable<int> Loop(int from, int to) => Enumerable.Range(from, to - from + 1);

        public IEnumerable<long> Loop(long count) => Loop(0, count - 1);
        public IEnumerable<long> Loop(long from, long to)
        {
            for (long i = from; i <= to; i++)
                yield return i;
        }

        public string YesNo(bool isYes) => isYes ? "Yes" : "No";

        public HashSet<T> ToHashSet<T>(IEnumerable<T> ts) => new HashSet<T>(ts);



        long Sl(long bg, long ed, long mx, long dig)
        {
            if (mx >= dig)
                return dig / 100;

            var f = mx / (dig / 10);
            if (bg < f)
                return dig / 100;
            if (bg > f)
                return 0;

            var l = mx % 10;
            var bs = mx % (dig / 10) / 10;

            if (ed <= l)
                return bs + 1;
            else
                return bs;

        }


        long Slv(long i, long n)
        {
            var e = i % 10;
            var b = First(i);

            var ed = b;
            var bg = e;

            if (bg == 0)
                return 0;


            var res = 0L;

            // 1dig
            res += bg == ed && bg <= n ? 1 : 0;


            res += Sl(bg, ed, n, 100);
            res += Sl(bg, ed, n, 1000);
            res += Sl(bg, ed, n, 10000);
            res += Sl(bg, ed, n, 100000);
            res += Sl(bg, ed, n, 1000000);
            res += Sl(bg, ed, n, 10000000);


            return res;
        }

        long First(long n)
        {
            var res = n;
            while (res >= 10)
                res /= 10;

            return res;
        }

        public IEnumerable<string> Solve()
        {


            //foreach (var k in Loop(1111))
            //{



            var n = Scan;
            var res = 0L;

            foreach (var i in Loop(n))
            {
                var s = Slv(i + 1, n);
                res += s;
            }

            yield return res.ToString();

            //    var r = 0L;
            //    foreach (var i in Loop(n))
            //    {
            //        foreach (var j in Loop(n))
            //        {
            //            var ii = i + 1;
            //            var jj = j + 1;

            //            if (ii % 10 == First(jj) && First(ii) == jj % 10)
            //                r++;
            //        }
            //    }
            //    //yield return r.ToString();

            //    yield return k.ToString();
            //    if (res != r)
            //    {
            //        yield return k.ToString();
            //        yield return res.ToString();
            //        yield return r.ToString();
            //        yield break;
            //    }
            //}

        }
    }
}