Added tasks 2682-2693

Author: ThanhNIT

src/main/kotlin/g2601_2700/s2682_find_the_losers_of_the_circular_game/Solution.kt

@@ -0,0 +1,26 @@
+package g2601_2700.s2682_find_the_losers_of_the_circular_game
+
+// #Easy #Array #Hash_Table #Simulation #2023_07_28_Time_186_ms_(100.00%)_Space_37.4_MB_(81.82%)
+
+class Solution {
+    fun circularGameLosers(n: Int, k: Int): IntArray {
+        val pointsMap = IntArray(n)
+        var friend = 0
+        var turn = 1
+        while (true) {
+            pointsMap[friend] = pointsMap[friend] + 1
+            if (pointsMap[friend] == 2) break
+            friend = (friend + turn * k) % n
+            turn++
+        }
+        val result = IntArray(n - (turn - 1))
+        var i = 0
+        pointsMap.forEachIndexed { index, points ->
+            if (points == 0) {
+                result[i] = index + 1
+                i++
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/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/kotlin/g2601_2700/s2683_neighboring_bitwise_xor/Solution.kt

@@ -0,0 +1,13 @@
+package g2601_2700.s2683_neighboring_bitwise_xor
+
+// #Medium #Array #Bit_Manipulation #2023_07_28_Time_988_ms_(100.00%)_Space_76.1_MB_(100.00%)
+
+class Solution {
+    fun doesValidArrayExist(derived: IntArray): Boolean {
+        var xor = 0
+        for (j in derived) {
+            xor = xor xor j
+        }
+        return xor == 0
+    }
+}

src/main/kotlin/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/kotlin/g2601_2700/s2684_maximum_number_of_moves_in_a_grid/Solution.kt

@@ -0,0 +1,29 @@
+package g2601_2700.s2684_maximum_number_of_moves_in_a_grid
+
+// #Medium #Array #Dynamic_Programming #Matrix
+// #2023_07_28_Time_542_ms_(100.00%)_Space_57.4_MB_(57.14%)
+
+class Solution {
+    fun maxMoves(grid: Array<IntArray>): Int {
+        val height = grid.size
+        val width = grid[0].size
+        val dp = Array(height) { IntArray(width) { Int.MIN_VALUE } }
+        var result = 0
+        for (i in 0 until height) {
+            dp[i][0] = 0
+        }
+        for (c in 1 until width) {
+            for (r in 0 until height) {
+                if (r > 0 && grid[r - 1][c - 1] < grid[r][c]) {
+                    dp[r][c] = dp[r][c].coerceAtLeast(dp[r - 1][c - 1] + 1)
+                }
+                if (grid[r][c - 1] < grid[r][c]) dp[r][c] = dp[r][c].coerceAtLeast(dp[r][c - 1] + 1)
+                if (r < height - 1 && grid[r + 1][c - 1] < grid[r][c]) {
+                    dp[r][c] = dp[r][c].coerceAtLeast(dp[r + 1][c - 1] + 1)
+                }
+                result = result.coerceAtLeast(dp[r][c])
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/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/kotlin/g2601_2700/s2685_count_the_number_of_complete_components/Solution.kt

@@ -0,0 +1,38 @@
+package g2601_2700.s2685_count_the_number_of_complete_components
+
+// #Medium #Array #Dynamic_Programming #Matrix #Graph #Depth_First_Search #Breadth_First_Search
+// #2023_07_28_Time_436_ms_(100.00%)_Space_58.6_MB_(66.67%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun countCompleteComponents(n: Int, edges: Array<IntArray>): Int {
+        val adj = HashMap<Int, ArrayList<Int>>().apply {
+            for ((u, v) in edges) {
+                this[u] = getOrDefault(u, arrayListOf()).apply { add(v) }
+                this[v] = getOrDefault(v, arrayListOf()).apply { add(u) }
+            }
+        }
+        val visited = BooleanArray(n)
+        fun bfs(i: Int): Pair<Int, Int> {
+            if (visited[i]) return 0 to 0
+            visited[i] = true
+            var nodes = 1
+            var edges = (adj[i]?.size ?: 0)
+            adj[i]?.forEach {
+                val (nodes2, edges2) = bfs(it)
+                nodes += nodes2
+                edges += edges2
+            }
+            return nodes to edges
+        }
+        var res = 0
+        for (i in 0 until n) {
+            if (!visited[i]) {
+                val (nodes, edges) = bfs(i)
+                if ((nodes * (nodes - 1)) == edges)
+                    res++
+            }
+        }
+        return res
+    }
+}

src/main/kotlin/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/kotlin/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/kotlin/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 {
+    let fn = this.bind(context)
+    return fn(...args)
+}
+
+/*
+ * function increment() { this.count++; return this.count; }
+ * increment.callPolyfill({count: 1}); // 2
+ */
+
+export { Function.prototype.callPolyfill }