add Count Primes and Reverse words in a string 2

update solutions

Author: FreeTymeKiyan

src/main/java/com/freetymekiyan/algorithms/level/easy/CountPrimes.java

@@ -0,0 +1,43 @@
+package com.freetymekiyan.algorithms.level.easy;
+
+/**
+ * 204. Count Primes
+ * <p>
+ * Count the number of prime numbers less than a non-negative number, n.
+ * <p>
+ * Example:
+ * <p>
+ * Input: 10
+ * Output: 4
+ * Explanation: There are 4 prime numbers less than 10, they are 2, 3, 5, 7.
+ * <p>
+ * Companies: Microsoft, Amazon, Adobe, Google, Apple, Yahoo, Goldman Sachs, Nvidia, Tesla, Tencent, Bloomberg, Capital
+ * One
+ * <p>
+ * Related Topics: Hash Table, Math
+ * <p>
+ * Similar Questions: (E) Ugly Number, (M) Ugly Number II, (M) Perfect Squares
+ */
+public class CountPrimes {
+
+  public int countPrimes(int n) {
+    if (n <= 2) return 0;
+
+    int res = n >> 1;
+    int m = (int) Math.sqrt(n - 1);
+    boolean[] notPrime = new boolean[n];
+
+    for (int i = 3; i <= m; i += 2) {
+      if (!notPrime[i]) {
+        for (int j = i * i, step = i << 1; j < n; j += step) {
+          if (!notPrime[j]) {
+            notPrime[j] = true;
+            --res;
+          }
+        }
+      }
+    }
+
+    return res;
+  }
+}

src/main/java/com/freetymekiyan/algorithms/level/easy/HappyNumber.java

@@ -4,69 +4,71 @@
 import java.util.Set;
 
 /**
+ * 202. Happy Number
+ * <p>
  * Write an algorithm to determine if a number is "happy".
- *
+ * <p>
  * A happy number is a number defined by the following process: Starting with any positive integer, replace the number
  * by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it
  * loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy
  * numbers.
- *
+ * <p>
  * Example:
  * 19 is a happy number
  * 1^2 + 9^2 = 82
  * 8^2 + 2^2 = 68
  * 6^2 + 8^2 = 100
  * 1^2 + 0^2 + 0^2 = 1
- *
+ * <p>
  * Tags: Hash Table Math
  * Similar Problems: (E) addRecursive Digits (E) Ugly Number
  */
 public class HappyNumber {
 
-    public static void main(String[] args) {
-        HappyNumber hn = new HappyNumber();
-        for (int i = 10; i < 20; i++) {
-            System.out.println(i + ": " + hn.isHappy(i));
-            System.out.println(i + ": " + hn.isHappy2(i));
-        }
+  public static void main(String[] args) {
+    HappyNumber hn = new HappyNumber();
+    for (int i = 10; i < 20; i++) {
+      System.out.println(i + ": " + hn.isHappy(i));
+      System.out.println(i + ": " + hn.isHappy2(i));
     }
+  }
 
-    /**
-     * loop detection like linked list
-     */
-    public boolean isHappy(int n) {
-        int slow, fast;
-        slow = fast = n;
-        do {
-            slow = digitSquareSum(slow);
-            fast = digitSquareSum(digitSquareSum(fast));
-        } while (slow != fast);
-        return slow == 1;
-    }
+  /**
+   * loop detection like linked list
+   */
+  public boolean isHappy(int n) {
+    int slow, fast;
+    slow = fast = n;
+    do {
+      slow = digitSquareSum(slow);
+      fast = digitSquareSum(digitSquareSum(fast));
+    } while (slow != fast);
+    return slow == 1;
+  }
 
-    /**
-     * loop detection using Set, use more space
-     */
-    public boolean isHappy2(int n) {
-        if (n < 1) return false;
+  /**
+   * loop detection using Set, use more space
+   */
+  public boolean isHappy2(int n) {
+    if (n < 1) return false;
 
-        int num = n;
-        Set<Integer> results = new HashSet<>();
-        while (!results.contains(num)) {
-            results.add(num);
-            num = digitSquareSum(num);
-        }
-        
-        return num == 1;
+    int num = n;
+    Set<Integer> results = new HashSet<>();
+    while (!results.contains(num)) {
+      results.add(num);
+      num = digitSquareSum(num);
     }
 
-    public int digitSquareSum(int n) {
-        int res = 0;
-        int digit;
-        for (; n > 0; n /= 10) {
-            digit = n % 10;
-            res += digit * digit;
-        }
-        return res;
+    return num == 1;
+  }
+
+  private int digitSquareSum(int n) {
+    int res = 0;
+    int digit;
+    for (; n > 0; n /= 10) {
+      digit = n % 10;
+      res += digit * digit;
     }
+    return res;
+  }
 }

src/main/java/com/freetymekiyan/algorithms/level/easy/IsomorphicStrings.java

@@ -6,6 +6,8 @@
 import org.junit.Test;
 
 /**
+ * 205. Isomorphic Strings
+ * <p>
  * Given two strings s and t, determine if they are isomorphic.
  * <p>
  * Two strings are isomorphic if the characters in s can be replaced to get t.
@@ -29,59 +31,59 @@
  */
 public class IsomorphicStrings {
 
-    private IsomorphicStrings is;
+  private IsomorphicStrings is;
 
-    /**
-     * Hash Table.
-     * Store the previous seen index of a character. 0 means not seen yet.
-     * If the last seen indices are different, return false.
-     * Update index to i + 1.
-     * After the check, return true, since s and t are of same length.
-     */
-    public boolean isIsomorphic(String s, String t) {
-        if (s == null || t == null) {
-            return false;
-        }
-        int[] m = new int[512];
-        for (int i = 0; i < s.length(); i++) {
-            if (m[s.charAt(i)] != m[t.charAt(i) + 256]) {
-                return false;
-            }
-            m[s.charAt(i)] = m[t.charAt(i) + 256] = i + 1;
-        }
-        return true;
+  /**
+   * Hash Table.
+   * Store the previous seen index of a character. 0 means not seen yet.
+   * If the last seen indices are different, return false.
+   * Update index to i + 1.
+   * After the check, return true, since s and t are of same length.
+   */
+  public boolean isIsomorphic(String s, String t) {
+    if (s == null || t == null) {
+      return false;
     }
-
-    @Before
-    public void setUp() {
-        is = new IsomorphicStrings();
+    int[] m = new int[512];
+    for (int i = 0; i < s.length(); i++) {
+      if (m[s.charAt(i)] != m[t.charAt(i) + 256]) {
+        return false;
+      }
+      m[s.charAt(i)] = m[t.charAt(i) + 256] = i + 1;
     }
+    return true;
+  }
 
-    @Test
-    public void testEdgeCases() {
-        Assert.assertFalse(is.isIsomorphic(null, null));
-        Assert.assertFalse(is.isIsomorphic(null, ""));
-        Assert.assertFalse(is.isIsomorphic("", null));
-        Assert.assertTrue(is.isIsomorphic("", ""));
-    }
+  @Before
+  public void setUp() {
+    is = new IsomorphicStrings();
+  }
 
-    @Test
-    public void testExamples() {
-        // "egg", "add", return true
-        Assert.assertTrue(is.isIsomorphic("egg", "add"));
-        // "foo", "bar", return false
-        Assert.assertFalse(is.isIsomorphic("foo", "bar"));
-        // "paper", "title", return true
-        Assert.assertTrue(is.isIsomorphic("paper", "title"));
-        // "papper", "tittle", return true
-        Assert.assertTrue(is.isIsomorphic("papper", "tittle"));
-        // "abba", "abab"
-        Assert.assertFalse(is.isIsomorphic("abba", "abab"));
-    }
+  @Test
+  public void testEdgeCases() {
+    Assert.assertFalse(is.isIsomorphic(null, null));
+    Assert.assertFalse(is.isIsomorphic(null, ""));
+    Assert.assertFalse(is.isIsomorphic("", null));
+    Assert.assertTrue(is.isIsomorphic("", ""));
+  }
 
-    @After
-    public void tearDown() {
-        is = null;
-    }
+  @Test
+  public void testExamples() {
+    // "egg", "add", return true
+    Assert.assertTrue(is.isIsomorphic("egg", "add"));
+    // "foo", "bar", return false
+    Assert.assertFalse(is.isIsomorphic("foo", "bar"));
+    // "paper", "title", return true
+    Assert.assertTrue(is.isIsomorphic("paper", "title"));
+    // "papper", "tittle", return true
+    Assert.assertTrue(is.isIsomorphic("papper", "tittle"));
+    // "abba", "abab"
+    Assert.assertFalse(is.isIsomorphic("abba", "abab"));
+  }
+
+  @After
+  public void tearDown() {
+    is = null;
+  }
 
 }