ඉරට්ටේ සංඛ්‍යා සංඛ්‍යාවක් සහිත අංක සොයන්න ලීට්කෝඩ් විසඳුම


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ කෝරා
අරා

මෙම ගැටලුවේදී අපට ලබා දී ඇත්තේ අ අරාව ධනාත්මක නිඛිලවල. ඉරට්ටේ ඉලක්කම් සංඛ්‍යාවක් ඇති සංඛ්‍යා ගණන අපට සොයාගත යුතුය.

උදාහරණයක්

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

පැහැදිලි කිරීම: ඉරට්ටේ ඉලක්කම් සංඛ්‍යාවක් සහිත පූර්ණ සංඛ්‍යා 34 සහ 3434 පමණි. ඉතින්, අපි 2 මුද්රණය කරමු.

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

පැහැදිලි කිරීම: දී ඇති අරාවෙහි ඉලක්කම් සංඛ්‍යාවක් සහිත පූර්ණ සංඛ්‍යාවක් නොමැත.

ප්රවේශය

මෙම ගැටලුවේ හරය වන්නේ පූර්ණ සංඛ්‍යාවක් තුළ ඇති ඉලක්කම් ගණන ගණනය කිරීමයි. අපට එය කළ හැකි නම්, අපට අරාවෙහි ඇති සෑම පූර්ණ සංඛ්‍යාවක් සඳහාම ක්‍රියාවලිය නැවත කළ හැකි අතර ඉලක්කම් සංඛ්‍යාවක් ඇති පූර්ණ සංඛ්‍යා ගණන ගණනය කළ හැකිය. ද්විමය නිරූපණයන්හිදී, අපට සංඛ්‍යා සංඛ්‍යාවක් ගණනය කිරීම ශුන්‍ය වන තෙක් දී ඇති පූර්ණ සංඛ්‍යාවක් නිවැරදිව මාරු කළ හැකිය (නැතහොත් එය 2 න් බෙදන්න) ටිකක් එහි. ඒ හා සමානව, ඉලක්කම් ගණනය කිරීම සඳහා, අපට පූර්ණ සංඛ්‍යාවක් බෙදීම දිගටම කරගෙන යා හැකිය 10 එය බවට පත් නොවන්නේ නම් 0. මෙම ක්‍රමය ඕනෑම පදනමක් සඳහා සත්‍ය වේ.

ඉරට්ටේ සංඛ්‍යා සංඛ්‍යාවක් සහිත අංක සොයන්න ලීට්කෝඩ් විසඳුම

 

ඇල්ගොරිතම

  1. අපි ශ්‍රිතයක් නිර්මාණය කරමු findNumbers () එය වෙත යොමු කරන ලද ඕනෑම අරාවක ඉලක්කම් සංඛ්‍යාවක් ඇති පූර්ණ සංඛ්‍යා ගණන සොයා ගැනීමට
  2. එසේම, අපි උපකාරක ශ්‍රිතයක් නිර්මාණය කරමු numberOfDigits () පූර්ණ සංඛ්‍යාවක් තුළ ඇති ඉලක්කම් ගණන එය වෙත ආපසු යැවීමට:
    1. ආරම්භ කරන්න cnt = 0
    2. නිඛිලය අතර n 0 ට වඩා වැඩිය:
      1. වර්ධක cnt, cnt ++
      2. බෙදනවා n by 10, n / = 10
    3. ආපසු cnt
  3. ආරම්භ කරන්න ප්රතිඵලය = 0 ඉරට්ටේ සංඛ්‍යාවක් ඇති පූර්ණ සංඛ්‍යා ගණන ගබඩා කිරීමට
  4. අරාවෙහි සෑම අංගයක් සඳහාම:
    1. අපි එහි ඇති ඉලක්කම් ගණන ලබා ගනිමු numberOfDigits () ක්රියාව
    2. ලබාගත් ඉලක්කම් ගණන ඉරට්ටේ නම්:
      1. වැඩි කිරීමේ ප්‍රති result ලය, ප්‍රති result ලය ++
  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) අපි භාවිතා කරන්නේ නියත මතක අවකාශයක් පමණි.