Problem:
Score : 400 points

Problem Statement

Takahashi had a pair of two positive integers not exceeding N, (a,b), which he has forgotten.
He remembers that the remainder of a divided by b was greater than or equal to K.
Find the number of possible pairs that he may have had.

Constraints

1 \leq N \leq 10^5

0 \leq K \leq N-1

All input values are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

Print the number of possible pairs that he may have had.

Sample Input 1

5 2

Sample Output 1

7

There are seven possible pairs: (2,3),(5,3),(2,4),(3,4),(2,5),(3,5) and (4,5).

Sample Input 2

10 0

Sample Output 2

100

Sample Input 3

31415 9265

Sample Output 3

287927211

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[test]
fn test_solve() {
   assert_eq!(solve("5 2\n"), "7\n");
   assert_eq!(solve("10 0\n"), "100\n");
   assert_eq!(solve("31415 9265\n"), "287927211\n");
}
fn solve(src: &str) -> String {
    let mut sc = Scanner::from_str(src);

    let n: isize = sc.read();
    let k: isize = sc.read();

    let mut ans = 0;
    for b in 1..n+1 {
        let p = n / b;
        let r = n % b;
        // n = pb + r

        ans += p * std::cmp::max(0, b-k);
        ans += std::cmp::max(0, r-k+1);
    }
    if k == 0 {
        ans -= n;
    }
    format!("{}\n", ans)
}
fn main() {
    let mut buf = String::new();
    use std::io::{Read, Write};
    std::io::stdin().read_to_string(&mut buf).unwrap();
    std::io::stdout().write_all(solve(&buf).as_bytes()).unwrap();
}
struct Scanner<'a>(std::str::SplitWhitespace<'a>);
impl<'a> Scanner<'a> {
    fn from_str(src: &str) -> Scanner {
        Scanner(src.split_whitespace())
    }
    fn get(&mut self) -> &str {
        self.0.next().unwrap()
    }
    fn read<T: std::str::FromStr>(&mut self) -> T {
        self.get().parse().ok().unwrap()
    }
}