હેપી નંબર લીટકોડ સોલ્યુશન


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે એડોબ એમેઝોન સફરજન
હેશિંગ

સમસ્યા નિવેદન

સમસ્યા એ છે કે નંબર ખુશ નંબર છે કે નહીં તે તપાસવાની છે.

એક નંબર ખુશ હોવાનું કહેવાય છે નંબર જો સંખ્યાને તેના અંકોના ચોરસના સરવાળો દ્વારા બદલીને, અને પ્રક્રિયાને પુનરાવર્તિત કરવાથી સંખ્યા 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 આપેલ નંબર છે. સાંકળમાં સંખ્યાના દરેક અંકના ચોરસનો સરવાળો શોધવાની કિંમત લોગ (એન) છે અને લોગરીધમિક પરિબળ સાથે સંખ્યા ઓછી થતી રહે છે. તેથી જટિલતા = ઓ (લnગિન) + ઓ (લloગલgnગ્ન) + ઓ (લlogગ્લોગન) +….
અહીં ઓ (લોગન) પ્રબળ ભાગ છે. તેથી એકંદર જટિલતા ઓ (લnગિન) છે.

અવકાશ જટિલતા 

ઓ (લnગન):  સમૂહનું મહત્તમ કદ પણ સમય જટિલતા જેવી આપેલ સંખ્યા સાથે લોગરીધમિક હશે.