Added tasks 780, 781, 782.

Author: javadev

src/main/java/g0701_0800/s0780_reaching_points/Solution.java

@@ -0,0 +1,26 @@
+package g0701_0800.s0780_reaching_points;
+
+// #Hard #Math
+
+public class Solution {
+    public boolean reachingPoints(int sx, int sy, int tx, int ty) {
+        while (tx >= sx && ty >= sy) {
+            if (tx > ty) {
+                if (ty == sy) {
+                    // ty==sy
+                    return (tx - sx) % sy == 0;
+                } else {
+                    // ty > sy
+                    tx %= ty;
+                }
+            } else if (sx == tx) {
+                // ty >= tx
+                return (ty - sy) % sx == 0;
+            } else {
+                // (tx > sx)
+                ty %= tx;
+            }
+        }
+        return false;
+    }
+}

src/main/java/g0701_0800/s0780_reaching_points/readme.md

@@ -0,0 +1,36 @@
+780\. Reaching Points
+
+Hard
+
+Given four integers `sx`, `sy`, `tx`, and `ty`, return `true` _if it is possible to convert the point_ `(sx, sy)` _to the point_ `(tx, ty)` _through some operations__, or_ `false` _otherwise_.
+
+The allowed operation on some point `(x, y)` is to convert it to either `(x, x + y)` or `(x + y, y)`.
+
+**Example 1:**
+
+**Input:** sx = 1, sy = 1, tx = 3, ty = 5
+
+**Output:** true
+
+**Explanation:**
+
+    One series of moves that transforms the starting point to the target is:
+    (1, 1) -> (1, 2)
+    (1, 2) -> (3, 2)
+    (3, 2) -> (3, 5) 
+
+**Example 2:**
+
+**Input:** sx = 1, sy = 1, tx = 2, ty = 2
+
+**Output:** false 
+
+**Example 3:**
+
+**Input:** sx = 1, sy = 1, tx = 1, ty = 1
+
+**Output:** true 
+
+**Constraints:**
+
+*   <code>1 <= sx, sy, tx, ty <= 10<sup>9</sup></code>

src/main/java/g0701_0800/s0781_rabbits_in_forest/Solution.java

@@ -0,0 +1,24 @@
+package g0701_0800.s0781_rabbits_in_forest;
+
+// #Medium #Array #Hash_Table #Math #Greedy
+
+public class Solution {
+    public int numRabbits(int[] answers) {
+        int[] counts = new int[1001];
+        for (int element : answers) {
+            counts[element]++;
+        }
+        int answer = counts[0];
+        for (int i = 1; i <= 1000; i++) {
+            if (counts[i] > 0) {
+                int rabbitsInPartialGroup = counts[i] % (i + 1);
+                int rabbitsInCompleteGroups = counts[i] - rabbitsInPartialGroup;
+                answer += rabbitsInCompleteGroups;
+                if (rabbitsInPartialGroup > 0) {
+                    answer += (i + 1);
+                }
+            }
+        }
+        return answer;
+    }
+}

src/main/java/g0701_0800/s0781_rabbits_in_forest/readme.md

@@ -0,0 +1,32 @@
+781\. Rabbits in Forest
+
+Medium
+
+There is a forest with an unknown number of rabbits. We asked n rabbits **"How many rabbits have the same color as you?"** and collected the answers in an integer array `answers` where `answers[i]` is the answer of the <code>i<sup>th</sup></code> rabbit.
+
+Given the array `answers`, return _the minimum number of rabbits that could be in the forest_.
+
+**Example 1:**
+
+**Input:** answers = [1,1,2]
+
+**Output:** 5
+
+**Explanation:**
+
+    The two rabbits that answered "1" could both be the same color, say red.
+    The rabbit that answered "2" can't be red or the answers would be inconsistent.
+    Say the rabbit that answered "2" was blue.
+    Then there should be 2 other blue rabbits in the forest that didn't answer into the array.
+    The smallest possible number of rabbits in the forest is therefore 5: 3 that answered plus 2 that didn't. 
+
+**Example 2:**
+
+**Input:** answers = [10,10,10]
+
+**Output:** 11 
+
+**Constraints:**
+
+*   `1 <= answers.length <= 1000`
+*   `0 <= answers[i] < 1000`

src/main/java/g0701_0800/s0782_transform_to_chessboard/Solution.java

