Added tasks 2012, 2013, 2014.

Author: ThanhNIT

src/main/java/g2001_2100/s2012_sum_of_beauty_in_the_array/Solution.java

@@ -0,0 +1,29 @@
+package g2001_2100.s2012_sum_of_beauty_in_the_array;
+
+// #Medium #Array #2022_05_24_Time_10_ms_(44.69%)_Space_98.1_MB_(18.43%)
+
+public class Solution {
+    public int sumOfBeauties(int[] nums) {
+        int[] maxArr = new int[nums.length];
+        maxArr[0] = nums[0];
+        for (int i = 1; i < nums.length - 1; i++) {
+            maxArr[i] = Math.max(maxArr[i - 1], nums[i]);
+        }
+        int[] minArr = new int[nums.length];
+        minArr[nums.length - 1] = nums[nums.length - 1];
+        for (int i = nums.length - 2; i >= 0; i--) {
+            minArr[i] = Math.min(minArr[i + 1], nums[i]);
+        }
+
+        int sum = 0;
+        for (int i = 1; i < nums.length - 1; i++) {
+            if (nums[i] > maxArr[i - 1] && nums[i] < minArr[i + 1]) {
+                sum += 2;
+            } else if (nums[i] > nums[i - 1] && nums[i] < nums[i + 1]) {
+                sum += 1;
+            }
+        }
+
+        return sum;
+    }
+}

src/main/java/g2001_2100/s2012_sum_of_beauty_in_the_array/readme.md

@@ -0,0 +1,44 @@
+2012\. Sum of Beauty in the Array
+
+Medium
+
+You are given a **0-indexed** integer array `nums`. For each index `i` (`1 <= i <= nums.length - 2`) the **beauty** of `nums[i]` equals:
+
+*   `2`, if `nums[j] < nums[i] < nums[k]`, for **all** `0 <= j < i` and for **all** `i < k <= nums.length - 1`.
+*   `1`, if `nums[i - 1] < nums[i] < nums[i + 1]`, and the previous condition is not satisfied.
+*   `0`, if none of the previous conditions holds.
+
+Return _the **sum of beauty** of all_ `nums[i]` _where_ `1 <= i <= nums.length - 2`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 2
+
+**Explanation:** For each index i in the range 1 <= i <= 1: - The beauty of nums[1] equals 2.
+
+**Example 2:**
+
+**Input:** nums = [2,4,6,4]
+
+**Output:** 1
+
+**Explanation:** For each index i in the range 1 <= i <= 2: 
+
+- The beauty of nums[1] equals 1.
+
+- The beauty of nums[2] equals 0.
+
+**Example 3:**
+
+**Input:** nums = [3,2,1]
+
+**Output:** 0
+
+**Explanation:** For each index i in the range 1 <= i <= 1: - The beauty of nums[1] equals 0.
+
+**Constraints:**
+
+*   <code>3 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>

src/main/java/g2001_2100/s2013_detect_squares/DetectSquares.java

@@ -0,0 +1,49 @@
+package g2001_2100.s2013_detect_squares;
+
+// #Medium #Array #Hash_Table #Design #Counting
+// #2022_05_24_Time_67_ms_(88.46%)_Space_46.1_MB_(96.15%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class DetectSquares {
+    private static final int MUL = 1002;
+    private final Map<Integer, int[]> map;
+
+    public DetectSquares() {
+        this.map = new HashMap<>();
+    }
+
+    public void add(int[] point) {
+        int x = point[0];
+        int y = point[1];
+        int hash = x * MUL + y;
+        if (map.containsKey(hash)) {
+            map.get(hash)[2]++;
+        } else {
+            map.put(hash, new int[] {x, y, 1});
+        }
+    }
+
+    public int count(int[] point) {
+        int ans = 0;
+        int x = point[0];
+        int y = point[1];
+        for (Map.Entry<Integer, int[]> entry : map.entrySet()) {
+            int[] diap = entry.getValue();
+            int x1 = diap[0];
+            int y1 = diap[1];
+            int num = diap[2];
+            if (Math.abs(x - x1) != Math.abs(y - y1) || x == x1 || y == y1) {
+                continue;
+            } else {
+                int p1hash = x * MUL + y1;
+                int p2hash = x1 * MUL + y;
+                if (map.containsKey(p1hash) && map.containsKey(p2hash)) {
+                    ans += map.get(p1hash)[2] * map.get(p2hash)[2] * num;
+                }
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2001_2100/s2013_detect_squares/readme.md

@@ -0,0 +1,49 @@
+2013\. Detect Squares
+
+Medium
+
+You are given a stream of points on the X-Y plane. Design an algorithm that:
+
+*   **Adds** new points from the stream into a data structure. **Duplicate** points are allowed and should be treated as different points.
+*   Given a query point, **counts** the number of ways to choose three points from the data structure such that the three points and the query point form an **axis-aligned square** with **positive area**.
+
+An **axis-aligned square** is a square whose edges are all the same length and are either parallel or perpendicular to the x-axis and y-axis.
+
+Implement the `DetectSquares` class:
+
+*   `DetectSquares()` Initializes the object with an empty data structure.
+*   `void add(int[] point)` Adds a new point `point = [x, y]` to the data structure.
+*   `int count(int[] point)` Counts the number of ways to form **axis-aligned squares** with point `point = [x, y]` as described above.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/09/01/image.png)
+
+**Input** ["DetectSquares", "add", "add", "add", "count", "count", "add", "count"] [[], [[3, 10]], [[11, 2]], [[3, 2]], [[11, 10]], [[14, 8]], [[11, 2]], [[11, 10]]]
+
+**Output:** [null, null, null, null, 1, 0, null, 2]
+
+**Explanation:** 
+
+DetectSquares detectSquares = new DetectSquares(); 
+
+detectSquares.add([3, 10]); 
+
+detectSquares.add([11, 2]); 
+
+detectSquares.add([3, 2]); 
+
+detectSquares.count([11, 10]); // return 1. You can choose: 
+                               // - The first, second, and third points 
+
+detectSquares.count([14, 8]); // return 0. The query point cannot form a square with any points in the data structure. 
+
+detectSquares.add([11, 2]); // Adding duplicate points is allowed. 
+
+detectSquares.count([11, 10]); // return 2. You can choose: // - The first, second, and third points // - The first, third, and fourth points
+
+**Constraints:**
+
+*   `point.length == 2`
+*   `0 <= x, y <= 1000`
+*   At most `3000` calls **in total** will be made to `add` and `count`.

src/main/java/g2001_2100/s2014_longest_subsequence_repeated_k_times/Solution.java

@@ -0,0 +1,60 @@
+package g2001_2100.s2014_longest_subsequence_repeated_k_times;
+
+// #Hard #String #Greedy #Backtracking #Counting #Enumeration
+// #2022_05_24_Time_169_ms_(98.59%)_Space_48.8_MB_(57.75%)
+
+import java.util.ArrayList;
+
+public class Solution {
+    public String longestSubsequenceRepeatedK(String s, int k) {
+        char[] ca = s.toCharArray();
+
+        char[] freq = new char[26];
+        for (char value : ca) {
+            ++freq[value - 'a'];
+        }
+
+        ArrayList<String>[] cand = new ArrayList[8];
+        cand[1] = new ArrayList<>();
+        String ans = "";
+        for (int i = 0; i < 26; i++) {
+            if (freq[i] >= k) {
+                ans = "" + (char) ('a' + i);
+                cand[1].add(ans);
+            }
+        }
+        for (int i = 2; i < 8; i++) {
+            cand[i] = new ArrayList<>();
+            for (String prev : cand[i - 1]) {
+                for (String c : cand[1]) {
+                    String next = prev + c;
+                    if (isSubsequenceRepeatedK(ca, next, k)) {
+                        ans = next;
+                        cand[i].add(ans);
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+
+    private boolean isSubsequenceRepeatedK(char[] ca, String t, int k) {
+        char[] ta = t.toCharArray();
+        int n = ca.length;
+        int m = ta.length;
+        int i = 0;
+        while (k-- > 0) {
+            int j = 0;
+            while (i < n && j < m) {
+                if (ca[i] == ta[j]) {
+                    j++;
+                }
+                i++;
+            }
+            if (j != m) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/g2001_2100/s2014_longest_subsequence_repeated_k_times/readme.md

@@ -0,0 +1,46 @@
+2014\. Longest Subsequence Repeated k Times
+
+Hard
+
+You are given a string `s` of length `n`, and an integer `k`. You are tasked to find the **longest subsequence repeated** `k` times in string `s`.
+
+A **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.
+
+A subsequence `seq` is **repeated** `k` times in the string `s` if `seq * k` is a subsequence of `s`, where `seq * k` represents a string constructed by concatenating `seq` `k` times.
+
+*   For example, `"bba"` is repeated `2` times in the string `"bababcba"`, because the string `"bbabba"`, constructed by concatenating `"bba"` `2` times, is a subsequence of the string `"**b**a**bab**c**ba**"`.
+
+Return _the **longest subsequence repeated**_ `k` _times in string_ `s`_. If multiple such subsequences are found, return the **lexicographically largest** one. If there is no such subsequence, return an **empty** string_.
+
+**Example 1:**
+
+![example 1](https://assets.leetcode.com/uploads/2021/08/30/longest-subsequence-repeat-k-times.png)
+
+**Input:** s = "letsleetcode", k = 2
+
+**Output:** "let"
+
+**Explanation:** There are two longest subsequences repeated 2 times: "let" and "ete". "let" is the lexicographically largest one.
+
+**Example 2:**
+
+**Input:** s = "bb", k = 2
+
+**Output:** "b"
+
+**Explanation:** The longest subsequence repeated 2 times is "b".
+
+**Example 3:**
+
+**Input:** s = "ab", k = 2
+
+**Output:** ""
+
+**Explanation:** There is no subsequence repeated 2 times. Empty string is returned.
+
+**Constraints:**
+
+*   `n == s.length`
+*   `2 <= n, k <= 2000`
+*   `2 <= n < k * 8`
+*   `s` consists of lowercase English letters.

src/test/java/g2001_2100/s2012_sum_of_beauty_in_the_array/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2001_2100.s2012_sum_of_beauty_in_the_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void sumOfBeauties() {
+        assertThat(new Solution().sumOfBeauties(new int[] {1, 2, 3}), equalTo(2));
+    }
+
+    @Test
+    void sumOfBeauties2() {
+        assertThat(new Solution().sumOfBeauties(new int[] {2, 4, 6, 4}), equalTo(1));
+    }
+
+    @Test
+    void sumOfBeauties3() {
+        assertThat(new Solution().sumOfBeauties(new int[] {3, 2, 1}), equalTo(0));
+    }
+}

src/test/java/g2001_2100/s2013_detect_squares/DetectSquaresTest.java

@@ -0,0 +1,20 @@
+package g2001_2100.s2013_detect_squares;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class DetectSquaresTest {
+    @Test
+    void detectSquaresTest() {
+        DetectSquares detectSquares = new DetectSquares();
+        detectSquares.add(new int[] {3, 10});
+        detectSquares.add(new int[] {11, 2});
+        detectSquares.add(new int[] {3, 2});
+        assertThat(detectSquares.count(new int[] {11, 10}), equalTo(1));
+        assertThat(detectSquares.count(new int[] {14, 8}), equalTo(0));
+        detectSquares.add(new int[] {11, 2});
+        assertThat(detectSquares.count(new int[] {11, 10}), equalTo(2));
+    }
+}

src/test/java/g2001_2100/s2014_longest_subsequence_repeated_k_times/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2001_2100.s2014_longest_subsequence_repeated_k_times;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void longestSubsequenceRepeatedK() {
+        assertThat(new Solution().longestSubsequenceRepeatedK("letsleetcode", 2), equalTo("let"));
+    }
+
+    @Test
+    void longestSubsequenceRepeatedK2() {
+        assertThat(new Solution().longestSubsequenceRepeatedK("bb", 2), equalTo("b"));
+    }
+
+    @Test
+    void longestSubsequenceRepeatedK3() {
+        assertThat(new Solution().longestSubsequenceRepeatedK("ab", 2), equalTo(""));
+    }
+}