计算n个可被给定数字整除的数字

给定数字n和一个数字，任务是计算可被该数字整除并具有n个数字的所有数字。
例子 ：

Input : n = 2, number = 7
Output : 9
There are nine n digit numbers that
are divisible by 7. Numbers are 14, 
21, 28, 35, 42, 49, .... 70.

Input : n = 3, number = 7
Output : 128

Input : n = 4, number = 4
Output : 2250

本机方法：遍历所有n位数字。对于每个数字，检查其可除性，

C++

// Simple CPP program to count n digit
// divisible numbers.
#include 
#include 
using namespace std;
 
// Returns count of n digit numbers
// divisible by 'number'
int numberofterm(int n, int number)
{
    // compute the first and last term
    int firstnum = pow(10, n - 1);
    int lastnum = pow(10, n);
 
    // count total number of which having
    // n digit and divisible by number
    int count = 0;
    for (int i = firstnum; i < lastnum; i++)
        if (i % number == 0)
            count++;
    return count;
}
 
// Driver code
int main()
{
    int n = 3, num = 7;
    cout << numberofterm(n, num) << "\n";
    return 0;
}

Java

// Simple Java program to count n digit
// divisible numbers.
import java.io.*;
 
class GFG {
     
    // Returns count of n digit numbers
    // divisible by 'number'
    static int numberofterm(int n, int number)
    {
        // compute the first and last term
        int firstnum = (int)Math.pow(10, n - 1);
        int lastnum = (int)Math.pow(10, n);
     
        // count total number of which having
        // n digit and divisible by number
        int count = 0;
        for (int i = firstnum; i < lastnum; i++)
            if (i % number == 0)
                count++;
        return count;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int n = 3, num = 7;
        System.out.println(numberofterm(n, num));
    }
}
 
// This code is contributed by Ajit.

Python3

# Simple Python 3 program to count n digit
# divisible numbers
 
import math
 
# Returns count of n digit
# numbers divisible by number
def numberofterm(n, number):
 
    # compute the first and last term
    firstnum = math.pow(10, n - 1)
    lastnum = math.pow(10, n)
 
    # count total number of which having
    # n digit and divisible by number
    count = 0
    for i in range(int(firstnum), int(lastnum)):
        if (i % number == 0):
            count += 1
    return count
 
 
# Driver code
n = 3
num = 7
print(numberofterm(n, num))
 
# This article is contributed
# by Smitha Dinesh Semwal

C#

// Simple C# program to count n digit
// divisible numbers.
using System;
 
class GFG
{
     
    // Returns count of n digit numbers
    // divisible by 'number'
    static int numberofterm(int n, int number)
    {
        // compute the first and last term
        int firstnum = (int)Math.Pow(10, n - 1);
        int lastnum = (int)Math.Pow(10, n);
     
        // count total number of which having
        // n digit and divisible by number
        int count = 0;
        for (int i = firstnum; i < lastnum; i++)
            if (i % number == 0)
                count++;
        return count;
    }
     
    // Driver code
    public static void Main ()
    {
        int n = 3, num = 7;
        Console.Write(numberofterm(n, num));
    }
}
 
// This code is contributed by nitin mittal

Javascript

// JavaScript program to count n digit
// divisible numbers.
 
// Returns count of n digit numbers
    // divisible by 'number'
    function numberofterm(n, number)
    {
        // compute the first and last term
        let firstnum = Math.pow(10, n - 1);
        let lastnum = Math.pow(10, n);
       
        // count total number of which having
        // n digit and divisible by number
        let count = 0;
        for (let i = firstnum; i < lastnum; i++)
            if (i % number == 0)
                count++;
        return count;
    }
 
// Driver Code
 
        let n = 3, num = 7;
        document.write(numberofterm(n, num));
 
// This code is contributed by code_hunt.

输出：

128

高效方法：找到可分解的第一个和最后一个术语，然后应用以下公式

Count of divisible = (lastnumber – firstnumber)/number + 1

C++

// Efficient CPP program to count n digit
// divisible numbers.
#include 
#include 
using namespace std;
 
// find the number of term
int numberofterm(int digit, int number)
{
    // compute the first and last term
    int firstnum = pow(10, digit - 1);
    int lastnum = pow(10, digit);
 
    // first number which is divisible by given number
    firstnum = (firstnum - firstnum % number) + number;
 
    // last number which is divisible by given number
    lastnum = (lastnum - lastnum % number);
 
    // Apply the formula here
    return ((lastnum - firstnum) / number + 1);
}
 
int main()
{
    int n = 3;
    int number = 7;
    cout << numberofterm(n, number) << "\n";
    return 0;
}

Java

// Efficient Java program to count n digit
// divisible numbers.
import java.io.*;
 
class GFG {
     
    // find the number of term
    static int numberofterm(int digit, int number)
    {
        // compute the first and last term
        int firstnum = (int)Math.pow(10, digit - 1);
        int lastnum = (int)Math.pow(10, digit);
     
        // first number which is divisible by given number
        firstnum = (firstnum - firstnum % number) + number;
     
        // last number which is divisible by given number
        lastnum = (lastnum - lastnum % number);
     
        // Apply the formula here
        return ((lastnum - firstnum) / number + 1);
    }
 
    // Driver code
    public static void main (String[] args)
    {
        int n = 3;
        int number = 7;
        System.out.println(numberofterm(n, number));
    }
}
 
// This code is contributed by Ajit.

Python3

# Efficient Python program to 
# count n digit divisible numbers.
 
# Find the number of term
def numberofterm(digit, number):
     
    # compute the first and last term
    firstnum = pow(10, digit - 1)
    lastnum = pow(10, digit)
 
    # First number which is divisible by given number
    firstnum = (firstnum - firstnum % number) + number
 
    # last number which is divisible by given number
    lastnum = (lastnum - lastnum % number)
 
    # Apply the formula here
    return ((lastnum - firstnum) // number + 1);
 
# Driver code
n = 3; number = 7
print(numberofterm(n, number))
 
# This code is contributed by Ajit.

C＃

// Efficient C# program to count n digit
// divisible numbers.
using System;
 
class GFG {
     
    // find the number of term
    static int numberofterm(int digit,
                            int number)
    {
         
        // compute the first and
        // last term
        int firstnum = (int)Math.Pow(10,
                             digit - 1);
                              
        int lastnum = (int)Math.Pow(10,
                                digit);
     
        // first number which is divisible
        // by given number
        firstnum = (firstnum - firstnum
                      % number) + number;
     
        // last number which is divisible
        // by given number
        lastnum = (lastnum - lastnum
                              % number);
     
        // Apply the formula here
        return ((lastnum - firstnum)
                          / number + 1);
    }
 
    // Driver code
    public static void Main ()
    {
        int n = 3;
        int number = 7;
         
        Console.WriteLine(
             numberofterm(n, number));
    }
}
 
// This code is contributed by anuj_67.

输出：

128