ප්‍රීතිමත් අංක ලීට්කෝඩ් විසඳුම


දුෂ්කරතා මට්ටම පහසු
නිතර අසනු ලැබේ ඇෙබෝ ඇමේසන් Apple ජංගම දුරකථන
හැෂිං

ගැටළු ප්රකාශය

ගැටළුව වන්නේ අංකයක් ප්‍රීතිමත් අංකයක්ද නැද්ද යන්න පරීක්ෂා කිරීමයි.

අංකයක් සතුටු වන බව කියනු ලැබේ අංකය එහි ඉලක්කම්වල වර්ගවල එකතුවෙන් සංඛ්‍යාව ප්‍රතිස්ථාපනය කරන්නේ නම් සහ ක්‍රියාවලිය පුනරාවර්තනය කිරීමෙන් එම සංඛ්‍යාව 1 ට සමාන වේ. එය 1 බවට පත් නොවන්නේ නම් සහ 1 ක් ඇතුළත් නොවන චක්‍රයක් තුළ නිමක් නැතිව ලූප වේ නම්, එය සතුටුදායක සංඛ්‍යාවක් නොවේ.

උදාහරණයක්

19
true

පැහැදිලි කිරීම:

සතුටු අංකය

1 ^ 2 + 9 ^ 2 = 82
8 ^ 2 + 2 ^ 2 = 68
6 ^ 2 + 8 ^ 2 = 100
1 ^ 2 + 0 ^ 2 + 0 ^ 2 = 1 (ප්‍රීතිමත් අංකය)

2
false

පැහැදිලි කිරීම:

එය නැවත 4 වන ස්ථානයට ලඟා වන බැවින්, මෙතැන් සිට එය සදහටම දම්වැලෙහි ලූප වන අතර කිසි විටෙකත් 1 ට අවසන් විය නොහැක. එබැවින් ලබා දී ඇති සංඛ්‍යාව ප්‍රීතිමත් අංකයක් නොවේ.

ප්රවේශය

අපට ටික වේලාවකින් පුනරාවර්තනය කළ හැකි අතර එම සංඛ්‍යාව 1 වන තෙක් එහි ඉලක්කම් වර්ගයේ එකතුව සමඟ ප්‍රතිස්ථාපනය කළ හැකිය, සෑම නව පරිවර්තන අංකයක්ම මීට පෙර සිදු නොවිය යුතුය යන කොන්දේසිය සමඟ වෙනත් ආකාරයකින් අපි අවිනිශ්චිත ලූපයකට යමු.
මේ සඳහා අපට පූර්ණ සංඛ්‍යා සමූහයක් ගත හැකිය, මුලින් හිස් සහ පහත පියවර අනුගමනය කරන්න:

  1. කුලකයේ වත්මන් අංකය දැනටමත් තිබේ නම් වැරදියි (ලූපයක් හමු විය).
  2. නැතහොත් එය 1 ට සමාන නම් නැවත පැමිණීම සත්‍ය වේ.
  3. වෙනත් ආකාරයකින් වත්මන් අංකය කට්ටලයට ඇතුළු කර වත්මන් අංකය එහි ඉලක්කම්වල වර්ග ප්‍රමාණය සමඟ ආදේශ කරන්න.
  4. එකම ක්රියාවලිය නැවත කරන්න.

ක්රියාත්මක කිරීම

ප්‍රීතිමත් අංක ලීට්කෝඩ් විසඳුම සඳහා සී ++ වැඩසටහන

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

bool isHappy(int n) {
                 
    set<int> s;

    while(s.count(n)==0)
    {
        if(n==1) return true;
        s.insert(n);
        int temp=0;

        while(n)
        {
            temp+= (n%10)*(n%10);
            n/=10;
        }
        n=temp;
    }
    return false;
}

int main()
{ 
    int n=19;
    
    if(isHappy(n)) 
        cout<<"true"<<endl;
    else 
        cout<<"false"<<endl;
    
 return 0;
}
true

ප්‍රීතිමත් අංක ලීට්කෝඩ් විසඳුම සඳහා ජාවා වැඩසටහන

import java.util.*;
import java.lang.*;

class Happy
{  
     public static boolean isHappy(int n) 
     {
        
        Set<Integer> set = new HashSet<Integer>();
        int sum,digit;

        while (set.add(n)) 
        {
            sum = 0;
            while (n > 0) {
                digit = n%10;
                sum += digit*digit;
                n /= 10;
            }
            if (sum == 1)
                return true;
            else
                n = sum;

        }
        return false;
    }
    
    
    public static void main(String args[])
    {
       int n=19;
       System.out.println(isHappy(n));
    }
}
true

ප්‍රීතිමත් අංක ලීට්කෝඩ් විසඳුම සඳහා සංකීර්ණ විශ්ලේෂණය

කාල සංකීර්ණත්වය

ඕ (ලොග්):  මෙහි n යනු දී ඇති අංකයයි. දාමයක අංකයක එක් එක් ඉලක්කම්වල වර්ගයේ එකතුව සොයා ගැනීමේ පිරිවැය ලොග් (n) වන අතර ල ar ු ගණක සාධකය සමඟ සංඛ්‍යාව අඩු වෙමින් පවතී. එබැවින් සංකීර්ණතාව = O (logn) + O (loglogn) + O (logloglogn) +….
මෙහි O (log⁡n) ප්‍රමුඛ කොටසයි. එබැවින් සමස්ත සංකීර්ණතාව O (logn) වේ.

අභ්‍යවකාශ සංකීර්ණතාව 

ඕ (ලොග්):  කාල සංකීර්ණත්වය වැනි දී ඇති සංඛ්‍යා සමඟ උපරිම කට්ටලයේ ල ar ු ගණකය වනු ඇත.