מזל נומער


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַדאָובי אַמאַזאָן עפּל דזשפּ מאָרגאַן
האַש האַשינג מאַט

פּראָבלעם סטאַטעמענט

וואָס איז אַ גליקלעך נומער?

א נומער איז אַ גליקלעך נומער אויב מיר קענען רעדוצירן אַ געגעבן נומער צו 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

מזל נומער

מיר קענען רעדוצירן דעם נומער צו איין אַזוי עס איז אַ גליקלעך נומער.

צוגאַנג

דער פּראָבלעם איז זייער פּשוט און ניצט בלויז די גרונט באַגריף פון דעם גאַנג.

וואָס איז אַ גאַנג?

שטעלן איז אַ אַסאָוסיאַטיוו קאַנטיינער מיט יינציק עלעמענטן.

צו סאָלווע דעם פּראָבלעם מיר וועלן נוצן אַ שטעלן. אין דעם גאַנג, מיר וועלן שטעלן די נייע געגרינדעט נומער נאָך אַדינג די קוואַדראַט פון די דידזשאַץ פון די נומער. איצט אויב דער עלעמענט איז שוין פאָרשטעלן אין דעם גאַנג, עס מיטל אַז עס איז פאָרמינג אַ שלייף און מיר קענען נישט קאָנווערט די געגעבן נומער אין איין, דאָס איז נישט אַ גליקלעך נומער. אויב די נומער איז רידוסט צו איינער, די נומער איז אַ גליקלעך נומער.

קאָדעקס

C ++ קאָד פֿאַר Happy Number

#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

דזשאַוואַ קאָד פֿאַר Happy Number

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), קלאָץ N האט באַזע 10. אַזוי, די צייט קאַמפּלעקסיטי איז אָפענגיק אויף די נומער פון דידזשאַץ אין די נומער. און עס האלט מיט דיקריסט מיט די לאָגאַריטמיק פאַקטאָר. אזוי די צייט קאַמפּלעקסיטי איז אָ (קלאָץ ען).

ספעיס קאַמפּלעקסיטי

אָ (לאָגן), פּלאַץ איז פארלאנגט צו קראָם די ינטערמידייט נומערן. ענלעך צו די צייט קאַמפּלעקסיטי, די פּלאַץ קאַמפּלעקסיטי איז אויך לאָגאַריטהממיק.