ಹ್ಯಾಪಿ ಸಂಖ್ಯೆ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಡೋಬ್ ಅಮೆಜಾನ್ ಆಪಲ್ JP ಮೋರ್ಗಾನ್
ಹ್ಯಾಶ್ ಹ್ಯಾಶಿಂಗ್ ಮಠ

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

ಸಂತೋಷದ ಸಂಖ್ಯೆ ಎಂದರೇನು?

ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅನುಸರಿಸಿ ನಾವು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯನ್ನು 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

ಹ್ಯಾಪಿ ಸಂಖ್ಯೆ

ನಾವು ಈ ಸಂಖ್ಯೆಯನ್ನು ಒಂದಕ್ಕೆ ಇಳಿಸಬಹುದು ಆದ್ದರಿಂದ ಅದು ಸಂತೋಷದ ಸಂಖ್ಯೆ.

ಅಪ್ರೋಚ್

ಈ ಸಮಸ್ಯೆ ತುಂಬಾ ಸರಳವಾಗಿದೆ ಮತ್ತು ಗುಂಪಿನ ಮೂಲ ಪರಿಕಲ್ಪನೆಯನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತದೆ.

ಒಂದು ಸೆಟ್ ಎಂದರೇನು?

ಸೆಟ್ ಎನ್ನುವುದು ಸಹಾಯಕ ಧಾರಕವಾಗಿದ್ದು ಇದರಲ್ಲಿ ವಿಶಿಷ್ಟ ಅಂಶಗಳು ಇರುತ್ತವೆ.

ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಾವು a ಅನ್ನು ಬಳಸುತ್ತೇವೆ ಸೆಟ್. ಸೆಟ್ನಲ್ಲಿ, ಸಂಖ್ಯೆಯ ಅಂಕೆಗಳ ಚೌಕವನ್ನು ಸೇರಿಸಿದ ನಂತರ ನಾವು ಹೊಸದಾಗಿ ರೂಪುಗೊಂಡ ಸಂಖ್ಯೆಯನ್ನು ಸೇರಿಸುತ್ತೇವೆ. ಈಗ ಅಂಶವು ಈಗಾಗಲೇ ಸೆಟ್ನಲ್ಲಿದ್ದರೆ ಅದು ಲೂಪ್ ಅನ್ನು ರೂಪಿಸುತ್ತಿದೆ ಎಂದರ್ಥ ಮತ್ತು ನಾವು ಕೊಟ್ಟಿರುವ ಸಂಖ್ಯೆಯನ್ನು ಒಂದನ್ನಾಗಿ ಪರಿವರ್ತಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಆದ್ದರಿಂದ ಇದು ಸಂತೋಷದ ಸಂಖ್ಯೆಯಲ್ಲ. ಸಂಖ್ಯೆಯನ್ನು ಒಂದಕ್ಕೆ ಇಳಿಸಿದರೆ, ಕೊಟ್ಟಿರುವ ಸಂಖ್ಯೆ ಸಂತೋಷದ ಸಂಖ್ಯೆಯಾಗಿದೆ.

ಕೋಡ್

ಹ್ಯಾಪಿ ಸಂಖ್ಯೆಗೆ ಸಿ ++ ಕೋಡ್

#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

ಸಂಕೀರ್ಣತೆ ವಿಶ್ಲೇಷಣೆ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಲಾಗ್ ಎನ್), ಲಾಗ್ ಎನ್ ಬೇಸ್ 10 ಅನ್ನು ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ, ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ಸಂಖ್ಯೆಯಲ್ಲಿನ ಅಂಕೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಮತ್ತು ಇದು ಲಾಗರಿಥಮಿಕ್ ಅಂಶದೊಂದಿಗೆ ಕಡಿಮೆಯಾಗುತ್ತಲೇ ಇರುತ್ತದೆ. ಆದ್ದರಿಂದ ಸಮಯದ ಸಂಕೀರ್ಣತೆಯು ಒ (ಲಾಗ್ ಎನ್) ಆಗಿದೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ

ಒ (ಲಾಗ್ ಎನ್), ಈ ಮಧ್ಯಂತರ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಸ್ಥಳಾವಕಾಶದ ಅಗತ್ಯವಿದೆ. ಸಮಯದ ಸಂಕೀರ್ಣತೆಗೆ ಹೋಲುವಂತೆ ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆಯು ಲಾಗರಿಥಮಿಕ್ ಆಗಿದೆ.