Skip to content
Related Articles

Related Articles

Count numbers up to N which contains at least one repeated digit
  • Difficulty Level : Easy
  • Last Updated : 09 Dec, 2020

Given an integer N, the task is to count the numbers less than or equal to N such that each number contains at least one repeated digit.

Examples:

Input: N = 20 
Output:
Explanation: 
Numbers containing at least one repeated digit and less than or equal to N(= 20) are {11}. 
Therefore, the required output is 1.

Input: N = 100 
Output: 10 
Explanation: 
Numbers containing at least one repeated digit and less than or equal to N(= 100) are {11, 22, 33, 44, 55, 66, 77, 88, 99, 100}. 
Therefore, the required output is 10.

Approach: Follow the steps below to solve the problem:



  • Initialize a variable, say X, to store the total count of digits in N.
  • Initialize a variable, say cntNumbers, to store the total count of numbers less than or equal to N consisting of unique digits.
  • Calculate the total count of X-digit numbers which contains unique digits and update cntNumbers. Below is the formula to calculate total count of X-digit numbers with all unique digits.

Total count of X-digit numbers with all unique digits = {(9 * factorial(9)) / factorial(10 – X)} 
 

  • Calculate total count of X-digit numbers less than or equal to N which contains unique digits by checking all possible values at each possible digits of a number less than or equal to N and update cntNumbers.
  • Finally, print the value of (N – cntNumbers).

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
long factorial(int n)
{
    return (n == 1 || n == 0) ? 1 :
            n * factorial(n - 1); 
}
 
// Function to count arrangements to
// select K elements from N elements 
long NPR(int n, int k)
{
    return factorial(n) / factorial(n - k);
}
 
// Function to count numbers less than or equal 
// to N with at least one repeated digits
int cntNumLessThanEqualNRepeatedDigits(int N)
{
     
    // Stores the value of N
    int temp = N;
 
    // Stores count of
    // digits in N
    int X = 0;
 
    // Store all possible
    // digits of N
    vector<int> nums;
 
    // Calculate digits in N
    while(temp)
    {
         
        // Update X
        X += 1;
 
        // Insert digits of N
        // into nums
        nums.push_back(temp % 10);
         
        // Update temp
        temp /= 10;
    }
    reverse(nums.begin(), nums.end());
     
    // Count numbers of (X)-digit
    // with no repeated digits
    int cntNumbers = 0;
 
    // Calculate count of numbers of less than
    // (X)-digit and no repeated digits
    for(int i = 1; i < X; i++)
    {
         
        // Update cntnumbers
        cntNumbers += 9 * (factorial(9) /
                           factorial(10 - i));
    }
     
    // Stores unique digits of
    // (X)-digit numbers
    unordered_set<int> vis;
     
    // Calculate (X) digits
    // numbers with no repeated digits
    for(int i = 0; i < nums.size(); i++)
    {
         
        // Stores count of unique
        // value at i_th digit
        int k = 0;
 
        // Stores minimum possible value of
        // i_th digit of a number
        int Min = 0;
 
        // If current digit is the first
        // digit of a number
        if (i == 0)
        {
             
            // Update Min
            Min = 1;
        }
        else
        {
             
            // Update Min
            Min = 0;
        }
         
        // Stores maximum possible value of
        // i_th digit if a number   
        int Max = 0;
 
        // If current digit is the last
        // digit of a number
        if (i == X - 1)
        {
             
            // Update Max
            Max = nums[i];
        }
        else
        {
             
            // Update Max
            Max = nums[i] - 1;
        }
             
        // Iterate over all possible value
        // of current digit
        for(int j = Min; j <= Max; j++)
        {
             
            // If value of current digit
            // already occurred in vis
            if (vis.find(j) != vis.end())
            {
                continue;
            }
                 
            // Update k
            k += 1;
        }
         
        // Update cntNumbers
        cntNumbers += k * (NPR(9 - i,
                      X - i - 1));
 
        // If current value of i-th digit
        // already occurred in vis             
        if (vis.find(nums[i]) != vis.end())
        {
            break;
        }
         
        // Insert val in vis
        vis.insert(nums[i]);
    }
     
    // Return total count of numbers less
    // than or equal to N with repetition
    return (N - cntNumbers);
}
 
// Driver Code
int main()
{
    int N = 100;
 
    cout << cntNumLessThanEqualNRepeatedDigits(N);
     
    return 0;
}
 
