Integers from the range that are composed of a single distinct digit

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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

//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.    
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

<?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
?>
chevron_right

Output:

4

Efficient Approach:

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

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.




Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :