Update

Author: ex01tus

src/dynamic_programming/DominoAndTrominoTiling.java

@@ -0,0 +1,33 @@
+package dynamic_programming;
+
+/**
+ * Description: https://leetcode.com/problems/domino-and-tromino-tiling
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class DominoAndTrominoTiling {
+
+    // since the answer may be too large, return it modulo 10^9 + 7
+    private static final int MOD = 1_000_000_007;
+
+    public int numTilings(int n) {
+        if (n <= 2) return n;
+
+        // number of ways to fully cover a 2xN board
+        long[] fullCoverage = new long[n + 1];
+        fullCoverage[1] = 1L;
+        fullCoverage[2] = 2L;
+
+        // number of ways to partially cover (one cell not being covered) a 2xN board
+        long[] partialCoverage = new long[n + 1];
+        partialCoverage[2] = 1L;
+
+        for (int i = 3; i <= n; i++) {
+            fullCoverage[i] = (fullCoverage[i - 1] + fullCoverage[i - 2] + 2 * partialCoverage[i - 1]) % MOD;
+            partialCoverage[i] = (partialCoverage[i - 1] + fullCoverage[i - 2]) % MOD;
+        }
+
+        return (int) fullCoverage[n];
+    }
+}

src/dynamic_programming/LongestArithmeticSubsequence.java

@@ -0,0 +1,28 @@
+package dynamic_programming;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/longest-arithmetic-subsequence
+ * Difficulty: Medium
+ * Time complexity: O(n^2)
+ * Space complexity: O(n^2)
+ */
+public class LongestArithmeticSubsequence {
+
+    public int longestArithSeqLength(int[] nums) {
+        Map<Integer, Integer>[] dp = new HashMap[nums.length];
+        int longest = 0;
+        for (int right = 0; right < nums.length; right++) {
+            dp[right] = new HashMap<>();
+            for (int left = 0; left < right; left++) {
+                int diff = nums[right] - nums[left];
+                dp[right].put(diff, dp[left].getOrDefault(diff, 1) + 1);
+                longest = Math.max(longest, dp[right].get(diff));
+            }
+        }
+
+        return longest;
+    }
+}

src/math/FactorialTrailingZeroes.java

@@ -0,0 +1,26 @@
+package math;
+
+/**
+ * Description: https://leetcode.com/problems/factorial-trailing-zeroes
+ * Difficulty: Medium
+ * Time complexity: O(log n)
+ * Space complexity: O(1)
+ */
+public class FactorialTrailingZeroes {
+
+    public int trailingZeroes(int n) {
+        int zeroes = 0;
+        while (n > 0) {
+            // every 5 results in a zero because there will always be a corresponding 2
+            // -> we need to count the number of factors of 5
+            // e.g. 1 * 2 * 3 * (4) * [5] * 6 * 7 * 9 * 9 * [10] * 11 * 12 * 13 * 14 * [15] * (16) * 17 * 18 * 19 * [20] * 21 * 22 * 23 * 24 * [25]
+            //                4 * 16 = 2 * 2 * 2 * 2 * 2 * 2
+            // 5 * 10 * 15 * 20 * 25 = 5 * 5 * 5 * 5 * 5 * 5 * (2 * 3 * 4)
+            // -> 25! = X000000
+            n /= 5;
+            zeroes += n;
+        }
+
+        return zeroes;
+    }
+}

src/math/IntegerToRoman.java

@@ -0,0 +1,39 @@
+package math;
+
+/**
+ * Description: https://leetcode.com/problems/integer-to-roman
+ * Difficulty: Medium
+ * Time complexity: O(1)
+ * Space complexity: O(1)
+ */
+public class IntegerToRoman {
+
+    private static final int[] VALUES =
+            new int[]{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+    private static final String[] SYMBOLS =
+            new String[]{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
+
+    public String intToRomanViaLoop(int num) {
+        StringBuilder roman = new StringBuilder();
+        for (int i = 0; i < VALUES.length; i++) {
+            while (VALUES[i] <= num) {
+                roman.append(SYMBOLS[i]);
+                num -= VALUES[i];
+            }
+        }
+
+        return roman.toString();
+    }
+
+    private static final String[] THOUSANDS = new String[]{"", "M", "MM", "MMM"};
+    private static final String[] HUNDREDS = new String[]{"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
+    private static final String[] TENS = new String[]{"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
+    private static final String[] ONES = new String[]{"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
+
+    public String intToRomanViaMod(int num) {
+        return THOUSANDS[num / 1000]
+                + HUNDREDS[(num % 1000) / 100]
+                + TENS[(num % 100) / 10]
+                + ONES[num % 10];
+    }
+}

src/math/SqrtX.java

@@ -0,0 +1,35 @@
+package math;
+
+/**
+ * Description: https://leetcode.com/problems/sqrtx
+ * Difficulty: Easy
+ * Time complexity: O(log n)
+ * Space complexity: O(1)
+ */
+public class SqrtX {
+
+    public int mySqrt(int x) {
+        if (x < 2) return x;
+
+        // 0 < sqrt(x) < x / 2
+        int left = 2;
+        int right = x / 2;
+
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            if (mid > x / mid) {
+                right = mid - 1;
+            } else if (mid < x / mid) {
+                left = mid + 1;
+            } else {
+                // only works if sqrt(x) is an integer
+                return mid;
+            }
+        }
+
+        // we reached the BS out condition
+        // -> left > right
+        // -> right is the closest value to sqrt(x) rounded down
+        return right;
+    }
+}