// This code is contributed by Manu Pathria

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
 
class GFG{
     
public static int factorial(int n)
{
    return (n == 1 || n == 0) ? 1 :
            n * factorial(n - 1); 
}
 
// Function to count arrangements to
// select K elements from N elements 
public static int NPR(int n, int k)
{
    return factorial(n) / factorial(n - k);
}
 
// Function to count numbers less than or equal 
// to N with at least one repeated digits
public static int cntNumLessThanEqualNRepeatedDigits(int N)
{
     
    // Stores the value of N
    int temp = N;
 
    // Stores count of
    // digits in N
    int X = 0;
 
    // Store all possible
    // digits of N
    List<Integer> nums = new ArrayList<>();
     
    // Calculate digits in N
    while (temp > 0)
    {
         
        // Update X
        X += 1;
 
        // Insert digits of N
        // into nums
        nums.add(temp % 10);
         
        // Update temp
        temp /= 10;
    }
    Collections.reverse(nums);
     
    // Count numbers of (X)-digit
    // with no repeated digits
    int cntNumbers = 0;
 
    // Calculate count of numbers of less than
    // (X)-digit and no repeated digits
    for(int i = 1; i < X; i++)
    {
         
        // Update cntnumbers
        cntNumbers += 9 * (factorial(9) /
                           factorial(10 - i));
    }
     
    // Stores unique digits of
    // (X)-digit numbers
    Set<Integer> vis=new HashSet<>();
     
    // Calculate (X) digits
    // numbers with no repeated digits
    for(int i = 0; i < nums.size(); i++)
    {
         
        // Stores count of unique
        // value at i_th digit
        int k = 0;
 
        // Stores minimum possible value of
        // i_th digit of a number
        int Min = 0;
 
        // If current digit is the first
        // digit of a number
        if (i == 0)
        {
             
            // Update Min
            Min = 1;
        }
        else
        {
             
            // Update Min
            Min = 0;
        }
 
        // Stores maximum possible value of
        // i_th digit if a number   
        int Max = 0;
 
        // If current digit is the last
        // digit of a number
        if (i == X - 1)
        {
             
            // Update Max
            Max = nums.get(i);
        }
        else
        {
             
            // Update Max
            Max = nums.get(i) - 1;
        }
             
        // Iterate over all possible value
        // of current digit
        for(int j = Min; j <= Max; j++)
        {
             
            // If value of current digit
            // already occurred in vis
            if (vis.contains(j))
            {
                continue;
            }
                 
            // Update k
            k += 1;
        }
         
        // Update cntNumbers
        cntNumbers += k * (NPR(9 - i,
                      X - i - 1));
 
        // If current value of i-th digit
        // already occurred in vis             
        if (vis.contains(nums.get(i)))
        {
            break;
        }
         
        // Insert val in vis
        vis.add(nums.get(i));
    }
     
    // Return total count of numbers less
    // than or equal to N with repetition
    return (N - cntNumbers);
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 100;
 
    System.out.print(
        cntNumLessThanEqualNRepeatedDigits(N));
}
}
 
// This code is contributed by Manu Pathria

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
 
import math
 
# Function to count arrangements to
# select K elements from N elements
def NPR(n, k):
        return (math.factorial(n) //
                math.factorial(n-k))
 
# Function to count numbers less than or equal
# to N with at least one repeated digits
def cntNumLessThanEqualNRepeatedDigits(N):
 
    # Stores the value of N
    temp = N
 
    # Stores count of
    # digits in N
    X = 0;
 
    # Store all possible
    # digits of N
    nums = []
 
    # Calculate digits in N
    while(temp):
 
        # Update X
        X += 1
 
        # Insert digits of N
        # into nums
        nums.append(temp % 10)
         
 
        # Update temp
        temp //= 10
         
 
    # Reverse nums
    nums.reverse()
 
    # Count numbers of (X)-digit
    # with no repeated digits
    cntNumbers = 0
 
    # Calculate count of numbers of less than
    # (X)-digit and no repeated digits
    for i in range(1, X):
 
        # Update cntnumbers
        cntNumbers += 9 * (math.factorial(9) //
                        math.factorial(10 - i))
 
    # Stores unique digits of
    # (X)-digit numbers
    vis = set()
 
    # Calculate (X) digits
    # numbers with no repeated digits
    for i, val in enumerate(nums):
 
        # Stores count of unique
        # value at i_th digit
        k = 0
 
        # Stores minimum possible value of
        # i_th digit of a number
        Min = 0;
 
        # If current digit is the first
        # digit of a number
        if i == 0:
 
            #Update Min
            Min = 1
        else:
 
            # Update Min
            Min = 0
 
        # Stores maximum possible value of
        # i_th digit if a number   
        Max = 0;
 
        # If current digit is the last
        # digit of a number
        if i == X - 1:
 
            # Update Max
            Max = val
        else:
             
 
            # Update Max
            Max = val - 1;
             
 
        # Iterate over all possible value
        # of current digit
        for j in range(Min, Max + 1):
 
            # If value of current digit
            # already occurred in vis
            if (j in vis):
                continue
                 
            # Update k
            k += 1
 
        # Update cntNumbers
        cntNumbers += k * (NPR(9 - i,
                      X - i - 1))
 
        # If current value of i-th digit
        # already occurred in vis             
        if val in vis:
            break
 
        # Insert val in vis
        vis.add(val)
 
    # Return total count of numbers less
    # than or equal to N with repetition
    return (N - cntNumbers)
 
