Skip to content
Related Articles

Related Articles

Integers from the range that are composed of a single distinct digit
  • Difficulty Level : Medium
  • Last Updated : 05 May, 2021

Given two integer L and R representing a range [L, R], the task is to find the count of integers from the range that are composed of a single distinct digit.
Examples: 
 

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

 

Naive Approach: Iterate through all the numbers and check if the number is composed of a single distinct digit only.
Below is the implementation of the above approach:
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
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.

PHP




<?php
// PHP implementation of the approach
 
// Boolean function to check distinct
// digits of a number
function 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 = floor($x / 10);
    }
 
    return true;
}
 
// Function to return the count of integers that
// are composed of a single distinct digit only
function findCount($L, $R)
{
    $count = 0;
 
    for ($i = $L; $i <= $R; $i++)
    {
 
        // If i has single distinct digit
        if (checkDistinct($i))
            $count += 1;
    }
 
    return $count;
}
 
// Driver code
$L = 10;
$R = 50;
 
echo findCount($L, $R);
 
// This code is contributed by Ryuga
?>

Javascript




<script>
//javascript implementation of the approach   
// Boolean function to check
    // distinct digits of a number
    function checkDistinct(x) {
        // Take last digit
        var 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 = parseInt(x / 10);
        }
 
        return true;
    }
 
    // Function to return the count of integers that
    // are composed of a single distinct digit only
    function findCount(L , R) {
        var count = 0;
 
        for (i = L; i <= R; i++) {
 
            // If i has single distinct digit
            if (checkDistinct(i))
                count += 1;
        }
 
        return count;
    }
 
    // Driver code
     
 
        var L = 10, R = 50;
        document.write(findCount(L, R));
 
// This code contributed by aashish1995
</script>
Output: 
4

 

Efficient Approach: 
 



  • If L is a 2 digit number and R is a 5 digit number then all the 3 and 4 digit numbers of the form 111, 222, …, 999 and 1111, 2222, …, 9999 will be valid.
  • So, count = count + (9 * (countDigits(R) – countDigits(L) – 1)).
  • And, for the numbers which have equal number of digits as L, count all the valid numbers ≥ L.
  • Similarly, for R count all the numbers ≤ R.
  • If countDigits(L) = countDigits(R) then count the valid numbers ≥ L and exclude valid elements ≥ R.
  • Print the count in the end.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
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
Output: 
4

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up
Recommended Articles
Page :