ਇੱਕ ਸੀਮਾ ਵਿੱਚ ਬਿਨਾਂ ਕਿਸੇ ਦੁਹਰਾਅ ਵਾਲੇ ਅੰਕ ਦੇ ਕੁੱਲ ਨੰਬਰ


ਮੁਸ਼ਕਲ ਪੱਧਰ ਦਰਮਿਆਨੇ
ਅਕਸਰ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ ਇਕੱਤਰ ਤੱਥ ਮੈਕ
ਗਣਿਤ ਨੰਬਰ-ਅੰਕ

ਤੁਹਾਨੂੰ ਸੰਖਿਆਵਾਂ ਦੀ ਇੱਕ ਸ਼੍ਰੇਣੀ ਦਿੱਤੀ ਗਈ ਹੈ (ਸ਼ੁਰੂ, ਅੰਤ) ਦਿੱਤਾ ਕੰਮ ਦੱਸਦਾ ਹੈ ਕਿ ਸੀਮਾ ਵਿੱਚ ਬਿਨਾਂ ਕਿਸੇ ਦੁਹਰਾਏ ਅੰਕ ਦੇ ਸੰਖਿਆਵਾਂ ਦੀ ਕੁੱਲ ਸੰਖਿਆ ਦਾ ਪਤਾ ਲਗਾਉਣਾ.

ਉਦਾਹਰਨ

ਇੰਪੁੱਟ:

10 50

ਆਉਟਪੁੱਟ:

37

ਸਪਸ਼ਟੀਕਰਨ:

10 ਦਾ ਕੋਈ ਦੁਹਰਾਇਆ ਅੰਕ ਨਹੀਂ ਹੈ. 11 ਦਾ ਦੁਹਰਾਇਆ ਅੰਕ ਹੈ. 12 ਦਾ ਕੋਈ ਦੁਹਰਾਇਆ ਅੰਕ ਨਹੀਂ ਹੈ. ਜਦੋਂ ਕਿ 22, 33 ਦਾ ਦੁਹਰਾਇਆ ਅੰਕ ਹੁੰਦਾ ਹੈ. ਇਸ ਲਈ ਜਦੋਂ ਸਾਨੂੰ ਉਹ ਨੰਬਰ ਮਿਲੇ ਜਿਨ੍ਹਾਂ ਦਾ ਕੋਈ ਦੁਹਰਾਇਆ ਅੰਕ ਨਹੀਂ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸ ਨੂੰ ਆਪਣੇ ਨਤੀਜੇ ਵਿਚ ਗਿਣਾਂਗੇ.

ਇੱਕ ਸੀਮਾ ਵਿੱਚ ਬਿਨਾਂ ਕਿਸੇ ਦੁਹਰਾਅ ਵਾਲੇ ਅੰਕ ਦੇ ਕੁੱਲ ਨੰਬਰ

ਐਲਗੋਰਿਥਮ

  1. ਘੋਸ਼ਣਾ ਏ ਸੈੱਟ ਕਰੋ ਅਤੇ ਇਕ ਵੈਕਟਰ.
  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

ਜਟਿਲਤਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਟਾਈਮ ਜਟਿਲਤਾ

ਓ (1) ਕਿਉਂਕਿ ਕਿਸੇ ਵਾਧੂ ਸਮੇਂ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ.

ਸਪੇਸ ਦੀ ਜਟਿਲਤਾ

ਹੇ (n) ਜਿੱਥੇ ਕਿ “ਐਨ” ਐਰੇ ਵਿਚਲੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਹੈ.