add Easy_202_Happy_Number Easy_263_Ugly_Number Easy_461_Hamming_Distance Easy_476_Number_Complement Easy_520_Detect_Capital.js

Author: zongyanqi

Easy_202_Happy_Number.js

@@ -0,0 +1,39 @@
+/**
+ * Write an algorithm to determine if a number is "happy".
+ * A happy number is a number defined by the following process: Starting with any positive integer,
+ * replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay),
+ * or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers.
+ *
+ * Example: 19 is a happy number
+ *
+ * 1^2 + 9^2 = 82
+ * 8^2 + 2^2 = 68
+ * 6^2 + 8^2 = 100
+ * 1^2 + 0^2 + 0^2 = 1
+ *
+ */
+
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+var isHappy = function (n) {
+
+    var num = n;
+    var results = [];
+    while (true) {
+        var digits = ('' + num).split('');
+        var newN = squareSumOfDigits(digits);
+        if (newN === 1) return true;
+        if (results.indexOf(newN) > -1) return false;
+        results.push(newN);
+        num = newN;
+    }
+};
+
+function squareSumOfDigits(digits) {
+    return digits.reduce((sum, d) => sum += d * d, 0);
+}
+
+console.log(isHappy(1));
+console.log(isHappy(19));

Easy_263_Ugly_Number.js

@@ -0,0 +1,35 @@
+/**
+ *
+ * https://leetcode.com/problems/ugly-number/#/description
+ *
+ * Write a program to check whether a given number is an ugly number.
+ *
+ * Ugly numbers are positive numbers whose prime factors only include 2, 3, 5.
+ *
+ * For example, 6, 8 are ugly while 14 is not ugly since it includes another prime factor 7.
+ *
+ * Note that 1 is typically treated as an ugly number.
+ */
+
+/**
+ * @param {number} num
+ * @return {boolean}
+ */
+var isUgly = function (num) {
+    if (num <= 0) return false;
+    if (num == 1) return true;
+
+    while (num > 1) {
+        var old = num;
+        if (!(num % 2)) num = num / 2;
+        if (!(num % 3)) num = num / 3;
+        if (!(num % 5)) num = num / 5;
+        if (old === num) return false;
+    }
+    return true;
+
+};
+
+console.log(isUgly(6) === true);
+console.log(isUgly(8) === true);
+console.log(isUgly(14) === false);

Easy_461_Hamming_Distance.js

@@ -0,0 +1,42 @@
+/**
+ *
+ * The Hamming distance between two integers is the number of positions at which the corresponding bits are different.
+
+ Given two integers x and y, calculate the Hamming distance.
+
+ Note:
+ 0 ≤ x, y < 231.
+
+ Example:
+
+ Input: x = 1, y = 4
+
+ Output: 2
+
+ Explanation:
+ 1   (0 0 0 1)
+ 4   (0 1 0 0)
+ ↑   ↑
+
+ The above arrows point to positions where the corresponding bits are different.
+
+ */
+
+/**
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+var hammingDistance = function (x, y) {
+
+    var z = x ^ y;
+    var ret = 0;
+    while (z) {
+        ret += z % 2;
+        z = Math.floor(z / 2);
+    }
+    return ret;
+
+};
+
+console.log(hammingDistance(1, 4));

Easy_476_Number_Complement.js

@@ -0,0 +1,32 @@
+/**
+ *
+ *
+ * Given a positive integer, output its complement number. The complement strategy is to flip the bits of its binary representation.
+ * Note:
+ *
+ * The given integer is guaranteed to fit within the range of a 32-bit signed integer.
+ * You could assume no leading zero bit in the integer’s binary representation.
+ *
+ * Example:
+ * Input: 5
+ * Output: 2
+ * Explanation: The binary representation of 5 is 101 (no leading zero bits), and its complement is 010. So you need to output 2.
+ */
+
+/**
+ * @param {number} num
+ * @return {number}
+ */
+var findComplement = function (num) {
+    var str = '';
+
+    while (num) {
+        str = ((num % 2) ? 0 : 1) + str;
+        num = Math.floor(num / 2);
+    }
+
+    return parseInt(str, 2);
+};
+
+console.log(findComplement(5));
+console.log(findComplement(2));

Easy_520_Detect_Capital.js

@@ -0,0 +1,38 @@
+/**
+ * Given a word, you need to judge whether the usage of capitals in it is right or not.
+
+ We define the usage of capitals in a word to be right when one of the following cases holds:
+
+ All letters in this word are capitals, like "USA".
+ All letters in this word are not capitals, like "leetcode".
+ Only the first letter in this word is capital if it has more than one letter, like "Google".
+ Otherwise, we define that this word doesn't use capitals in a right way.
+
+ */
+
+/**
+ * @param {string} word
+ * @return {boolean}
+ */
+var detectCapitalUse = function (word) {
+
+    var len = word.length;
+    var upperLen = 0;
+    var lowerLen = 0;
+    var firstCap = false;
+    for (var i = 0; i < len; i++) {
+        var ch = word[i];
+        if (/[A-Z]/.test(ch)) {
+            upperLen++;
+            if (i == 0) {
+                firstCap = true;
+            }
+        }
+        if (/[a-z]/.test(ch)) {
+            lowerLen++;
+        }
+    }
+    if (upperLen == len) return true;
+    if (lowerLen == len) return true;
+    return (upperLen == 1 && firstCap && len > 1);
+};