1118

Author: surajr

README.md

@@ -260,6 +260,7 @@ Feel free to submit pull requests, add issues and be a contributer.
 ## Math
 | Website | Title | Solution | Time | Space | Difficulty | Note| 
 |---------------- |---------------- | ----------- | --------------- | --------------- | ------------- |-----|
+| Leetcode | [204. Count Primes](https://leetcode.com/problems/count-primes/description/) | [Java](./java/countPrimes.java) | _O(n)_ | _O(n)_ | Easy | |
 | Leetcode | [223. Rectangle Area](https://leetcode.com/problems/rectangle-area/description/) | [Java](./java/computeArea.java) | _O(1)_ | _O(1)_ | Medium | |
 | Leetcode | [319. Bulb Switcher](https://leetcode.com/problems/bulb-switcher/description/) | [Java](./java/bulbSwitch.java) | _O(n)_ | _O(1)_ | Medium | |
 

java/countPrimes.java

@@ -0,0 +1,16 @@
+class Solution {
+ public int countPrimes(int n) {
+ boolean [] notPrime = new boolean[n+1];
+ int count = 0;
+ for(int i=2; i<n; i++)
+ {
+ if(notPrime[i] == false)
+ {
+ count++;
+ for(int j=2; i*j<n; j++)
+ notPrime[i*j] = true;
+ }
+ }
+ return count;
+ }
+}

java/isBalanced.java

@@ -1,33 +1,19 @@
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- * int val;
- * TreeNode left;
- * TreeNode right;
- * TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
+public class Solution {
  public boolean isBalanced(TreeNode root) {
- 
- if(root == null)
- return true;
- 
- return getHeight(root) != -1;
- 
+ return getDepth(root)!=-1;
  }
 
- public int getHeight(TreeNode root)
- {
- if(root == null)
-  return -1;
- 
- int l = getHeight(root.left);
- int r = getHeight(root.right);
- 
- if(l == -1 || r == -1 || Math.abs(l-r) > 1)
- return -1;
- 
- return 1 + Math.max(l,r);
+ public int getDepth(TreeNode root){
+  if(root==null){
+  return 0;
+ }
+ int left = getDepth(root.left);
+ if(left!=-1){
+  int right = getDepth(root.right);
+  if(right!=-1){
+  return Math.abs(left-right)<=1?1+Math.max(left,right):-1;
+ }
+ }
+ return -1;
  }
 }

java/nthUglyNumber.java

@@ -8,25 +8,22 @@
  We can find that every subsequence is the ugly-sequence itself (1, 2, 3, 4, 5, …) multiply 2, 3, 5. Then we use similar merge method as merge sort, to get every ugly number from the three subsequence. Every step we choose the smallest one, and move one step after.
 
 */
-
-class Solution {
+public class Solution {
  public int nthUglyNumber(int n) {
- 
- if(n == 1) return 1;
- 
- int[] dp = new int[n+1];
- dp[1]=1;
- int p2 = 1, p3 = 1, p5 = 1;
- 
- for(int i=2; i<=n; i++)
- {
- dp[i] = Math.min(p2*2, Math.min(p3*3, p5*5));
- 
- if(dp[i] == 2*dp[p2]) p2++;
- if(dp[i] == 3*dp[p3]) p3++;
- if(dp[i] == 5*dp[p5]) p5++;
- } 
- return dp[n];
- 
+ int[] ugly = new int[n];
+ ugly[0] = 1;
+ int index2 = 0, index3 = 0, index5 = 0;
+ int factor2 = 2, factor3 = 3, factor5 = 5;
+ for(int i=1;i<n;i++){
+ int min = Math.min(Math.min(factor2,factor3),factor5);
+ ugly[i] = min;
+ if(factor2 == min)
+ factor2 = 2*ugly[++index2];
+ if(factor3 == min)
+ factor3 = 3*ugly[++index3];
+ if(factor5 == min)
+ factor5 = 5*ugly[++index5];
+ }
+ return ugly[n-1];
  }
 }

java/sumOfLeftLeaves.java

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ * int val;
+ * TreeNode left;
+ * TreeNode right;
+ * TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+ public int sumOfLeftLeaves(TreeNode root) {
+ if(root == null) return 0;
+ int ans = 0;
+ Stack<TreeNode> stack = new Stack<TreeNode>();
+ stack.push(root);
+
+ while(!stack.empty()) {
+ TreeNode node = stack.pop();
+ if(node.left != null) {
+ if (node.left.left == null && node.left.right == null)
+ ans += node.left.val;
+ else
+ stack.push(node.left);
+ }
+ if(node.right != null) {
+ if (node.right.left != null || node.right.right != null)
+ stack.push(node.right);
+ }
+ }
+ return ans;
+ }
+}