Added 1 solution

Author: varunu28

Easy/Find the Town Judge.java

@@ -0,0 +1,18 @@
+class Solution {
+    public int findJudge(int N, int[][] trust) {
+        int[] count = new int[N + 1];
+        
+        for (int[] item : trust) {
+            count[item[0]]--;
+            count[item[1]]++;
+        }
+        
+        for (int i = 1; i <= N; i++) {
+            if (count[i] == N - 1) {
+                return i;
+            }
+        }
+        
+        return -1;
+    }
+}

Easy/Nested List Weight Sum.java

@@ -27,23 +27,20 @@
  * }
  */
 class Solution {
-    int sum = 0;
-    
+    int sum;
     public int depthSum(List<NestedInteger> nestedList) {
-        for (NestedInteger n : nestedList) {
-            dfsHelper(n, 1);
-        }    
-        
+        sum = 0;
+        helper(nestedList, 1);
         return sum;
     }
 
-    private void dfsHelper(NestedInteger n, int depth) {
-        if (n.isInteger()) {
-            sum += n.getInteger() * depth;
-        }
-        else {
-            for (NestedInteger i : n.getList()) {
-                dfsHelper(i, depth+1);
+    private void helper(List<NestedInteger> nestedList, int level) {
+        for (NestedInteger nested : nestedList) {
+            if (nested.isInteger()) {
+                sum += nested.getInteger() * level;
+            }
+            else {
+                helper(nested.getList(), level + 1);
             }
         }
     }

Medium/Missing Ranges.java

@@ -1,109 +1,31 @@
 class Solution {
-    public static List<String> findMissingRanges(int[] nums, int lower, int upper) {
+    public List<String> findMissingRanges(int[] nums, int lower, int upper) {
         List<String> list = new ArrayList<>();
-
-        if (nums.length == 0) {
-            list.add(getString(lower, upper));
-            return list;
-        }
-
-        List<String> range = getRange(nums);
-        int i = 0;
-
-        while (lower <= upper && i < range.size()) {
-            String s = range.get(i);
-            if (s.indexOf('>') != -1) {
-                int start = Integer.parseInt(s.split("->")[0]);
-                int end = Integer.parseInt(s.split("->")[1]);
-
-                if (lower != start) {
-                    list.add(getString(lower, start-1));
-                }
-
-                lower = end + 1;
-            }
-            else {
-                int num = Integer.parseInt(s);
-                if (lower != num) {
-                    list.add(getString(lower, num-1));
-                }
-
-                lower = num + 1;
-            }
-
-            i++;
-        }
-
-        String s = range.get(range.size()-1);
-        if (s.indexOf('>') != -1) {
-            int start = Integer.parseInt(s.split("->")[0]);
-            int end = Integer.parseInt(s.split("->")[1]);
-
-            if (end != upper) {
-                list.add(getString(end+1, upper));
-            }
-        }
-        else {
-            int num = Integer.parseInt(s);
-            if (upper != num) {
-                list.add(getString(num+1, upper));
-            }
-        }
-
-        return list;
-    }
-
-    private static List<String> getRange(int[] num) {
-
-        List<String> list = new ArrayList<>();
-        if (num.length == 0) {
-            return list;
-        }
-
-        int i = 1;
-        StringBuilder sb = new StringBuilder();
-        sb.append(num[0]);
-        int count = 1;
-
-        while (i<num.length) {
-            if (num[i] - num[i-1] == 1 || num[i] - num[i-1] == 0) {
-                count++;
+        long next = lower;
+        
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] < next) {
+                continue;
             }
-            else {
-                if (count > 1) {
-                    sb.append("->").append(num[i-1]);
-                    list.add(sb.toString());
-                }
-                else {
-                    list.add(sb.toString());
-                }
-
-                sb = new StringBuilder();
-                sb.append(num[i]);
-                count = 1;
+            
+            if (nums[i] == next) {
+                next++;
+                continue;
             }
-
-            i++;
+            
+            list.add(getRange(next, ((long) nums[i]) - 1));
+            
+            next = ((long) nums[i]) + 1;
         }
 
-        if (count > 1) {
-            sb.append("->").append(num[num.length-1]);
+        if (next <= upper) {
+            list.add(getRange(next, (long) upper));
         }
-
-        list.add(sb.toString());
-
+        
         return list;
     }
-
-    private static String getString(int start, int end) {
-        StringBuilder sb = new StringBuilder();
-        if (start == end) {
-            sb.append(start);
-        }
-        else {
-            sb.append(start).append("->").append(end);
-        }
-
-        return sb.toString();
+    
+    private String getRange(long down, long up) {
+        return up == down ? String.valueOf(up) : String.format("%d->%d", down, up);
     }
 }

Medium/Nested List Weight Sum II.java

@@ -27,38 +27,35 @@
  * }
  */
 class Solution {
-    int maxDepth = 1;
-    int sum = 0;
+    int maxDepth;
+    int sum;
     public int depthSumInverse(List<NestedInteger> nestedList) {
-        for (NestedInteger n : nestedList) {
-            updateMaxDepth(n, 1);
-        }
+        maxDepth = 0;
+        maxDepthHelper(nestedList, 1);
 
-        for (NestedInteger n : nestedList) {
-            dfsHelper(n, maxDepth);
-        }
+        sum = 0;
+        helper(nestedList, maxDepth);
 
         return sum;
     }
 
-    private void dfsHelper(NestedInteger n, int depth) {
-        if (n.isInteger()) {
-            sum += n.getInteger() * depth;
-        }
-        else {
-            for (NestedInteger i : n.getList()) {
-                dfsHelper(i, depth-1);
+    private void helper(List<NestedInteger> nestedList, int level) {
+        for (NestedInteger nested : nestedList) {
+            if (nested.isInteger()) {
+                sum += nested.getInteger() * level;
+            }
+            else {
+                helper(nested.getList(), level - 1);
             }
         }
     }
 
-    private void updateMaxDepth(NestedInteger n, int depth) {
-        if (n.isInteger()) {
-            maxDepth = Math.max(maxDepth, depth);
-        }
-        else {
-            for (NestedInteger i : n.getList()) {
-                updateMaxDepth(i, depth+1);
+    private void maxDepthHelper(List<NestedInteger> nestedList, int currLevel) {
+        maxDepth = Math.max(maxDepth, currLevel);
+        
+        for (NestedInteger nestedInteger : nestedList) {
+            if (!nestedInteger.isInteger()) {
+                maxDepthHelper(nestedInteger.getList(), currLevel + 1);
             }
         }
     }