Encuentre las ocurrencias del dígito d en el rango [0..n]

Dado un número n y un dígito d, cuente todas las ocurrencias de d en el rango de 0 a n.
Ejemplos: 
 

Input :  n = 25 
         d = 2
Output : 9
The occurrences are 2, 12, 20, 21
22 (Two occurrences), 23, 24, 25

Input : n = 25 
        d = 3
Output :3
The occurrences are 3, 13, 23

Input : n = 32 
        d = 3
Output : 6
The occurrences are 3, 13, 23, 30, 31, 32

La primera aparición de d no puede estar antes del número d. Entonces comenzamos a iterar desde d y hacemos la siguiente verificación una y otra vez. Saltamos el número por 10 la mayor parte del tiempo (en el paso 2) excepto en los casos mencionados en los pasos 2.a y 2.b. 
Paso 1 : compruebe si el último dígito del número es igual a la d, si es así, incremente la cuenta. 
Paso 2
a) Si el número es completamente divisible por 10, incremente tanto el conteo como el número (por ejemplo, si llegamos al número 30 que es completamente divisible por 10 y d=3, entonces tenemos que contar todos los números desde 31- 39 por eso incrementamos el conteo en 1 y el número en 1) 
b) de lo contrario, si el primer dígito del número es uno menos que d, significa que hemos llegado a la fila donde tenemos que incrementar el número en 10 y restarle la d. Por ejemplo, si llegamos a 23 para d=3, incrementamos el número en 23+10-3 = 30) 
c) de lo contrario, incrementamos el número en 10 únicamente. (Por ejemplo: d=3, itr=3, luego incremente en 10, es decir, 13, 23) 
Paso 3:- Devuelva el conteo.
 

C++

// C++ program to count appearances of
// a digit 'd' in range from [0..n]
#include <bits/stdc++.h>
using namespace std;
 
int getOccurrence(int n, int d)
{
    int result = 0; // Initialize result
 
    // Count appearances in numbers starting
    // from d.
    int itr = d;
    while (itr <= n)
    {
        // When the last digit is equal to d
        if (itr%10 == d)
            result++;
 
        // When the first digit is equal to d then
        if (itr != 0 && itr/10 == d)
        {
            // increment result as well as number
            result++;
            itr++;
        }
 
        // In case of reverse of number such as 12 and 21
        else if (itr/10 == d-1)
            itr = itr + (10 - d);
        else
            itr = itr+10;
    }
    return result;
}
 
// Driver code
int main(void)
{
    int n = 11, d = 1;
    cout << getOccurrence(n, d);
    return 0;
}

Java

// java program to count appearances of
// a digit 'd' in range from [0..n]
import java.*;
 
public class GFG {
     
    static int getOccurrence(int n, int d)
    {
         
        // Initialize result
        int result = 0;
     
        // Count appearances in numbers
        // starting from d.
        int itr = d;
         
        while (itr <= n)
        {
             
            // When the last digit is
            // equal to d
            if (itr % 10 == d)
                result++;
     
            // When the first digit is
            // equal to d then
            if (itr != 0 && itr/10 == d)
            {
                 
                // increment result as
                // well as number
                result++;
                itr++;
            }
     
            // In case of reverse of number
            // such as 12 and 21
            else if (itr/10 == d-1)
                itr = itr + (10 - d);
            else
                itr = itr + 10;
        }
         
        return result;
    }
 
     
    // Driver code
    public static void main (String[] args)
    {
        int n = 11, d = 1;
     
        System.out.println(getOccurrence(n, d) );
    }
}
 
// This code is contributed by Sam007.

Python3

# Python3 program to count appearances
# of a digit 'd' in range from [0..n]
import math;
def getOccurrence(n, d):
     
    # Initialize result
    result = 0;
 
    # Count appearances in numbers
    # starting from d.
    itr = d;
    while(itr <= n):
         
        # When the last digit is equal to d
        if (itr % 10 == d):
            result += 1;
 
        # When the first digit is equal to d then
        if (itr != 0 and math.floor(itr / 10) == d):
             
            # increment result as well as number
            result += 1;
            itr += 1;
 
        # In case of reverse of number
        # such as 12 and 21
        elif (math.floor(itr / 10) == d - 1):
            itr = itr + (10 - d);
        else:
            itr = itr + 10;
 
    return result;
 
# Driver code
n = 11;
d = 1;
print(getOccurrence(n, d));
 
# This code is contributed by mits

C#

// C# program to count appearances of
// a digit 'd' in range from [0..n]
using System;
         
public class GFG {
     
    static int getOccurrence(int n, int d)
    {
         
        // Initialize result
        int result = 0;
     
        // Count appearances in numbers
        // starting from d.
        int itr = d;
        while (itr <= n)
        {
             
            // When the last digit is
            // equal to d
            if (itr % 10 == d)
                result++;
     
            // When the first digit is
            // equal to d then
            if (itr != 0 && itr/10 == d)
            {
                 
                // increment result as
                // well as number
                result++;
                itr++;
            }
     
            // In case of reverse of number
            // such as 12 and 21
            else if (itr/10 == d-1)
                itr = itr + (10 - d);
            else
                itr = itr + 10;
        }
         
        return result;
    }
     
    // Driver code
    public static void Main()
    {
        int n = 11, d = 1;
         
        Console.Write(getOccurrence(n, d));
    }
}
 
// This code is contributed by Sam007.

PHP

<?php
// PHP program to count appearances of
// a digit 'd' in range from [0..n]
 
function getOccurrence($n, $d)
{
     
    // Initialize result
    $result = 0;
 
    // Count appearances in numbers
    // starting from d.
    $itr = $d;
    while($itr <= $n)
    {
         
        // When the last digit
        // is equal to d
        if ($itr % 10 == $d)
            $result++;
 
        // When the first digit
        // is equal to d then
        if ($itr != 0 && floor($itr / 10) == $d)
        {
             
            // increment result as
            // well as number
            $result++;
            $itr++;
        }
 
        // In case of reverse of
        // number such as 12 and 21
        else if (floor($itr / 10) == $d - 1)
            $itr = $itr + (10 - $d);
        else
            $itr = $itr + 10;
    }
    return $result;
}
 
    // Driver code
    $n = 11;
    $d = 1;
    echo getOccurrence($n, $d);
 
// This code is contributed by nitin mittal.
?>

Javascript

<script>
    // Javascript program to count appearances of
// a digit 'd' in range from [0..n]
 
function getOccurrence(n, d)
{
     
    // Initialize result
    let result = 0;
 
    // Count appearances in numbers
    // starting from d.
    let itr = d;
    while(itr <= n)
    {
         
        // When the last digit
        // is equal to d
        if (itr % 10 == d)
            result++;
 
        // When the first digit
        // is equal to d then
        if (itr != 0 && Math.floor(itr / 10) == d)
        {
             
            // increment result as
            // well as number
            result++;
            itr++;
        }
 
        // In case of reverse of
        // number such as 12 and 21
        else if (Math.floor(itr / 10) == d - 1)
            itr = itr + (10 - d);
        else
            itr = itr + 10;
    }
    return result;
}
 
    // Driver code
    let n = 11;
    let d = 1;
    document.write(getOccurrence(n, d));
 
// This code is contributed by _saurabh_jaiswal.
</script>

Producción: 
 

4

Este artículo es una contribución de Rakesh Kumar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
 

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *