Cuente todos los números hasta N con M como último dígito

Dados dos números positivos M y N , la tarea es encontrar el conteo de todos los números que tienen M como el último dígito del rango [1, N] .

Ejemplos: 

Entrada: M = 5, N = 15 
Salida: 2 
Explicación: 
Solo 2 números (5 y 15) del rango [1, 15] terminan con el dígito ‘5’.
Entrada: M = 1, N = 100 
Salida: 10

Enfoque ingenuo: el enfoque más simple es iterar sobre el rango de 1 a N y verificar si el último dígito es igual a M o no. Si se encuentra que es cierto, entonces incremente el conteo. Finalmente, imprima el conteo obtenido. 
Complejidad de tiempo: O(N) 
Espacio auxiliar: O(1)
Enfoque eficiente: Para optimizar el enfoque anterior, la idea se basa en el hecho de que el conteo de números que terminan con cada dígito será el mismo hasta el mayor múltiplo de 10 que es menor que N (digamos x ). Por tanto, su recuento será (N/10). Ahora, la tarea se reduce a calcular el conteo de números que terminan en M y que están entrex y N.
A continuación se muestran los pasos:

• Inicialice una variable para almacenar el recuento total, digamos total_count .
• Sume (N/10) al conteo total.
• Calcule x para almacenar el mayor múltiplo de 10 que es menor que N usando la fórmula:

 
 

x = (N / 10) * 10

 

• Ahora, calcule la cantidad de números que terminan en M que se encuentran entre x y N.
• Agregue este conteo al total_count . Imprime el valor final del total_count obtenido.

A continuación se muestra la implementación del enfoque anterior:

// C++ Program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the numbers
// ending with M
int getCount(int N, int M)
{
 
    // Stores the count of
    // numbers required
    int total_count = 0;
 
    // Calculate count upto
    // nearest power of 10
    total_count += (N / 10);
 
    // Computing the value of x
    int x = (N / 10) * 10;
 
    // Adding the count of numbers
    // ending at M from x to N
    if ((N - x) >= M)
    {
        total_count = total_count + 1;
    }
    return total_count;
}
 
// Driver Code
int main()
{
    int N = 100, M = 1;
 
    // Function Call
    cout << getCount(N, M);
    return 0;
}

// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
// Function to count the numbers
// ending with M
static int getCount(int N, int M)
{
 
    // Stores the count of
    // numbers required
    int total_count = 0;
 
    // Calculate count upto
    // nearest power of 10
    total_count += (N / 10);
 
    // Computing the value of x
    int x = (N / 10) * 10;
 
    // Adding the count of numbers
    // ending at M from x to N
    if ((N - x) >= M)
    {
        total_count = total_count + 1;
    }
    return total_count;
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 100, M = 1;
 
    // Function call
    System.out.print(getCount(N, M));
}
}
 
// This code is contributed by 29AjayKumar

# Python3 Program to implement
# the above approach
 
# Function to count the numbers
# ending with M
def getCount(N, M):
 
    # Stores the count of
    # numbers required
    total_count = 0
 
    # Calculate count upto
    # nearest power of 10
    total_count += N // 10
 
    # Computing the value of x
    x = (N // 10) * 10
 
    # Adding the count of numbers
    # ending at M from x to N
    if((N - x) >= M):
        total_count = total_count + 1
 
    return total_count
 
# Driver Code
N = 100
M = 1
 
# Function call
print(getCount(N, M))
 
# This code is contributed by Shivam Singh

// C# program to implement
// the above approach
using System;
class GFG{
 
    // Function to count the
    // numbers ending with M
    static int getCount(int N, int M)
    {
 
        // Stores the count of
        // numbers required
        int total_count = 0;
 
        // Calculate count upto
        // nearest power of 10
        total_count += (N / 10);
 
        // Computing the value of x
        int x = (N / 10) * 10;
 
        // Adding the count of numbers
        // ending at M from x to N
        if ((N - x) >= M)
        {
            total_count = total_count + 1;
        }
        return total_count;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int N = 100, M = 1;
 
        // Function call
        Console.Write(getCount(N, M));
    }
}
 
// This code is contributed by shikhasingrajput

<script>
// Javascript Program to implement
// the above approach
 
// Function to count the numbers
// ending with M
function getCount(N, M){
 
    // Stores the count of
    // numbers required
    let total_count = 0
 
    // Calculate count upto
    // nearest power of 10
    total_count += Math.floor(N / 10)
 
    // Computing the value of x
    let x = Math.floor(N / 10) * 10
 
    // Adding the count of numbers
    // ending at M from x to N
    if((N - x) >= M){
        total_count = total_count + 1
    }
 
    return total_count
}
// Driver Code
let N = 100
let M = 1
 
// Function call
document.write(getCount(N, M))
 
// This code is contributed by Saurabh Jaiswal
</script>

10

Complejidad temporal: O(1) 
Espacio auxiliar: O(1)