Added 4 solutions

varunu28 · varunu28 · commit 4e2d8f34de72 · 2017-11-12T09:25:30.000-08:00
diff --git a/Easy/Diameter of Binary Tree.java b/Easy/Diameter of Binary Tree.java
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int diameterOfBinaryTree(TreeNode root) {
+        if (root == null) return 0;
+        
+        int rootDiam = depth(root.left) + depth(root.right);
+        int leftDia = diameterOfBinaryTree(root.left);
+        int rightDia = diameterOfBinaryTree(root.right);
+        
+        return Math.max(rootDiam, Math.max(leftDia, rightDia));
+    }
+    
+    public int depth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        
+        return 1 + Math.max(depth(root.left), depth(root.right));
+    }
+}
diff --git a/Easy/Find Pivot Index.java b/Easy/Find Pivot Index.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int pivotIndex(int[] nums) {
+        int left = 0;
+        int sum = 0;
+        
+        for (int i=0;i<nums.length;i++) {
+            sum += nums[i];
+        }
+        
+        for (int i=0;i<nums.length;i++) {
+            if (i != 0) {
+                left += nums[i-1];
+            }
+            if (sum - left - nums[i] == left) {
+                return i;
+            }
+        }
+        
+        return -1;
+    }
+}
diff --git a/Easy/Image Smoother.java b/Easy/Image Smoother.java
@@ -0,0 +1,49 @@
+class Solution {
+    public int[][] imageSmoother(int[][] M) {
+        
+        int[][] res = new int[M.length][M[0].length];
+        for (int i=0;i<M.length;i++) {
+            for (int j=0;j<M[0].length;j++) {
+                int count = 1;
+                int sum = M[i][j];
+                
+                if(j-1 >= 0) {
+                    count++;
+                    sum += M[i][j-1];
+                }
+                if(j+1 < M[0].length) {
+                    count++;
+                    sum += M[i][j+1];
+                }
+                if(i-1 >= 0) {
+                    count++;
+                    sum += M[i-1][j];
+                }
+                if(i+1 < M.length) {
+                    count++;
+                    sum += M[i+1][j];
+                }
+                if(i+1 < M.length && j+1 < M[0].length) {
+                    count++;
+                    sum += M[i+1][j+1];
+                }
+                if(i+1 < M.length && j-1 >= 0) {
+                    count++;
+                    sum += M[i+1][j-1];
+                }
+                if(i-1 >= 0 && j-1 >= 0) {
+                    count++;
+                    sum += M[i-1][j-1];
+                }
+                if(i-1 >= 0 && j+1 < M[0].length) {
+                    count++;
+                    sum += M[i-1][j+1];
+                }
+                
+                res[i][j] = (int)Math.floor(sum/count);
+            }
+        }
+        
+        return res;
+    }
+}
diff --git a/Easy/Number of Boomerangs.java b/Easy/Number of Boomerangs.java
@@ -0,0 +1,31 @@
+class Solution {
+    public int numberOfBoomerangs(int[][] points) {
+        
+        int res = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        
+        for (int i=0;i<points.length;i++) {
+            for (int j=0;j<points.length;j++) {
+                if (i == j) {
+                    continue;
+                }
+                int d = getDistance(points[i], points[j]);
+                
+                map.put(d, map.getOrDefault(d,0) + 1);
+            }
+            
+            for (int val: map.values()) {
+                res += val*(val-1); 
+            }
+            map.clear();
+        }
+        
+        return res;
+    }
+    
+    public int getDistance(int[] a, int[] b) {
+        int dx = a[0] - b[0];
+        int dy = a[1] - b[1];
+        return dx*dx + dy*dy;
+    }
+}
