લિટકોડ સોલ્યુશનના ઇવન નંબરની સંખ્યાવાળા નંબરો શોધો


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે Quora
અરે

આ સમસ્યામાં, અમને એક આપવામાં આવે છે એરે સકારાત્મક પૂર્ણાંકોની. આપણે અંકની સમાન સંખ્યા સાથે સંખ્યાઓની ગણતરી શોધવાની જરૂર છે.

ઉદાહરણ

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

સમજૂતી: ફક્ત 34 અને 3434 એ એક સમાન સંખ્યાના અંકો સાથે પૂર્ણાંકો છે. તેથી, આપણે 2 છાપીશું.

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

સમજૂતી: આપેલ એરેમાં એક સમાન સંખ્યાની સંખ્યા સાથે પૂર્ણાંક નથી.

અભિગમ

આ સમસ્યાનું મૂળ એ પૂર્ણાંકમાં અંકોની સંખ્યા ગણતરી છે. જો આપણે તે કરી શકીએ, તો પછી આપણે એરેમાં દરેક પૂર્ણાંક માટેની પ્રક્રિયાને પુનરાવર્તિત કરી શકીએ અને એક સમાન સંખ્યાવાળા પૂર્ણાંકોની સંખ્યા ગણી શકીએ. દ્વિસંગી રજૂઆતોમાં, આપેલ પૂર્ણાંક (અથવા તેને 2 દ્વારા વિભાજીત) કરી શકીએ ત્યાં સુધી આપણે તેની સંખ્યા ગણી શકીએ નહીં બિટ્સ તેમાં. એ જ રીતે, અંકોની ગણતરી કરવા માટે, આપણે પૂર્ણાંક દ્વારા ભાગ રાખી શકીએ છીએ 10 સિવાય કે તે બને 0. આ પદ્ધતિ કોઈપણ પાયા માટે સાચી છે.

લિટકોડ સોલ્યુશનના ઇવન નંબરની સંખ્યાવાળા નંબરો શોધો

 

અલ્ગોરિધમ

  1. આપણે ફંકશન બનાવીએ છીએ નંબરો () પૂર્ણાંકોની ગણતરી શોધવા માટે કોઈપણ એરેમાં એક સમાન સંખ્યાની સંખ્યા હોવા
  2. ઉપરાંત, અમે સહાયક કાર્ય બનાવીએ છીએ સંખ્યાઓફડિગિટ્સ () પૂર્ણાંકમાં અંકોની સંખ્યા તેને પાછા મોકલવા માટે:
    1. પ્રારંભ કરો CNT = 0
    2. જ્યારે પૂર્ણાંક, n 0 કરતા વધારે છે:
      1. વૃદ્ધિ CNT, સીએનટી ++
      2. વિભાજન n by 10, એન / = 10
    3. વળતર CNT
  3. પ્રારંભ કરો પરિણામ = 0 એક સમાન સંખ્યાવાળા અંકો ધરાવતા પૂર્ણાંકોની ગણતરી સ્ટોર કરવા
  4. એરેમાં દરેક તત્વ માટે:
    1. અમે તેનો ઉપયોગ કરીને તેમાં અંકોની ગણતરી પ્રાપ્ત કરીએ છીએ સંખ્યાઓફડિગિટ્સ () કાર્ય
    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

સંખ્યાની સંખ્યાની સાથે લેટકોડ સોલ્યુશન સાથે નંબરો શોધોનું જટિલતા વિશ્લેષણ

સમય જટિલતા

સમયની જટિલતા છે ઓ (એન) જ્યાં આપણે એરેનો એક પાસ કરીએ છીએ તેમ એરેનું એન = કદ અને અંકોની સંખ્યા સતત સમયમાં પ્રાપ્ત થાય છે.

અવકાશ જટિલતા

ઓ (1) આપણે ફક્ત સતત મેમરી જગ્યા વાપરીએ છીએ.