இனிய எண் லீட்கோட் தீர்வு


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது அடோப் அமேசான் ஆப்பிள்
ஹேஷிங்

சிக்கல் அறிக்கை

ஒரு எண் மகிழ்ச்சியான எண்ணா இல்லையா என்பதைச் சோதிப்பதுதான் பிரச்சினை.

ஒரு எண் மகிழ்ச்சியாக இருப்பதாகக் கூறப்படுகிறது எண் அதன் இலக்கங்களின் சதுரங்களின் கூட்டுத்தொகையால் எண்ணை மாற்றினால், மற்றும் செயல்முறையை மீண்டும் செய்வது எண்ணை 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) மற்றும் மடக்கைக் காரணியுடன் எண்ணிக்கை குறைந்து கொண்டே செல்கிறது. எனவே சிக்கலானது = O (logn) + O (loglogn) + O (logloglogn) +….
இங்கே O (log⁡n) ஆதிக்கம் செலுத்தும் பகுதியாகும். எனவே ஒட்டுமொத்த சிக்கலானது O (logn) ஆகும்.

விண்வெளி சிக்கலானது 

ஓ (பதிவு):  தொகுப்பின் அதிகபட்ச அளவு நேர சிக்கலானது போன்ற கொடுக்கப்பட்ட எண்ணிக்கையுடன் மடக்கை இருக்கும்.