ഒരു ശ്രേണിയിൽ ആവർത്തിച്ചുള്ള അക്കങ്ങളില്ലാത്ത ആകെ നമ്പറുകൾ


വൈഷമ്യ നില മീഡിയം
പതിവായി ചോദിക്കുന്നു അക്കോലൈറ്റ് ഫാക്റ്റ്സെറ്റ് 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

സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

O (1) അധിക സമയം ആവശ്യമില്ലാത്തതിനാൽ.

ബഹിരാകാശ സങ്കീർണ്ണത

O (n) എവിടെ “N” അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം.