Add medium problems

Author: das-jishu

Leetcode/medium/map-sum-pairs.py

@@ -0,0 +1,75 @@
+"""
+# MAP SUM PAIRS
+
+Implement the MapSum class:
+
+MapSum() Initializes the MapSum object.
+void insert(String key, int val) Inserts the key-val pair into the map. If the key already existed, the original key-value pair will be overridden to the new one.
+int sum(string prefix) Returns the sum of all the pairs' value whose key starts with the prefix.
+ 
+Example 1:
+
+Input
+["MapSum", "insert", "sum", "insert", "sum"]
+[[], ["apple", 3], ["ap"], ["app", 2], ["ap"]]
+Output
+[null, null, 3, null, 5]
+
+Explanation
+MapSum mapSum = new MapSum();
+mapSum.insert("apple", 3);  
+mapSum.sum("ap");           // return 3 (apple = 3)
+mapSum.insert("app", 2);    
+mapSum.sum("ap");           // return 5 (apple + app = 3 + 2 = 5)
+ 
+
+Constraints:
+
+1 <= key.length, prefix.length <= 50
+key and prefix consist of only lowercase English letters.
+1 <= val <= 1000
+At most 50 calls will be made to insert and sum.
+"""
+
+class MapSum:
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.root = {}
+        self.endSymbol = "*"
+
+    def insert(self, key: str, val: int) -> None:
+        current = self.root
+        for letter in key:
+            if letter not in current:
+                current[letter] = {}
+            current = current[letter]
+        
+        current[self.endSymbol] = val
+
+    def sum(self, prefix: str) -> int:
+        current = self.root
+        for letter in prefix:
+            if letter not in current:
+                return 0
+            current = current[letter]
+        
+        return self.getSum(current)
+    
+    def getSum(self, trieNode):
+        currentSum = 0
+        for letter in trieNode:
+            if letter == self.endSymbol:
+                currentSum += trieNode[letter]
+            else:
+                currentSum += self.getSum(trieNode[letter])
+            
+        return currentSum
+
+
+# Your MapSum object will be instantiated and called as such:
+# obj = MapSum()
+# obj.insert(key,val)
+# param_2 = obj.sum(prefix)

Leetcode/medium/top-k-frequent-words.py

@@ -0,0 +1,60 @@
+"""
+# TOP K FREQUENT WORDS
+
+Given a non-empty list of words, return the k most frequent elements.
+
+Your answer should be sorted by frequency from highest to lowest. If two words have the same frequency, then the word with the lower alphabetical order comes first.
+
+Example 1:
+Input: ["i", "love", "leetcode", "i", "love", "coding"], k = 2
+Output: ["i", "love"]
+Explanation: "i" and "love" are the two most frequent words.
+    Note that "i" comes before "love" due to a lower alphabetical order.
+Example 2:
+Input: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
+Output: ["the", "is", "sunny", "day"]
+Explanation: "the", "is", "sunny" and "day" are the four most frequent words,
+    with the number of occurrence being 4, 3, 2 and 1 respectively.
+Note:
+You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
+Input words contain only lowercase letters.
+Follow up:
+Try to solve it in O(n log k) time and O(n) extra space.
+"""
+
+class Solution:
+    def topKFrequent(self, words: List[str], k: int) -> List[str]:
+        frequency = {}
+        trie = Trie()
+        for word in words:
+            freq = trie.insert(word)
+            if freq == 1:
+                frequency[word] = 1
+            else:
+                frequency[word] += 1
+                
+        wordList = []
+        for word in frequency:
+            wordList.append((word, frequency[word]))
+            
+        wordList.sort(key = lambda x: (-x[1], x[0]))
+        return (word[0] for word in wordList[:k])
+            
+    
+class Trie:
+    def __init__(self):
+        self.root = {}
+        self.endSymbol = "*"
+        
+    def insert(self, word):
+        current = self.root
+        for letter in word:
+            if letter not in current:
+                current[letter] = {}
+            current = current[letter]
+        if self.endSymbol not in current:
+            current[self.endSymbol] = 0
+        
+        current[self.endSymbol] += 1
+        return current[self.endSymbol]
+