范围内的整数，由单个不同的数字组成

给定两个代表范围[L，R]的整数L和R ，任务是从范围中查找由单个不同数字组成的整数的计数。

例子：

Input : L = 9, R = 11
Output : 2
Only 9 and 11 have single distinct digit

Input : L = 10, R = 50
Output : 4
11, 22, 33 and 44 are the only valid numbers

天真的方法：遍历所有数字，并检查数字是否仅由单个不同的数字组成。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
  
// Boolean function to check
// distinct digits of a number
bool checkDistinct(int x)
{
    // Take last digit
    int last = x % 10;
  
    // Check if all other digits
    // are same as last digit
    while (x) {
        if (x % 10 != last)
            return false;
  
        // Remove last digit
        x = x / 10;
    }
  
    return true;
}
  
// Function to return the count of integers that
// are composed of a single distinct digit only
int findCount(int L, int R)
{
    int count = 0;
  
    for (int i = L; i <= R; i++) {
  
        // If i has single distinct digit
        if (checkDistinct(i))
            count += 1;
    }
  
    return count;
}
  
// Driver code
int main()
{
    int L = 10, R = 50;
  
    cout << findCount(L, R);
  
    return 0;
}

Java

//Java implementation of the approach
  
import java.io.*;
  
class GFG {
      
// Boolean function to check
// distinct digits of a number
static boolean checkDistinct(int x)
{
    // Take last digit
    int last = x % 10;
  
    // Check if all other digits
    // are same as last digit
    while (x >0) {
        if (x % 10 != last)
            return false;
  
        // Remove last digit
        x = x / 10;
    }
  
    return true;
}
  
// Function to return the count of integers that
// are composed of a single distinct digit only
static int findCount(int L, int R)
{
    int count = 0;
  
    for (int i = L; i <= R; i++) {
  
        // If i has single distinct digit
        if (checkDistinct(i))
            count += 1;
    }
  
    return count;
}
  
// Driver code
    public static void main (String[] args) {
  
          
        int L = 10, R = 50;
        System.out.println (findCount(L, R));
    }
//This code is contributed by ajit.    
}

Python3

# Python3 implementation of above approach
  
# Boolean function to check 
# distinct digits of a number 
def checkDistinct(x): 
  
    # Take last digit 
    last = x % 10
  
    # Check if all other digits 
    # are same as last digit 
    while (x):
          
        if (x % 10 != last):
            return False
  
        # Remove last digit 
        x = x // 10
  
    return True
  
# Function to return the count of 
# integers that are composed of a 
# single distinct digit only 
def findCount(L, R):
  
    count = 0
  
    for i in range(L, R + 1): 
  
        # If i has single distinct digit 
        if (checkDistinct(i)):
            count += 1
  
    return count
  
# Driver code 
L = 10
R = 50
  
print(findCount(L, R)) 
  
# This code is contributed
# by saurabh_shukla

C#

// C# implementation of the approach
 using System;
   
class GFG {
       
// Boolean function to check
// distinct digits of a number
static Boolean checkDistinct(int x)
{
    // Take last digit
    int last = x % 10;
   
    // Check if all other digits
    // are same as last digit
    while (x >0) {
        if (x % 10 != last)
            return false;
   
        // Remove last digit
        x = x / 10;
    }
   
    return true;
}
   
// Function to return the count of integers that
// are composed of a single distinct digit only
static int findCount(int L, int R)
{
    int count = 0;
   
    for (int i = L; i <= R; i++) {
   
        // If i has single distinct digit
        if (checkDistinct(i))
            count += 1;
    }
   
    return count;
}
   
// Driver code
    static public void Main (String []args) {
   
           
        int L = 10, R = 50;
        Console.WriteLine (findCount(L, R));
    }    
}
//This code is contributed by Arnab Kundu.

输出：

4

高效方法：

• 如果L是2位数字， R是5位数字，则格式为111、222，…，999和1111、2222，…，9999的所有3位和4位数字均有效。
• 因此， count = count +(9 *(countDigits(R)– countDigits(L)– 1)) 。
• 并且，对于与L相等的数字，请对所有有效数字≥L进行计数。
• 类似地，对于R计数所有≤R的数字。
• 如果countDigits(L)= countDigits(R)然后计算有效号码≥L和排除有效元素≥R上。
• 最后打印计数。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
  
// Function to return the count of digits of a number
int countDigits(int n)
{
    int count = 0;
  
    while (n > 0) {
        count += 1;
        n /= 10;
    }
  
    return count;
}
  
// Function to return a number that contains only
// digit 'd' repeated exactly count times
int getDistinct(int d, int count)
{
    int num = 0;
    count = pow(10, count - 1);
    while (count > 0) {
        num += (count * d);
        count /= 10;
    }
  
    return num;
}
  
// Function to return the count of integers that
// are composed of a single distinct digit only
int findCount(int L, int R)
{
    int count = 0;
  
    // Count of digits in L and R
    int countDigitsL = countDigits(L);
    int countDigitsR = countDigits(R);
  
    // First digits of L and R
    int firstDigitL = (L / pow(10, countDigitsL - 1));
    int firstDigitR = (R / pow(10, countDigitsR - 1));
  
    // If L has lesser number of digits than R
    if (countDigitsL < countDigitsR) {
  
        count += (9 * (countDigitsR - countDigitsL - 1));
  
        // If the number that starts with firstDigitL and has
        // number of digits = countDigitsL is within the range
        // include the number
        if (getDistinct(firstDigitL, countDigitsL) >= L)
            count += (9 - firstDigitL + 1);
  
        // Exclude the number
        else
            count += (9 - firstDigitL);
  
        // If the number that starts with firstDigitR and has
        // number of digits = countDigitsR is within the range
        // include the number
        if (getDistinct(firstDigitR, countDigitsR) <= R)
            count += firstDigitR;
  
        // Exclude the number
        else
            count += (firstDigitR - 1);
    }
  
    // If both L and R have equal number of digits
    else {
  
        // Include the number greater than L upto
        // the maximum number whose digit = coutDigitsL
        if (getDistinct(firstDigitL, countDigitsL) >= L)
            count += (9 - firstDigitL + 1);
        else
            count += (9 - firstDigitL);
  
        // Exclude the numbers which are greater than R
        if (getDistinct(firstDigitR, countDigitsR) <= R)
            count -= (9 - firstDigitR);
        else
            count -= (9 - firstDigitR + 1);
    }
  
    // Return the count
    return count;
}
  
// Driver code
int main()
{
    int L = 10, R = 50;
  
    cout << findCount(L, R);
  
    return 0;
}

Java

// java  implementation of the approach
import java.io.*;
  
class GFG {
     
  
// Function to return the count of digits of a number
static int countDigits(int n)
{
    int count = 0;
  
    while (n > 0) {
        count += 1;
        n /= 10;
    }
  
    return count;
}
  
// Function to return a number that contains only
// digit 'd' repeated exactly count times
static int getDistinct(int d, int count)
{
    int num = 0;
    count = (int)Math.pow(10, count - 1);
    while (count > 0) {
        num += (count * d);
        count /= 10;
    }
  
    return num;
}
  
// Function to return the count of integers that
// are composed of a single distinct digit only
static int findCount(int L, int R)
{
    int count = 0;
  
    // Count of digits in L and R
    int countDigitsL = countDigits(L);
    int countDigitsR = countDigits(R);
  
    // First digits of L and R
    int firstDigitL = (L /(int)Math. pow(10, countDigitsL - 1));
    int firstDigitR = (R / (int)Math.pow(10, countDigitsR - 1));
  
    // If L has lesser number of digits than R
    if (countDigitsL < countDigitsR) {
  
        count += (9 * (countDigitsR - countDigitsL - 1));
  
        // If the number that starts with firstDigitL and has
        // number of digits = countDigitsL is within the range
        // include the number
        if (getDistinct(firstDigitL, countDigitsL) >= L)
            count += (9 - firstDigitL + 1);
  
        // Exclude the number
        else
            count += (9 - firstDigitL);
  
        // If the number that starts with firstDigitR and has
        // number of digits = countDigitsR is within the range
        // include the number
        if (getDistinct(firstDigitR, countDigitsR) <= R)
            count += firstDigitR;
  
        // Exclude the number
        else
            count += (firstDigitR - 1);
    }
  
    // If both L and R have equal number of digits
    else {
  
        // Include the number greater than L upto
        // the maximum number whose digit = coutDigitsL
        if (getDistinct(firstDigitL, countDigitsL) >= L)
            count += (9 - firstDigitL + 1);
        else
            count += (9 - firstDigitL);
  
        // Exclude the numbers which are greater than R
        if (getDistinct(firstDigitR, countDigitsR) <= R)
            count -= (9 - firstDigitR);
        else
            count -= (9 - firstDigitR + 1);
    }
  
    // Return the count
    return count;
}
  
// Driver code
  
  
    public static void main (String[] args) {
        int L = 10, R = 50;
  
    System.out.println( findCount(L, R));
    }
}
// This code is contributed by inder_verma.

Python3

# Python3 implementation of the approach
  
# Function to return the count 
# of digits of a number
def countDigits(n):
    count = 0
  
    while (n > 0):
        count += 1
        n //= 10
  
    return count
  
# Function to return a number that contains only
# digit 'd' repeated exactly count times
def getDistinct(d, count):
    num = 0
    count = pow(10, count - 1)
    while (count > 0):
        num += (count * d)
        count //= 10
  
    return num
  
# Function to return the count of integers that
# are composed of a single distinct digit only
def findCount(L, R):
    count = 0
  
    # Count of digits in L and R
    countDigitsL = countDigits(L)
    countDigitsR = countDigits(R)
  
    # First digits of L and R
    firstDigitL = (L // pow(10, countDigitsL - 1))
    firstDigitR = (R // pow(10, countDigitsR - 1))
  
    # If L has lesser number of digits than R
    if (countDigitsL < countDigitsR):
  
        count += (9 * (countDigitsR - countDigitsL - 1))
  
        # If the number that starts with firstDigitL 
        # and has number of digits = countDigitsL is 
        # within the range include the number
        if (getDistinct(firstDigitL, countDigitsL) >= L):
            count += (9 - firstDigitL + 1)
  
        # Exclude the number
        else:
            count += (9 - firstDigitL)
  
        # If the number that starts with firstDigitR 
        # and has number of digits = countDigitsR is 
        # within the range include the number
        if (getDistinct(firstDigitR, countDigitsR) <= R):
            count += firstDigitR
  
        # Exclude the number
        else:
            count += (firstDigitR - 1)
  
    # If both L and R have equal number of digits
    else:
  
        # Include the number greater than L upto
        # the maximum number whose digit = coutDigitsL
        if (getDistinct(firstDigitL, countDigitsL) >= L):
            count += (9 - firstDigitL + 1)
        else:
            count += (9 - firstDigitL)
  
        # Exclude the numbers which are greater than R
        if (getDistinct(firstDigitR, countDigitsR) <= R):
            count -= (9 - firstDigitR)
        else:
            count -= (9 - firstDigitR + 1)
  
    # Return the count
    return count
  
# Driver code
L = 10
R = 50
  
print(findCount(L, R))
  
# This code is contributed by Mohit Kumar

C＃

// C# implementation of the approach
using System;
  
class GFG 
{
  
// Function to return the count 
// of digits of a number
static int countDigits(int n)
{
    int count = 0;
  
    while (n > 0) 
    {
        count += 1;
        n /= 10;
    }
  
    return count;
}
  
// Function to return a number that contains only
// digit 'd' repeated exactly count times
static int getDistinct(int d, int count)
{
    int num = 0;
    count = (int)Math.Pow(10, count - 1);
    while (count > 0) 
    {
        num += (count * d);
        count /= 10;
    }
  
    return num;
}
  
// Function to return the count of integers that
// are composed of a single distinct digit only
static int findCount(int L, int R)
{
    int count = 0;
  
    // Count of digits in L and R
    int countDigitsL = countDigits(L);
    int countDigitsR = countDigits(R);
  
    // First digits of L and R
    int firstDigitL = (L / (int)Math.Pow(10, countDigitsL - 1));
    int firstDigitR = (R / (int)Math.Pow(10, countDigitsR - 1));
  
    // If L has lesser number of digits than R
    if (countDigitsL < countDigitsR) 
    {
  
        count += (9 * (countDigitsR - countDigitsL - 1));
  
        // If the number that starts with firstDigitL 
        // and has number of digits = countDigitsL is 
        // within the range include the number
        if (getDistinct(firstDigitL, countDigitsL) >= L)
            count += (9 - firstDigitL + 1);
  
        // Exclude the number
        else
            count += (9 - firstDigitL);
  
        // If the number that starts with firstDigitR 
        // and has number of digits = countDigitsR is 
        // within the range include the number
        if (getDistinct(firstDigitR, countDigitsR) <= R)
            count += firstDigitR;
  
        // Exclude the number
        else
            count += (firstDigitR - 1);
    }
  
    // If both L and R have equal number of digits
    else
    {
  
        // Include the number greater than L upto
        // the maximum number whose digit = coutDigitsL
        if (getDistinct(firstDigitL, countDigitsL) >= L)
            count += (9 - firstDigitL + 1);
        else
            count += (9 - firstDigitL);
  
        // Exclude the numbers which are 
        // greater than R
        if (getDistinct(firstDigitR, countDigitsR) <= R)
            count -= (9 - firstDigitR);
        else
            count -= (9 - firstDigitR + 1);
    }
  
    // Return the count
    return count;
}
  
// Driver code
public static void Main() 
{
    int L = 10, R = 50;
  
    Console.WriteLine(findCount(L, R));
}
}
  
// This code is contributed 
// by Akanksha Rai

输出：

4