Problem:
Score : 300 points

Problem Statement

Given is a positive integer N.
How many tuples (A,B,C) of positive integers satisfy A \times B + C = N?

Constraints

2 \leq N \leq 10^6

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

3

Sample Output 1

3

There are 3 tuples of integers that satisfy A \times B + C = 3: (A, B, C) = (1, 1, 2), (1, 2, 1), (2, 1, 1).

Sample Input 2

100

Sample Output 2

473

Sample Input 3

1000000

Sample Output 3

13969985

Solution in Java (OpenJDK 11.0.6) (judge verdict: Accepted)

import java.util.*; 

public class Main { 

	static int MAX = 1000001; 
	static int factor[]; 

	// function to generate all prime 
	// factors of numbers from 1 to 10^6 
	static void generatePrimeFactors() 
	{ 
		factor[1] = 1; 

		// Initializes all the positions with 
		// their value. 
		for (int i = 2; i < MAX; i++) 
			factor[i] = i; 

		// Initializes all multiples of 2 with 2 
		for (int i = 4; i < MAX; i += 2) 
			factor[i] = 2; 

		// A modified version of Sieve of 
		// Eratosthenes to store the 
		// smallest prime factor that 
		// divides every number. 
		for (int i = 3; i * i < MAX; i++) { 
			// check if it has no prime factor. 
			if (factor[i] == i) { 
				// Initializes of j starting from i*i 
				for (int j = i * i; j < MAX; j += i) { 
					// if it has no prime factor 
					// before, then stores the 
					// smallest prime divisor 
					if (factor[j] == j) 
						factor[j] = i; 
				} 
			} 
		} 
	} 

	// function to calculate number of factors 
	static int calculateNoOFactors(int n) 
	{ 
		if (n == 1) 
			return 1; 

		int ans = 1; 

		// stores the smallest prime number 
		// that divides n 
		int dup = factor[n]; 

		// stores the count of number of times 
		// a prime number divides n. 
		int c = 1; 

		// reduces to the next number after prime 
		// factorization of n 
		int j = n / factor[n]; 

		// false when prime factorization is done 
		while (j != 1) { 
			// if the same prime number is dividing n, 
			// then we increase the count 
			if (factor[j] == dup) 
				c += 1; 

			/* if its a new prime factor that is 
			factorizing n, then we again set c=1 
			and change dup to the new prime factor, 
			and apply the formula explained 
			above. */
			else { 
				dup = factor[j]; 
				ans = ans * (c + 1); 
				c = 1; 
			} 

			// prime factorizes a number 
			j = j / factor[j]; 
		} 

		// for the last prime factor 
		ans = ans * (c + 1); 

		return ans; 
	} 

	/* Driver program to test above function */
	public static void main(String[] args) 
	{ 
		// array to store prime factors 
		factor = new int[MAX]; 
		factor[0] = 0; 

		// generate prime factors of number 
		// upto 10^6 
		generatePrimeFactors(); 
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
		int res=0;
		for (int i = 1; i < n; i++) 
			res+=calculateNoOFactors(i);
      	System.out.println(res);
        sc.close();
	} 
} 

// This code is contributed by Arnav Kr. Mandal.