Add solution for leetcode #146

JavaScript/146.LRU-Cache.js

@@ -0,0 +1,91 @@
+/**
+ * Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.
+
+Implement the LRUCache class:
+
+LRUCache(int capacity) Initialize the LRU cache with positive size capacity.
+int get(int key) Return the value of the key if the key exists, otherwise return -1.
+void put(int key, int value) Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.
+Follow up:
+Could you do get and put in O(1) time complexity?
+
+
+
+Example 1:
+
+Input
+["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
+[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+Output
+[null, null, null, 1, null, -1, null, -1, 3, 4]
+
+Explanation
+LRUCache lRUCache = new LRUCache(2);
+lRUCache.put(1, 1); // cache is {1=1}
+lRUCache.put(2, 2); // cache is {1=1, 2=2}
+lRUCache.get(1);    // return 1
+lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3}
+lRUCache.get(2);    // returns -1 (not found)
+lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
+lRUCache.get(1);    // return -1 (not found)
+lRUCache.get(3);    // return 3
+lRUCache.get(4);    // return 4
+
+
+Constraints:
+
+1 <= capacity <= 3000
+0 <= key <= 3000
+0 <= value <= 104
+At most 3 * 104 calls will be made to get and put.
+ */
+
+/**
+ * @param {number} capacity
+ */
+var LRUCache = function (capacity) {
+  this.cache = new Map();
+  this.capacity = capacity;
+};
+
+/**
+ * @param {number} key
+ * @return {number}
+ */
+LRUCache.prototype.get = function (key) {
+  if (!this.cache.has(key)) {
+    return -1;
+  }
+  const value = this.cache.get(key);
+  this.cache.delete(key);
+  this.cache.set(key, value);
+  return value;
+};
+
+/**
+ * @param {number} key
+ * @param {number} value
+ * @return {void}
+ */
+LRUCache.prototype.put = function (key, value) {
+  if (this.capacity <= 0) {
+    return;
+  }
+  if (this.cache.has(key)) {
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return;
+  }
+  if (this.cache.size >= this.capacity) {
+    const removedKey = this.cache.keys().next().value;
+    this.cache.delete(removedKey);
+  }
+  this.cache.set(key, value);
+};
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * var obj = new LRUCache(capacity)
+ * var param_1 = obj.get(key)
+ * obj.put(key,value)
+ */

README.md

@@ -205,7 +205,8 @@ Check out ---> [Sample PR](https://github.com/codedecks-in/LeetCode-Solutions/pu
 | 242 | [Valid Anagram](https://leetcode.com/problems/valid-anagram/) | [Java](./Java/valid-anagram.java)                               | _O(n)_ | _O(1)_ | Easy       |     | [Tutorial](https://www.youtube.com/watch?v=sbX1Ze9lNQE) |
 | 146 | [LRU Cache](https://leetcode.com/problems/lru-cache/)         | [Java](./Java/LRU-Cache.java)                                   |        |        | Medium     |     |                                                         |
 | 217 | [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/)         | [Python](./Python/contains-duplicate.py)      | _O(n)_ | _O(n)_ |            |     |
-| 554 | [Brick Wall](https://leetcode.com/problems/brick-wall/) | [C++](./C++/brick-walls.cpp)| _O(n)_ | _O(n)_ | Medium     |     |
+| 554 | [Brick Wall](https://leetcode.com/problems/brick-wall/)         | [C++](./C++/brick-walls.cpp)      | _O(n)_ | _O(n)_ |      Medium      |     |
+| 146 | [LRU Cache](https://leetcode.com/problems/lru-cache/)         | [Javascript](../JavaScript/146.LRU-Cache.js)      | _O(log(n))_ | _O(n)_ |    Medium        |     |
 
 <br/>
 <div align="right">