Added 4 solutions

varunu28 · varunu28 · commit 4c9a3a9da9a5 · 2019-08-18T09:10:34.000-07:00
diff --git a/Easy/Day of the Year.java b/Easy/Day of the Year.java
@@ -0,0 +1,37 @@
+class Solution {
+    List<Integer> daysInMonth = Arrays.asList(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
+    public int dayOfYear(String date) {
+        int year = Integer.parseInt(date.split("-")[0]);
+        int month = Integer.parseInt(date.split("-")[1]);
+        int day = Integer.parseInt(date.split("-")[2]);
+        
+        int numOfDays = getNumOfDays(month, isLeapYear(year));
+        
+        return numOfDays + day;
+    }
+    
+    private boolean isLeapYear(int year) {
+        if (year % 4 == 0) {
+            if (year % 100 == 0) {
+                return year % 400 == 0;
+            }
+            else {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    private int getNumOfDays(int month, boolean isLeapYear) {
+        int numOfDays = 0;
+        for (int i = 1; i < month; i++) {
+            if (i == 2) {
+                numOfDays += isLeapYear ? daysInMonth.get(i - 1) + 1 : daysInMonth.get(i - 1);            
+            } 
+            else {
+                numOfDays += daysInMonth.get(i - 1);
+            }
+        }
+        return numOfDays;
+    }
+}
diff --git a/Easy/Find Words That Can Be Formed by Characters.java b/Easy/Find Words That Can Be Formed by Characters.java
@@ -0,0 +1,33 @@
+class Solution {
+    public int countCharacters(String[] words, String chars) {
+        int goodWordsLength = 0;
+        Map<Character, Integer> charsMap = getMap(chars);
+
+        for (String word : words) {
+            Map<Character, Integer> wordMap = getMap(word);
+            boolean allFound = true;
+            for (Character character : wordMap.keySet()) {
+                if (charsMap.getOrDefault(character, 0) < wordMap.get(character)) {
+                    allFound = false;
+                    break;
+                }
+            }
+
+            if (allFound) {
+                goodWordsLength +=word.length();
+            }
+        }
+
+
+        return goodWordsLength;
+    }
+
+    private Map<Character, Integer> getMap(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+
+        return map;
+    }
+}
diff --git a/Medium/As Far from Land as Possible.java b/Medium/As Far from Land as Possible.java
@@ -0,0 +1,36 @@
+class Solution {
+    public int maxDistance(int[][] grid) {
+        if (grid.length == 0 || grid[0].length == 0) {
+            return -1;
+        }
+        int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+        boolean[][] visited = new boolean[grid.length][grid[0].length];
+        Queue<int[]> queue = new LinkedList<>();
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1) {
+                    queue.add(new int[]{i, j});
+                    visited[i][j] = true;
+                }
+            }
+        }
+        int maxDist = -1;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] curr = queue.remove();
+                for (int[] dir : dirs) {
+                    int x = curr[0] + dir[0];
+                    int y = curr[1] + dir[1];
+                    if (x >= 0 &&  x < grid.length && y >= 0 && y < grid[0].length && !visited[x][y] && grid[x][y] == 0) {
+                        visited[x][y] = true;
+                        queue.add(new int[]{x, y});
+                    }
+                }
+            }
+            maxDist++;
+        }
+
+        return maxDist == 0 ? -1 : maxDist;
+    }
+}
diff --git a/Medium/Maximum Level Sum of a Binary Tree.java b/Medium/Maximum Level Sum of a Binary Tree.java
@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int maxLevelSum(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        int maxSum = 0;
+        int maxLevel = 1;
+        int currLevel = 1;
+        
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            int tempSum = 0;
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                tempSum += removed.val;
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            if (maxSum < tempSum) {
+                maxSum = tempSum;
+                maxLevel = currLevel;
+            }
+            currLevel++;
+        }
+        
+        return maxLevel;
+    }
+}
