ഇരട്ട അക്കങ്ങളുടെ ലീറ്റ്കോഡ് പരിഹാരമുള്ള നമ്പറുകൾ കണ്ടെത്തുക


വൈഷമ്യ നില എളുപ്പമായ
പതിവായി ചോദിക്കുന്നു Quora
അറേ

ഈ പ്രശ്‌നത്തിൽ, ഞങ്ങൾക്ക് ഒരു നൽകിയിട്ടുണ്ട് ശ്രേണി പോസിറ്റീവ് സംഖ്യകളുടെ. ഇരട്ട അക്കങ്ങളുള്ള അക്കങ്ങളുടെ എണ്ണം ഞങ്ങൾ കണ്ടെത്തേണ്ടതുണ്ട്.

ഉദാഹരണം

Array = {123 , 34 , 3434 , 121 , 100}
2

വിശദീകരണം: 34 ഉം 3434 ഉം മാത്രമാണ് ഇരട്ട സംഖ്യകളുള്ള സംഖ്യകൾ. അതിനാൽ, ഞങ്ങൾ 2 അച്ചടിക്കുന്നു.

Array = {1 , 111 , 11111 , 12345}
0

വിശദീകരണം: തന്നിരിക്കുന്ന അറേയിൽ ഇരട്ട സംഖ്യകളുള്ള സംഖ്യകളൊന്നുമില്ല.

സമീപനം

ഒരു സംഖ്യയിലെ അക്കങ്ങളുടെ എണ്ണം കണക്കാക്കുക എന്നതാണ് ഈ പ്രശ്നത്തിന്റെ കാതൽ. നമുക്ക് അത് ചെയ്യാൻ കഴിയുമെങ്കിൽ, അറേയിലെ ഓരോ സംഖ്യകൾക്കുമായി നമുക്ക് പ്രക്രിയ ആവർത്തിക്കാനും ഇരട്ട അക്കങ്ങളുള്ള പൂർണ്ണസംഖ്യകളുടെ എണ്ണം കണക്കാക്കാനും കഴിയും. ബൈനറി പ്രാതിനിധ്യങ്ങളിൽ, തന്നിരിക്കുന്ന സംഖ്യയെ എണ്ണാൻ പൂജ്യമാകുന്നതുവരെ നമുക്ക് ഒരു നിശ്ചിത സംഖ്യ വലത്തേക്ക് മാറ്റാം (അല്ലെങ്കിൽ അതിനെ 2 കൊണ്ട് ഹരിക്കാം) ബിറ്റുകൾ അതിൽ. അതുപോലെ, അക്കങ്ങൾ എണ്ണുന്നതിന്, നമുക്ക് ഒരു സംഖ്യയെ ഹരിച്ചാൽ തുടരാം 10 അത് സംഭവിച്ചില്ലെങ്കിൽ 0. ഏത് അടിസ്ഥാനത്തിനും ഈ രീതി ശരിയാണ്.

ഇരട്ട അക്കങ്ങളുടെ ലീറ്റ്കോഡ് പരിഹാരമുള്ള നമ്പറുകൾ കണ്ടെത്തുക

 

അൽഗോരിതം

  1. ഞങ്ങൾ ഒരു ഫംഗ്ഷൻ സൃഷ്ടിക്കുന്നു findNumbers () ഏത് അറേയിലും തുല്യ സംഖ്യകളുള്ള പൂർണ്ണസംഖ്യകളുടെ എണ്ണം കണ്ടെത്തുന്നതിന്
  2. കൂടാതെ, ഞങ്ങൾ ഒരു സഹായ ഫംഗ്ഷൻ സൃഷ്ടിക്കുന്നു numberOfDigits () ഇതിലേക്ക് കൈമാറിയ ഒരു സംഖ്യയിലെ അക്കങ്ങളുടെ എണ്ണം തിരികെ നൽകാൻ:
    1. ആരംഭിക്കുക കറ്റലോണിയയിലെ = 0
    2. പൂർണ്ണസംഖ്യ, n 0 നെക്കാൾ വലുതാണ്:
      1. ഇൻക്രിമെന്റും കറ്റലോണിയയിലെ, cnt ++
      2. വീതിക്കുക n by 10, n / = 10
    3. മടക്കം കറ്റലോണിയയിലെ
  3. ആരംഭിക്കുക ഫലം ഇരട്ട സംഖ്യകളുള്ള സംഖ്യകളുടെ എണ്ണം സംഭരിക്കുന്നതിന് = 0
  4. അറേയിലെ എല്ലാ ഘടകങ്ങൾക്കും:
    1. ഉപയോഗിച്ചുള്ള അക്കങ്ങളുടെ എണ്ണം ഞങ്ങൾ വീണ്ടെടുക്കുന്നു numberOfDigits () ഫംഗ്ഷൻ
    2. ലഭിച്ച അക്കങ്ങളുടെ എണ്ണം തുല്യമാണെങ്കിൽ:
      1. വർദ്ധന ഫലം, ഫലം ++
  5. റിട്ടേൺ ഫലം

ഇരട്ട അക്കങ്ങളുടെ ലീറ്റ്കോഡ് പരിഹാരമുള്ള കണ്ടെത്തൽ നമ്പറുകൾ നടപ്പിലാക്കൽ

സി ++ പ്രോഗ്രാം

#include <bits/stdc++.h>
using namespace std;

int numberOfDigits(int n)
{
    int cnt = 0;
    while(n > 0)
    {
        n /= 10;
        cnt++;
    }
    return cnt;
}

int findNumbers(vector <int> &a)
{
    int result = 0;
    for(int &i : a)
        if(numberOfDigits(i) % 2 == 0)
            result++;

    return result;
}

int main()
{
    vector <int> a = {123 , 34 , 3434 , 121 , 100};
    cout << findNumbers(a) << '\n';
    return 0;
}

ജാവ പ്രോഗ്രാം

class find_numbers
{
    public static void main(String args[])
    {
        int[] a = {123 , 34 , 3434 , 121 , 100};
        System.out.println(findNumbers(a));
    }

    static int numberOfDigits(int n)
    {
        int cnt = 0;
        while(n > 0)
        {
            n /= 10;
            cnt++;
        }
        return cnt;
    }

    static int findNumbers(int[] a)
    {
        int result = 0;
        for(int i = 0 ; i < a.length ; i++)
            if(numberOfDigits(a[i]) % 2 == 0)
                result++;

        return result;
    }
}
2

ഇരട്ട അക്കങ്ങളുടെ ലീറ്റ്കോഡ് പരിഹാരമുള്ള കണ്ടെത്തൽ നമ്പറുകളുടെ സങ്കീർണ്ണത വിശകലനം

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

സമയ സങ്കീർണ്ണതയാണ് O (N) ഇവിടെ അറേയുടെ ഒരൊറ്റ പാസ് ചെയ്യുന്നതുപോലെ അറേയുടെ N = വലുപ്പം, അക്കങ്ങളുടെ എണ്ണം സ്ഥിരമായ സമയത്ത് വീണ്ടെടുക്കുന്നു.

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

O (1) ഞങ്ങൾ സ്ഥിരമായ മെമ്മറി ഇടം മാത്രം ഉപയോഗിക്കുന്നതിനാൽ.