Added 4 medium solutions

varunu28 · varunu28 · commit e71da8b1664a · 2018-09-26T09:04:16.000-07:00
diff --git a/Medium/Binary Search Tree Iterator.java b/Medium/Binary Search Tree Iterator.java
@@ -0,0 +1,54 @@
+/**
+ * Definition for binary tree
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class BSTIterator {
+    
+    Stack<TreeNode> stack;
+    public BSTIterator(TreeNode root) {
+        stack = new Stack<>();
+        TreeNode curr = root;
+        while(curr != null) {
+            stack.push(curr);
+            curr = curr.left;
+        }
+    }
+
+    /** @return whether we have a next smallest number */
+    public boolean hasNext() {
+        return !stack.empty();
+    }
+
+    /** @return the next smallest number */
+    public int next() {
+        TreeNode node = stack.pop();
+        TreeNode curr = node;
+        
+        if (curr.right != null) {
+            curr = curr.right;
+            while(curr != null) {
+                stack.push(curr);
+                if (curr.left != null) {
+                    curr = curr.left;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        
+        return node.val;
+    }
+}
+
+/**
+ * Your BSTIterator will be called like this:
+ * BSTIterator i = new BSTIterator(root);
+ * while (i.hasNext()) v[f()] = i.next();
+ */
diff --git a/Medium/Hand of Straights.java b/Medium/Hand of Straights.java
@@ -0,0 +1,41 @@
+class Solution {
+    public static boolean isNStraightHand(int[] hand, int W) {
+        if (hand.length%W != 0) {
+            return false;
+        }
+
+        Map<Integer, Integer> map = new TreeMap<>();
+
+        for (int num : hand) {
+            map.put(num, map.getOrDefault(num, 0)+1);
+        }
+
+        Set<Integer> keys;
+        int batches = hand.length/W;
+        int batchSize;
+
+        while (batches-- > 0) {
+            keys = map.keySet();
+            Iterator<Integer> iterator = keys.iterator();
+            batchSize = W;
+            int val = iterator.next();
+
+            while (batchSize-- > 0) {
+                if (map.containsKey(val)) {
+                    if (map.get(val) == 1) {
+                        map.remove(val);
+                    }
+                    else {
+                        map.put(val, map.getOrDefault(val, 0)-1);
+                    }
+                    val++;
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/Medium/Is Subsequence.java b/Medium/Is Subsequence.java
@@ -0,0 +1,21 @@
+class Solution {
+    public boolean isSubsequence(String s, String t) {
+        char[] sChar = s.toCharArray();
+        char[] tChar = t.toCharArray();
+        
+        int i=0;
+        int j=0;
+        int low = s.length();
+        int high = t.length();
+        
+        while(i<low && j<high) {
+            if (sChar[i] == tChar[j]) {
+                i++;
+            }
+            
+            j++;
+        }
+        
+        return i == low;
+    }
+}
diff --git a/Medium/Number of Matching Subsequence.java b/Medium/Number of Matching Subsequence.java
@@ -0,0 +1,45 @@
+class Solution {
+    public int numMatchingSubseq(String S, String[] words) {
+        int count = 0;
+        Set<String> match = new HashSet<>();
+        Set<String> unmatch = new HashSet<>();
+        
+        for (String word : words) {
+            if (match.contains(word)) {
+                count++;
+            }
+            else if (unmatch.contains(word)) {
+                continue;
+            }
+            else if (isSubsequence(word, S)) {
+                match.add(word);
+                count++;
+            }
+            else {
+                unmatch.add(word);
+            }
+        }
+        
+        return count;
+    }
+    
+    private boolean isSubsequence(String s, String t) {
+        char[] sChar = s.toCharArray();
+        char[] tChar = t.toCharArray();
+        
+        int i=0;
+        int j=0;
+        int low = s.length();
+        int high = t.length();
+        
+        while(i<low && j<high) {
+            if (sChar[i] == tChar[j]) {
+                i++;
+            }
+            
+            j++;
+        }
+        
+        return i == low;
+    }
+}
