இனிய எண்


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

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

மகிழ்ச்சியான எண் என்றால் என்ன?

இந்த செயல்முறையைப் பின்பற்றி கொடுக்கப்பட்ட எண்ணை 1 ஆகக் குறைக்க முடிந்தால் ஒரு எண் மகிழ்ச்சியான எண்:

-> கொடுக்கப்பட்ட எண்ணின் இலக்கங்களின் சதுரத்தின் தொகையைக் கண்டறியவும். இந்த தொகையை பழைய எண்ணுடன் மாற்றவும். எண்ணை ஒன்றிற்குக் குறைக்கும் வரை அல்லது அது ஒரு சுழற்சியை உருவாக்கும் வரை இந்த செயல்முறையை மீண்டும் செய்வோம்.

அதாவது ஒரு எண்ணுடன் தொடங்கி, அதை ஒன்றாக மாற்றுவதற்கான செயல்முறையைப் பின்பற்றினால் ஒரு சுழற்சி உருவாகிறது, ஆனால் நாங்கள் முறைத்துப் பார்த்த எண்ணை அடைந்தோம், அது ஒரு சுழற்சியை உருவாக்குகிறது என்று நாங்கள் கூறுகிறோம்.

எண் உருவாக்கும் சுழற்சியின் எடுத்துக்காட்டு பின்வருமாறு:

89
8*8+9*9=145
1*1*+4*4+5*5=42
4*4+2*2=20
2*2+0*0=4
4*4=16
1*1+6*6=37
3*3+7*7=58
5*5+8*8=89

எனவே இது ஒரு சுழற்சியை உருவாக்குகிறது. எனவே மகிழ்ச்சியான எண்ணாக இல்லை, ஏனெனில் இதை 1 ஆக குறைக்க முடியாது, ஏனெனில் இது ஒவ்வொரு முறையும் 89 ஐ உருவாக்கும். எண்ணை 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

இனிய எண்

இந்த எண்ணை நாம் ஒன்றாக குறைக்க முடியும், எனவே இது ஒரு மகிழ்ச்சியான எண்.

அணுகுமுறை

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

ஒரு தொகுப்பு என்றால் என்ன?

தொகுப்பு என்பது ஒரு தனித்துவமான கொள்கலன், இதில் தனித்துவமான கூறுகள் உள்ளன.

இந்த சிக்கலை தீர்க்க நாம் ஒரு பயன்படுத்துவோம் தொகுப்பு. தொகுப்பில், எண்ணின் இலக்கங்களின் சதுரத்தைச் சேர்த்த பிறகு புதிதாக உருவாக்கப்பட்ட எண்ணைச் செருகுவோம். இப்போது உறுப்பு ஏற்கனவே தொகுப்பில் இருந்தால், அது ஒரு வளையத்தை உருவாக்குகிறது என்பதோடு, கொடுக்கப்பட்ட எண்ணை ஒன்றாக மாற்ற முடியாது, எனவே இது மகிழ்ச்சியான எண் அல்ல. எண்ணை ஒன்றாகக் குறைத்தால், கொடுக்கப்பட்ட எண் மகிழ்ச்சியான எண்ணாகும்.

குறியீடு

இனிய எண்ணிற்கான சி ++ குறியீடு

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

 bool isHappy(int n) {
        unordered_set<int> tmp;
        while(n != 1)
        {
            if(tmp.find(n) == tmp.end())
                tmp.insert(n);
            else
                return false;
            int sum = 0;
            while(n != 0)
            {
                sum += pow(n % 10,2);
                n = n / 10;
            }
            n = sum;
        }
        return true;
    }

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

இனிய எண்ணிற்கான ஜாவா குறியீடு

import java.util.*;

class Main
{
  static public boolean isHappy(int n) {
      Set<Integer> inLoop = new HashSet<Integer>();
      int squareSum,remain;
      while (inLoop.add(n)) {
      	squareSum = 0;
        while (n > 0) {
            remain = n%10;
          squareSum += remain*remain;
          n /= 10;
        }
        if (squareSum == 1)
          return true;
        else
          n = squareSum;
    }
    return false;
  }

  public static void main (String[] args) throws java.lang.Exception
  {
    int n = 19;
    boolean result = isHappy(n);
    System.out.print(result);
  }
}
19
true

சிக்கலான பகுப்பாய்வு

நேர சிக்கலானது

ஓ (பதிவு என்), log N க்கு அடிப்படை 10 உள்ளது. எனவே, நேர சிக்கலானது எண்ணில் உள்ள இலக்கங்களின் எண்ணிக்கையைப் பொறுத்தது. மேலும் இது மடக்கைக் காரணியுடன் குறைந்து கொண்டே செல்கிறது. இதனால் நேர சிக்கலானது O (log N) ஆகும்.

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

ஓ (logN), இந்த இடைநிலை எண்களை சேமிக்க இடம் தேவை. நேர சிக்கலைப் போலவே விண்வெளி சிக்கலானது மடக்கை ஆகும்.