Added 4 solutions

varunu28 · varunu28 · commit f33674227ec2 · 2018-10-09T11:44:07.000-07:00
diff --git a/Easy/Valid Word Abbrevation.java b/Easy/Valid Word Abbrevation.java
@@ -0,0 +1,31 @@
+class Solution {
+    public static boolean validWordAbbreviation(String word, String abbr) {
+        char[] wordChar = word.toCharArray();
+        char[] abbrChar = abbr.toCharArray();
+
+        int i = 0;
+        int j = 0;
+
+        while (j < abbrChar.length && i < wordChar.length) {
+            if (abbrChar[j] == wordChar[i]) {
+                i++;
+                j++;
+                continue;
+            }
+
+            if (abbrChar[j] <= '0' || abbrChar[j] > '9') {
+                return false;
+            }
+
+            int start = j;
+            while (j<abbrChar.length && abbrChar[j] >= '0' && abbrChar[j] <= '9') {
+                ++j;
+            }
+
+            int num = Integer.valueOf(abbr.substring(start, j));
+            i += num;
+        }
+
+        return i == wordChar.length && j == abbrChar.length;
+    }
+}
diff --git a/Medium/Count Univalue Subtrees.java b/Medium/Count Univalue Subtrees.java
@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    int count = 0;
+    public int countUnivalSubtrees(TreeNode root) {
+        updateCount(root);
+        return count;
+    }
+    
+    private void updateCount(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        
+        if (isUnivalue(root, root.val)) {
+            count++;
+        }
+        
+        updateCount(root.left);
+        updateCount(root.right);
+    }
+    
+    private boolean isUnivalue(TreeNode root, int val) {
+        if (root == null) {
+            return true;
+        }
+        if (root.val != val) {
+            return false;
+        }
+        
+        return isUnivalue(root.left, val) && isUnivalue(root.right, val);
+    }
+}
diff --git a/Medium/Max Consecutives Ones II.java b/Medium/Max Consecutives Ones II.java
@@ -0,0 +1,28 @@
+class Solution {
+    public int findMaxConsecutiveOnes(int[] nums) {
+        int slow = 0;
+        int fast = 0;
+        int max = Integer.MIN_VALUE;
+        boolean flipped = false;
+        int zeroIndex = slow;
+        
+        while (fast < nums.length) {
+            if (nums[fast] != 1) {
+                if (!flipped) {
+                    flipped = true;
+                    zeroIndex = fast;
+                }
+                else {
+                    max = Math.max(max, fast - slow);
+                    slow = zeroIndex + 1;
+                    flipped = false;
+                    fast = zeroIndex;
+                }
+            }
+            
+            fast++;
+        }
+        
+        return Math.max(max, fast-slow);
+    }
+}
diff --git a/Medium/Sort Transformed Array.java b/Medium/Sort Transformed Array.java
@@ -0,0 +1,24 @@
+class Solution {
+    public static int[] sortTransformedArray(int[] nums, int a, int b, int c) {
+        int[] ans = new int[nums.length];
+        int start = 0;
+        int end = nums.length-1;
+
+        int index = a >= 0 ? end : start;
+
+        while (start <= end){
+            if (a >= 0) {
+                ans[index--] = getQuad(nums[start], a, b, c) >= getQuad(nums[end], a, b, c) ? getQuad(nums[start++], a, b, c) : getQuad(nums[end--], a, b, c);
+            }
+            else {
+                ans[index++] = getQuad(nums[start], a, b, c) >= getQuad(nums[end], a, b, c) ? getQuad(nums[end--], a, b, c) : getQuad(nums[start++], a, b, c);
+            }
+        }
+
+        return ans;
+    }
+
+    private static int getQuad(int num, int a, int b, int c) {
+        return a *(num * num) + b * num + c;
+    }
+}
