పరిధిలో పునరావృతమయ్యే అంకెలు లేని మొత్తం సంఖ్యలు


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది అకోలైట్ ఫాక్ట్‌సెట్ మాక్య్
మఠం సంఖ్య-అంకెలు

మీకు సంఖ్యల శ్రేణి ఇవ్వబడుతుంది (ప్రారంభం, ముగింపు). ఇచ్చిన విధి పరిధిలో పునరావృత అంకెలు లేని మొత్తం సంఖ్యల సంఖ్యను కనుగొనమని చెబుతుంది.

ఉదాహరణ

ఇన్పుట్:

10 50

అవుట్పుట్:

37

వివరణ:

10 కి పదేపదే అంకె లేదు. 11 పునరావృత అంకెను కలిగి ఉంది. 12 కు పదేపదే అంకె లేదు. 22, 33 పునరావృత అంకెను కలిగి ఉంది. కాబట్టి పదేపదే అంకెలు లేని సంఖ్యలను మేము కనుగొన్నప్పుడు, మన ఫలితంలో దాన్ని లెక్కించాము.

పరిధిలో పునరావృతమయ్యే అంకెలు లేని మొత్తం సంఖ్యలు

అల్గారిథం

  1. ప్రకటించండి a సెట్ మరియు వెక్టర్.
  2. వెక్టర్‌లోకి 0 మరియు 1 ని నెట్టి, 10 కాలానికి సంబంధించిన అన్ని అంశాలను తెలుసుకోండి మరియు మిగిలిన వాటిని సెట్‌లో నిల్వ చేయండి. సెట్‌లో ఇప్పటికే ఆ సంఖ్య రిటర్న్ ఉంటే 0 లేకపోతే రిటర్న్ 1.
  3. ఆ సంఖ్యను పొందండి మరియు దానిని జోడించండి వెక్టర్.
  4. ప్రతి ప్రశ్నకు, వెక్టర్ [ముగింపు] మరియు వెక్టర్ [ప్రారంభం] యొక్క వ్యత్యాసాన్ని తిరిగి ఇవ్వండి.

పరిధిలో పునరావృతమయ్యే అంకెలు లేని మొత్తం సంఖ్యల వివరణ

మేము ఒక పరిధిని ఇచ్చాము. ఇచ్చిన పరిధిలో వచ్చే మొత్తం సంఖ్య యొక్క సంఖ్యను పునరావృతం చేయమని మేము కోరాము. దీని కోసం, మేము సేకరణ ఫ్రేమ్‌వర్క్‌ను ఉపయోగించబోతున్నాము. మేము సెట్ మరియు వెక్టర్ ఉపయోగిస్తాము. సెట్ అనేది అసాధారణమైన కారకాలను లేదా సంఖ్య యొక్క మిగిలిన భాగాన్ని నిల్వ చేయడం మరియు వెక్టర్ సెట్ నుండి ఫిల్టర్ చేసిన సంఖ్యను నిల్వ చేయడం. వాటిలో కొన్ని ఏ 10 అంకెల స్థలంలో ఉన్న సంఖ్య మాత్రమే పునరావృతం కాదని మాకు తెలుసు, 1 నుండి 10 వరకు, పునరావృత సంఖ్య లేదు. 11 నుండి 10 వరకు మరియు 21 నుండి 30 వరకు, 11 మరియు 22 గా అంకెలను పునరావృతం చేసే రెండు సంఖ్యలు ఉన్నాయి, ఇది ఒకే విధంగా ఉంటుంది.

విలువ 0 నుండి ఇచ్చిన విలువకు, అది ఏమైనప్పటికీ, వెక్టర్‌లో 1 మరియు 2 సంఖ్యను చేర్చుతాము. పైన పేర్కొన్న విధంగా 10 పరంగా ఒక కారకం లేదా మిగిలిన సంఖ్యను పొందండి. సెట్‌లో ఆ సంఖ్య ఇప్పటికే మిగిలి ఉంటే సెట్‌లో చేర్చుతాము. తిరిగి 0 మరెన్నో ఆ సెట్‌ను సెట్‌కు జోడించండి. ఇది క్రొత్త సంఖ్య లేదా మిగిలినది మరియు తిరిగి 1. విలువ 0 అయ్యే వరకు ప్రయాణిస్తూ ఉండండి. ఇక్కడ మనం 0 లేదా 1 వంటి సంఖ్యను పొందుతాము మరియు దానిని వెక్టర్ ద్వారా పొందే సంఖ్యతో జోడించి, గణనను నెట్టండి వెక్టర్కు.

ప్రతి ప్రశ్న ఇవ్వడానికి, మేము సరైన స్థానం వద్ద సంఖ్యల వ్యత్యాసాన్ని తిరిగి ఇస్తాము, అంటే సరైన పరిధి, మరియు ఎడమ స్థానంలో ఉన్న సంఖ్యలు అంటే వెక్టర్‌లోని ఎడమ పరిధిలోని సంఖ్య. మేము ఈ వ్యత్యాసాన్ని తిరిగి ఇస్తాము, దీనికి మేము అవసరమైన సమాధానం.

అమలు

పరిధిలో పునరావృతమయ్యే అంకెలు లేని మొత్తం సంఖ్యల కోసం C ++ ప్రోగ్రామ్

#include <iostream>
#include<vector>
#include<unordered_set>

using namespace std;

int MAX = 1000;

vector<int> numbers = {0};

int getRepeatedNumber(int n)
{

    unordered_set<int> SET;
    int rem;

    while (n != 0)
    {
        rem = n % 10;
        if (SET.find(rem) != SET.end())
            return 0;

        SET.insert(rem);
        n = n / 10;
    }
    return 1;
}

void buildSetOfNumbers(int MAX)
{

    numbers.push_back(getRepeatedNumber(1));

    for (int i = 2; i < MAX + 1; i++)
        numbers.push_back(getRepeatedNumber(i) + numbers[i-1]);
}

int getNumber(int left,int right)
{
    return numbers[right] - numbers[left-1];
}
int main()
{
    int Left = 10, Right = 50;
    buildSetOfNumbers(MAX);

    cout << getNumber(Left, Right) << endl;

    return 0;
}
37

పరిధిలో పునరావృతమయ్యే అంకెలు లేని మొత్తం సంఖ్యల కోసం జావా ప్రోగ్రామ్

import java.util.Vector;
import java.util.HashSet;

class repeatedDigits
{
    private static int MAX = 100;
    private static Vector<Integer> numbers = new Vector<>();
    
    static int getRepeatedNumber(int n)
    {
        HashSet<Integer> set = new HashSet<>();
        int rem;

        while (n != 0)
        {
            rem = n % 10;

            if (set.contains(rem))
                return 0;

            set.add(rem);
            n /= 10;
        }
        return 1;
    }
    
    static void buildSetOfNumbers()
    {
        numbers.add(0);
        numbers.add(getRepeatedNumber(1));

        for (int i = 2; i < MAX + 1; i++)
            numbers.add(getRepeatedNumber(i) + numbers.elementAt(i - 1));
    }
    
    static int getNumber(int left, int right)
    {
        return numbers.elementAt(right) - numbers.elementAt(left - 1);
    }
    
    public static void main(String[] args)
    {
        int Left = 10, Right = 50;

        buildSetOfNumbers();
        System.out.println(getNumber(Left, Right));
    }
}
37

సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

O (1) అదనపు సమయం అవసరం లేదు.

అంతరిక్ష సంక్లిష్టత

పై) (ఇక్కడ “N” శ్రేణిలోని మూలకాల సంఖ్య.