Added tasks 2682-2693

Author: ThanhNIT

src/main/java/g2601_2700/s2682_find_the_losers_of_the_circular_game/Solution.java

@@ -0,0 +1,28 @@
+package g2601_2700.s2682_find_the_losers_of_the_circular_game;
+
+// #Easy #Array #Hash_Table #Simulation #2023_09_12_Time_1_ms_(100.00%)_Space_43.6_MB_(51.49%)
+
+public class Solution {
+    public int[] circularGameLosers(int n, int k) {
+        int[] pointsMap = new int[n];
+        int friend = 0;
+        int turn = 1;
+        while (true) {
+            pointsMap[friend] = pointsMap[friend] + 1;
+            if (pointsMap[friend] == 2) {
+                break;
+            }
+            friend = (friend + turn * k) % n;
+            turn++;
+        }
+        int[] result = new int[n - (turn - 1)];
+        int i = 0;
+        for (int index = 0; index < pointsMap.length; index++) {
+            if (pointsMap[index] == 0) {
+                result[i] = index + 1;
+                i++;
+            }
+        }
+        return result;
+    }
+}

src/main/java/g2601_2700/s2682_find_the_losers_of_the_circular_game/readme.md

@@ -0,0 +1,47 @@
+2682\. Find the Losers of the Circular Game
+
+Easy
+
+There are `n` friends that are playing a game. The friends are sitting in a circle and are numbered from `1` to `n` in **clockwise order**. More formally, moving clockwise from the <code>i<sup>th</sup></code> friend brings you to the <code>(i+1)<sup>th</sup></code> friend for `1 <= i < n`, and moving clockwise from the <code>n<sup>th</sup></code> friend brings you to the <code>1<sup>st</sup></code> friend.
+
+The rules of the game are as follows:
+
+<code>1<sup>st</sup></code> friend receives the ball.
+
+*   After that, <code>1<sup>st</sup></code> friend passes it to the friend who is `k` steps away from them in the **clockwise** direction.
+*   After that, the friend who receives the ball should pass it to the friend who is `2 * k` steps away from them in the **clockwise** direction.
+*   After that, the friend who receives the ball should pass it to the friend who is `3 * k` steps away from them in the **clockwise** direction, and so on and so forth.
+
+In other words, on the <code>i<sup>th</sup></code> turn, the friend holding the ball should pass it to the friend who is `i * k` steps away from them in the **clockwise** direction.
+
+The game is finished when some friend receives the ball for the second time.
+
+The **losers** of the game are friends who did not receive the ball in the entire game.
+
+Given the number of friends, `n`, and an integer `k`, return _the array answer, which contains the losers of the game in the **ascending** order_.
+
+**Example 1:**
+
+**Input:** n = 5, k = 2
+
+**Output:** [4,5]
+
+**Explanation:** The game goes as follows: 
+1) Start at 1<sup>st</sup> friend and pass the ball to the friend who is 2 steps away from them - 3<sup>rd</sup> friend. 
+2) 3<sup>rd</sup> friend passes the ball to the friend who is 4 steps away from them - 2<sup>nd</sup> friend. 
+3) 2<sup>nd</sup> friend passes the ball to the friend who is 6 steps away from them - 3<sup>rd</sup> friend. 
+4) The game ends as 3<sup>rd</sup> friend receives the ball for the second time.
+
+**Example 2:**
+
+**Input:** n = 4, k = 4
+
+**Output:** [2,3,4]
+
+**Explanation:** The game goes as follows: 
+1) Start at the 1<sup>st</sup> friend and pass the ball to the friend who is 4 steps away from them - 1<sup>st</sup> friend. 
+2) The game ends as 1<sup>st</sup> friend receives the ball for the second time.
+
+**Constraints:**
+
+*   `1 <= k <= n <= 50`

src/main/java/g2601_2700/s2683_neighboring_bitwise_xor/Solution.java

@@ -0,0 +1,13 @@
+package g2601_2700.s2683_neighboring_bitwise_xor;
+
+// #Medium #Array #Bit_Manipulation #2023_09_12_Time_2_ms_(100.00%)_Space_59.9_MB_(62.03%)
+
+public class Solution {
+    public boolean doesValidArrayExist(int[] derived) {
+        int xor = 0;
+        for (int j : derived) {
+            xor = xor ^ j;
+        }
+        return xor == 0;
+    }
+}

src/main/java/g2601_2700/s2683_neighboring_bitwise_xor/readme.md

@@ -0,0 +1,56 @@
+2683\. Neighboring Bitwise XOR
+
+Medium
+
+A **0-indexed** array `derived` with length `n` is derived by computing the **bitwise XOR** (⊕) of adjacent values in a **binary array** `original` of length `n`.
+
+Specifically, for each index `i` in the range `[0, n - 1]`:
+
+*   If `i = n - 1`, then `derived[i] = original[i] ⊕ original[0]`.
+*   Otherwise, `derived[i] = original[i] ⊕ original[i + 1]`.
+
+Given an array `derived`, your task is to determine whether there exists a **valid binary array** `original` that could have formed `derived`.
+
+Return _**true** if such an array exists or **false** otherwise._
+
+*   A binary array is an array containing only **0's** and **1's**
+
+**Example 1:**
+
+**Input:** derived = [1,1,0]
+
+**Output:** true
+
+**Explanation:** A valid original array that gives derived is [0,1,0]. 
+
+derived[0] = original[0] ⊕ original[1] = 0 ⊕ 1 = 1 
+
+derived[1] = original[1] ⊕ original[2] = 1 ⊕ 0 = 1 
+
+derived[2] = original[2] ⊕ original[0] = 0 ⊕ 0 = 0
+
+**Example 2:**
+
+**Input:** derived = [1,1]
+
+**Output:** true
+
+**Explanation:** A valid original array that gives derived is [0,1]. 
+
+derived[0] = original[0] ⊕ original[1] = 1 
+
+derived[1] = original[1] ⊕ original[0] = 1
+
+**Example 3:**
+
+**Input:** derived = [1,0]
+
+**Output:** false
+
+**Explanation:** There is no valid original array that gives derived.
+
+**Constraints:**
+
+*   `n == derived.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   The values in `derived` are either **0's** or **1's**

src/main/java/g2601_2700/s2684_maximum_number_of_moves_in_a_grid/Solution.java

@@ -0,0 +1,25 @@
+package g2601_2700.s2684_maximum_number_of_moves_in_a_grid;
+
+// #Medium #Array #Dynamic_Programming #Matrix #2023_09_12_Time_4_ms_(97.95%)_Space_54.4_MB_(68.34%)
+
+public class Solution {
+    public int maxMoves(int[][] grid) {
+        int m = Integer.MIN_VALUE;
+        int[][] vis = new int[grid.length][grid[0].length];
+        for (int i = 0; i < grid.length; i++) {
+            m = Math.max(m, mov(i, 0, grid, Integer.MIN_VALUE, vis));
+        }
+        return m - 1;
+    }
+
+    private int mov(int i, int j, int[][] g, int p, int[][] vis) {
+        if (i < 0 || j < 0 || i >= g.length || j >= g[0].length || g[i][j] <= p || vis[i][j] == 1) {
+            return 0;
+        }
+        vis[i][j] = 1;
+        int ur = 1 + mov(i - 1, j + 1, g, g[i][j], vis);
+        int dr = 1 + mov(i + 1, j + 1, g, g[i][j], vis);
+        int r = 1 + mov(i, j + 1, g, g[i][j], vis);
+        return Math.max(ur, Math.max(dr, r));
+    }
+}

src/main/java/g2601_2700/s2684_maximum_number_of_moves_in_a_grid/readme.md

@@ -0,0 +1,42 @@
+2684\. Maximum Number of Moves in a Grid
+
+Medium
+
+You are given a **0-indexed** `m x n` matrix `grid` consisting of **positive** integers.
+
+You can start at **any** cell in the first column of the matrix, and traverse the grid in the following way:
+
+*   From a cell `(row, col)`, you can move to any of the cells: `(row - 1, col + 1)`, `(row, col + 1)` and `(row + 1, col + 1)` such that the value of the cell you move to, should be **strictly** bigger than the value of the current cell.
+
+Return _the **maximum** number of **moves** that you can perform._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/04/11/yetgriddrawio-10.png)
+
+**Input:** grid = [[2,4,3,5],[5,4,9,3],[3,4,2,11],[10,9,13,15]]
+
+**Output:** 3
+
+**Explanation:** We can start at the cell (0, 0) and make the following moves: 
+- (0, 0) -> (0, 1). 
+- (0, 1) -> (1, 2). 
+- (1, 2) -> (2, 3). 
+
+It can be shown that it is the maximum number of moves that can be made.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/04/12/yetgrid4drawio.png) **Input:** grid = [[3,2,4],[2,1,9],[1,1,7]]
+
+**Output:** 0
+
+**Explanation:** Starting from any cell in the first column we cannot perform any moves.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `2 <= m, n <= 1000`
+*   <code>4 <= m * n <= 10<sup>5</sup></code>
+*   <code>1 <= grid[i][j] <= 10<sup>6</sup></code>

src/main/java/g2601_2700/s2685_count_the_number_of_complete_components/Solution.java

@@ -0,0 +1,59 @@
+package g2601_2700.s2685_count_the_number_of_complete_components;
+
+// #Medium #Array #Dynamic_Programming #Depth_First_Search #Breadth_First_Search #Matrix #Graph
+// #2023_09_12_Time_5_ms_(98.65%)_Space_43.8_MB_(65.96%)
+
+public class Solution {
+    private static class DSU {
+        int[] roots;
+        int[] sizes;
+
+        DSU(int n) {
+            roots = new int[n];
+            sizes = new int[n];
+            for (int i = 0; i < n; i++) {
+                sizes[i] = 1;
+                roots[i] = i;
+            }
+        }
+
+        public int find(int v) {
+            if (roots[v] != v) {
+                roots[v] = find(roots[v]);
+            }
+            return roots[v];
+        }
+
+        public void union(int a, int b) {
+            int rootA = find(a);
+            int rootB = find(b);
+            if (rootA == rootB) {
+                return;
+            }
+            roots[rootB] = rootA;
+            sizes[rootA] += sizes[rootB];
+        }
+    }
+
+    public int countCompleteComponents(int n, int[][] edges) {
+        DSU dsu = new DSU(n);
+        int[] indegree = new int[n];
+        for (int[] e : edges) {
+            dsu.union(e[0], e[1]);
+            indegree[e[0]]++;
+            indegree[e[1]]++;
+        }
+        int[] gcount = new int[n];
+        int res = 0;
+        for (int i = 0; i < n; i++) {
+            int root = dsu.find(i);
+            if (dsu.sizes[root] == (indegree[i] + 1)) {
+                gcount[root]++;
+            }
+            if (gcount[root] == dsu.sizes[root]) {
+                res++;
+            }
+        }
+        return res;
+    }
+}

src/main/java/g2601_2700/s2685_count_the_number_of_complete_components/readme.md

@@ -0,0 +1,40 @@
+2685\. Count the Number of Complete Components
+
+Medium
+
+You are given an integer `n`. There is an **undirected** graph with `n` vertices, numbered from `0` to `n - 1`. You are given a 2D integer array `edges` where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> denotes that there exists an **undirected** edge connecting vertices <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>.
+
+Return _the number of **complete connected components** of the graph_.
+
+A **connected component** is a subgraph of a graph in which there exists a path between any two vertices, and no vertex of the subgraph shares an edge with a vertex outside of the subgraph.
+
+A connected component is said to be **complete** if there exists an edge between every pair of its vertices.
+
+**Example 1:**
+
+**![](https://assets.leetcode.com/uploads/2023/04/11/screenshot-from-2023-04-11-23-31-23.png)**
+
+**Input:** n = 6, edges = [[0,1],[0,2],[1,2],[3,4]]
+
+**Output:** 3
+
+**Explanation:** From the picture above, one can see that all of the components of this graph are complete.
+
+**Example 2:**
+
+**![](https://assets.leetcode.com/uploads/2023/04/11/screenshot-from-2023-04-11-23-32-00.png)**
+
+**Input:** n = 6, edges = [[0,1],[0,2],[1,2],[3,4],[3,5]]
+
+**Output:** 1
+
+**Explanation:** The component containing vertices 0, 1, and 2 is complete since there is an edge between every pair of two vertices. On the other hand, the component containing vertices 3, 4, and 5 is not complete since there is no edge between vertices 4 and 5. Thus, the number of complete components in this graph is 1.
+
+**Constraints:**
+
+*   `1 <= n <= 50`
+*   `0 <= edges.length <= n * (n - 1) / 2`
+*   `edges[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> <= n - 1</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   There are no repeated edges.

src/main/java/g2601_2700/s2693_call_function_with_custom_context/readme.md

@@ -0,0 +1,53 @@
+2693\. Call Function with Custom Context
+
+Medium
+
+Enhance all functions to have the `callPolyfill` method. The method accepts an object `obj` as it's first parameter and any number of additional arguments. The `obj` becomes the `this` context for the function. The additional arguments are passed to the function (that the `callPolyfill` method belongs on).
+
+For example if you had the function:
+
+function tax(price, taxRate) { const totalCost = price \* (1 + taxRate); console.log(\`The cost of ${this.item} is ${totalCost}\`); }
+
+Calling this function like `tax(10, 0.1)` will log `"The cost of undefined is 11"`. This is because the `this` context was not defined.
+
+However, calling the function like `tax.callPolyfill({item: "salad"}, 10, 0.1)` will log `"The cost of salad is 11"`. The `this` context was appropriately set, and the function logged an appropriate output.
+
+Please solve this without using the built-in `Function.call` method.
+
+**Example 1:**
+
+**Input:** 
+
+    fn = function add(b) { 
+        return this.a + b; 
+    } 
+
+    args = [{"a": 5}, 7]
+
+**Output:** 12
+
+**Explanation:** 
+
+    fn.callPolyfill({"a": 5}, 7); // 12 
+
+callPolyfill sets the "this" context to {"a": 5}. 7 is passed as an argument.
+
+**Example 2:**
+
+**Input:** 
+
+    fn = function tax(price, taxRate) { 
+        return \`The cost of the ${this.item} is ${price \* taxRate}\`; 
+    } 
+
+    args = [{"item": "burger"}, 10, 1.1]
+
+**Output:** "The cost of the burger is 11"
+
+**Explanation:** callPolyfill sets the "this" context to {"item": "burger"}. 10 and 1.1 are passed as additional arguments.
+
+**Constraints:**
+
+*   `typeof args[0] == 'object' and args[0] != null`
+*   `1 <= args.length <= 100`
+*   <code>2 <= JSON.stringify(args[0]).length <= 10<sup>5</sup></code>

src/main/java/g2601_2700/s2693_call_function_with_custom_context/solution.ts

@@ -0,0 +1,19 @@
+// #Medium #Array #Dynamic_Programming #Matrix #2023_07_28_Time_51_ms_(97.92%)_Space_43_MB_(91.84%)
+
+declare global {
+    interface Function {
+        callPolyfill(context: Record<any, any>, ...args: any[]): any
+    }
+}
+
+Function.prototype.callPolyfill = function (context, ...args): any { //NOSONAR
+    let fn = this.bind(context)
+    return fn(...args)
+}
+
+/*
+ * function increment() { this.count++; return this.count; }
+ * increment.callPolyfill({count: 1}); // 2
+ */
+
+export {}