హ్యాపీ నంబర్


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది Adobe అమెజాన్ ఆపిల్ జెపి మోర్గాన్
హాష్ హ్యాషింగ్ మఠం

సమస్యల నివేదిక

సంతోషకరమైన సంఖ్య అంటే ఏమిటి?

ఈ విధానాన్ని అనుసరించి ఇచ్చిన సంఖ్యను 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

సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

ఓ (లాగ్ ఎన్), లాగ్ N కి బేస్ 10 ఉంది. కాబట్టి, సమయ సంక్లిష్టత సంఖ్యలోని అంకెల సంఖ్యపై ఆధారపడి ఉంటుంది. మరియు ఇది లోగరిథమిక్ కారకంతో తగ్గుతూనే ఉంటుంది. అందువలన సమయం సంక్లిష్టత O (లాగ్ N).

అంతరిక్ష సంక్లిష్టత

O (logN), ఈ ఇంటర్మీడియట్ సంఖ్యలను నిల్వ చేయడానికి స్థలం అవసరం. సమయ సంక్లిష్టత మాదిరిగానే స్థల సంక్లిష్టత కూడా లోగరిథమిక్.