不超过 M 后缀 N 的所有可能数字的计数

给定两个正整数N和M ，任务是找到范围[1, M]中所有可能数字的计数，后缀为N 。

例子：

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

朴素的方法：最简单的方法是遍历[1, M]范围内的所有整数，并检查后缀是否为N。
时间复杂度： O(M)
辅助空间： O(1)

高效的方法：要优化上述方法，需要进行以下观察：

Let N = 5 and M = 100 
The Suffix numbers are 5, 15, 25, 35…95, which forms an Arithmetic Progression with 
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.

因此，为了计算 [1, M] 范围内可能的数字的计数，需要计算以下表达式：

Count of numbers = Number of terms in the series = (t_n – a)/d + 1 , where 
t_n is the last term of the sequence, a is the first term of the sequence, d is the common difference = (t_i+1 – t_i), i = 1, 2, 3…n-1

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
 
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

 
// 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));
            

输出：

45

时间复杂度： O(1)
辅助空间： O(1)