Added tasks 2484, 2485, 2486, 2487, 2488

Author: ThanhNIT

README.md

@@ -1848,6 +1848,11 @@ implementation 'com.github.javadev:leetcode-in-java:1.17'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2488 |[Count Subarrays With Median K](src/main/java/g2401_2500/s2488_count_subarrays_with_median_k/Solution.java)| Hard | Array, Hash_Table, Prefix_Sum | 24 | 72.25
+| 2487 |[Remove Nodes From Linked List](src/main/java/g2401_2500/s2487_remove_nodes_from_linked_list/Solution.java)| Medium | Stack, Linked_List, Monotonic_Stack, Recursion | 5 | 99.79
+| 2486 |[Append Characters to String to Make Subsequence](src/main/java/g2401_2500/s2486_append_characters_to_string_to_make_subsequence/Solution.java)| Medium | String, Greedy, Two_Pointers | 2 | 99.89
+| 2485 |[Find the Pivot Integer](src/main/java/g2401_2500/s2485_find_the_pivot_integer/Solution.java)| Easy | Math, Prefix_Sum | 1 | 95.67
+| 2484 |[Count Palindromic Subsequences](src/main/java/g2401_2500/s2484_count_palindromic_subsequences/Solution.java)| Hard | String, Dynamic_Programming | 93 | 76.16
 | 2483 |[Minimum Penalty for a Shop](src/main/java/g2401_2500/s2483_minimum_penalty_for_a_shop/Solution.java)| Medium | String, Prefix_Sum | 17 | 69.62
 | 2482 |[Difference Between Ones and Zeros in Row and Column](src/main/java/g2401_2500/s2482_difference_between_ones_and_zeros_in_row_and_column/Solution.java)| Medium | Array, Matrix, Simulation | 9 | 94.05
 | 2481 |[Minimum Cuts to Divide a Circle](src/main/java/g2401_2500/s2481_minimum_cuts_to_divide_a_circle/Solution.java)| Easy | Math, Geometry | 0 | 100.00

src/main/java/g2401_2500/s2484_count_palindromic_subsequences/Solution.java

@@ -0,0 +1,24 @@
+package g2401_2500.s2484_count_palindromic_subsequences;
+
+// #Hard #String #Dynamic_Programming #2023_01_26_Time_93_ms_(76.16%)_Space_40.2_MB_(99.74%)
+
+public class Solution {
+    public int countPalindromes(String s) {
+        int n = s.length();
+        long ans = 0;
+        int mod = (int) 1e9 + 7;
+        int[] count = new int[10];
+        for (int i = 0; i < n; i++) {
+            long m = 0;
+            for (int j = n - 1; j > i; j--) {
+                if (s.charAt(i) == s.charAt(j)) {
+                    ans += (m * (j - i - 1));
+                    ans = ans % mod;
+                }
+                m += count[s.charAt(j) - '0'];
+            }
+            count[s.charAt(i) - '0']++;
+        }
+        return (int) ans;
+    }
+}

src/main/java/g2401_2500/s2484_count_palindromic_subsequences/readme.md

@@ -0,0 +1,39 @@
+2484\. Count Palindromic Subsequences
+
+Hard
+
+Given a string of digits `s`, return _the number of **palindromic subsequences** of_ `s` _having length_ `5`. Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Note:**
+
+*   A string is **palindromic** if it reads the same forward and backward.
+*   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.
+
+**Example 1:**
+
+**Input:** s = "103301"
+
+**Output:** 2
+
+**Explanation:** There are 6 possible subsequences of length 5: "10330","10331","10301","10301","13301","03301". Two of them (both equal to "10301") are palindromic.
+
+**Example 2:**
+
+**Input:** s = "0000000"
+
+**Output:** 21
+
+**Explanation:** All 21 subsequences are "00000", which is palindromic.
+
+**Example 3:**
+
+**Input:** s = "9999900000"
+
+**Output:** 2
+
+**Explanation:** The only two palindromic subsequences are "99999" and "00000".
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of digits.

src/main/java/g2401_2500/s2485_find_the_pivot_integer/Solution.java

@@ -0,0 +1,24 @@
+package g2401_2500.s2485_find_the_pivot_integer;
+
+// #Easy #Math #Prefix_Sum #2023_01_26_Time_1_ms_(95.67%)_Space_39.2_MB_(91.00%)
+
+public class Solution {
+    public int pivotInteger(int n) {
+        if (n == 0 || n == 1) {
+            return n;
+        }
+        int sum = 0;
+        for (int i = 1; i <= n; i++) {
+            sum += i;
+        }
+        int ad = 0;
+        for (int i = 1; i <= n; i++) {
+            ad += i - 1;
+            sum -= i;
+            if (sum == ad) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

src/main/java/g2401_2500/s2485_find_the_pivot_integer/readme.md

@@ -0,0 +1,37 @@
+2485\. Find the Pivot Integer
+
+Easy
+
+Given a positive integer `n`, find the **pivot integer** `x` such that:
+
+*   The sum of all elements between `1` and `x` inclusively equals the sum of all elements between `x` and `n` inclusively.
+
+Return _the pivot integer_ `x`. If no such integer exists, return `-1`. It is guaranteed that there will be at most one pivot index for the given input.
+
+**Example 1:**
+
+**Input:** n = 8
+
+**Output:** 6
+
+**Explanation:** 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21.
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1
+
+**Explanation:** 1 is the pivot integer since: 1 = 1.
+
+**Example 3:**
+
+**Input:** n = 4
+
+**Output:** -1
+
+**Explanation:** It can be proved that no such integer exist.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`

src/main/java/g2401_2500/s2486_append_characters_to_string_to_make_subsequence/Solution.java

@@ -0,0 +1,25 @@
+package g2401_2500.s2486_append_characters_to_string_to_make_subsequence;
+
+// #Medium #String #Greedy #Two_Pointers #2023_01_26_Time_2_ms_(99.89%)_Space_49.5_MB_(39.30%)
+
+public class Solution {
+    public int appendCharacters(String s, String t) {
+        int lengthOfT = t.length();
+        int indexOfT = 0;
+        int indexOfS = 0;
+        int position;
+        if (s.contains(t)) {
+            return 0;
+        }
+        while (indexOfT < lengthOfT) {
+            position = s.indexOf(t.charAt(indexOfT), indexOfS);
+            if (position < 0) {
+                return lengthOfT - indexOfT;
+            }
+            indexOfS = position;
+            indexOfT++;
+            indexOfS++;
+        }
+        return lengthOfT - (indexOfT);
+    }
+}

src/main/java/g2401_2500/s2486_append_characters_to_string_to_make_subsequence/readme.md

@@ -0,0 +1,38 @@
+2486\. Append Characters to String to Make Subsequence
+
+Medium
+
+You are given two strings `s` and `t` consisting of only lowercase English letters.
+
+Return _the minimum number of characters that need to be appended to the end of_ `s` _so that_ `t` _becomes a **subsequence** of_ `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.
+
+**Example 1:**
+
+**Input:** s = "coaching", t = "coding"
+
+**Output:** 4
+
+**Explanation:** Append the characters "ding" to the end of s so that s = "coachingding". Now, t is a subsequence of s ("<ins>**co**</ins>aching<ins>**ding**</ins>"). It can be shown that appending any 3 characters to the end of s will never make t a subsequence.
+
+**Example 2:**
+
+**Input:** s = "abcde", t = "a"
+
+**Output:** 0
+
+**Explanation:** t is already a subsequence of s ("<ins>**a**</ins>bcde").
+
+**Example 3:**
+
+**Input:** s = "z", t = "abcde"
+
+**Output:** 5
+
+**Explanation:** Append the characters "abcde" to the end of s so that s = "zabcde". Now, t is a subsequence of s ("z<ins>**abcde**</ins>"). It can be shown that appending any 4 characters to the end of s will never make t a subsequence.
+
+**Constraints:**
+
+*   <code>1 <= s.length, t.length <= 10<sup>5</sup></code>
+*   `s` and `t` consist only of lowercase English letters.

src/main/java/g2401_2500/s2487_remove_nodes_from_linked_list/Solution.java

@@ -0,0 +1,44 @@
+package g2401_2500.s2487_remove_nodes_from_linked_list;
+
+// #Medium #Stack #Linked_List #Monotonic_Stack #Recursion
+// #2023_01_26_Time_5_ms_(99.79%)_Space_67_MB_(74.44%)
+
+import com_github_leetcode.ListNode;
+
+public class Solution {
+    public ListNode removeNodes(ListNode head) {
+        head = reverse(head);
+        if (head == null) {
+            return null;
+        }
+        int max = head.val;
+        ListNode temp = head;
+        ListNode temp1 = head.next;
+        while (temp1 != null) {
+            if (temp1.val >= max) {
+                max = temp1.val;
+                temp.next = temp1;
+                temp = temp.next;
+            }
+            temp1 = temp1.next;
+        }
+        temp.next = null;
+        return reverse(head);
+    }
+
+    private ListNode reverse(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode prev = null;
+        ListNode curr = head;
+        ListNode next;
+        while (curr != null) {
+            next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
+    }
+}

src/main/java/g2401_2500/s2487_remove_nodes_from_linked_list/readme.md

@@ -0,0 +1,36 @@
+2487\. Remove Nodes From Linked List
+
+Medium
+
+You are given the `head` of a linked list.
+
+Remove every node which has a node with a **strictly greater** value anywhere to the right side of it.
+
+Return _the_ `head` _of the modified linked list._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/10/02/drawio.png)
+
+**Input:** head = [5,2,13,3,8]
+
+**Output:** [13,8]
+
+**Explanation:** The nodes that should be removed are 5, 2 and 3. 
+
+- Node 13 is to the right of node 5. 
+- Node 13 is to the right of node 2. 
+- Node 8 is to the right of node 3.
+
+**Example 2:**
+
+**Input:** head = [1,1,1,1]
+
+**Output:** [1,1,1,1]
+
+**Explanation:** Every node has value 1, so no nodes are removed.
+
+**Constraints:**
+
+*   The number of the nodes in the given list is in the range <code>[1, 10<sup>5</sup>]</code>.
+*   <code>1 <= Node.val <= 10<sup>5</sup></code>

src/main/java/g2401_2500/s2488_count_subarrays_with_median_k/Solution.java

@@ -0,0 +1,49 @@
+package g2401_2500.s2488_count_subarrays_with_median_k;
+
+// #Hard #Array #Hash_Table #Prefix_Sum #2023_01_26_Time_24_ms_(72.25%)_Space_51_MB_(99.24%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int countSubarrays(int[] nums, int k) {
+        int idx;
+        int n = nums.length;
+        int ans = 0;
+        for (idx = 0; idx < n; idx++) {
+            if (nums[idx] == k) {
+                break;
+            }
+        }
+        int[][] arr = new int[n - idx][2];
+        int j = 1;
+        for (int i = idx + 1; i < n; i++) {
+            if (nums[i] < k) {
+                arr[j][0] = arr[j - 1][0] + 1;
+                arr[j][1] = arr[j - 1][1];
+            } else {
+                arr[j][1] = arr[j - 1][1] + 1;
+                arr[j][0] = arr[j - 1][0];
+            }
+            j++;
+        }
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int[] ints : arr) {
+            int d2 = ints[1] - ints[0];
+            map.put(d2, map.getOrDefault(d2, 0) + 1);
+        }
+        int s1 = 0;
+        int g1 = 0;
+        for (int i = idx; i >= 0; i--) {
+            if (nums[i] < k) {
+                s1++;
+            } else if (nums[i] > k) {
+                g1++;
+            }
+            int d1 = g1 - s1;
+            int cur = map.getOrDefault(-d1, 0) + map.getOrDefault(1 - d1, 0);
+            ans += cur;
+        }
+        return ans;
+    }
+}