आनंदी क्रमांक


अडचण पातळी सोपे
वारंवार विचारले अडोब ऍमेझॉन सफरचंद जेपी मॉर्गन
हॅश हॅशिंग गणित

समस्या विधान

आनंदी क्रमांक काय आहे?

या प्रक्रियेचे अनुसरण करून दिलेली संख्या 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

गुंतागुंत विश्लेषण

वेळ कॉम्प्लेक्सिटी

ओ (लॉग एन), लॉग एनचा आधार १० आहे. तर वेळ गुंतागुंत संख्यांच्या अंकांच्या संख्येवर अवलंबून आहे. आणि हे लोगॅरिथमिक फॅक्टरसह कमी होत आहे. अशा प्रकारे वेळची जटिलता ओ (लॉग एन) आहे.

स्पेस कॉम्प्लेक्सिटी

ओ (लॉगएन), या दरम्यानचे क्रमांक साठवण्यासाठी जागा आवश्यक आहे. वेळेच्या जटिलतेसारखेच स्पेस कॉम्प्लेक्सिटी देखील लॉगरिथमिक आहे.