ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಪುನರಾವರ್ತಿತ ಅಂಕೆಗಳಿಲ್ಲದ ಒಟ್ಟು ಸಂಖ್ಯೆಗಳು


ತೊಂದರೆ ಮಟ್ಟ ಮಧ್ಯಮ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಕೋಲೈಟ್ ಫ್ಯಾಕ್ಟ್‌ಸೆಟ್ MAQ
ಮಠ ಸಂಖ್ಯೆ-ಅಂಕೆಗಳು

ನಿಮಗೆ ಸಂಖ್ಯೆಗಳ ಶ್ರೇಣಿಯನ್ನು ನೀಡಲಾಗಿದೆ (ಪ್ರಾರಂಭ, ಅಂತ್ಯ). ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಪುನರಾವರ್ತಿತ ಅಂಕೆಗಳಿಲ್ಲದ ಒಟ್ಟು ಸಂಖ್ಯೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಕೊಟ್ಟಿರುವ ಕಾರ್ಯ ಹೇಳುತ್ತದೆ.

ಉದಾಹರಣೆ

ಇನ್ಪುಟ್:

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 ರಂತೆ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ವೆಕ್ಟರ್ ಮೂಲಕ ಪಡೆಯುವ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಸೇರಿಸಿ ಮತ್ತು ಎಣಿಕೆ ತಳ್ಳಿರಿ ವೆಕ್ಟರ್ಗೆ.

ಪ್ರತಿ ಪ್ರಶ್ನೆಗೆ, ನಾವು ಸರಿಯಾದ ಸ್ಥಾನದಲ್ಲಿರುವ ಸಂಖ್ಯೆಗಳ ವ್ಯತ್ಯಾಸವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತೇವೆ, ಅಂದರೆ ಸರಿಯಾದ ಶ್ರೇಣಿ, ಮತ್ತು ಎಡ ಸ್ಥಾನದಲ್ಲಿರುವ ಸಂಖ್ಯೆಗಳು ವೆಕ್ಟರ್‌ನಲ್ಲಿ ಎಡ ವ್ಯಾಪ್ತಿಯಲ್ಲಿರುವ ಸಂಖ್ಯೆ ಎಂದರ್ಥ. ನಾವು ಈ ವ್ಯತ್ಯಾಸವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತೇವೆ, ಇದು ನಾವು ಅಗತ್ಯವಾದ ಉತ್ತರವಾಗಿರುತ್ತದೆ.

ಅನುಷ್ಠಾನ

ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಪುನರಾವರ್ತಿತ ಅಂಕೆಗಳಿಲ್ಲದ ಒಟ್ಟು ಸಂಖ್ಯೆಗಳಿಗೆ ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#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) ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಸಮಯ ಅಗತ್ಯವಿಲ್ಲ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಓ (ಎನ್) ಅಲ್ಲಿ “ಎನ್” ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ.