090?

Author: coffeexy

climbing-stairs.js

@@ -0,0 +1,39 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+    var result = 0
+    function me(num) {
+        if (num === 0 || num === 1) {
+            result++
+            return
+        }
+        me(num-2)
+        me(num-1)
+    }
+    me(n)
+    return result  
+};
+/**
+ * 递归的做法，有点慢，超时了
+ * 第n个等于，第n-1 和 n-2 的和
+ * 斐波那契数列
+ */
+var climbStairs = function(n) {
+    if(n <= 2) return n
+    return climbStairs(n-1) + climbStairs(n-2)
+};
+
+var climbStairs = function(n) {
+    if(n <= 3) return n
+    var a = 2
+    var b = 3
+    var result = 5
+    for (let i = 5; i <= n; i++) {  
+        a = result;  
+        result += b;  
+        b = a;
+    }  
+    return result;
+};

contains-duplicate-ii.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {boolean}
+ */
+var containsNearbyDuplicate = function(nums, k) {
+    var len = nums.length
+    if (len <= 1) return false
+    
+    var map = new Map()
+    for (let i = 0; i < len; i++) {
+        let key = nums[i]
+        if (map.has(key) && i-map.get(key) <= k) return true
+        map.set(key, i)
+    }
+    return false
+};

contains-duplicate.js

@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+
+var containsDuplicate = function(nums) {
+    var len = nums.length
+    if (len <= 1) return false
+    
+    var map = new Map()
+    for (let i = 0; i < len; i++) {
+        let key = nums[i]
+        map.set(key, map.has(key) ? map.get(key) + 1 : 1)
+    }
+    
+    for (let [key, value] of map) {
+        if (value > 1) return true
+    }
+    return false
+};
+
+/**
+ * 上面那个 map 做法要写成精了
+ * 用set优化一下，一个遍历
+ */
+var containsDuplicate = function(nums) {
+    var len = nums.length
+    if (len <= 1) return false
+    
+    var map = new Set()
+    for (let i = 0; i < len; i++) {
+        let key = nums[i]
+        if(map.has(key)) return true
+        map.add(key)
+    }
+    return false
+};

excel-sheet-column-number.js

@@ -0,0 +1,13 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var titleToNumber = function(s) {
+    var len = s.length
+    var result = 0
+    for (let i = 0; i < len; i++) {
+        let x = s.charCodeAt(i) - 64
+        result += x * Math.pow(26, len-1-i)
+    }
+    return result
+};

excel-sheet-column-title.js

@@ -0,0 +1,9 @@
+/**
+ * @param {number} n
+ * @return {string}
+ */
+var convertToTitle = function(n) {
+    n = n - 1
+    if (n < 26) return String.fromCharCode(n + 65)
+    return convertToTitle(~~(n/26)) + String.fromCharCode(n%26 + 65)
+};

factorial-trailing-zeroes.js

@@ -0,0 +1,8 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var trailingZeroes = function(n) {
+    n = ~~(n/5)
+    return n === 0 ? 0 : n + trailingZeroes(n);
+};

happy-number.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+
+
+var isHappy = function(n) {
+    var map = new Set()
+    
+    function me(n) {
+        if (n===1) return true
+        
+        var result = 0
+        if (map.has(n)) return false
+        
+        map.add(n)
+        
+        while (n) {
+            result += Math.pow(n%10, 2)
+            n = ~~(n/10)
+        }
+        
+        return me(result)
+    }
+    
+        
+    return me(n)
+};

house-robber.js

@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function(nums) {
+    
+    var sum = 0
+    var result = 0
+    
+    function me(i) {
+        // 选还是不选，取决于选了这个数，sum更大
+        if(i >= nums.length) {
+            result = Math.max(sum, result)
+            return
+        }
+        // 不选
+        me(i+1)
+        // 选
+        sum += nums[i]
+        me(i+2)
+        sum -= nums[i]
+    }
+    me(0)
+    return result
+};

integer-to-roman.js

@@ -0,0 +1,36 @@
+/**
+ * @param {number} num
+ * @return {string}
+ */
+var romanint = function(n) {
+    switch(n) {  
+        case 1: return 'I';  
+        case 5: return 'V';  
+        case 10: return 'X';  
+        case 50: return 'L';  
+        case 100: return 'C';  
+        case 500: return 'D';  
+        case 1000: return 'M';  
+        default: return '';  
+    }
+}
+var intToRoman = function(num) {
+    var scale = [1000, 500, 100, 50, 10, 5, 1]
+    var result = []
+    let i = 0
+    
+    while (num && i <= 6) {
+        var x = ~~(num/scale[i])
+        
+        if (x === 4) result += romanint(scale[i]) + romanint(scale[i-1])
+        while (x>0 && x<4) {
+            result += romanint(scale[i])
+            x--
+        }
+        
+        num = num%scale[i]
+        i++
+        
+    }
+    return result.replace(/VIV/, 'IX').replace(/DCD/, 'CM').replace(/LXL/, 'XC')
+};

roman-to-integer.js

@@ -0,0 +1,27 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var romanint = function(c) {
+    switch(c) {  
+        case 'I': return 1;  
+        case 'V': return 5;  
+        case 'X': return 10;  
+        case 'L': return 50;  
+        case 'C': return 100;  
+        case 'D': return 500;  
+        case 'M': return 1000;  
+        default: return 0;  
+    }
+}
+var romanToInt = function(s) {
+    var len = s.length
+    var result = 0
+    for( let i = 0; i < len; i++) {
+        result += romanint(s[i])
+        if (i > 0 && romanint(s[i]) > romanint(s[i-1])) {
+            result -= 2*romanint(s[i-1])
+        }
+    }
+    return result
+};

swap-nodes-in-pairs.js

@@ -0,0 +1,24 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var swapPairs = function(head) {
+    if (!head || !head.next) return head
+
+    var pointer = head
+    while(pointer && pointer.next) {
+        let temp = pointer.next.val
+        pointer.next.val = pointer.val
+        pointer.val = temp
+        
+        pointer = pointer.next.next
+    }
+    return head
+};

ugly-number.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number} num
+ * @return {boolean}
+ */
+var isUgly = function(num) {
+    if (num === 1 || num === 2 || num === 3 || num === 5) return true
+    if (num <= 0) return false
+    
+    while(num) {
+        if (num === 1 || num === 2 || num === 3 || num === 5) return true
+        if (num%2 && num%3 && num%5) return false
+        if (num%2 === 0) num = num/2
+        else if (num%3 === 0) num = num/3
+        else if (num%5 === 0) num = num/5
+    }
+    return true
+};

valid-anagram.js

@@ -0,0 +1,24 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function(s, t) {
+    if (s === t) return true
+    
+    var len = s.length
+    if (len !== t.length) return false
+    
+    var smap = new Map()
+    var tmap = new Map()
+    for (let i = 0; i < len; i++) {
+        let skey = s[i]
+        let tkey = t[i]
+        smap.set(skey, smap.has(skey) ? smap.get(skey) + 1 : 1)
+        tmap.set(tkey, tmap.has(tkey) ? tmap.get(tkey) + 1 : 1)
+    }
+    for (let [key, value] of smap) {
+        if (value !== tmap.get(key)) return false
+    }
+    return true
+};