add more solutions

Author: chihungyu1116

243 Shortest Word Distance.js

@@ -0,0 +1,34 @@
+// Given a list of words and two words word1 and word2, return the shortest distance between these two words in the list.
+
+// For example,
+// Assume that words = ["practice", "makes", "perfect", "coding", "makes"].
+
+// Given word1 = “coding”, word2 = “practice”, return 3.
+// Given word1 = "makes", word2 = "coding", return 1.
+
+// Note:
+// You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.
+
+// Hide Company Tags LinkedIn
+// Hide Tags
+
+
+var shortestDistance = function(words, word1, word2) {
+    var idx1 = -1;
+    var idx2 = -1;
+    var dist = words.length - 1;
+    
+    for(var i = 0; i < words.length; i++) {
+        if(words[i] === word1) {
+            idx1 = i;
+        } else if(words[i] === word2) {
+            idx2 = i;
+        }
+      
+        if(idx1 !== -1 && idx2 !== -1) {
+          dist = Math.min(dist, Math.abs(idx1 - idx2))
+        }
+    }
+    
+    return dist;
+};

244 Shortest Word Distance II.js

@@ -0,0 +1,67 @@
+// This is a follow up of Shortest Word Distance. The only difference is now you are given the list of words and your method will be called repeatedly many times with different parameters. How would you optimize it?
+
+// Design a class which receives a list of words in the constructor, and implements a method that takes two words word1 and word2 and return the shortest distance between these two words in the list.
+
+// For example,
+// Assume that words = ["practice", "makes", "perfect", "coding", "makes"].
+
+// Given word1 = “coding”, word2 = “practice”, return 3.
+// Given word1 = "makes", word2 = "coding", return 1.
+
+// Note:
+// You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.
+
+// Hide Company Tags LinkedIn
+// Hide Tags Hash Table Design
+// Show Similar Problems
+
+
+/**
+ * @constructor
+ * @param {string[]} words
+ */
+var WordDistance = function(words) {
+    this.positions = {};
+    
+    for(var i = 0; i < words.length; i++) {
+        var word = words[i];
+        
+        this.positions[word] = this.positions[word] || [];
+        this.positions[word].push(i);
+    }
+};
+
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {integer}
+ */
+WordDistance.prototype.shortest = function(word1, word2) {
+    var i = 0;
+    var j = 0;
+    var dist = Infinity;
+    var pos1 = this.positions[word1];
+    var pos2 = this.positions[word2];
+    
+    while(i < pos1.length && j < pos2.length) {
+        var i1 = pos1[i];
+        var i2 = pos2[j];
+        
+        dist = Math.min(dist, Math.abs(i1 - i2));
+        
+        if(i1 < i2) {
+            i++;
+        } else {
+            j++;
+        }
+    }
+    
+    return dist;
+};
+
+/**
+ * Your WordDistance object will be instantiated and called as such:
+ * var wordDistance = new WordDistance(words);
+ * wordDistance.shortest("word1", "word2");
+ * wordDistance.shortest("anotherWord1", "anotherWord2");
+ */

245 Shortest Word Distance III.js

@@ -0,0 +1,49 @@
+// This is a follow up of Shortest Word Distance. The only difference is now word1 could be the same as word2.
+
+// Given a list of words and two words word1 and word2, return the shortest distance between these two words in the list.
+
+// word1 and word2 may be the same and they represent two individual words in the list.
+
+// For example,
+// Assume that words = ["practice", "makes", "perfect", "coding", "makes"].
+
+// Given word1 = “makes”, word2 = “coding”, return 1.
+// Given word1 = "makes", word2 = "makes", return 3.
+
+// Note:
+// You may assume word1 and word2 are both in the list.
+
+// Hide Company Tags LinkedIn
+// Hide Tags Array
+// Hide Similar Problems
+
+
+/**
+ * @param {string[]} words
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+var shortestWordDistance = function(words, word1, word2) {
+    var idx1 = -1;
+    var idx2 = -1;
+    var dist = words.length - 1;
+    
+    for(var i = 0; i < words.length; i++) {
+        if(words[i] === word1) {
+            if(words[idx1] === word1 && word1 === word2) {
+                idx2 = idx1;
+            }
+            
+            idx1 = i;
+        } else if(words[i] === word2) {
+            idx2 = i;
+        }
+      
+        if(idx1 !== -1 && idx2 !== -1) {
+          dist = Math.min(dist, Math.abs(idx1 - idx2))
+        }
+    }
+    
+    return dist;
+};

277 Find the Celebrity.js

@@ -0,0 +1,59 @@
+// Suppose you are at a party with n people (labeled from 0 to n - 1) and among them, there may exist one celebrity. The definition of a celebrity is that all the other n - 1 people know him/her but he/she does not know any of them.
+
+// Now you want to find out who the celebrity is or verify that there is not one. The only thing you are allowed to do is to ask questions like: "Hi, A. Do you know B?" to get information of whether A knows B. You need to find out the celebrity (or verify there is not one) by asking as few questions as possible (in the asymptotic sense).
+
+// You are given a helper function bool knows(a, b) which tells you whether A knows B. Implement a function int findCelebrity(n), your function should minimize the number of calls to knows.
+
+// Note: There will be exactly one celebrity if he/she is in the party. Return the celebrity's label if there is a celebrity in the party. If there is no celebrity, return -1.
+
+// Hide Company Tags LinkedIn Facebook
+// Show Tags
+
+
+
+/**
+ * Definition for knows()
+ * 
+ * @param {integer} person a
+ * @param {integer} person b
+ * @return {boolean} whether a knows b
+ * knows = function(a, b) {
+ *     ...
+ * };
+ */
+
+/**
+ * @param {function} knows()
+ * @return {function}
+ */
+var solution = function(knows) {
+    /**
+     * @param {integer} n Total people
+     * @return {integer} The celebrity
+     */
+    return function(n) {
+        var candidate = 0;
+        
+        // iterate through the list,
+        // if candidate is known by i -> continue
+        // if i doesnt know candidate, i becomes the candidate
+        for(var i = 1; i < n; i++) {
+            if(!knows(i, candidate)) {
+                candidate = i;
+            }
+        }
+        
+        for(i = 0; i < n; i++) {
+            if(i === candidate) {
+                continue;
+            }
+            
+            // if candidate is not known by i or candidate know i
+            if(!knows(i, candidate) || knows(candidate, i)) {
+                return -1;
+            }
+        }
+        
+        return candidate;
+    };
+};

339 Nested List Weight Sum.js

@@ -0,0 +1,64 @@
+// Given a nested list of integers, return the sum of all integers in the list weighted by their depth.
+
+// Each element is either an integer, or a list -- whose elements may also be integers or other lists.
+
+// Example 1:
+// Given the list [[1,1],2,[1,1]], return 10. (four 1's at depth 2, one 2 at depth 1)
+
+// Example 2:
+// Given the list [1,[4,[6]]], return 27. (one 1 at depth 1, one 4 at depth 2, and one 6 at depth 3; 1 + 4*2 + 6*3 = 27)
+
+// Hide Company Tags LinkedIn
+// Show Tags
+// Show Similar Problems
+
+
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * function NestedInteger() {
+ *
+ *     Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     @return {boolean}
+ *     this.isInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     Return null if this NestedInteger holds a nested list
+ *     @return {integer}
+ *     this.getInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     Return null if this NestedInteger holds a single integer
+ *     @return {NestedInteger[]}
+ *     this.getList = function() {
+ *         ...
+ *     };
+ * };
+ */
+/**
+ * @param {NestedInteger[]} nestedList
+ * @return {number}
+ */
+ 
+var depthSum = function(nestedList) {
+    
+    function traverse(arr, lvl) {
+        var sum = 0;
+        
+        for(var i = 0; i < arr.length; i++) {
+            if(arr[i].isInteger()) {
+                sum += arr[i].getInteger()*lvl;
+            } else {
+                sum += traverse(arr[i].getList(), lvl + 1);
+            }
+        }
+        
+        return sum;
+    }
+    
+    return traverse(nestedList, 1);
+};

364 Nested List Weight Sum II.js

@@ -0,0 +1,82 @@
+// Given a nested list of integers, return the sum of all integers in the list weighted by their depth.
+
+// Each element is either an integer, or a list -- whose elements may also be integers or other lists.
+
+// Different from the previous question where weight is increasing from root to leaf, now the weight is defined from bottom up. i.e., the leaf level integers have weight 1, and the root level integers have the largest weight.
+
+// Example 1:
+// Given the list [[1,1],2,[1,1]], return 8. (four 1's at depth 1, one 2 at depth 2)
+
+// Example 2:
+// Given the list [1,[4,[6]]], return 17. (one 1 at depth 3, one 4 at depth 2, and one 6 at depth 1; 1*3 + 4*2 + 6*1 = 17)
+
+// Hide Company Tags LinkedIn
+// Show Tags
+// Show Similar Problems
+
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * function NestedInteger() {
+ *
+ *     Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     @return {boolean}
+ *     this.isInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     Return null if this NestedInteger holds a nested list
+ *     @return {integer}
+ *     this.getInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     Return null if this NestedInteger holds a single integer
+ *     @return {NestedInteger[]}
+ *     this.getList = function() {
+ *         ...
+ *     };
+ * };
+ */
+/**
+ * @param {NestedInteger[]} nestedList
+ * @return {number}
+ */
+var depthSumInverse = function(nestedList) {
+    
+    function getDepth(arr, lvl) {
+        var maxDepth = lvl;
+        
+        for(var i = 0; i < arr.length; i++) {
+            if(!arr[i].isInteger()) {
+                // maxDepth represents the max depth at that level, 
+                // e.g. [[[[55]]],[[31]],[99],[],75]
+                // at lvl 1, we want to know which [[[55]]], [[31]], [99], [], 75
+                // has the maxDepth
+                maxDepth = Math.max(maxDepth, getDepth(arr[i].getList(), lvl + 1));
+            }
+        }
+        
+        return maxDepth;
+    }
+        
+    var depth = getDepth(nestedList, 1);
+    
+    function traverse(arr, lvl) {
+        var sum = 0;
+        
+        for(var i = 0; i < arr.length; i++) {
+            if(arr[i].isInteger()) {
+                sum += arr[i].getInteger()*lvl;
+            } else {
+                sum += traverse(arr[i].getList(), lvl - 1);
+            }
+        }
+        
+        return sum;
+    }
+    
+    return traverse(nestedList, depth);
+};