Added 4 solutions

varunu28 · varunu28 · commit 0c646a38977b · 2018-10-01T09:37:32.000-07:00
diff --git a/Medium/Masking Personal Information.java b/Medium/Masking Personal Information.java
@@ -0,0 +1,76 @@
+class Solution {
+    public static String maskPII(String S) {
+        if (S.length() == 0) {
+            return S;
+        }
+        
+        if (S.indexOf('@') != -1) {
+            return formatEmail(S);
+        }
+        else {
+            return formatNumber(S);
+        }
+    }
+
+    private static String formatNumber(String s) {
+        StringBuilder sb = new StringBuilder();
+        int digitCount = getDigitCount(s);
+
+        if (digitCount > 10) {
+            sb.append("+");
+            int extra = digitCount - 10;
+            while (extra-- > 0) {
+                sb.append("*");
+            }
+            sb.append("-");
+        }
+        sb.append("***-***-");
+
+        StringBuilder last4 = new StringBuilder();
+        for (int i=s.length()-1; i>=0; i--) {
+            if (Character.isDigit(s.charAt(i))) {
+                last4.append(s.charAt(i));
+            }
+
+            if (last4.length() == 4) {
+                break;
+            }
+        }
+
+        sb.append(last4.reverse().toString());
+
+        return sb.toString();
+    }
+
+    private static int getDigitCount(String s) {
+        char[] chars = s.toCharArray();
+        int count = 0;
+
+        for (char c : chars) {
+            if (Character.isDigit(c)) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+    private static String formatEmail(String s) {
+        int idx = s.indexOf('@');
+        int revStart = idx - 1;
+        while (revStart >= 0 && Character.isLetter(s.charAt(revStart))) {
+            revStart--;
+        }
+
+        StringBuilder sb = new StringBuilder();
+
+        sb.
+        append(s.substring(0, revStart+1)).
+        append(Character.toLowerCase(s.charAt(revStart + 1))).
+        append("*****").
+        append(Character.toLowerCase(s.charAt(s.indexOf('@') - 1))).
+        append(s.substring(s.indexOf('@')));
+
+        return sb.toString().toLowerCase();
+    }
+}
diff --git a/Medium/Maximum Width of Binary Tree.java b/Medium/Maximum Width of Binary Tree.java
@@ -0,0 +1,64 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int widthOfBinaryTree(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        
+        List<TreeNode> list = new ArrayList<>();
+        list.add(root);
+        int res = 1;
+        
+        while (list.size() != 0) {
+            List<TreeNode> temp = new ArrayList<>();
+            for (TreeNode node : list) {
+                if(node == null) {
+                    temp.add(null);
+                    temp.add(null);
+                }
+                else {
+                    temp.add(node.left);
+                    temp.add(node.right);
+                }
+            }
+            
+            temp = removeExtraNull(temp);
+            res = Math.max(res, temp.size());
+            list = temp;
+        }
+        
+        return res;
+    }
+    
+    private List<TreeNode> removeExtraNull(List<TreeNode> list) {
+        List<TreeNode> ans = new ArrayList<>();
+        if (list.size() == 0) {
+            return ans;
+        }
+        
+        int start = 0;
+        int end = list.size() - 1;
+        
+        while (start <= end && list.get(start) == null) {
+            start++;
+        }
+        
+        while (end >= 0 && list.get(end) == null) {
+            end--;
+        }
+        
+        while (start <= end) {
+            ans.add(list.get(start++));
+        }
+        
+        return ans;
+    }
+}
diff --git a/Medium/Super Ugly Number.java b/Medium/Super Ugly Number.java
@@ -0,0 +1,28 @@
+class Solution {
+    public static int nthSuperUglyNumber(int n, int[] primes) {
+        int[] arr = new int[n+1];
+        arr[0] = 1;
+
+        int[] counter = new int[primes.length];
+
+        for (int i=1; i<n; i++) {
+            int temp = Integer.MAX_VALUE;
+            int idx = -1;
+
+            for (int j=0; j<primes.length; j++) {
+                if (primes[j]*arr[counter[j]] < temp) {
+                    temp = primes[j]*arr[counter[j]];
+                    idx = j;
+                }
+                else if (primes[j]*arr[counter[j]] == temp) {
+                    counter[j]++;
+                }
+            }
+
+            arr[i] = temp;
+            counter[idx]++;
+        }
+
+        return arr[n-1];
+    }
+}
diff --git a/Medium/Ugly Number II.java b/Medium/Ugly Number II.java
@@ -0,0 +1,35 @@
+class Solution {
+    public static int nthUglyNumber(int n) {
+        int[] arr = new int[n];
+        arr[0] = 1;
+        int i2 = 0;
+        int i3 = 0;
+        int i5 = 0;
+
+        int mul2 = 2;
+        int mul3 = 3;
+        int mul5 = 5;
+
+        int ugly = 1;
+
+        for (int i=1; i<n; i++) {
+            ugly = Math.min(mul2, Math.min(mul3, mul5));
+            arr[i] = ugly;
+
+            if (ugly == mul2) {
+                i2++;
+                mul2 = arr[i2]*2;
+            }
+            if (ugly == mul3) {
+                i3++;
+                mul3 = arr[i3]*3;
+            }
+            if (ugly == mul5) {
+                i5++;
+                mul5 = arr[i5]*5;
+            }
+        }
+
+        return ugly;
+    }
+}
