# Count of all possible numbers not exceeding M having suffix N

Given two positive integers **N** and **M**, the task is to find the count of all possible numbers in the range **[1, M]**, having suffix as **N**.

**Examples:**

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

Input:N = 5, M = 15Output:2Explanation:Only numbers satisfying the conditions are {5, 15}.Input:N = 25, M = 4500Output: 45

**Naive Approach: **The simplest approach is to traverse all integers in the range **[1, M]** and check if the suffix is **N** or not. **Time Complexity:** O(M) **Auxiliary Space:** O(1)

**Efficient Approach:** To optimize the above approach, following observation needs to be made:

Let

N= 5 andM= 100

The Suffix numbers are 5, 15, 25, 35…95, which forms anArithmetic Progressionwith

first term = 5, last term = 95, common difference = Base of N (eg: 6 has base 10, 45 has base 100 which is nothing but the exponentiation of the form 10^{digitsOf(N)}, where digitsOf(N) = no. of digits present in N.

Therefore, in order to calculate the count of possible numbers in the range [1, M], the following expression needs to be evaluated:

Count of numbers = Number of terms in the series =

(t, where_{n}– a)/d + 1tis the last term of the sequence,_{n}ais the first term of the sequence,dis the common difference =(t_{i+1}– t_{i}), i = 1, 2, 3…n-1

Below is the implementation of the above approach:

## C++

`// C++ Program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count the` `// no. of digits of N` `int` `digitsOf(` `int` `num)` `{` ` ` `return` `to_string(num).size();` `}` `// Function to count all possible` `// numbers having Suffix as N` `int` `count(` `int` `a, ` `int` `tn)` `{` ` ` `// Difference of the A.P` ` ` `int` `diff = ` `pow` `(10, digitsOf(a));` ` ` `// Count of the number of terms` ` ` `return` `((tn - a) / diff) + 1;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `n, m;` ` ` `n = 25, m = 4500;` ` ` `cout << count(n, m);` ` ` `return` `0;` `}` |

## Java

`// Java program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to count the` `// no. of digits of N` `static` `int` `digitsOf(` `int` `num)` `{` ` ` `return` `Integer.toString(num).length();` `}` `// Function to count all possible` `// numbers having Suffix as N` `static` `int` `count(` `int` `a, ` `int` `tn)` `{` ` ` ` ` `// Difference of the A.P` ` ` `int` `diff = (` `int` `)Math.pow(` `10` `, digitsOf(a));` ` ` `// Count of the number of terms` ` ` `return` `((tn - a) / diff) + ` `1` `;` `}` `// Driver code` `public` `static` `void` `main (String[] args)` `{` ` ` `int` `n = ` `25` `, m = ` `4500` `;` ` ` ` ` `System.out.println(count(n, m));` `}` `}` `// This code is contributed by offbeat` |

## Python3

`# Python3 program to implement` `# the above approach` `# Function to count the` `# no. of digits of N` `def` `digitsOf(num):` ` ` `return` `len` `(` `str` `(num));` `# Function to count all possible` `# numbers having Suffix as N` `def` `count(a, tn):` ` ` `# Difference of the A.P` ` ` `diff ` `=` `int` `(` `pow` `(` `10` `, digitsOf(a)));` ` ` `# Count of the number of terms` ` ` `return` `((tn ` `-` `a) ` `/` `diff) ` `+` `1` `;` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `n ` `=` `25` `; m ` `=` `4500` `;` ` ` `print` `(` `int` `(count(n, m)));` `# This code is contributed by sapnasingh4991` |

## C#

`// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{` `// Function to count the` `// no. of digits of N` `static` `int` `digitsOf(` `int` `num)` `{` ` ` `return` `num.ToString().Length;` `}` `// Function to count all possible` `// numbers having Suffix as N` `static` `int` `count(` `int` `a, ` `int` `tn)` `{` ` ` ` ` `// Difference of the A.P` ` ` `int` `diff = (` `int` `)Math.Pow(10, digitsOf(a));` ` ` `// Count of the number of terms` ` ` `return` `((tn - a) / diff) + 1;` `}` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `n = 25, m = 4500;` ` ` ` ` `Console.WriteLine(count(n, m));` `}` `}` `// This code is contributed by PrinciRaj1992` |

## Javascript

`<script>` `// JavaScript program to implement` `// the above approach` `// Function to count the` `// no. of digits of N` `function` `digitsOf(num)` `{` ` ` `return` `num.toString().length;` `}` ` ` `// Function to count all possible` `// numbers having Suffix as N` `function` `count(a, tn)` `{` ` ` ` ` `// Difference of the A.P` ` ` `let diff = Math.floor(Math.pow(10, digitsOf(a)));` ` ` ` ` `// Count of the number of terms` ` ` `return` `Math.floor((tn - a) / diff) + 1;` `}` `// Driver Code` ` ` `let n = 25, m = 4500;` ` ` ` ` `document.write(count(n, m));` ` ` `</script>` |

**Output:**

45

**Time Complexity:** O(1) **Auxiliary Space:** O(1)