@@ -0,0 +1,49 @@
+package g0701_0800.s0782_transform_to_chessboard;
+
+// #Hard #Array #Math #Matrix #Bit_Manipulation
+
+public class Solution {
+    public int movesToChessboard(int[][] board) {
+        int n = board.length;
+        int colToMove = 0;
+        int rowToMove = 0;
+        int rowOneCnt = 0;
+        int colOneCnt = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (((board[0][0] ^ board[i][0]) ^ (board[i][j] ^ board[0][j])) == 1) {
+                    return -1;
+                }
+            }
+        }
+        for (int i = 0; i < n; i++) {
+            rowOneCnt += board[0][i];
+            colOneCnt += board[i][0];
+            if (board[i][0] == i % 2) {
+                rowToMove++;
+            }
+            if (board[0][i] == i % 2) {
+                colToMove++;
+            }
+        }
+        if (rowOneCnt < n / 2 || rowOneCnt > (n + 1) / 2) {
+            return -1;
+        }
+        if (colOneCnt < n / 2 || colOneCnt > (n + 1) / 2) {
+            return -1;
+        }
+        if (n % 2 == 1) {
+            // we cannot make it when ..ToMove is odd
+            if (colToMove % 2 == 1) {
+                colToMove = n - colToMove;
+            }
+            if (rowToMove % 2 == 1) {
+                rowToMove = n - rowToMove;
+            }
+        } else {
+            colToMove = Math.min(colToMove, n - colToMove);
+            rowToMove = Math.min(rowToMove, n - rowToMove);
+        }
+        return (colToMove + rowToMove) / 2;
+    }
+}

src/main/java/g0701_0800/s0782_transform_to_chessboard/readme.md

@@ -0,0 +1,50 @@
+782\. Transform to Chessboard
+
+Hard
+
+You are given an `n x n` binary grid `board`. In each move, you can swap any two rows with each other, or any two columns with each other.
+
+Return _the minimum number of moves to transform the board into a **chessboard board**_. If the task is impossible, return `-1`.
+
+A **chessboard board** is a board where no `0`'s and no `1`'s are 4-directionally adjacent.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/29/chessboard1-grid.jpg)
+
+**Input:** board = [[0,1,1,0],[0,1,1,0],[1,0,0,1],[1,0,0,1]]
+
+**Output:** 2
+
+**Explanation:**
+
+    One potential sequence of moves is shown.
+    The first move swaps the first and second column.
+    The second move swaps the second and third row. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/06/29/chessboard2-grid.jpg)
+
+**Input:** board = [[0,1],[1,0]]
+
+**Output:** 0
+
+**Explanation:** Also note that the board with 0 in the top left corner, is also a valid chessboard. 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/06/29/chessboard3-grid.jpg)
+
+**Input:** board = [[1,0],[1,0]]
+
+**Output:** -1
+
+**Explanation:** No matter what sequence of moves you make, you cannot end with a valid chessboard. 
+
+**Constraints:**
+
+*   `n == board.length`
+*   `n == board[i].length`
+*   `2 <= n <= 30`
+*   `board[i][j]` is either `0` or `1`.

src/test/java/g0701_0800/s0780_reaching_points/SolutionTest.java

@@ -0,0 +1,23 @@
+package g0701_0800.s0780_reaching_points;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void reachingPoints() {
+        assertThat(new Solution().reachingPoints(1, 1, 3, 5), equalTo(true));
+    }
+
+    @Test
+    void reachingPoints2() {
+        assertThat(new Solution().reachingPoints(1, 1, 2, 2), equalTo(false));
+    }
+
+    @Test
+    void reachingPoints3() {
+        assertThat(new Solution().reachingPoints(1, 1, 1, 1), equalTo(true));
+    }
+}

src/test/java/g0701_0800/s0781_rabbits_in_forest/SolutionTest.java

@@ -0,0 +1,23 @@
+package g0701_0800.s0781_rabbits_in_forest;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void numRabbits() {
+        assertThat(new Solution().numRabbits(new int[] {1, 1, 2}), equalTo(5));
+    }
+
+    @Test
+    void numRabbits2() {
+        assertThat(new Solution().numRabbits(new int[] {10, 10, 10}), equalTo(11));
+    }
+
+    @Test
+    void numRabbits3() {
+        assertThat(new Solution().numRabbits(new int[] {1, 0, 1, 0, 0}), equalTo(5));
+    }
+}

src/test/java/g0701_0800/s0782_transform_to_chessboard/SolutionTest.java

@@ -0,0 +1,29 @@
+package g0701_0800.s0782_transform_to_chessboard;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void movesToChessboard() {
+        assertThat(
+                new Solution()
+                        .movesToChessboard(
+                                new int[][] {
+                                    {0, 1, 1, 0}, {0, 1, 1, 0}, {1, 0, 0, 1}, {1, 0, 0, 1}
+                                }),
+                equalTo(2));
+    }
+
+    @Test
+    void movesToChessboard2() {
+        assertThat(new Solution().movesToChessboard(new int[][] {{0, 1}, {1, 0}}), equalTo(0));
+    }
+
+    @Test
+    void movesToChessboard3() {
+        assertThat(new Solution().movesToChessboard(new int[][] {{1, 0}, {1, 0}}), equalTo(-1));
+    }
+}