မင်္ဂလာနံပါတ် Leetcode ဖြေရှင်းချက်


ခက်ခဲအဆင့် လွယ်ကူသော
မကြာခဏမေးတယ် Adobe က အမေဇုံ Apple
တားဆီးခြင်း

ပြProbleနာဖော်ပြချက်

ပြနာကနံပါတ်တစ်ခုသည်ပျော်ရွှင်သောနံပါတ်ဟုတ်မဟုတ်စစ်ဆေးရန်ဖြစ်သည်။

အတော်များများကပျော်ရွှင်တယ်လို့ပြောကြတယ် ဂဏန်း နံပါတ်ကို၎င်း၏ဂဏန်းများ၏စတုရန်း၏ပေါင်းလဒ်အားဖြင့်အစားထိုးခြင်းနှင့်လုပ်ငန်းစဉ်ကိုထပ်လုပ်ပါကနံပါတ် 1 နှင့်ညီမျှလျှင် 1 ကိုမဖြစ်လာနိုင်ပါက 1 မပါဝင်သည့်သံသရာတွင်အစဉ်မပြတ် loops လျှင်၎င်းသည် happy_number မဟုတ်ပါ။

နမူနာ

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

ရှင်းလင်းချက်:

နံပါတ် ၄ ကိုထပ်မံရောက်သွားပါကထိုနေရာမှ၎င်းသည်ကွင်းဆက်တွင်အမြဲတမ်းကွင်းဆက်ချိတ်ဆက်သွားမှာဖြစ်ပြီးဘယ်တော့မှ ၁ မှာအဆုံးသတ်မည်မဟုတ်ပါ။ ထို့ကြောင့်ပေးထားသောနံပါတ်သည်ပျော်ရွှင်သောနံပါတ်မဟုတ်ပါ။

ချဉ်းကပ်နည်း

while loop ကိုနံပါတ် ၁ ဖြစ်လာသည်အထိကိန်းဂဏန်း၏နှစ်ထပ်ကိန်းကို ပေါင်း၍ ကိန်းဂဏန်းကိုအစားထိုးနိုင်သည်။ ပြောင်းလဲထားသောနံပါတ်အသစ်တစ်ခုမပေါ်ပေါက်သေးပါကကျွန်ုပ်တို့သည်အကန့်အသတ်မဲ့ loop သို့သွားမည်ဖြစ်သည်။
၎င်းအတွက်ကျွန်ုပ်တို့သည်ကိန်းဂဏန်းအစုံအလင်ကိုယူနိုင်သည်၊ အစပိုင်းတွင်ဗလာဖြစ်ပြီးအောက်ပါအဆင့်များကိုလုပ်ဆောင်နိုင်သည်။

  1. အကယ်၍ လက်ရှိနံပါတ်သည် set ထဲတွင်ရှိနေပြီးဖြစ်ပါက false (return loop) ကိုပြန်ပို့ပါ။
  2. ကျန်သည်က 1 ပြန်လာ true နှင့်ညီလျှင်။
  3. ကျန်သည်လက်ရှိနံပါတ်ကိုအစုထဲသို့ထည့်ပြီးလက်ရှိနံပါတ်ကို၎င်း၏ဂဏန်း၏စတုရန်းနှင့်ပေါင်းပါ။
  4. တူညီတဲ့လုပ်ငန်းစဉ်ကိုပြန်လုပ်ပါ။

အကောင်အထည်ဖော်ရေး

Happy Number Leetcode ဖြေရှင်းနည်းအတွက် C ++ အစီအစဉ်

#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

ပျော်ရွှင်သောနံပါတ် Leetcode ဖြေရှင်းနည်းအတွက် Java အစီအစဉ်

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

ပျော်ရွှင်သောနံပါတ် Leetcode ဖြေရှင်းနည်းအတွက်ရှုပ်ထွေးမှုဆန်းစစ်ခြင်း

အချိန်ရှုပ်ထွေး

အို (logn) -  ဘယ်မှာ number ပေးထားသောအရေအတွက်သည်။ ကွင်းဆက်ရှိဂဏန်းတစ်ခုစီ၏စတုရန်း၏နှစ်ထပ်ကိန်းကိုရှာရန်ကုန်ကျစရိတ်သည် log (n) ဖြစ်ပြီး၊ ဂဏန်းသည် logarithmic factor နှင့်အတူဆက်လက်ကျဆင်းနေသည်။ ထို့ကြောင့်ရှုပ်ထွေး = အို (logn) + အို (loglogn) + အို (logloglogn) + .... ။
ဤတွင်အို (log⁡n) သည်အဓိကအစိတ်အပိုင်းဖြစ်သည်။ ထို့ကြောင့်ရှုပ်ထွေးမှုမှာအို (logn) ဖြစ်သည်။

အာကာသရှုပ်ထွေးမှု 

အို (logn) -  သတ်မှတ်ထားသောအမြင့်ဆုံးအရွယ်အစားသည်အချိန်ရှုပ်ထွေးမှုကဲ့သို့သောအရေအတွက်နှင့်အတူလော်ဂရစ်သမ်ဖြစ်လိမ့်မည်။