add Easy_136_Single_Number Easy_190_Reverse_Bits Easy_191_Number_of_1_Bits

zongyanqi · zongyanqi · commit 63ae02fd4769 · 2017-03-19T10:03:42.000+08:00
diff --git a/Easy_136_Single_Number.js b/Easy_136_Single_Number.js
@@ -0,0 +1,28 @@
+/**
+ *
+ * https://leetcode.com/problems/single-number/#/description
+ *
+ * Given an array of integers, every element appears twice except for one. Find that single one.
+ *
+ * Note:
+ * Your algorithm should have a linear runtime complexity.
+ *
+ * Could you implement it without using extra memory?
+ *
+ *
+ * https://discuss.leetcode.com/topic/1916/my-o-n-solution-using-xor/1
+ * Hint: known that A XOR A = 0 and the XOR operator is commutative
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var singleNumber = function (nums) {
+
+    return nums.reduce((ret, n) => ret ^= n, 0);
+
+};
+
+console.log(singleNumber([1, 2, 2]) == 1);
+console.log(singleNumber([1, 2, 1]) == 2);
diff --git a/Easy_190_Reverse_Bits.js b/Easy_190_Reverse_Bits.js
@@ -0,0 +1,30 @@
+/**
+ * https://leetcode.com/problems/reverse-bits/#/description
+ *
+ * Reverse bits of a given 32 bits unsigned integer.
+ *
+ * For example, given input 43261596 (represented in binary as 00000010100101000001111010011100),
+ *
+ * return 964176192 (represented in binary as 00111001011110000010100101000000).
+ *
+ * 00000010100101000001111010011100
+ * 00111001011110000010100101000000
+ */
+
+/**
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ */
+var reverseBits = function (n) {
+    // reverse binary str
+    var str = '';
+    var i = 32;
+    while (i--) {
+        str += n % 2;
+        n = Math.floor(n / 2);
+    }
+
+    return parseInt(str, 2);
+};
+
+console.log(reverseBits(43261596) == 964176192);
diff --git a/Easy_191_Number_of_1_Bits.js b/Easy_191_Number_of_1_Bits.js
@@ -0,0 +1,29 @@
+/**
+ *
+ * https://leetcode.com/problems/number-of-1-bits/#/description
+ *
+ * Write a function that takes an unsigned integer and returns the number of ’1' bits it has
+ * (also known as the Hamming weight).
+ *
+ * For example, the 32-bit integer ’11' has binary representation
+ * 00000000000000000000000000001011, so the function should return 3.
+ */
+
+/**
+ * @param {number} n - a positive integer
+ * @return {number}
+ */
+var hammingWeight = function (n) {
+    var weight = 0;
+
+    while (n > 0) {
+        weight += n % 2;
+        n = Math.floor(n / 2);
+    }
+    return weight;
+
+};
+
+console.log(hammingWeight(11) == 3);
+console.log(hammingWeight(0) == 0);
+console.log(hammingWeight(1) == 1);
