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 Rust (1.15.1) (judge verdict: Wrong Answer)

use std::vec::Vec;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}

fn read_touple<T: std::str::FromStr + Copy>() -> (T, T) {
  let v: Vec<T> = read_vec();
  assert_eq!(v.len(), 2);
  (v[0], v[1])
}

fn main() {
    let n: usize = read();
    let mut ns  = digit_vec(n);
    ns.reverse();
    let (n1, nz) = digit_top_last(n);
    let z = ns.len();
    let mut ans = 0;

    for a in 1..n+1 {
      let (a1, ax) = digit_top_last(a);
      //println!("{} {} {}", a, a1, ax);
      if a1 == 0 || ax == 0 {
         continue
      }
      if a1 == ax && a1 <= n {
        //println!("{}, {}", a, ax);
         ans += 1;
      }
      if z == 1 {
         continue
      } else if z == 2 {
         if 10 * ax + a1 <= n {
           ans += 1;
           //println!("{}, {}", a, 10 * ax + a1);
         }
         continue
      }

      for l in 2..z+1 {
        let tmp = ax * 10usize.pow(l as u32) + a1;
        for i in 0..10 {
          for j in 0..10 {
            for k in 0..10 {
              let x: usize = i * 10 + j * 100 + k * 1000;
              if tmp <= x {
                 continue
              }
              if tmp + x <= n  {
                //println!("{} {}", tmp+x, a);
                 ans += 1;
              }
            }
          }
        }
     }
    }
    println!("{}", ans);
}

fn digit_vec(n: usize) -> Vec<usize> {
  let mut res = Vec::new();
  let mut n = n;
  while n > 0 {
    let x = n % 10;
    res.push(x);
    n /= 10;
  }
  res
}

fn digit_top_last(n: usize) -> (usize, usize) {
  let v = digit_vec(n);
  let l = v.len();
  (v[l-1], v[0])
}