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 (GCC 5.4.1) (judge verdict: Wrong Answer)

/******************************************************************************

                            Online C Compiler.
                Code, Compile, Run and Debug C program online.
Write your code in this editor and press "Run" button to compile and execute it.

*******************************************************************************/

#include <stdio.h>
#include <math.h>

signed char first_digit(signed long n)
{


    /* Remove last digit from number till only one digit is left */
    while(n >= 10)
    {
        n = n / 10;
    }

    return n;
}
signed char swap(signed long n)
{
    int num, last, first, temp, count = 0;
 
 
    temp = num;
    last = temp % 10;
    count = (int)log10(temp);
 
    while(temp>=10)
    {
        temp /= 10;
    }
    first = temp;
    return (last * pow(10, count) + first) + (num - (first * pow(10, count) + last));
}

signed long factorial(signed long n) 
{ 
    if (n == 0) 
        return 1; 
    return n * factorial(n - 1); 
} 

int main()
{
    signed long n,mid_term,first_digit,i,k,j,count,final_Result,curr_num,temp,d=0;

    signed char max[6]={0};
    signed long result_forward[10][10]={0};
    final_Result = 0;
    scanf("%ld",&n);
    temp = n;
    while(temp != 0)
    { 
        max[d] = temp%10;
        temp = temp/10;
        d++;
        
    }
    if(d>=3)
    {
    mid_term = (n/10)%(d-2);
    }
    first_digit = n%10;

    //printf("D: %ld\n",d);
    for(i=0;i<10;i++)
    {
        for(j=1;j<10;j++)
        {
            k = 1;
            count = 0;
        while(k<d )
        {
            //curr_num = i+j*pow(10,k);
            if(k<d-1)
            {
                
                count = count + pow(10,k-1);
             //   printf("K: %ld number:%ld\n",k,i+j*(signed long)(pow(10,k)));
             //   printf("K<d: count: %ld\n",count);
            }
            else if(k==d-1)
            {
              //  printf("K: %ld number:%ld\n",k,i+j*(signed long)(pow(10,k)));
              //  printf("K=d\n");
               // printf("max[k]: %ld\n",max[k]);
                curr_num = i+j*(signed long)(pow(10,k));
                if(j<max[k] && curr_num<=n)
                {
                    count = count + pow(10,k-1);
                  //  printf("K: %ld number:%ld\n",k,i+j*(signed long)(pow(10,k)));
                  //  printf("j<max: count %ld\n",count);
                }
                else if(j==max[k] && d>2 && curr_num<=n)
                {
                    
                    if(i<=first_digit)
                    {
                        count = count + mid_term + 1;
                    }else
                    {
                        count = count + mid_term;
                    }
                    //printf("K: %ld number:%ld\n",k,i+j*(signed long)(pow(10,k)));
                    //printf("j=max: count %ld\n",count);
                }
                else if(j==max[k] && d==2 && curr_num<=n)
                {
                    count++;
                }
            }
            
            k++;
        }
            result_forward[i][j] = count;
            //printf("i,j: %ld %ld result:%ld\n",i,j,count);
        }
    }
    
    for(i=1;i<10;i++)
    {
        result_forward[i][i]++;
    }
    for(i=1;i<10;i++)
    {
        for(j=1;j<10;j++)
        {
         //   if(result_forward[i][j] == 0 && result_forward[j][i]>0)
         //      final_Result = final_Result + 1*result_forward[j][i];
         //   else if(result_forward[j][1] == 0 && result_forward[i][j]>0)   
         //       final_Result = final_Result + 1*result_forward[i][j];
         //   else
            {
            final_Result = final_Result + result_forward[i][j]*result_forward[j][i];
            }
           //printf("j: %ld i:%ld  %ld %ld\n",j,i,result_forward[j][i], result_forward[i][j]);

        }
    }
    
    if(n<10)
    {
       printf("%ld",n); 
    }
    else
    {
    printf("%ld",final_Result);
    }
    return 0;
}