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: Accepted)

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 ans = 0;
    let mut d = vec![(0, 0); n+1];
    for i in 1..n+1 {
      d[i] = digit_top_last(i);
      //println!("{}, {:?}", i, d[i]);
    }
    for i in 1..10 {
      for j in 1..10 {
        let c = count(n, i, j, &d) * count(n, j, i, &d);
        //println!("i = {}, j = {}, count = {}", i, j, count(n, i, j));
        ans += c;
      }
    }
    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])
}

fn count(n: usize, i: usize, j: usize, d: &Vec<(usize, usize)>) -> usize {
  let mut res = 0;
  for x in 1..n+1 {
    let (top, last) = d[x];
    if i == top && j == last {
       res += 1;
    }
  }
  res
}