# Driver Code
if __name__ == '__main__':
    N = 100
 
    # Function call
    print(cntNumLessThanEqualNRepeatedDigits(N))

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG {
     
    static int factorial(int n)
    {
        return (n == 1 || n == 0) ? 1 :
                n * factorial(n - 1); 
    }
      
    // Function to count arrangements to
    // select K elements from N elements 
    static int NPR(int n, int k)
    {
        return factorial(n) / factorial(n - k);
    }
      
    // Function to count numbers less than or equal 
    // to N with at least one repeated digits
    static int cntNumLessThanEqualNRepeatedDigits(int N)
    {
          
        // Stores the value of N
        int temp = N;
      
        // Stores count of
        // digits in N
        int X = 0;
      
        // Store all possible
        // digits of N
        List<int> nums = new List<int>();
          
        // Calculate digits in N
        while (temp > 0)
        {
              
            // Update X
            X += 1;
      
            // Insert digits of N
            // into nums
            nums.Add(temp % 10);
              
            // Update temp
            temp /= 10;
        }
        nums.Reverse();
          
        // Count numbers of (X)-digit
        // with no repeated digits
        int cntNumbers = 0;
      
        // Calculate count of numbers of less than
        // (X)-digit and no repeated digits
        for(int i = 1; i < X; i++)
        {
              
            // Update cntnumbers
            cntNumbers += 9 * (factorial(9) /
                               factorial(10 - i));
        }
          
        // Stores unique digits of
        // (X)-digit numbers
        HashSet<int> vis = new HashSet<int>();
          
        // Calculate (X) digits
        // numbers with no repeated digits
        for(int i = 0; i < nums.Count; i++)
        {
              
            // Stores count of unique
            // value at i_th digit
            int k = 0;
      
            // Stores minimum possible value of
            // i_th digit of a number
            int Min = 0;
      
            // If current digit is the first
            // digit of a number
            if (i == 0)
            {
                  
                // Update Min
                Min = 1;
            }
            else
            {
                  
                // Update Min
                Min = 0;
            }
      
            // Stores maximum possible value of
            // i_th digit if a number   
            int Max = 0;
      
            // If current digit is the last
            // digit of a number
            if (i == X - 1)
            {
                  
                // Update Max
                Max = nums[i];
            }
            else
            {
                  
                // Update Max
                Max = nums[i] - 1;
            }
                  
            // Iterate over all possible value
            // of current digit
            for(int j = Min; j <= Max; j++)
            {
                  
                // If value of current digit
                // already occurred in vis
                if (vis.Contains(j))
                {
                    continue;
                }
                      
                // Update k
                k += 1;
            }
              
            // Update cntNumbers
            cntNumbers += k * (NPR(9 - i,
                          X - i - 1));
      
            // If current value of i-th digit
            // already occurred in vis             
            if (vis.Contains(nums[i]))
            {
                break;
            }
              
            // Insert val in vis
            vis.Add(nums[i]);
        }
          
        // Return total count of numbers less
        // than or equal to N with repetition
        return (N - cntNumbers);
    }
 
  static void Main()
  {
        int N = 100;
  
        Console.WriteLine(cntNumLessThanEqualNRepeatedDigits(N));
  }
}
 
// This code is contributed by divyeshrabadiya07

chevron_right


Output: 

10

 

Time Complexity: O((log10N)2
Auxiliary Space: O(1)

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :