Added tasks 1861, 1862.

Author: ThanhNIT

src/main/java/g1801_1900/s1861_rotating_the_box/Solution.java

@@ -0,0 +1,36 @@
+package g1801_1900.s1861_rotating_the_box;
+
+// #Medium #Array #Matrix #Two_Pointers #2022_05_08_Time_16_ms_(30.81%)_Space_77.6_MB_(95.11%)
+
+public class Solution {
+    public char[][] rotateTheBox(char[][] box) {
+        int m = box.length;
+        int n = box[0].length;
+        for (int i = 0; i < m; i++) {
+            for (int j = n - 1; j >= 0; j--) {
+                if (box[i][j] == '#') {
+                    int empty = j + 1;
+                    while (empty < n && box[i][empty] == '.') {
+                        empty++;
+                    }
+                    if (empty < n && box[i][empty] == '.') {
+                        box[i][empty] = '#';
+                        box[i][j] = '.';
+                    } else if (empty - 1 < n && box[i][empty - 1] == '.') {
+                        box[i][empty - 1] = '#';
+                        box[i][j] = '.';
+                    }
+                }
+            }
+        }
+        char[][] result = new char[n][m];
+        int k = m - 1;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                result[j][k] = box[i][j];
+            }
+            k--;
+        }
+        return result;
+    }
+}

src/main/java/g1801_1900/s1861_rotating_the_box/readme.md

@@ -0,0 +1,59 @@
+1861\. Rotating the Box
+
+Medium
+
+You are given an `m x n` matrix of characters `box` representing a side-view of a box. Each cell of the box is one of the following:
+
+*   A stone `'#'`
+*   A stationary obstacle `'*'`
+*   Empty `'.'`
+
+The box is rotated **90 degrees clockwise**, causing some of the stones to fall due to gravity. Each stone falls down until it lands on an obstacle, another stone, or the bottom of the box. Gravity **does not** affect the obstacles' positions, and the inertia from the box's rotation **does not** affect the stones' horizontal positions.
+
+It is **guaranteed** that each stone in `box` rests on an obstacle, another stone, or the bottom of the box.
+
+Return _an_ `n x m` _matrix representing the box after the rotation described above_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/08/rotatingtheboxleetcodewithstones.png)
+
+**Input:** box = [["#",".","#"]]
+
+**Output:** [["."], 
+             ["#"], 
+             ["#"]]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/04/08/rotatingtheboxleetcode2withstones.png)
+
+**Input:** box = [["#",".","*","."], 
+                  ["#","#","*","."]]
+
+**Output:** [["#","."], 
+             ["#","#"], 
+             ["*","*"], 
+             [".","."]]
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/04/08/rotatingtheboxleetcode3withstone.png)
+
+**Input:** box = [["#","#","*",".","*","."], 
+                  ["#","#","#","*",".","."], 
+                  ["#","#","#",".","#","."]]
+
+**Output:** [[".","#","#"], 
+             [".","#","#"], 
+             ["#","#","*"], 
+             ["#","*","."], 
+             ["#",".","*"], 
+             ["#",".","."]]
+
+**Constraints:**
+
+*   `m == box.length`
+*   `n == box[i].length`
+*   `1 <= m, n <= 500`
+*   `box[i][j]` is either `'#'`, `'*'`, or `'.'`.

src/main/java/g1801_1900/s1862_sum_of_floored_pairs/Solution.java

@@ -0,0 +1,37 @@
+package g1801_1900.s1862_sum_of_floored_pairs;
+
+// #Hard #Array #Math #Binary_Search #Prefix_Sum
+// #2022_05_08_Time_115_ms_(70.91%)_Space_57.2_MB_(81.82%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int sumOfFlooredPairs(int[] nums) {
+        long mod = 1000000007;
+        Arrays.sort(nums);
+        int max = nums[nums.length - 1];
+        int[] counts = new int[max + 1];
+        long[] qnts = new long[max + 1];
+        for (int k : nums) {
+            counts[k]++;
+        }
+        for (int i = 1; i < max + 1; i++) {
+            if (counts[i] == 0) {
+                continue;
+            }
+            int j = i;
+            while (j <= max) {
+                qnts[j] += counts[i];
+                j = j + i;
+            }
+        }
+        for (int i = 1; i < max + 1; i++) {
+            qnts[i] = (qnts[i] + qnts[i - 1]) % mod;
+        }
+        long sum = 0;
+        for (int k : nums) {
+            sum = (sum + qnts[k]) % mod;
+        }
+        return (int) sum;
+    }
+}

src/main/java/g1801_1900/s1862_sum_of_floored_pairs/readme.md

@@ -0,0 +1,38 @@
+1862\. Sum of Floored Pairs
+
+Hard
+
+Given an integer array `nums`, return the sum of `floor(nums[i] / nums[j])` for all pairs of indices `0 <= i, j < nums.length` in the array. Since the answer may be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+The `floor()` function returns the integer part of the division.
+
+**Example 1:**
+
+**Input:** nums = [2,5,9]
+
+**Output:** 10
+
+**Explanation:** 
+
+floor(2 / 5) = floor(2 / 9) = floor(5 / 9) = 0 
+
+floor(2 / 2) = floor(5 / 5) = floor(9 / 9) = 1 
+
+floor(5 / 2) = 2 
+
+floor(9 / 2) = 4 
+
+floor(9 / 5) = 1 
+
+We calculate the floor of the division for every pair of indices in the array then sum them up.
+
+**Example 2:**
+
+**Input:** nums = [7,7,7,7,7,7,7]
+
+**Output:** 49
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>

src/test/java/g1801_1900/s1861_rotating_the_box/SolutionTest.java

@@ -0,0 +1,44 @@
+package g1801_1900.s1861_rotating_the_box;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void rotateTheBox() {
+        assertThat(
+                new Solution().rotateTheBox(new char[][] {{'#', '.', '#'}}),
+                equalTo(new char[][] {{'.'}, {'#'}, {'#'}}));
+    }
+
+    @Test
+    void rotateTheBox2() {
+        assertThat(
+                new Solution()
+                        .rotateTheBox(new char[][] {{'#', '.', '*', '.'}, {'#', '#', '*', '.'}}),
+                equalTo(new char[][] {{'#', '.'}, {'#', '#'}, {'*', '*'}, {'.', '.'}}));
+    }
+
+    @Test
+    void rotateTheBox3() {
+        assertThat(
+                new Solution()
+                        .rotateTheBox(
+                                new char[][] {
+                                    {'#', '#', '*', '.', '*', '.'},
+                                    {'#', '#', '#', '*', '.', '.'},
+                                    {'#', '#', '#', '.', '#', '.'}
+                                }),
+                equalTo(
+                        new char[][] {
+                            {'.', '#', '#'},
+                            {'.', '#', '#'},
+                            {'#', '#', '*'},
+                            {'#', '*', '.'},
+                            {'#', '.', '*'},
+                            {'#', '.', '.'}
+                        }));
+    }
+}

src/test/java/g1801_1900/s1862_sum_of_floored_pairs/SolutionTest.java

@@ -0,0 +1,18 @@
+package g1801_1900.s1862_sum_of_floored_pairs;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void sumOfFlooredPairs() {
+        assertThat(new Solution().sumOfFlooredPairs(new int[] {2, 5, 9}), equalTo(10));
+    }
+
+    @Test
+    void sumOfFlooredPairs2() {
+        assertThat(new Solution().sumOfFlooredPairs(new int[] {7, 7, 7, 7, 7, 7, 7}), equalTo(49));
+    }
+}