Número de N dígito más pequeño divisible por N

Dado un número entero positivo N , la tarea es encontrar el número de N dígito más pequeño divisible por N .

Ejemplos:

Entrada: N = 2
Salida: 10
Explicación:
10 es el número más pequeño de 2 dígitos que es divisible por 2.

Entrada: N = 3
Salida: 102
Explicación:
102 es el número más pequeño de 3 dígitos que es divisible por 3.

Enfoque ingenuo: el enfoque ingenuo es iterar desde el número de N dígitos más pequeño (digamos S ) hasta el número de N dígitos más grande (digamos L ). El primer número entre [S, L] divisible por N es el resultado requerido.

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

C++

// C++ program for the above approach
#include <iostream>
#include <math.h>
using namespace std;
 
// Function to find the smallest
// N-digit number divisible by N
void smallestNumber(int N)
{
    // Find largest n digit number
    int L = pow(10, N) - 1;
 
    // Find smallest n digit number
    int S = pow(10, N - 1);
 
    for (int i = S; i <= L; i++) {
 
        // If i is divisible by N,
        // then print i and return ;
        if (i % N == 0) {
 
            cout << i;
            return;
        }
    }
}
 
// Driver Code
int main()
{
    // Given Number
    int N = 2;
 
    // Function Call
    smallestNumber(N);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG{
 
// Function to find the smallest
// N-digit number divisible by N
static void smallestNumber(int N)
{
 
    // Find largest n digit number
    int L = (int) (Math.pow(10, N) - 1);
 
    // Find smallest n digit number
    int S = (int) Math.pow(10, N - 1);
 
    for (int i = S; i <= L; i++)
    {
 
        // If i is divisible by N,
        // then print i and return ;
        if (i % N == 0)
        {
            System.out.print(i);
            return;
        }
    }
}
 
// Driver Code
public static void main(String[] args)
{
    // Given Number
    int N = 2;
 
    // Function Call
    smallestNumber(N);
}
}
 
// This code is contributed by Amit Katiyar

Python3

# Python3 program for the above approach
 
# Function to find the smallest
# N-digit number divisible by N
def smallestNumber(N):
 
    # Find largest n digit number
    L = pow(10, N) - 1;
 
    # Find smallest n digit number
    S = pow(10, N - 1);
 
    for i in range(S, L):
 
        # If i is divisible by N,
        # then print i and return ;
        if (i % N == 0):
            print(i);
            return;
         
# Driver Code
if __name__ == "__main__" :
     
    # Given number
    N = 2;
 
    # Function call
    smallestNumber(N)
 
# This code is contributed by rock_cool

C#

// C# program for the above approach
using System;
class GFG{
 
// Function to find the smallest
// N-digit number divisible by N
static void smallestNumber(int N)
{
 
    // Find largest n digit number
    int L = (int)(Math.Pow(10, N) - 1);
 
    // Find smallest n digit number
    int S = (int)Math.Pow(10, N - 1);
 
    for(int i = S; i <= L; i++)
    {
        
       // If i is divisible by N,
       // then print i and return ;
       if (i % N == 0)
       {
           Console.Write(i);
           return;
       }
    }
}
 
// Driver Code
public static void Main()
{
     
    // Given number
    int N = 2;
 
    // Function call
    smallestNumber(N);
}
}
 
// This code is contributed by Nidhi_biet

Javascript

<script>
 
// Javascript program for the above approach
 
// Function to find the smallest
// N-digit number divisible by N
function smallestNumber(N)
{
     
    // Find largest n digit number
    let L = Math.pow(10, N) - 1;
 
    // Find smallest n digit number
    let S = Math.pow(10, N - 1);
 
    for(let i = S; i <= L; i++)
    {
         
        // If i is divisible by N,
        // then print i and return ;
        if (i % N == 0)
        {
            document.write(i);
            return;
        }
    }
}
 
// Driver code
 
// Given Number
let N = 2;
 
// Function Call
smallestNumber(N);
     
// This code is contributed by divyeshrabadiya07
 
</script>

Producción:

Complejidad de tiempo: O(L – S) , donde L y S son el número de N dígitos más grande y más pequeño respectivamente.

Enfoque eficiente: si el número es divisible por N , entonces el número tendrá la forma N * X para algún número entero positivo X.
Dado que tiene que ser el número de N dígitos más pequeño , X vendrá dado por:

$\lceil \frac{10^{N-1}}{N} \rceil$ . Therefore, the smallest number N-digit number is given by:

$N*\lceil \frac{10^{N-1}}{N} \rceil$

Por ejemplo:

Para N = 3, el número más pequeño de 3 dígitos viene dado por:
=> $3*\lceil \frac{10^{3-1}}{3} \rceil$

=> $3*\lceil \frac{100}{3} \rceil$

=> $3*\lceil 33.3 \rceil$

=> 102

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

C++

// C++ program for the above approach
#include <iostream>
#include <math.h>
using namespace std;
 
// Function to find the smallest
// N-digit number divisible by N
int smallestNumber(int N)
{
 
    // Return the smallest N-digit
    // number calculated using above
    // formula
    return N * ceil(pow(10, (N - 1)) / N);
}
 
// Driver Code
int main()
{
    // Given N
    int N = 2;
 
    // Function Call
    cout << smallestNumber(N);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG{
 
// Function to find the smallest
// N-digit number divisible by N
static int smallestNumber(int N)
{
 
    // Return the smallest N-digit
    // number calculated using above
    // formula
    return (int) (N * Math.ceil(Math.pow(10, (N - 1)) / N));
}
 
// Driver Code
public static void main(String[] args)
{
    // Given N
    int N = 2;
 
    // Function Call
    System.out.print(smallestNumber(N));
}
}
 
// This code is contributed by Princi Singh

Python3

# Python3 program for the above approach
import math
 
# Function to find the smallest
# N-digit number divisible by N
def smallestNumber(N):
 
    # Return the smallest N-digit
    # number calculated using above
    # formula
    return N * math.ceil(pow(10, (N - 1)) // N);
 
# Driver Code
 
# Given N
N = 2;
 
# Function Call
print(smallestNumber(N));
 
# This code is contributed by Code_Mech

C#

// C# program for the above approach
using System;
class GFG{
 
// Function to find the smallest
// N-digit number divisible by N
static int smallestNumber(int N)
{
 
    // Return the smallest N-digit
    // number calculated using above
    // formula
    return (int) (N * Math.Ceiling(Math.Pow(10, (N - 1)) / N));
}
 
// Driver Code
public static void Main()
{
    // Given N
    int N = 2;
 
    // Function Call
    Console.Write(smallestNumber(N));
}
}
 
// This code is contributed by Code_Mech

Javascript

<script>
    // Javascript program for the above approach
     
    // Function to find the smallest
    // N-digit number divisible by N
    function smallestNumber(N)
    {
 
        // Return the smallest N-digit
        // number calculated using above
        // formula
        return N * Math.ceil(Math.pow(10, (N - 1)) / N);
    }
     
    // Given N
    let N = 2;
  
    // Function Call
    document.write(smallestNumber(N));
     
    // This code is contributed by divyesh072019.
</script>

Producción:

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)

Publicación traducida automáticamente

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

C++

Java

Python3

C#

Javascript

C++

Java

Python3

C#

Javascript

Deja una respuesta Cancelar la respuesta